@sema-agent/server 7.145.0 → 7.147.0

package/dist/plugins/file-run-store.js

@@ -2,13 +2,13 @@ import { redactErrorMessage, redactLedgerEventData, sealRunRowResult } from "../
 import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, sanitizePathComponent, sanitizeScope, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 import { joinFromStore, splitForStore } from "./wiring-section-codec.js";
-import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { readRunIdentityCells, runIdentityCells } from "../identity-source.js";
 import { createInProcessSpaceCommitTable, fenceSpaceCommitAtTerminal, SPACE_COMMIT_RECORD_SCHEMA } from "../workspace-space-commit.js";
@@ -58,6 +58,9 @@ const PARK_ORPHAN_SETTLE_MS = 30_000;
 export class RunStoreStrictHydrateError extends StoreBootRefusalError {
     name = "RunStoreStrictHydrateError";
 }
+export function fileRunStoreDirsFor(root) {
+    return { runs: join(root, "runs"), active: join(root, "runs", "active"), tmp: join(root, "tmp"), spaceCommits: join(root, "space-commits") };
+}
 export class FileRunStore {
     runsDir;
     activeDir;
@@ -81,15 +84,16 @@ export class FileRunStore {
     constructor(root, opts) {
         this.logger = opts;
         this.strictHydrate = opts?.strictHydrate === true;
-        this.runsDir = join(root, "runs");
-        this.activeDir = join(root, "runs", "active");
-        this.tmpDir = join(root, "tmp");
+        const dirs = fileRunStoreDirsFor(root);
+        this.runsDir = dirs.runs;
+        this.activeDir = dirs.active;
+        this.tmpDir = dirs.tmp;
         this.blobsDir = join(root, "run-blobs");
-        this.spaceCommitsDir = join(root, "space-commits");
+        this.spaceCommitsDir = dirs.spaceCommits;
         this.spaceCommits = createInProcessSpaceCommitTable({
             load: (spaceKey) => this.loadSpaceCommit(spaceKey),
             save: (record) => {
-                mkdirSync(this.spaceCommitsDir, { recursive: true });
+                ensureDir(this.spaceCommitsDir);
                 atomicWriteFile(this.tmpDir, this.spaceCommitPath(record.spaceKey), `${JSON.stringify(record)}\n`);
             },
             remove: (spaceKey) => rmSync(this.spaceCommitPath(spaceKey), { force: true }),
@@ -353,17 +357,21 @@ export class FileRunStore {
         }
     }
     writeRunFile(r) {
-        mkdirSync(this.runDir(r.taskId), { recursive: true });
+        ensureDir(this.runDir(r.taskId));
         atomicWriteFile(this.tmpDir, this.runJsonPath(r.taskId), `${JSON.stringify(this.toDisk(r))}\n`);
     }
-    persist(r) {
-        this.writeRunFile(r);
-        this.runs.set(r.taskId, r);
+    persist(draft) {
+        this.writeRunFile(draft);
+        const live = this.runs.get(draft.taskId);
+        if (live === undefined)
+            this.runs.set(draft.taskId, draft);
+        else
+            Object.assign(live, draft);
     }
     eventLogFor(taskId) {
         let log = this.eventLogs.get(taskId);
         if (!log) {
-            mkdirSync(this.runDir(taskId), { recursive: true });
+            ensureDir(this.runDir(taskId));
             log = new AppendLog(this.eventsPath(taskId));
             this.eventLogs.set(taskId, log);
         }
@@ -434,15 +442,13 @@ export class FileRunStore {
         const r = this.runs.get(taskId);
         if (!r || r.objectivePreview !== null)
             return;
-        this.writeRunFile({ ...r, objectivePreview: preview });
-        r.objectivePreview = preview;
+        this.persist({ ...r, objectivePreview: preview });
     }
     async requestCancel(taskId, owner) {
         const r = this.runs.get(taskId);
         if (!r || !ownerEq(r.owner, owner) || r.status !== "running")
             return false;
-        r.cancelRequested = true;
-        this.persist(r);
+        this.persist({ ...r, cancelRequested: true });
         return true;
     }
     async isCancelRequested(taskId, owner) {
@@ -453,8 +459,7 @@ export class FileRunStore {
         const r = this.runs.get(taskId);
         if (!r || !ownerEq(r.owner, owner) || r.status !== "running")
             return false;
-        r.preemptRequested = true;
-        this.persist(r);
+        this.persist({ ...r, preemptRequested: true });
         return true;
     }
     async isPreemptRequested(taskId, owner) {
@@ -463,10 +468,8 @@ export class FileRunStore {
     }
     async heartbeat(taskId, owner) {
         const r = this.runs.get(taskId);
-        if (r && ownerEq(r.owner, owner) && r.status === "running") {
-            r.updatedAt = new Date();
-            this.persist(r);
-        }
+        if (r && ownerEq(r.owner, owner) && r.status === "running")
+            this.persist({ ...r, updatedAt: new Date() });
     }
     async appendEvent(taskId, seq, type, data) {
         data = redactLedgerEventData(type, data);
@@ -569,12 +572,8 @@ export class FileRunStore {
         }
         let pending;
         if (r.status === "running" || r.status === "suspended" || r.status === "needs_review") {
-            r.status = status;
-            r.result = result;
-            r.error = error;
-            r.errorCode = result === null ? null : (outwardPlane(result.terminal).errorCode ?? null);
-            r.updatedAt = new Date();
-            this.persist(r);
+            const errorCode = result === null ? null : (outwardPlane(result.terminal).errorCode ?? null);
+            this.persist({ ...r, status, result, error, errorCode, updatedAt: new Date() });
             pending = {
                 runId: taskId,
                 sessionId: r.sessionId,
@@ -582,7 +581,7 @@ export class FileRunStore {
                 status,
                 resultTaskId: result?.taskId,
                 model: result?.model,
-                errorCode: r.errorCode ?? undefined,
+                errorCode: errorCode ?? undefined,
                 errorMessage: (result === null ? undefined : outwardPlane(result.terminal).errorMessage) ?? error ?? undefined,
                 elapsedMs: Math.max(0, Date.now() - r.createdAt.getTime()),
             };
@@ -597,33 +596,29 @@ export class FileRunStore {
         const sealed = sealRunRowResult(result);
         const r = this.runs.get(taskId);
         if (r && (r.status === "running" || r.status === "suspended")) {
-            r.status = "suspended";
-            r.result = sealed;
-            r.updatedAt = new Date();
-            this.persist(r);
+            this.persist({ ...r, status: "suspended", result: sealed, updatedAt: new Date() });
         }
     }
     async setNeedsReview(taskId, result) {
         const sealed = sealRunRowResult(result);
         const r = this.runs.get(taskId);
         if (r && (r.status === "running" || r.status === "needs_review")) {
-            r.status = "needs_review";
-            r.result = sealed;
-            r.updatedAt = new Date();
-            this.persist(r);
+            this.persist({ ...r, status: "needs_review", result: sealed, updatedAt: new Date() });
         }
     }
     async markResuming(taskId, instanceId) {
         const r = this.runs.get(taskId);
         if (!r || (r.status !== "suspended" && r.status !== "needs_review"))
             return false;
-        r.status = "running";
-        r.result = null;
-        r.instanceId = instanceId;
-        r.cancelRequested = false;
-        r.preemptRequested = false;
-        r.updatedAt = new Date();
-        this.persist(r);
+        this.persist({
+            ...r,
+            status: "running",
+            result: null,
+            instanceId,
+            cancelRequested: false,
+            preemptRequested: false,
+            updatedAt: new Date(),
+        });
         return true;
     }
     async getActiveTaskId(sessionId) {
@@ -633,8 +628,7 @@ export class FileRunStore {
         const r = this.runs.get(taskId);
         if (this.active.get(sessionId) !== taskId || r === undefined || r.status !== "running")
             return false;
-        r.updatedAt = new Date();
-        this.persist(r);
+        this.persist({ ...r, updatedAt: new Date() });
         write({ instanceId: r.instanceId });
         return true;
     }
@@ -806,12 +800,14 @@ export class FileRunStore {
         let reaped = 0;
         for (const r of this.runs.values()) {
             if (r.status === "running" && pred(r)) {
-                r.status = "failed";
-                r.result = null;
-                r.error = reason;
-                r.errorCode = code;
-                r.updatedAt = new Date();
-                this.persist(r);
+                this.persist({
+                    ...r,
+                    status: "failed",
+                    result: null,
+                    error: reason,
+                    errorCode: code,
+                    updatedAt: new Date(),
+                });
                 reaped += 1;
             }
         }
@@ -829,12 +825,14 @@ export class FileRunStore {
                 orphans.push(r);
         }
         for (const r of orphans) {
-            r.status = "failed";
-            r.result = null;
-            r.error = RUN_ORPHANED_ERROR;
-            r.errorCode = RUN_HOLDER_DEATH_CODES.orphaned;
-            r.updatedAt = new Date();
-            this.persist(r);
+            this.persist({
+                ...r,
+                status: "failed",
+                result: null,
+                error: RUN_ORPHANED_ERROR,
+                errorCode: RUN_HOLDER_DEATH_CODES.orphaned,
+                updatedAt: new Date(),
+            });
         }
         this.sweepClaims();
         return orphans.length;
@@ -843,12 +841,14 @@ export class FileRunStore {
         this.checkpointProbe = probe;
     }
     failExpiredPark(r) {
-        r.status = "failed";
-        r.result = null;
-        r.error = "approval expired before decision";
-        r.errorCode = "approval.expired";
-        r.updatedAt = new Date();
-        this.persist(r);
+        this.persist({
+            ...r,
+            status: "failed",
+            result: null,
+            error: "approval expired before decision",
+            errorCode: "approval.expired",
+            updatedAt: new Date(),
+        });
     }
     async reapSuspended(olderThanMs) {
         const probe = this.checkpointProbe;
@@ -1107,17 +1107,6 @@ export class FileRunStore {
             }
         }
     }
-    migrateLegacyHolderDeathCodes() {
-        let migrated = 0;
-        for (const r of this.runs.values()) {
-            const code = readLegacyHolderDeathCode(r);
-            if (code === null || r.errorCode === code)
-                continue;
-            this.persist({ ...r, errorCode: code });
-            migrated += 1;
-        }
-        return migrated;
-    }
     sessionIdsWithRuns() {
         return new Set([...this.runs.values()].map((r) => r.sessionId));
     }

package/dist/plugins/fork-routing-session-store.d.ts

@@ -34,7 +34,7 @@
  */
 import { type SessionStore, type AcquiredSession, type SessionHead, type SessionStoreSummary, type SessionPlacement, type PlacedSessionRow } from "@sema-agent/core";
 import type { ExecutionPlacementSeat } from "../execution-placement.js";
-import type { ForkToFn } from "./session-fork.js";
+import type { ForkPlacement, ForkToFn } from "./session-fork.js";
 /** acquire 选项形(core 5.48 SessionStore 契约):[ref] placement=受信 spawner 的分区建会话声明。 */
 type AcquireOpts = {
     requireExisting?: boolean;
@@ -86,7 +86,11 @@ export declare class ForkRoutingSessionStore implements SessionStore {
     unpin(sessionId: string): void | Promise<void>;
     noteTaskRun(sessionId: string, taskId: string, runId?: string): void | Promise<void>;
     list(): Promise<SessionStoreSummary[]>;
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    /** `opts.placement`(后台 fork 子代的转录进委派分区)原样交给做这次 fork 的那只店 —— 落不落由那只店的声明判(host 声明了分区就落;瞬态店不声明 ⇒ 忽略),
+     *  本类不判第二次(声明面从 host 逐字转发,引擎据它决定交不交元组)。 */
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     get size(): number;
     dispose(): void | Promise<void>;
 }

package/dist/plugins/fork-routing-session-store.js

@@ -191,10 +191,10 @@ export class ForkRoutingSessionStore {
     list() {
         return this.transient.list?.() ?? Promise.resolve([]);
     }
-    async fork(sourceId, owner) {
+    async fork(sourceId, owner, opts) {
         const routed = this.route.get(sourceId);
         const tryFork = async (store, where) => {
-            const forked = (await store.fork?.(sourceId, owner)) ?? null;
+            const forked = (await store.fork?.(sourceId, owner, opts)) ?? null;
             if (forked !== null) {
                 this.remember(sourceId, where);
                 this.remember(forked, where);

package/dist/plugins/imported-layer-root-retirement.d.ts

@@ -16,9 +16,12 @@
  * 一律问**店**:它能叫出名字的每一只桶,判据在桶里判(不在桶外按「谁可能有」预筛)。
  *  · SQL:规则表里的每一只桶(`listRuleBucketOwners`,按 `owner_key` 分页)。不从审批记录推 —— 收编把规则桶整桶改键到新身份、审批史留在旧身份名下,
  *    从记录推出的属主集在收编之后漏掉新桶。
- *  · File:引擎的 File 分区后端**没有**列桶口(桶文件按属主名的单向摘要命名),本步能叫出名字的只有本店导入记录点名过的属主
- *    (`FileRuleApprovalRecordStore.importRecordOwners`;`imported-cc` 只由导入记录派生,记录是只增日志)。**已知缺口(如实)**:引擎的本地数据根收编
- *    把一只桶改名到一个没有任何导入记录点名的身份之后,那只桶本步叫不出、不读 —— 等引擎给 File 分区后端一个列桶口再收。
+ *  · File:引擎 File 分区后端的列桶口一次答(`FileDurableRulePartitionProvider.listBucketOwners({ knownOwners })`):目录自己叫得出名字的属主(本机属主那只桶、
+ *    收编标记点名的身份 —— 收编把桶改名到一个没有任何导入记录点名的身份之后,那只桶照样被叫出来、被读),加上本店导入记录点名过的身份里桶文件在场的那些
+ *    (`knownOwners` = `FileRuleApprovalRecordStore.importRecordOwners` 的身份名;`imported-cc` 只由导入记录派生,记录是只增日志;桶名由引擎的那一只摘要算,本仓不算)。
+ *    **两者都叫不出属主的桶**(桶文件按属主名的单向摘要命名)本步读不到 —— 引擎在同一次答里给出它们的个数(`unnamedBuckets`),本步原样记进报告
+ *    (`importedLayerRootBucketsUnnamed`),非零每次起服 warn 一行;它不是「空」,是本步的普查缺了这么多只。
+ *  一种店一个来源、一次答 ⇒ 属主不重(引擎:同名给两次、或收编标记也点了它,是一个属主;SQL:按 `owner_key` 分页,键唯一)。
  *
  * ## 写在哪里(一处)
  * 墓碑经**这只桶自己的写面**落(`writerOf(partition).apply({ kind: "tighten-delete" })`,引擎的写面契约)—— SQL 两孪生走 `SqlDurableRulePartition` 的那只
@@ -30,10 +33,11 @@
  * 列桶 / 解析桶 / 读桶 / 取点 / 写面**抛** ⇒ 原样抛:起服拒,收据账里已提交的墓碑随拒因交出(与本段其余各步同一条路)。例外两条,都由店的判官按抛出物的**类**判(不按文案):
  * 取点时店说这只桶**在写它的那一步里没了**(`source.isVanishedBucket`:另一只副本删桶恰落在这一窗)⇒ 无可退役、点名跳过 `vanished`(桶都没了,它什么都不放行);
  * 另一条是解析桶(属主 → 分区)或读桶时**店的唯一判官整桶拒**了
- * 这只桶(解析与读同一条律、同一只判官;`source.isWholeBucketRefusal`:确定性判决,引擎读侧对它同样整桶拒、它什么都不放行;SQL = 读腿真往外交的那两类 —— 判官四道的拒与某只 JSON 列的体读不出)
- * ⇒ 点名跳过 `bucket_unreadable`,接着读下一只桶(一只读不出的桶不挡别的桶,也不挡起服);一次读失败(连接 / 超时)
- * 证明不了以后也读不出,所以它**不**归这一类 —— 跳过它就是让那几行在读恢复之后照旧放行。File 店没有这种判决证据(引擎的 File 分区对损坏与 I/O 失败抛同一种错,
- * 解析时读收编标记也是:一次 EIO 与一份坏标记同一种错)⇒ 那一侧解析 / 读桶抛一律起服拒。另两种店**答了**却做不了的(没有写面或写面拒 / 并发争不过)⇒ 点名跳过,下一次起服再试,其间那几行照旧放行,每次起服都点名。
+ * 这只桶(解析与读同一条律、同一只判官;`source.isWholeBucketRefusal`:确定性判决,引擎读侧对它同样整桶拒、它什么都不放行;SQL = 读腿真往外交的那两类 —— 判官四道的拒与某只 JSON 列的体读不出;
+ * File = 引擎 File 分区的拒码 `permission_rules.bucket_damaged`〔同一份字节每次读都同样拒〕)
+ * ⇒ 点名跳过 `bucket_unreadable`,接着读下一只桶(一只读不出的桶不挡别的桶,也不挡起服);一次读失败(连接 / 超时;File 的拒码 `permission_rules.bucket_unreadable`,
+ * 带系统错名 `errno`)证明不了以后也读不出,所以它**不**归这一类 —— 跳过它就是让那几行在读恢复之后照旧放行。File 解析时读收编标记的拒(标记自己的拒,不带桶拒码)同样不归这一类 ⇒ 起服拒。
+ * 另两种店**答了**却做不了的(没有写面或写面拒 / 并发争不过)⇒ 点名跳过,下一次起服再试,其间那几行照旧放行,每次起服都点名。
  */
 import { type DurableRulePartitionProvider, type PersistedRule, type RuleAdd, type RuleOwner } from "@sema-agent/core";
 /** 一只被退役的导入 add 所在的行(一行一条读数)。**不带规则正文**(与 M11 同一条纪律:规则正文不出店)—— 桶键 + 工具名足够让运维去列举面对上它。 */
@@ -61,14 +65,21 @@ export interface ImportedLayerRootBucketSkipped {
      *  原句由店自己的披露口说,File 店的 `permission_rule_store_disclosure`、SQL 店的整桶拒句);写面拒的是闭集词,原样带。 */
     readonly why: string;
 }
-/** 本步记进收据账的两格(`OneTimeMigrationReport` 的两只键,随提交追加)。 */
+/** 本步记进收据账的三格(`OneTimeMigrationReport` 的三只键;前两格随提交追加,第三格在列桶那一刻落定)。 */
 export interface ImportedLayerRootReadings {
     importedLayerRootAllowsRetired: ImportedLayerRootAllowRetired[];
     importedLayerRootBucketsSkipped: ImportedLayerRootBucketSkipped[];
+    /** 店在场却叫不出属主、本步因此没读的桶数(见头注「读哪些桶」;SQL 恒 0)。 */
+    importedLayerRootBucketsUnnamed: number;
 }
-/** 一种店交给本步的三样东西:它能叫出名字的桶的属主(见头注「读哪些桶」)、它的 durable 分区后端(读桶、写墓碑)、它的整桶拒判别(见头注「失败方向」)。 */
+/** 一种店的桶普查(一次答):叫得出名字的属主,与在场却叫不出名字的桶数。 */
+export interface RuleBucketCensus {
+    readonly owners: readonly RuleOwner[];
+    readonly unnamedBuckets: number;
+}
+/** 一种店交给本步的三样东西:它的桶普查(见头注「读哪些桶」)、它的 durable 分区后端(读桶、写墓碑)、它的整桶拒判别(见头注「失败方向」)。 */
 export interface ImportedLayerRootRetirementSource {
-    candidateOwners(): Promise<readonly RuleOwner[]>;
+    candidateOwners(): Promise<RuleBucketCensus>;
     readonly durable: DurableRulePartitionProvider;
     /** 这只读桶抛出物是不是店的唯一判官的**确定性**整桶拒(真 ⇒ 点名跳过、读下一只桶;假 ⇒ 原样抛、起服拒)。判的是读面**真往外交的**抛出物的类,不按文案。 */
     isWholeBucketRefusal(e: unknown): boolean;
@@ -77,6 +88,6 @@ export interface ImportedLayerRootRetirementSource {
 }
 /** 判据(引擎 §5.14 那一句,逐字):这一行里该退役的 add;不选 ⇒ 空。 */
 export declare function importedLayerRootAddsOf(row: PersistedRule): readonly RuleAdd[];
-/** 跑一遍:读记录点名的每只桶(按桶键去重),退役判据选中的 add。读数随每次提交记进 `into`。 */
+/** 跑一遍:读店叫得出名字的每只桶(`candidateOwners()` 一次答,见头注「读哪些桶」),退役判据选中的 add;叫不出名字的桶数记进 `into`。读数随每次提交记进 `into`。 */
 export declare function retireImportedLayerRootAllows(source: ImportedLayerRootRetirementSource, into: ImportedLayerRootReadings): Promise<void>;
 //# sourceMappingURL=imported-layer-root-retirement.d.ts.map

package/dist/plugins/imported-layer-root-retirement.js

@@ -7,14 +7,10 @@ export function importedLayerRootAddsOf(row) {
     return row.adds.filter((a) => a.origin === "imported-cc");
 }
 export async function retireImportedLayerRootAllows(source, into) {
-    const seen = new Set();
-    for (const owner of await source.candidateOwners()) {
-        const ownerKey = buildRuleOwnerKey(owner);
-        if (seen.has(ownerKey))
-            continue;
-        seen.add(ownerKey);
-        await retireInBucket(source, owner, ownerKey, into);
-    }
+    const census = await source.candidateOwners();
+    into.importedLayerRootBucketsUnnamed = census.unnamedBuckets;
+    for (const owner of census.owners)
+        await retireInBucket(source, owner, buildRuleOwnerKey(owner), into);
 }
 async function retireInBucket(source, owner, ownerKey, into) {
     const durable = source.durable;

package/dist/plugins/inbox-payload-column.d.ts

@@ -0,0 +1,14 @@
+/** 两方言的列类型词(键表对 {@link SqlDialect} 闭合:加一种方言 ⇒ 编译红)。 */
+export declare const INBOX_PAYLOAD_COLUMN_TYPE: {
+    readonly mysql: "TEXT";
+    readonly pg: "TEXT";
+};
+/** 列定义(两方言 DDL 内插;存量库缺列由起服列册对账拒启,拒句里的 ALTER 由建表语句生成)。 */
+export declare const INBOX_PAYLOAD_COLUMN: {
+    readonly name: "payload";
+    readonly mysql: "payload TEXT NULL";
+    readonly pg: "payload TEXT COLLATE \"C\"";
+};
+/** 收件条目 `payload` 的字节预算(UTF-8 字节,量最终 JSON)= 各方言 `payload` 列容量的最小值。 */
+export declare const INBOX_PAYLOAD_MAX_BYTES: number;
+//# sourceMappingURL=inbox-payload-column.d.ts.map

package/dist/plugins/inbox-payload-column.js

@@ -0,0 +1,13 @@
+import { TEXT_COLUMN_TYPE_MAX_BYTES } from "./text-column-capacity.js";
+export const INBOX_PAYLOAD_COLUMN_TYPE = { mysql: "TEXT", pg: "TEXT" };
+export const INBOX_PAYLOAD_COLUMN = {
+    name: "payload",
+    mysql: `payload ${INBOX_PAYLOAD_COLUMN_TYPE.mysql} NULL`,
+    pg: `payload ${INBOX_PAYLOAD_COLUMN_TYPE.pg} COLLATE "C"`,
+};
+const INBOX_PAYLOAD_COLUMN_MAX_BYTES = {
+    mysql: TEXT_COLUMN_TYPE_MAX_BYTES.mysql[INBOX_PAYLOAD_COLUMN_TYPE.mysql],
+    pg: TEXT_COLUMN_TYPE_MAX_BYTES.pg[INBOX_PAYLOAD_COLUMN_TYPE.pg],
+};
+export const INBOX_PAYLOAD_MAX_BYTES = Math.min(...Object.values(INBOX_PAYLOAD_COLUMN_MAX_BYTES));
+//# sourceMappingURL=inbox-payload-column.js.map

package/dist/plugins/local-checkpoint-store.d.ts

@@ -1,5 +1,5 @@
 import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
 import { type FencedRun, type InProcessClaimFence } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 export interface LocalCheckpointStoreOptions {
@@ -11,6 +11,11 @@ export interface LocalCheckpointStoreOptions {
     /** ctx 改写的认领栅栏({@link LocalCheckpointStore.rewriteCtxWhileClaimed}):同一数据根上的文件 run 店(进程内栅栏形)。缺席 ⇒ 那一口响亮抛(装配缺陷)。 */
     claims?: InProcessClaimFence;
 }
+/** checkpoint 店在数据根下自己铸的目录(构造器与一次性迁移 M39 的名册同读这一只)。 */
+export declare function localCheckpointStoreDirsFor(root: string): {
+    readonly ctx: string;
+    readonly tmp: string;
+};
 export declare class LocalCheckpointStore {
     /** [ref] 车1:托管留存声明 —— **诚实的 none**(与 local session 店同一条判据:本店的行没有按期删除的腿;
      *  留存三方法只实现在 SQL 聚合店上)。locked policy + 本店 ⇒ core 的门拒启,那是契约的正确行为。 */
@@ -221,7 +226,7 @@ export declare class LocalCheckpointStore {
      */
     rewriteCtxWhileClaimed(sessionId: string, taskId: string, ctx: SealedCheckpointCtx, legHolds: (run: FencedRun) => boolean): Promise<CtxClaimRewrite>;
     /**
-     * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
+     * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-face.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
      * 逐档读(信封经读腿**同一只**判形 —— 读不出 ⇒ 计数、跳过、**不删**),`rewrite` 交回新体 ⇒ 信封原样(`sessionId` / `updatedAt` 不动:收割按 `updatedAt` 判)
      * 只换 `ctx`,经写腿同一只形闸、同一只原子写落回原档。封签绑的是信封里的 `sessionId`(与 `getCtx` 认行的那一格同一个)。
      * 数据根独占 + 起服在任何读写者之前跑 ⇒ 本车道没有并发写者,不需要 CAS;没有一行装不下这回事(`tooLarge` 恒 0)。

package/dist/plugins/local-checkpoint-store.js

@@ -3,13 +3,14 @@ import { denySweepOwns, parkedApprovalCard } from "../approval-content-kind.js";
 import { parkRowFacts, skillCardFacts } from "../approval-card.js";
 import { durableRowIdentity } from "../checkpoint-identity.js";
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
-import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, candidateIdentityOf, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
+import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, ensureDir, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
+import { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
+import { approvalDecisionOfWinner, boundedRuleOffers, boundedToolInput, candidateIdentityOf, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-face.js";
 import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
 import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
-import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
+import { UNMANAGED_RETENTION } from "./retention-declaration.js";
 import { assertJsonColumnWritable, createObjectColumnReader } from "./sql-json-column.js";
 import { FENCE_LANDED } from "./store-contracts.js";
 function terminalAtOf(cp) {
@@ -46,6 +47,9 @@ function refusingCtx(sessionId, read) {
         throw foldJsonColumn(e, (m) => `LocalCheckpointStore: ${m} — refusing rather than serve a resume context nobody can read (session ${JSON.stringify(sessionId)})`);
     }
 }
+export function localCheckpointStoreDirsFor(root) {
+    return { ctx: join(root, "checkpoint-ctx"), tmp: join(root, ".tmp") };
+}
 export class LocalCheckpointStore {
     retention = UNMANAGED_RETENTION;
     durability = "durable";
@@ -64,10 +68,11 @@ export class LocalCheckpointStore {
         this.opts = opts;
         this.scopesPath = join(root, "checkpoint-scopes.json");
         this.sessionTokensPath = join(root, "checkpoint-session-tokens.json");
-        this.ctxDir = join(root, "checkpoint-ctx");
-        this.tmpDir = join(root, ".tmp");
-        mkdirSync(this.ctxDir, { recursive: true });
-        mkdirSync(this.tmpDir, { recursive: true });
+        const dirs = localCheckpointStoreDirsFor(root);
+        this.ctxDir = dirs.ctx;
+        this.tmpDir = dirs.tmp;
+        ensureDir(this.ctxDir);
+        ensureDir(this.tmpDir);
         if (existsSync(this.scopesPath)) {
             try {
                 for (const s of decodeJsonColumn(readFileSync(this.scopesPath, "utf8"), readScopeRegistry, "checkpoint-scopes.json (the local scope registry)"))

package/dist/plugins/local-data-dir-modes-m39.d.ts

@@ -0,0 +1,48 @@
+/** 披露码:路径(含数据根自身、名册目录的子项)经符号链接 —— 不跟,这一条不走(「不在根内」一类,不按链接指向哪里特判)。 */
+export declare const SYMLINK_IN_PATH = "SYMLINK_IN_PATH";
+/**
+ * 本迁移看的两只根:数据根(`LocalBackend` 持锁的那一只物理路径 —— core `resolveDataRoot` 的 `physicalPathOf` 拼写 = 店构造时拿到的值;身份核拿它当「根内」的唯一判据,
+ * 不是物理拼写的值 ⇒ 每一只目录都过不了核、逐个进披露行)与记忆引擎根(boot 的 `memoryEngineRootFor` 推导,同步游标在它下面;
+ * 调用方先把它换成与数据根同一种拼写 —— 见 `LocalBackend` 的 `dataDirLayout`)。名册包含关系按字面判:引擎根经数据根之外的别名拼写 ⇒ 当作在数据根之外(不进名册)。
+ */
+export interface DataDirLayout {
+    readonly dataRoot: string;
+    readonly memoryEngineRoot: string;
+}
+/**
+ * 布局只在这里铸一次(`LocalBackend` 取锁之后调):数据根 = 持锁的物理路径(配置里的拼写若经链接,事后改指也不影响);
+ * 记忆引擎根落在配置拼写的数据根之下 ⇒ 换成物理拼写(同一只目录只认一种拼写),否则原样(在数据根之外,名册不收)。
+ */
+export declare function buildDataDirLayout(a: {
+    readonly configuredRoot: string;
+    readonly physicalRoot: string;
+    readonly memoryEngineRoot: string;
+}): DataDirLayout;
+export interface DataDirModeRefusal {
+    /** 相对数据根的路径。 */
+    readonly path: string;
+    /** 错误码(`EPERM` / `EACCES` / `ESTALE` / …)或 {@link SYMLINK_IN_PATH};没有码的错误记 `UNKNOWN`。 */
+    readonly code: string;
+}
+export interface DataDirModeReading {
+    /** 本次收紧成 0o700 的目录(相对数据根)。 */
+    readonly tightened: readonly string[];
+    /** 本次没能收紧 / 没能看见 / 没有走的目录。 */
+    readonly refused: readonly DataDirModeRefusal[];
+}
+/** 两只日志座:成功提示与失败披露各一(失败那只由调用方接**不可缺席**的口)。 */
+export interface DataDirModeSinks {
+    readonly tightened: (msg: string, meta: Record<string, unknown>) => void;
+    readonly refused: (msg: string, meta: Record<string, unknown>) => void;
+}
+/** 测试座:收紧动作(默认对过了身份核的 fd `fchmod`)与平台(默认 `IS_WIN32`)。 */
+export interface DataDirModeSeats {
+    readonly fchmod?: (fd: number, mode: number, rel: string) => void;
+    readonly win32?: boolean;
+}
+/**
+ * 把数据根下名册里的 0755 店目录一次收紧成 0o700。起服时调(`LocalBackend.runOneTimeMigrations`,任何读者之前);数据根独占 ⇒ 没有滚动升级窗,不需要读侧半场。
+ * 失败不抛(见头注);读数也由两只日志座打出。
+ */
+export declare function tightenLocalDataDirModes(layout: DataDirLayout, sinks: DataDirModeSinks, seats?: DataDirModeSeats): DataDirModeReading;
+//# sourceMappingURL=local-data-dir-modes-m39.d.ts.map