@sema-agent/server 7.146.0 → 7.147.0

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

@@ -2,7 +2,7 @@ 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";
@@ -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;

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

@@ -16,10 +16,12 @@
  * 一律问**店**:它能叫出名字的每一只桶,判据在桶里判(不在桶外按「谁可能有」预筛)。
  *  · SQL:规则表里的每一只桶(`listRuleBucketOwners`,按 `owner_key` 分页)。不从审批记录推 —— 收编把规则桶整桶改键到新身份、审批史留在旧身份名下,
  *    从记录推出的属主集在收编之后漏掉新桶。
- *  · File:本店导入记录点名过的属主(`FileRuleApprovalRecordStore.importRecordOwners`;`imported-cc` 只由导入记录派生,记录是只增日志)∪ 引擎 File 分区后端
- *    自己列得出名字的属主(`FileDurableRulePartitionProvider.listBucketOwners().owners`:本机属主那只桶,与收编标记点名的身份 —— 收编把桶改名到一个没有任何
- *    导入记录点名的身份之后,那只桶照样被叫出来、被读)。**已知缺口(如实)**:桶文件按属主名的单向摘要命名,记录与收编标记都叫不出属主的桶本步不读;
- *    引擎给的「叫不出名字的桶数」(`unnamedBuckets`)只认本机属主那只桶与收编标记、把导入记录点名过的桶也算进去,不是本步的缺数 —— 不报它(报了会把读过的桶说成没读)。
+ *  · File:引擎 File 分区后端的列桶口一次答(`FileDurableRulePartitionProvider.listBucketOwners({ knownOwners })`):目录自己叫得出名字的属主(本机属主那只桶、
+ *    收编标记点名的身份 —— 收编把桶改名到一个没有任何导入记录点名的身份之后,那只桶照样被叫出来、被读),加上本店导入记录点名过的身份里桶文件在场的那些
+ *    (`knownOwners` = `FileRuleApprovalRecordStore.importRecordOwners` 的身份名;`imported-cc` 只由导入记录派生,记录是只增日志;桶名由引擎的那一只摘要算,本仓不算)。
+ *    **两者都叫不出属主的桶**(桶文件按属主名的单向摘要命名)本步读不到 —— 引擎在同一次答里给出它们的个数(`unnamedBuckets`),本步原样记进报告
+ *    (`importedLayerRootBucketsUnnamed`),非零每次起服 warn 一行;它不是「空」,是本步的普查缺了这么多只。
+ *  一种店一个来源、一次答 ⇒ 属主不重(引擎:同名给两次、或收编标记也点了它,是一个属主;SQL:按 `owner_key` 分页,键唯一)。
  *
  * ## 写在哪里(一处)
  * 墓碑经**这只桶自己的写面**落(`writerOf(partition).apply({ kind: "tighten-delete" })`,引擎的写面契约)—— SQL 两孪生走 `SqlDurableRulePartition` 的那只
@@ -63,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;
@@ -79,6 +88,6 @@ export interface ImportedLayerRootRetirementSource {
 }
 /** 判据(引擎 §5.14 那一句,逐字):这一行里该退役的 add;不选 ⇒ 空。 */
 export declare function importedLayerRootAddsOf(row: PersistedRule): readonly RuleAdd[];
-/** 跑一遍:读店叫得出名字的每只桶(`candidateOwners()`,见头注「读哪些桶」;两源有重 ⇒ 按桶键去重),退役判据选中的 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

@@ -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 的门拒启,那是契约的正确行为。 */

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

@@ -3,14 +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 { 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) {
@@ -47,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";
@@ -65,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

package/dist/plugins/local-data-dir-modes-m39.js

@@ -0,0 +1,182 @@
+import { closeSync, constants as FS, fchmodSync, fstatSync, lstatSync, openSync, readdirSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { physicalPathOf } from "@sema-agent/core";
+import { IS_WIN32 } from "./host-platform.js";
+import { fileRunStoreDirsFor } from "./file-run-store.js";
+import { localCheckpointStoreDirsFor } from "./local-checkpoint-store.js";
+import { attachmentStoreDirFor } from "./local-task-attachment-store.js";
+import { scratchpadRootFor } from "../env-facts.js";
+import { pluginCacheRootFor } from "../capabilities/center-plugins.js";
+import { memorySyncCursorDirFor } from "../memory-sync-client.js";
+const DIR_MODE = 0o700;
+const GROUP_OTHER_BITS = 0o077;
+const TIGHTENED_EXAMPLES = 5;
+const REFUSED_LISTED = 10;
+export const SYMLINK_IN_PATH = "SYMLINK_IN_PATH";
+export function buildDataDirLayout(a) {
+    const rel = relative(resolve(a.configuredRoot), resolve(a.memoryEngineRoot));
+    const underConfigured = rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+    return { dataRoot: a.physicalRoot, memoryEngineRoot: underConfigured ? join(a.physicalRoot, rel) : a.memoryEngineRoot };
+}
+function rosterFor(layout) {
+    const run = fileRunStoreDirsFor(layout.dataRoot);
+    const checkpoint = localCheckpointStoreDirsFor(layout.dataRoot);
+    return [
+        { abs: run.runs, children: 1 },
+        { abs: run.tmp, children: 0 },
+        { abs: run.spaceCommits, children: 0 },
+        { abs: checkpoint.ctx, children: 0 },
+        { abs: checkpoint.tmp, children: 0 },
+        { abs: attachmentStoreDirFor(layout.dataRoot), children: 0 },
+        { abs: scratchpadRootFor(layout.dataRoot), children: 1 },
+        { abs: pluginCacheRootFor(layout.dataRoot), children: 2 },
+        { abs: memorySyncCursorDirFor(layout.memoryEngineRoot), children: 0 },
+    ];
+}
+function segmentsUnder(root, abs) {
+    const rel = relative(resolve(root), resolve(abs));
+    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        return undefined;
+    return rel.split(sep);
+}
+const codeOf = (e) => (typeof e === "object" && e !== null && "code" in e && typeof e.code === "string" ? e.code : "UNKNOWN");
+const emit = (sink, msg, meta) => {
+    try {
+        sink(msg, meta);
+    }
+    catch {
+        console.warn(msg, meta);
+    }
+};
+const sameObject = (a, b) => a.dev === b.dev && a.ino === b.ino;
+function inRootBreak(root, segs, fd) {
+    try {
+        const held = fstatSync(fd, { bigint: true });
+        const physical = physicalPathOf(join(root, ...segs));
+        if (segmentsUnder(root, physical) === undefined)
+            return SYMLINK_IN_PATH;
+        if (!sameObject(lstatSync(physical, { bigint: true }), held))
+            return "ESTALE";
+        for (let i = 0; i <= segs.length; i += 1) {
+            const st = lstatSync(join(root, ...segs.slice(0, i)), { bigint: true });
+            if (st.isSymbolicLink())
+                return SYMLINK_IN_PATH;
+            if (!st.isDirectory())
+                return "ESTALE";
+        }
+        return undefined;
+    }
+    catch (e) {
+        return codeOf(e);
+    }
+}
+export function tightenLocalDataDirModes(layout, sinks, seats = {}) {
+    if (seats.win32 ?? IS_WIN32)
+        return { tightened: [], refused: [] };
+    const fchmod = seats.fchmod ?? ((fd, mode) => fchmodSync(fd, mode));
+    const root = layout.dataRoot;
+    const tightened = [];
+    const refused = [];
+    const refuse = (rel, code) => {
+        if (code !== "ENOENT")
+            refused.push({ path: rel, code });
+    };
+    const tighten = (segs, rel) => {
+        let fd;
+        try {
+            fd = openSync(join(root, ...segs), FS.O_RDONLY | FS.O_DIRECTORY | FS.O_NOFOLLOW);
+        }
+        catch (e) {
+            refuse(rel, codeOf(e));
+            return;
+        }
+        try {
+            const broken = inRootBreak(root, segs, fd);
+            if (broken !== undefined) {
+                refuse(rel, broken);
+                return;
+            }
+            fchmod(fd, DIR_MODE, rel);
+            tightened.push(rel);
+        }
+        catch (e) {
+            refuse(rel, codeOf(e));
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+    const step = (parent, name, more, depth) => {
+        const segs = [...parent, name];
+        const rel = join(...segs);
+        let mode;
+        try {
+            const st = lstatSync(join(root, ...segs));
+            if (st.isSymbolicLink()) {
+                refused.push({ path: rel, code: SYMLINK_IN_PATH });
+                return;
+            }
+            if (!st.isDirectory())
+                return;
+            mode = st.mode;
+        }
+        catch (e) {
+            refuse(rel, codeOf(e));
+            return;
+        }
+        const [next, ...rest] = more;
+        if (next !== undefined) {
+            step(segs, next, rest, depth);
+            return;
+        }
+        if ((mode & GROUP_OTHER_BITS) !== 0)
+            tighten(segs, rel);
+        if (depth === 0)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(join(root, ...segs), { withFileTypes: true });
+        }
+        catch (e) {
+            refuse(rel, codeOf(e));
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory() || entry.isSymbolicLink())
+                step(segs, entry.name, [], depth - 1);
+        }
+    };
+    let rootIntact = false;
+    try {
+        if (lstatSync(root).isSymbolicLink())
+            refused.push({ path: ".", code: SYMLINK_IN_PATH });
+        else
+            rootIntact = true;
+    }
+    catch (e) {
+        refuse(".", codeOf(e));
+    }
+    for (const { abs, children } of rootIntact ? rosterFor(layout) : []) {
+        const [first, ...rest] = segmentsUnder(root, abs) ?? [];
+        if (first !== undefined)
+            step([], first, rest, children);
+    }
+    if (refused.length > 0) {
+        emit(sinks.refused, "local_data_dir_mode_refused", {
+            count: refused.length,
+            mode: "0700",
+            entries: refused.slice(0, REFUSED_LISTED),
+            remedy: "these directories (relative to the data root) could not be tightened or read, or are reached through a symbolic link (SYMLINK_IN_PATH: links are never followed, the data root itself included) — as the owner of the real directory run `chmod 700` on it (or chown it to the server's user) and restart; the server keeps serving meanwhile",
+        });
+    }
+    if (tightened.length > 0) {
+        emit(sinks.tightened, "local_data_dir_modes_tightened", {
+            count: tightened.length,
+            mode: "0700",
+            examples: tightened.slice(0, TIGHTENED_EXAMPLES),
+            note: "store directories created by earlier versions with the default mode were tightened to 0700 once; later boots find them tight",
+        });
+    }
+    return { tightened, refused };
+}
+//# sourceMappingURL=local-data-dir-modes-m39.js.map

package/dist/plugins/local-engine-high-water.d.ts

@@ -0,0 +1,11 @@
+/** marker 的文件名(数据根顶层;公开契约)。 */
+export declare const ENGINE_HIGH_WATER_FILE = "engine-high-water.json";
+/**
+ * **判与抬**(唯一的座;唯一调用点 `openLocalBackend`,数据根锁在手、本仓任何一只店建起之前):
+ *  ① 本构建版本 `engine` 按发布线读不出({@link buildReleaseTriple})⇒ 抛 {@link StoreBootRefusalError}(marker 不读、不写);
+ *  ② 读 `<root>/engine-high-water.json`:读不出 / 高水位高于本构建 ⇒ 抛 {@link LocalDataRootSchemaMismatchError}(`boot` 形;文件原地不动,不抬);
+ *  ③ 缺席或低于本构建 ⇒ 原子写 `{"highWater": <本构建的纯三段>}`(`required`);相等 ⇒ 不写,只过持久化屏障(读到的可能是上一次没证完的那份)。写不进 / 证不了 ⇒ 抛(点名路径与原因)。
+ * 同步:它在后端打开的同步段里跑(建店之前),拒在这里就不会有一只店被建起。
+ */
+export declare function holdEngineHighWater(root: string, engine: string): void;
+//# sourceMappingURL=local-engine-high-water.d.ts.map