@sema-agent/server 7.139.0 → 7.140.0

package/dist/runs.js

@@ -1,5 +1,5 @@
 import { runWithVerification, runCascade, defaultTaskRegistry, taskNotificationDedupKey, DURABLE_AGENT_HANDLE_RE } from "@sema-agent/core";
-import { failureCodeOf, sealResultForExit, outwardPlane } from "./terminal.js";
+import { atHostBoundary, failureCodeOf, sealResultForExit, outwardPlane } from "./terminal.js";
 import { NOT_IN_ROSTER, entryProblemsFacts } from "./entry-problems.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
 import { TOOL_DECLARATION_HTTP_STATUS } from "./tool-declaration-http-status.js";
@@ -19,6 +19,7 @@ import { createApprovalCardEmitter, resolveApprovalLeg } from "./tool-approval.j
 import { fleetRunResiduals, isFleetAgentTerminalNotification } from "./fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
 import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotificationStreamKeyOf, NotifiedKeys } from "./orchestration/workflow-completion-inbox.js";
+import { isParkLedgerEventType } from "./trace/ledger-events.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { errorText as errText } from "./observability/err-text.js";
 import { LIVENESS_HEARTBEAT_MS } from "./config-invariants.js";
@@ -88,6 +89,7 @@ const PREPARE_REFUSAL_HTTP_STATUS = {
     "config.project_identity_mismatch": 409,
     "config.memory_project_marker": 409,
     "config.memory_project_marker_nested": 409,
+    "config.read_deny_floor_unkept": 409,
 };
 export function resumeAtHttpStatus(result) {
     const code = failureCodeOf(result.terminal);
@@ -326,14 +328,38 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     let legLive = true;
     const notifiedKeys = new NotifiedKeys();
     const subagentHandleEvictions = [];
-    const parkNeedsReview = async (res) => {
-        await sink.appendParked("needs_review", res);
+    const parkRowWrite = {
+        suspended: (sealed) => runStore.setSuspended(taskId, sealed),
+        needs_review: (sealed) => runStore.setNeedsReview(taskId, sealed),
+    };
+    const parkLeg = async (word, res) => {
+        const grafted = await graftParkToolCallId(res, parkCheckpointReader);
+        await sink.appendParked(word, grafted);
         await flushModelUsage();
-        const sealed = sealResultForExit(res);
-        reached = { kind: "needs_review", result: sealed };
-        await runStore.setNeedsReview(taskId, sealed);
+        const sealed = sealResultForExit(grafted);
+        reached = { kind: word, result: sealed };
+        await parkRowWrite[word](sealed);
+        acceptance?.settle(sealed);
         metrics?.addGauge("runs_active", -1);
-        metrics?.inc("tasks_total", { status: "needs_review" });
+        metrics?.inc("tasks_total", { status: word });
+    };
+    const settleLegResult = async (engineResult) => {
+        const result = atHostBoundary(engineResult, spec.sessionId);
+        const parkWord = result.terminal.kind === "paused" ? outwardPlane(result.terminal).status : undefined;
+        if (parkWord !== undefined && isParkLedgerEventType(parkWord)) {
+            await parkLeg(parkWord, result);
+            return;
+        }
+        const settled = causeAtDone !== undefined ? cancelledResult(causeAtDone, result) : result;
+        settledAsCancel = failureCodeOf(settled.terminal) === CANCELLED_CODE;
+        const safe = await withModelUsage(sealResultForExit(settled));
+        await sink.appendDone(safe);
+        reached = { kind: "done", result: safe };
+        const plane = outwardPlane(safe.terminal);
+        await runStore.setTerminal(taskId, plane.status, safe, plane.errorMessage ?? null);
+        await releaseKeyIfZeroWorkRefusal(runStore, taskId, safe);
+        acceptance?.settle(safe);
+        recordDone(safe, settledAsCancel ? CANCELLED_CODE : plane.status);
     };
     const instructionLeg = createInstructionSelectionLeg();
     const sink = createLedgerSink({ appendEvent: (seq, type, data) => runStore.appendEvent(taskId, seq, type, data), persistThinking, notifiedKeys, onActivity: (kind, statusData) => recordTurnActivity(taskId, kind, statusData), legSections: () => ({ instructions: instructionLeg.segment(), skills: runSkillsOf(spec) }) });
@@ -419,32 +445,18 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     void sink.appendStatus(e).catch((err) => completionDiagLog?.("status_event_append_failed", { route: "bg-run-composite", taskId, err: err instanceof Error ? err.message : String(err) }));
                 },
             };
-            if (verify !== undefined) {
-                const result = await runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, { ...fwdInternals, ...statusSeat });
-                await flush();
-                await flushPromptManifest();
-                const safe = await withModelUsage(sealResultForExit(result));
-                await append("done", { result: safe });
-                reached = { kind: "done", result: safe };
-                const plane = outwardPlane(safe.terminal);
-                await runStore.setTerminal(taskId, plane.status, safe, plane.errorMessage ?? null);
-                await releaseKeyIfZeroWorkRefusal(runStore, taskId, safe);
-                acceptance?.settle(safe);
-                recordDone(safe, plane.status);
-                return;
-            }
-            if (cascade !== undefined) {
-                const result = await runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, { ...fwdInternals, ...statusSeat });
+            const compositeLeg = verify !== undefined
+                ? () => runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, { ...fwdInternals, ...statusSeat })
+                : cascade !== undefined
+                    ? () => runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, { ...fwdInternals, ...statusSeat })
+                    : undefined;
+            if (compositeLeg !== undefined) {
+                const result = await compositeLeg();
+                observedDone = result;
+                causeAtDone = cancelCtrl.cause();
                 await flush();
                 await flushPromptManifest();
-                const safe = await withModelUsage(sealResultForExit(result));
-                await append("done", { result: safe });
-                reached = { kind: "done", result: safe };
-                const plane = outwardPlane(safe.terminal);
-                await runStore.setTerminal(taskId, plane.status, safe, plane.errorMessage ?? null);
-                await releaseKeyIfZeroWorkRefusal(runStore, taskId, safe);
-                acceptance?.settle(safe);
-                recordDone(safe, plane.status);
+                await settleLegResult(result);
                 return;
             }
             const stream = runner.runTaskStream({ ...spec, taskId, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, undefined, fwdInternals);
@@ -479,33 +491,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 }
                 if (ev.type === "done") {
                     await flush();
-                    const parkStatus = ev.result.terminal.kind === "paused" ? outwardPlane(ev.result.terminal).status : undefined;
-                    if (parkStatus === "suspended") {
-                        const grafted = await graftParkToolCallId(ev.result, parkCheckpointReader);
-                        await sink.appendParked("suspended", grafted);
-                        await flushModelUsage();
-                        const sealed = sealResultForExit(grafted);
-                        reached = { kind: "suspended", result: sealed };
-                        await runStore.setSuspended(taskId, sealed);
-                        metrics?.addGauge("runs_active", -1);
-                        metrics?.inc("tasks_total", { status: "suspended" });
-                        continue;
-                    }
-                    if (parkStatus === "needs_review") {
-                        await parkNeedsReview(ev.result);
-                        continue;
-                    }
-                    {
-                        const settled = causeAtDone !== undefined ? cancelledResult(causeAtDone, ev.result) : ev.result;
-                        settledAsCancel = failureCodeOf(settled.terminal) === CANCELLED_CODE;
-                        const safe = await withModelUsage(sealResultForExit(settled));
-                        await sink.appendDone(safe);
-                        reached = { kind: "done", result: safe };
-                        const plane = outwardPlane(safe.terminal);
-                        await runStore.setTerminal(taskId, plane.status, safe, plane.errorMessage ?? null);
-                        await releaseKeyIfZeroWorkRefusal(runStore, taskId, safe);
-                        recordDone(safe, failureCodeOf(safe.terminal) === CANCELLED_CODE ? CANCELLED_CODE : plane.status);
-                    }
+                    await settleLegResult(ev.result);
                     continue;
                 }
                 await sink.onEvent(ev);
@@ -581,11 +567,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 await releaseKeyIfZeroWorkRefusal(runStore, taskId, reached.result);
                 acceptance?.settle(reached.result);
             }
-            else if (reached?.kind === "suspended") {
-                await runStore.setSuspended(taskId, reached.result);
-            }
-            else if (reached?.kind === "needs_review") {
-                await runStore.setNeedsReview(taskId, reached.result);
+            else if (reached !== undefined) {
+                await parkRowWrite[reached.kind](reached.result);
+                acceptance?.settle(reached.result);
             }
             else if (thrownCancelCause !== undefined && observedDone === undefined) {
                 const c = cancelledResult(thrownCancelCause);
@@ -614,9 +598,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
         }
         if (reached?.kind === "done")
             recordDone(reached.result, failureCodeOf(reached.result.terminal) === CANCELLED_CODE ? CANCELLED_CODE : outwardPlane(reached.result.terminal).status);
-        else if (reached?.kind === "suspended") {
+        else if (reached !== undefined) {
             metrics?.addGauge("runs_active", -1);
-            metrics?.inc("tasks_total", { status: "suspended" });
+            metrics?.inc("tasks_total", { status: reached.kind });
         }
         else if (settledAsCancel) {
             recordDone(null, CANCELLED_CODE);

package/dist/session-incarnation.d.ts

@@ -146,7 +146,7 @@ export declare function carriedRowCells(sessionId: string, prior: {
  */
 export declare const SESSION_META_INCARNATION_COLUMN: {
     readonly name: "incarnation";
-    readonly tidb: "incarnation VARCHAR(64) NOT NULL DEFAULT ''";
+    readonly mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''";
     readonly pg: "incarnation VARCHAR(64) COLLATE \"C\" NOT NULL DEFAULT ''";
 };
 //# sourceMappingURL=session-incarnation.d.ts.map

package/dist/session-incarnation.js

@@ -75,7 +75,7 @@ export function carriedRowCells(sessionId, prior) {
 }
 export const SESSION_META_INCARNATION_COLUMN = {
     name: "incarnation",
-    tidb: "incarnation VARCHAR(64) NOT NULL DEFAULT ''",
+    mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''",
     pg: `incarnation VARCHAR(64) COLLATE "C" NOT NULL DEFAULT ''`,
 };
 //# sourceMappingURL=session-incarnation.js.map

package/dist/session-policy-wire.d.ts

@@ -139,7 +139,7 @@ export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly
  *  · `conflict`(409)—— CAS 输了,重读 `rev` 再来。**码位与状态逐字不变**。
  *  · `loosen_forbidden`(403)—— 非 operator 想放松。**码位与状态逐字不变**。⚠️ 这个词还有**第二个铸点**([ref] B5,
  *    如实登记、未改):PG 后端的 SQL 双生对含 NUL / 孤代理字节的规则拒收时借用了它
- *    (`plugins/session-policy-store-sql.ts` 的 `pgHasUnstorable` 臂)—— 那一形**既非放宽也非越权**,operator 写同样撞上;
+ *    (`stores-sql/session-policy-store-sql.ts` 的 `pgHasUnstorable` 臂)—— 那一形**既非放宽也非越权**,operator 写同样撞上;
  *    core 的闭集里没有「输入不可存」这个词,改码位要先裁定新码与 PUT / 2c 导入两条入口同判(DEBTS [ref] B5)。
  *  · `corrupt`(**500**)—— 店读不出它自己该读的那份字节(记号/行被列外篡改或撕裂,或存着引擎今天的形读法读不出的规则体)。
  *    不是 4xx:调用方没做错任何事,它也改不了这件事;不是 503:重试改不了判(修复路径是**人**去改回或删掉那一行,

package/dist/sql-engine-posture.d.ts

@@ -38,7 +38,7 @@ export declare function sqlPoolsOf(backend: Pick<StoreBackend, "mysqlPool" | "pg
     pgPool: PgPool | undefined;
 };
 /**
- * `ServiceDeps.sqlEngine` 座的**值形**判:`{ dialect: "tidb" | "pg", facts }`,`facts` 是 `null`(池上连接初始化还没成功)或一份引擎事实 —— 判到墙判官 `sqlWallsOf` 读的那几位
+ * `ServiceDeps.sqlEngine` 座的**值形**判:`{ dialect: "mysql" | "pg", facts }`,`facts` 是 `null`(池上连接初始化还没成功)或一份引擎事实 —— 判到墙判官 `sqlWallsOf` 读的那几位
  * (`maxRowBytes` / `maxPacketBytes` 是 `null` 或数,`wallSources` 两位是出处词)。一个函数(7.131.x 的事实读口 `() => facts` 只改了键名)、缺 `facts` 的对象、错方言词都不是它。
  * `facts` 是活读(getter):这里读一次,判的是装配这一刻看得到的那一份。
  */

package/dist/sql-engine-posture.js

@@ -2,7 +2,7 @@ import { mysqlDriver, pgDriver } from "./plugins/sql-driver.js";
 export function sqlPoolsOf(backend) {
     return { mysqlPool: backend?.mysqlPool?.(), pgPool: backend?.pgPool?.() };
 }
-const DIALECT_WORDS = { tidb: true, pg: true };
+const DIALECT_WORDS = { mysql: true, pg: true };
 const WALL_SOURCE_WORDS = { reported: true, assumed: true };
 const isWallBytes = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && v >= 0);
 const isWallSourceWord = (v) => typeof v === "string" && Object.hasOwn(WALL_SOURCE_WORDS, v);

package/dist/{plugins → stores-sql}/background-agent-store-sql.d.ts

@@ -31,8 +31,8 @@
  */
 import type { Pool } from "mysql2/promise";
 import { type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentStore } from "@sema-agent/core";
-import type { PgQueryFn } from "./pg-query.js";
-import { type IndexSpec } from "./ensure-index.js";
+import type { PgQueryFn } from "../plugins/pg-query.js";
+import { type IndexSpec } from "../plugins/ensure-index.js";
 export declare const BACKGROUND_AGENT_TABLE = "background_agent";
 type ReapOpts = {
     maxAgeMs?: number;

package/dist/{plugins → stores-sql}/background-agent-store-sql.js

@@ -1,8 +1,8 @@
 import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, } from "@sema-agent/core";
-import { pgSafeJsonStringify, pgSanitizeText } from "./pg-safe-json.js";
-import { isMysqlDupKeyError } from "./sql-errors.js";
-import { ensureIndexes } from "./ensure-index.js";
-import { createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
+import { pgSafeJsonStringify, pgSanitizeText } from "../plugins/pg-safe-json.js";
+import { isMysqlDupKeyError } from "../plugins/sql-errors.js";
+import { ensureIndexes } from "../plugins/ensure-index.js";
+import { createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, jsonColumnText } from "../plugins/sql-json-column.js";
 import { backgroundAgentNameOf } from "../background-agent-name.js";
 export const BACKGROUND_AGENT_TABLE = "background_agent";
 function summaryCols(dialect) {
@@ -215,7 +215,7 @@ export class TiDBBackgroundAgentStore {
         }
     }
     async get(handle, scope) {
-        const [rows] = (await this.pool.query(`SELECT ${jsonColumnText("tidb", "record_json")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND handle = ?`, [scope, handle]));
+        const [rows] = (await this.pool.query(`SELECT ${jsonColumnText("mysql", "record_json")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND handle = ?`, [scope, handle]));
         return rows.length > 0 ? readRecordColumn(rows[0].record_json, handle) : null;
     }
     async update(handle, scope, record, expect) {
@@ -234,12 +234,12 @@ export class TiDBBackgroundAgentStore {
         return res.affectedRows === 1;
     }
     async listBySession(scope, sessionId, opts) {
-        const [rows] = (await this.pool.query(`SELECT ${summaryCols("tidb")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND (session_anchor = ? OR root_session_id = ?)${opts?.status !== undefined ? " AND status = ?" : ""}
+        const [rows] = (await this.pool.query(`SELECT ${summaryCols("mysql")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND (session_anchor = ? OR root_session_id = ?)${opts?.status !== undefined ? " AND status = ?" : ""}
        ORDER BY spawned_at_ms DESC, handle DESC${limitClause(opts?.limit)}`, opts?.status !== undefined ? [scope, sessionId, sessionId, opts.status] : [scope, sessionId, sessionId]));
         return rows.map(rowToSummary);
     }
     async listByScope(scope, opts) {
-        const [rows] = (await this.pool.query(`SELECT ${summaryCols("tidb")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ?${opts?.status !== undefined ? " AND status = ?" : ""}
+        const [rows] = (await this.pool.query(`SELECT ${summaryCols("mysql")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ?${opts?.status !== undefined ? " AND status = ?" : ""}
        ORDER BY spawned_at_ms DESC, handle DESC${limitClause(opts?.limit)}`, opts?.status !== undefined ? [scope, opts.status] : [scope]));
         return rows.map(rowToSummary);
     }
@@ -252,7 +252,7 @@ export class TiDBBackgroundAgentStore {
             return 0;
         const flipped = new Set();
         if (opts.staleRunningMaxAgeMs !== undefined) {
-            const [stale] = (await this.pool.query(`SELECT handle, ${jsonColumnText("tidb", "record_json")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND status = 'running' AND updated_at_ms < ?`, [scope, now - opts.staleRunningMaxAgeMs]));
+            const [stale] = (await this.pool.query(`SELECT handle, ${jsonColumnText("mysql", "record_json")} FROM ${BACKGROUND_AGENT_TABLE} WHERE scope_key = ? AND status = 'running' AND updated_at_ms < ?`, [scope, now - opts.staleRunningMaxAgeMs]));
             for (const row of stale) {
                 const live = readRecordColumn(row.record_json, String(row.handle));
                 if (await this.update(String(row.handle), scope, flippedForm(live, now), { rev: live.rev }))

package/dist/{plugins → stores-sql}/session-policy-store-sql.d.ts

@@ -1,9 +1,8 @@
 import { type SessionPolicyStore, type SessionPermissionRules, type StoredSessionRules, type SessionRulesRecord, type PutRulesOptions } from "@sema-agent/core";
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type JsonColumnShape } from "./sql-json-column.js";
-import { type SqlDriver } from "./sql-driver.js";
-import type { Logger } from "../observability/logger.js";
+import { type JsonColumnShape } from "../plugins/sql-json-column.js";
+import { type SqlDriver } from "../plugins/sql-driver.js";
 /** `session_policy.policy_key` 的**唯一铸造点**(core 复合键的 sha256)。
  *
  *  🔴 导出而不是让收编腿再抄一份(clay 宪法「schema 单一属主禁复制」):[ref] form b 的身份重绑要
@@ -45,8 +44,11 @@ export type StoredSessionRulesBody = SessionPermissionRules & Pick<StoredSession
  * + 恰好解一次 `decodeJsonColumn` + 折码 `foldJsonColumn`);本店只留「形判据是哪一只」与「坏体折成哪个码」。
  */
 export declare function readSessionRulesBody(body: unknown): JsonColumnShape<StoredSessionRulesBody>;
-/** 本店唯一的日志口:抹除封键那一臂([ref])的点名。缺席 ⇒ 退回 `console.warn`(不静默)。 */
-export type SessionPolicyStoreLogger = Pick<Logger, "warn">;
+/** 本店唯一的日志口:抹除封键那一臂([ref])的点名。缺席 ⇒ 退回 `console.warn`(不静默)。
+ *  结构型,与服务日志口的 `warn` 逐位同形:本目录对服务的观测模块零依赖(目录的可搬性),服务的日志口照样直接交进来。 */
+export type SessionPolicyStoreLogger = {
+    warn(msg: string, fields?: Record<string, unknown>): void;
+};
 /** Dual-dialect durable SessionPolicyStore. See the file header for the dialect-delta ledger. */
 export declare class SqlSessionPolicyStore implements SessionPolicyStore {
     private readonly db;

package/dist/{plugins → stores-sql}/session-policy-store-sql.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { judgeSessionRulesWrite, readSessionRulesShape, SessionPolicyError } from "@sema-agent/core";
-import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
-import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "./sql-json-column.js";
-import { pgHasUnstorable } from "./pg-safe-json.js";
-import { mysqlDriver, pgDriver } from "./sql-driver.js";
-import { isDeadlockError, isDupKeyError } from "./sql-errors.js";
+import { SESSION_RULES_COLUMN } from "../plugins/session-rules-column.js";
+import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "../plugins/sql-json-column.js";
+import { pgHasUnstorable } from "../plugins/pg-safe-json.js";
+import { mysqlDriver, pgDriver } from "../plugins/sql-driver.js";
+import { isDeadlockError, isDupKeyError } from "../plugins/sql-errors.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
 const RETRY_LIMIT = 8;
@@ -63,15 +63,15 @@ export class SqlSessionPolicyStore {
         this.db = db;
         this.logger = logger;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     isDupKey(e) {
         return isDupKeyError(this.db.dialect, e);
     }
     async getRules(sessionId, principal) {
         const key = policyKey(sessionId, principal);
-        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE policy_key = ?` +
+        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, ${jsonColumnText("mysql", RULES)}, rev, gen FROM session_policy WHERE policy_key = ?` +
             " UNION ALL SELECT 'seal', NULL, rev, gen FROM session_policy_rev_mark WHERE policy_key = ? AND rev = ?", `SELECT 'row' AS src, ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1` +
             " UNION ALL SELECT 'seal', NULL, rev, gen FROM session_policy_rev_mark WHERE policy_key = $2 AND rev = $3"), [key, key, SEALED_MARK_REV]);
         if (rows.some((r) => r.src === "seal"))
@@ -82,7 +82,7 @@ export class SqlSessionPolicyStore {
         return rowToStored(row, `for session ${JSON.stringify(sessionId)}`);
     }
     async listBySession(sessionId) {
-        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, principal, ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE session_id = ?` +
+        const { rows } = await this.db.query(this.q(`SELECT 'row' AS src, principal, ${jsonColumnText("mysql", RULES)}, rev, gen FROM session_policy WHERE session_id = ?` +
             " UNION ALL SELECT 'seal', NULL, NULL, rev, gen FROM session_policy_rev_mark WHERE session_id = ? AND rev = ?", `SELECT 'row' AS src, principal, ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE session_id = $1` +
             " UNION ALL SELECT 'seal', NULL, NULL, rev, gen FROM session_policy_rev_mark WHERE session_id = $2 AND rev = $3"), [sessionId, sessionId, SEALED_MARK_REV]);
         if (rows.some((r) => r.src === "seal"))
@@ -95,7 +95,7 @@ export class SqlSessionPolicyStore {
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         return this.retrying(() => this.tx(async (conn) => {
-            const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("tidb", RULES)}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
+            const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("mysql", RULES)}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
             const prior = rows[0] ? rowToStored(rows[0], `for session ${JSON.stringify(sessionId)} (pre-write snapshot)`) : undefined;
             const priorRev = prior?.rev ?? 0;
             if (opts?.expectedRev !== undefined && priorRev !== opts.expectedRev) {
@@ -157,12 +157,12 @@ export class SqlSessionPolicyStore {
                     sealedKeys.push({ policyKey: String(r.policy_key), rev: String(r.rev), gen: String(r.gen) });
                 params.push(String(r.policy_key), sessionId, readable ? counters.rev : SEALED_MARK_REV, readable ? counters.gen + 1 : 0, now);
                 const base = params.length - 5;
-                return this.db.dialect === "tidb" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
+                return this.db.dialect === "mysql" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
             });
             await conn.query(this.q(`INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
                 " ON DUPLICATE KEY UPDATE rev = GREATEST(session_policy_rev_mark.rev, VALUES(rev)), gen = GREATEST(session_policy_rev_mark.gen + 1, VALUES(gen)), erased_at = VALUES(erased_at)", `INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
                 " ON CONFLICT (policy_key) DO UPDATE SET rev = GREATEST(session_policy_rev_mark.rev, EXCLUDED.rev), gen = GREATEST(session_policy_rev_mark.gen + 1, EXCLUDED.gen), erased_at = EXCLUDED.erased_at"), params);
-            const holes = keys.map((_, i) => (this.db.dialect === "tidb" ? "?" : `$${i + 1}`)).join(",");
+            const holes = keys.map((_, i) => (this.db.dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
             await conn.query(`DELETE FROM session_policy WHERE policy_key IN (${holes})`, keys);
             return sealedKeys;
         }));

package/dist/{plugins → stores-sql}/usage-window-store-sql.d.ts

@@ -26,7 +26,7 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import type { UsageWindow, UsageWindowReading, UsageWindowRecord, UsageWindowStore } from "@sema-agent/core";
-import { type JsonColumnShape } from "./sql-json-column.js";
+import { type JsonColumnShape } from "../plugins/sql-json-column.js";
 export declare const USAGE_WINDOW_TABLE = "usage_window";
 /**
  * `usage_window.record` 的**形读者**([ref] 车③a:本店既有的那一份深度判据逐字搬进来,一个字没改判)。

package/dist/{plugins → stores-sql}/usage-window-store-sql.js

@@ -1,5 +1,5 @@
 import { EMPTY_USAGE_WINDOW_RECORD, chargeUsageRecord, readUsageRecord } from "@sema-agent/core";
-import { decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
+import { decodeJsonColumn, foldJsonColumn, jsonColumnText } from "../plugins/sql-json-column.js";
 export const USAGE_WINDOW_TABLE = "usage_window";
 class UsageRecordShapeProblem extends Error {
 }
@@ -84,7 +84,7 @@ export class TiDBUsageWindowStore {
         try {
             await c.beginTransaction();
             await c.query(`INSERT INTO ${USAGE_WINDOW_TABLE} (usage_key, record, updated_at_ms) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE usage_key = usage_key`, [key, JSON.stringify(EMPTY_USAGE_WINDOW_RECORD), at]);
-            const [rows] = (await c.query(`SELECT ${jsonColumnText("tidb", "record")} FROM ${USAGE_WINDOW_TABLE} WHERE usage_key = ? FOR UPDATE`, [key]));
+            const [rows] = (await c.query(`SELECT ${jsonColumnText("mysql", "record")} FROM ${USAGE_WINDOW_TABLE} WHERE usage_key = ? FOR UPDATE`, [key]));
             if (rows.length === 0) {
                 throw new Error(`usage_window row for key "${key}" vanished between ensure and lock — refusing to drop a governance charge`);
             }
@@ -102,7 +102,7 @@ export class TiDBUsageWindowStore {
         }
     }
     async read(key, windows, now) {
-        const [rows] = (await this.pool.query(`SELECT ${jsonColumnText("tidb", "record")} FROM ${USAGE_WINDOW_TABLE} WHERE usage_key = ?`, [key]));
+        const [rows] = (await this.pool.query(`SELECT ${jsonColumnText("mysql", "record")} FROM ${USAGE_WINDOW_TABLE} WHERE usage_key = ?`, [key]));
         const record = rows.length === 0 ? EMPTY_USAGE_WINDOW_RECORD : parseRecord(rows[0].record, key);
         return readUsageRecord(record, windows, now);
     }

package/dist/task-a2a.js

@@ -8,7 +8,7 @@ import { readRequestToolAxes } from "./request-tool-axes.js";
 import { MAX_KEY_ECHO, echoKeyName, keyClosureClause, scanKeyNames } from "./request-key-closure.js";
 import { urlCredentialHeaderExit, urlCredentialRefusalReason } from "./url-credential-refusal.js";
 import { declarationEntryNotObject, declarationIssueFacts, declarationNameIssue, declarationOverCapFacts, declaredName, judgeDeclarationKeys, requestDeclarationRefusal, throwDeclarationRefusal, } from "./request-declaration-refusal.js";
-import { principalHeaderOwnershipIssue } from "./task-mcp.js";
+import { sendHeaderOwnershipIssue } from "./task-mcp.js";
 import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 export const MAX_REQUEST_A2A_PEERS = 32;
 export function a2aInjectionHonored(config) {
@@ -52,6 +52,7 @@ function peerUrlIssue(key) {
         return found === undefined ? undefined : { path: key, reason: urlCredentialRefusalReason(found, urlCredentialHeaderExit(`${at}.headers`)), credential: found };
     };
 }
+const A2A_SEND_HEADER_PATHS = { headers: "headers", principalHeader: "principalHeader" };
 const HEADERS_RESERVED_MEMBER_PATH = "headers.__proto__";
 const PEER_SNAPSHOT = Symbol("a2aPeerSnapshot");
 function openCloneNode(v, ancestors) {
@@ -170,11 +171,9 @@ const A2A_PEER_KEY_JUDGES = {
         const reserved = read.stripped[0];
         return reserved === undefined ? undefined : { path: HEADERS_RESERVED_MEMBER_PATH, reason: reserved.fault };
     },
-    principalHeader: (o) => o.principalHeader === undefined
-        ? undefined
-        : typeof o.principalHeader !== "string"
-            ? { path: "principalHeader", reason: `must be a string (a header name) — got ${describeValueShape(o.principalHeader)}` }
-            : principalHeaderOwnershipIssue(o.principalHeader, "a2a", "principalHeader"),
+    principalHeader: (o) => o.principalHeader !== undefined && typeof o.principalHeader !== "string"
+        ? { path: "principalHeader", reason: `must be a string (a header name) — got ${describeValueShape(o.principalHeader)}` }
+        : sendHeaderOwnershipIssue({ headers: o.headers?.ok === true ? o.headers.record : undefined, principalHeader: o.principalHeader }, "a2a", A2A_SEND_HEADER_PATHS),
     allowSkills: (o) => o.allowSkills === undefined || isStringArray(o.allowSkills)
         ? undefined
         : { path: "allowSkills", reason: `must be an array of strings (omit the key to leave the peer's skills unrestricted) — got ${describeNotStringArray(o.allowSkills)}` },

package/dist/task-mcp.d.ts

@@ -158,7 +158,7 @@ export declare function requestEntryIdentityIssue(entry: unknown): McpIdentityHe
  *     `name` = `isUsableWireName`;`allowTools` / `transport.args` = {@link isStringArray};`transport.env` / `headers` = 契约包读器 {@link readRequestMcpTransport} 的纯数据记录读法;`elicitation` = {@link isElicitationFlag};
  *     `transport` 的硬字段(`kind` / `command` / `url`)与软字段(`args` / `env` / `headers` / `principalHeader`)= {@link readRequestMcpTransport}(读器投影 transport 的那一只函数,门读它报的 `lost`;读器在契约包,本仓只据 `lost[0]` 拒、据 `lost` 在重放腿逐处点名);
  *     读器交回的 http `url` 再问「带不带凭据」= 契约包根的 `findUrlCredential`([ref];拒体另带机读 `field` + `reason`,见 {@link transportUrlCredentialIssue});
- *     http `principalHeader` 再问「这个名有没有别的属主」= 引擎包根的 `headerOwnershipCollision`(见 {@link principalHeaderOwnershipIssue})。
+ *     http 这次发送的头集合(件头 + `principalHeader`)再问「有没有一个头名两个属主」= 引擎包根的 `headerOwnershipCollision`(见 {@link sendHeaderOwnershipIssue})。
  * 于是判官受理的条目,读器({@link normalizeServer})交回的就是申报本身(只差判官自己的合法归一:空容器 / `skillScopeEligible:false` 折成缺席、`toolAxes` 取引擎的拷贝)——
  * 探测口拨的那一份因此就是提交腿会挂的那一份,不另比一遍(另比就是第二只回答者)。唯一按门分的后果是「声明了 `assertionHeader`」这一个事实(本部署不发送断言,
  * 承载、不发送):新提交照挂 + 运维 info,探测口整条拒 —— 判据是同一只谓词 `specWithholdsMcpAssertionHeader`(开关 `MCP_ASSERTION_HEADER_SENT` 假时「声明了」即「被扣下」),不是第二份判法(见 `readMcpProbeBody`)。
@@ -185,14 +185,27 @@ export declare function requestMcpDeclarationRefusal(list: unknown): Declaration
  * 交出去的剔掉 `__proto__` 名成员),server 照挂,运维 warn `mcp_transport_members_dropped` 逐处点名 —— 续跑重放腿不静默丢声明。
  */
 export declare function assertRequestMcpEntries(bodyMcp: unknown): void;
+/** 一次发送从一份声明里带出的头:件头(调用方原样写的名 → 值,由对端座按原字节作答)与身份头名(引擎按主体写值)。 */
+export interface DeclaredSendHeaders {
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    readonly principalHeader?: string | undefined;
+}
 /**
- * `principalHeader` 的**名**有没有别的属主:判官是引擎包根的 `headerOwnershipCollision`(拨号时判同一条的那一只;这里只问身份头这一个名,件头名由引擎在发送时判)——
- * 名(任何大小写)是这一协议的传输自己写的头(MCP:`mcp-session-id` · `mcp-protocol-version` · `content-type` · `accept` · `last-event-id`;A2A 没有),或是引擎的断言头
- * (`connector-assertion`)⇒ 这一台拨号时必被拒,新提交在门上按名拒。原因句只点名**属主的拼写**(引擎固定表里的规范化小写头名),不回显调用方写的原串 / 大小写形(调用方写的恰是小写时,句里的名与所写相同)。
- * 新提交腿上按名 400(MCP 门表的 `transport`、A2A 判官表的 `principalHeader`)。续跑重放腿不 4xx:MCP 的读器不问它 —— 存量体里这一形照挂,由引擎在拨号时拒那一台、兄弟照挂;
- * A2A 的读器问同一张判官表 —— 这一条对端整条不进、`a2a_injection_dropped` 点名原因(引擎物化时同样拒那一台;结局同,原因说在本仓这一行)。
+ * 一次发送的**头属主** —— 一条规则:这次发送会带的头集合(件头 + 身份头名)只有一只属主判官,引擎包根的 `headerOwnershipCollision`(引擎每次发送时判同一组的那一只);
+ * 受理口用**全部**问它一次。MCP 与 A2A 两座都调这一只:MCP 门表的 `transport` 格,A2A 判官表的 `principalHeader` 格(两键里判序靠后的那一格,读两键的读数)。
+ * 判官答撞 ⇒ 这一台拨号即拒(`config.protocol_header_collision`)或此后每一次发送都被拒(`credential_unavailable`)⇒ 新提交在门上按格 400:
+ *  · 身份头名本身是这一协议的传输自己写的头(MCP:`mcp-session-id` · `mcp-protocol-version` · `content-type` · `accept` · `last-event-id`,任何大小写;A2A 没有),或是引擎的断言头
+ *    (`connector-assertion`)⇒ `paths.principalHeader`;
+ *  · 件头名是传输自己写的头 ⇒ `paths.headers`;件里同一头名两个拼写、件头名撞身份头名 ⇒ `paths.headers`。
+ * 件里名叫 `connector-assertion` 的头不撞(断言头在件里是座的;引擎只在它作身份头名时保留这个名)。原因句只点名**规范化小写**的头名(属主拼写,或调用方所写名字的小写形、经回显清洗),
+ * 不回显调用方的大小写形,从不带值。
+ * 不在本规则里的件形 —— 件值字节(CR / LF / NUL)、头名不是 HTTP token、stdio 变量名 —— 只由引擎内部的答案读器判(包根不导出),受理口没有同一只判官可问,照旧运行期 `credential_unavailable`。
+ * 续跑重放腿不 4xx:MCP 的读器不问门表 —— 存量体里撞属主的那一台照挂,由引擎拨号 / 发送时拒、兄弟照挂;A2A 的读器问同一张判官表 —— 这一条对端整条不进、`a2a_injection_dropped` 点名原因。
  */
-export declare function principalHeaderOwnershipIssue(principalHeader: string | undefined, protocol: "mcp" | "a2a", path: string): DeclarationKeyIssue | undefined;
+export declare function sendHeaderOwnershipIssue(send: DeclaredSendHeaders, protocol: "mcp" | "a2a", paths: {
+    readonly headers: string;
+    readonly principalHeader: string;
+}): DeclarationKeyIssue | undefined;
 /**
  * The ONE predicate for "this MCP server name belongs to the deployment": the scenario baseline (what mounted for
  * this scenario) ∪ every name the deployment DECLARED (`CenterMcp.reservedNames` — mounted or not, any scenario).

package/dist/task-mcp.js

@@ -171,17 +171,25 @@ function transportUrlCredentialIssue(url) {
         return undefined;
     return { path: "transport.url", reason: urlCredentialRefusalReason(found, urlCredentialHeaderExit("transport.headers")), credential: found };
 }
-export function principalHeaderOwnershipIssue(principalHeader, protocol, path) {
-    if (principalHeader === undefined)
-        return undefined;
-    const collision = headerOwnershipCollision({ principalHeader }, protocol);
+export function sendHeaderOwnershipIssue(send, protocol, paths) {
+    const collision = headerOwnershipCollision({ headers: send.headers === undefined ? undefined : { ...send.headers }, principalHeader: send.principalHeader }, protocol);
     if (collision === undefined)
         return undefined;
-    return {
-        path,
-        reason: `names the header "${collision.first}" (header names are case-insensitive), which is not the principal header's to own — it is ${protocol === "mcp" && collision.first !== MCP_ASSERTION_HEADER ? "a header the MCP transport writes itself" : "the engine's connector assertion header"}; name the principal header something of its own`,
-    };
+    if (collision.engineOwned) {
+        const owner = echoKeyName("", collision.first);
+        const ownedBy = collision.first === MCP_ASSERTION_HEADER ? "the engine's connector assertion header" : "a header the MCP transport writes itself";
+        if (collision.second === send.principalHeader) {
+            return { path: paths.principalHeader, reason: `names the header "${owner}" (header names are case-insensitive), which is not the principal header's to own — it is ${ownedBy}; name the principal header something of its own` };
+        }
+        return { path: paths.headers, reason: `carries the header "${owner}" (header names are case-insensitive), which is not this declaration's to send — it is ${ownedBy}; leave it out` };
+    }
+    const name = echoKeyName("", collision.first.toLowerCase());
+    if (collision.first === send.principalHeader || collision.second === send.principalHeader) {
+        return { path: paths.headers, reason: `carries a header named as the principal header "${name}" (header names are case-insensitive) — the engine writes the principal under that name; rename one of them` };
+    }
+    return { path: paths.headers, reason: `carries the header "${name}" under two spellings (header names are case-insensitive) — one send carries one value per header name; keep one` };
 }
+const MCP_SEND_HEADER_PATHS = { headers: "transport.headers", principalHeader: "transport.principalHeader" };
 const ENTRY_KEY_JUDGES = {
     allowTools: (o) => o.allowTools === undefined || isStringArray(o.allowTools)
         ? undefined
@@ -231,7 +239,7 @@ const ENTRY_KEY_JUDGES = {
             return read.lost[0];
         if (read.transport.kind !== "http")
             return undefined;
-        return transportUrlCredentialIssue(read.transport.url) ?? principalHeaderOwnershipIssue(read.transport.principalHeader, "mcp", "transport.principalHeader");
+        return transportUrlCredentialIssue(read.transport.url) ?? sendHeaderOwnershipIssue({ headers: read.transport.headers, principalHeader: read.transport.principalHeader }, "mcp", MCP_SEND_HEADER_PATHS);
     },
 };
 function requestEntryRefusal(entry, at) {

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/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` 并跑比对;
  * 折入本身与整表重建的对拍是那个测试文件里的一份测试本地参照)。