@sema-agent/server 7.150.0 → 7.152.0

package/dist/plugins/store-backend.js

@@ -8,7 +8,7 @@ import { FileWorkflowJournalStore } from "@sema-agent/core";
 import { fileSessionCaptureRecordStore } from "@sema-agent/core";
 import { TiDBOutcomeLedger, PgOutcomeLedger } from "./outcome-ledger-sql.js";
 import { FileOutcomeSink } from "./file-outcome-sink.js";
-import { TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, TiDBWorkflowAgentSessionIndex, SqlWorkflowParkDecisionStore, PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore, PgWorkflowAgentSessionIndex } from "./workflow-run-store-sql.js";
+import { TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, TiDBWorkflowAgentSessionIndex, SqlWorkflowParkDecisionStore, SqlWorkflowRunStore, PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore, PgWorkflowAgentSessionIndex } from "./workflow-run-store-sql.js";
 import { FileRunStore } from "./file-run-store.js";
 import { LocalWorkflowParkDecisionStore } from "../orchestration/workflow-park-decision.js";
 import { StoreBootRefusalError } from "./store-contracts.js";
@@ -25,6 +25,7 @@ import { SKILL_EXEMPTION_CUTOFF_ID } from "./one-time-migration-marker.js";
 import { LocalTaskAttachmentStore } from "./local-task-attachment-store.js";
 import { assertRetiredSchemaAbsentOnPool } from "./schema-consistency.js";
 import { LocalSessionStore, createLocalSessionRepo } from "./local-session-store.js";
+import { createLocalWorkflowRunsSeat } from "./local-session-live-reference.js";
 import { localStoreDeclarationOf } from "../local-store-declaration.js";
 import { SESSION_PLACEMENTS } from "./session-placement.js";
 import { LocalCheckpointStore, dropLocalCheckpointCtxStrict } from "./local-checkpoint-store.js";
@@ -40,19 +41,22 @@ import { TiDBSendFileLedger, PgSendFileLedger, FileSendFileLedger } from "./send
 import { FileUserInputLedgerStore } from "./user-input-ledger-file.js";
 import { TiDBUserInputLedgerStore, PgUserInputLedgerStore } from "./user-input-ledger-sql.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
-import { TiDBSessionPolicyStore, PgSessionPolicyStore } from "../stores-sql/session-policy-store-sql.js";
-import { countClientWriteOn } from "./session-withdraw-sql.js";
-import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "../stores-sql/workflow-journal-store-sql.js";
-import { TiDBFileHistoryStore, PgFileHistoryStore, FILE_HISTORY_BLOB_KEY_PREFIX } from "../stores-sql/file-history-store-sql.js";
-import { SqlBlobIndex } from "../stores-sql/blob-index-sql.js";
-import { MinioBlobBackend } from "./blob-backend.js";
+import { TiDBSessionPolicyStore, PgSessionPolicyStore, SqlSessionPolicyStore } from "../stores-sql/session-policy-store-sql.js";
+import { SQL_SESSION_ROOT_SEAT } from "./session-row-sql.js";
+import { TiDBWorkflowJournalStore, PgWorkflowJournalStore, SqlWorkflowJournalStore } from "../stores-sql/workflow-journal-store-sql.js";
+import { TiDBFileHistoryStore, PgFileHistoryStore, SqlFileHistoryStore, SqlBlobExchange, SqlBlobLanding } from "../stores-sql/file-history-store-sql.js";
+import { createLocalLandedAttendantSeat, createSqlLandedAttendantSeat } from "./landed-attendants.js";
+import { SqlBlobIndex, blobGcCutoffAt } from "../stores-sql/blob-index-sql.js";
+import { createSessionBlobBackend } from "./blob-backend.js";
+import { createSessionBlobNamespace } from "./session-blob-namespace.js";
+import { ensureSessionBlobClaimToken } from "./session-blob-claim-token.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
 import { fileMemoryControlDirFor, memoryEngineRootFor } from "../memory-scope.js";
 import { createTidbPool, ensureSchema as ensureTidbSchema } from "./tidb-pool.js";
 import { createPgPool, ensurePgSchema, pgPoolOptions } from "./pg-pool.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
-import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
-import { TiDBToolResultStore, PgToolResultStore } from "../stores-sql/tool-result-store-sql.js";
+import { TiDBCheckpointStore, PgCheckpointStore, SqlCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
+import { TiDBToolResultStore, PgToolResultStore, SqlToolResultStore } from "../stores-sql/tool-result-store-sql.js";
 import { TiDBImageIndex, PgImageIndex } from "./image-index-sql.js";
 import { TiDBImageBake, PgImageBake } from "./image-bake-store-sql.js";
 import { TiDBLeaderRunStore, PgLeaderRunStore } from "./leader-run-store-sql.js";
@@ -62,8 +66,8 @@ import { TiDBCostQuota } from "./tidb-cost-quota.js";
 import { PgCostQuota } from "./pg-cost-quota.js";
 import { TiDBRateLimiter } from "./tidb-rate-limiter.js";
 import { PgRateLimiter } from "./pg-rate-limiter.js";
-import { TiDBSessionStore } from "../stores-sql/tidb-session-store.js";
-import { PgSessionStore } from "../stores-sql/pg-session-storage.js";
+import { TiDBSessionStore, TiDBStagingHandle } from "../stores-sql/tidb-session-store.js";
+import { PgSessionStore, PgSessionStorage, PgStagingHandle } from "../stores-sql/pg-session-storage.js";
 import { SqlSessionStore } from "./session-store-sql.js";
 import { TiDBSharedMemoryStore, PgSharedMemoryStore } from "./shared-memory-store-sql.js";
 import { TiDBAdoptionLogStore, PgAdoptionLogStore } from "./adoption-log-sql.js";
@@ -83,6 +87,14 @@ import { admitLocalDataRoot, holdLocalDataRootAdmission } from "./local-data-roo
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { localDataRootHoldsData, storeDegradedReasonFor } from "../store-posture.js";
 import { openWithinWait } from "./store-open-wait.js";
+import { sealStoreClass, sealStoreObject } from "./store-boundary.js";
+import { WindowedSessionStorage } from "../stores-sql/windowed-session-storage.js";
+import { PgBackgroundAgentStore, TiDBBackgroundAgentStore } from "../stores-sql/background-agent-store-sql.js";
+import { PgMailboxStore, TiDBMailboxStore } from "../stores-sql/mailbox-store-sql.js";
+import { PgRosterStore, TiDBRosterStore } from "../stores-sql/roster-store-sql.js";
+import { TiDBSessionStorage } from "../stores-sql/tidb-session-storage.js";
+import { PgUsageWindowStore, TiDBUsageWindowStore } from "../stores-sql/usage-window-store-sql.js";
+import { createCardScopeRootSeat } from "./checkpoint-store-face.js";
 export function createRunStallWiring(config, observers) {
     const count = observers?.runStallVerdicts;
     return { windowMs: () => config.runStaleSec * 1000, onVerdicts: (landed) => count?.(landed) };
@@ -90,19 +102,10 @@ export function createRunStallWiring(config, observers) {
 export function workflowJournalOf(config, backend) {
     return config.selfOrchestrationEnabled && backend ? backend.workflowJournal() : undefined;
 }
-function fileHistoryOptions(config) {
-    const s = config.snapshotBlobStore;
-    const placement = s
+function fileHistoryOptions(config, namespace) {
+    const placement = namespace
         ? {
-            blobs: new MinioBlobBackend({
-                endpoint: s.endpoint,
-                bucket: s.bucket,
-                accessKey: s.accessKey,
-                secretKey: s.secretKey,
-                ...(s.region ? { region: s.region } : {}),
-                keyPrefix: `${s.keyPrefix ?? ""}${FILE_HISTORY_BLOB_KEY_PREFIX}`,
-                ...(s.presignTtlSec ? { presignTtlSec: s.presignTtlSec } : {}),
-            }),
+            blobs: createSessionBlobBackend(namespace, "file-history"),
         }
         : {
             ...(config.snapshotBlobSqlMaxBytes !== undefined ? { blobSqlMaxBytes: config.snapshotBlobSqlMaxBytes } : {}),
@@ -110,35 +113,21 @@ function fileHistoryOptions(config) {
         };
     return { ...config.fileHistory, ...placement };
 }
-function legacyBlobIndex(config, dialect, pool) {
-    const s = config.snapshotBlobStore;
-    const bytes = s
-        ? new MinioBlobBackend({
-            endpoint: s.endpoint,
-            bucket: s.bucket,
-            accessKey: s.accessKey,
-            secretKey: s.secretKey,
-            ...(s.region ? { region: s.region } : {}),
-            ...(s.keyPrefix ? { keyPrefix: s.keyPrefix } : {}),
-            ...(s.presignTtlSec ? { presignTtlSec: s.presignTtlSec } : {}),
-        })
-        : undefined;
+function legacyBlobIndex(config, dialect, pool, namespace) {
+    const bytes = namespace ? createSessionBlobBackend(namespace, "legacy-blobs") : undefined;
     return new SqlBlobIndex(dialect, pool, { table: "snapshot_blob", ...(bytes !== undefined ? { bytes } : {}), log: createLogger(config.logLevel) });
 }
-async function legacySweepImpl(config, dialect, pool) {
+async function legacySweepImpl(config, dialect, pool, namespace) {
     const sql = "SELECT blob_hash FROM snapshot_blob";
-    let orphans;
-    if (dialect === "mysql") {
-        const [rows] = await pool.query(sql);
-        orphans = rows.map((r) => String(r.blob_hash));
-    }
-    else {
+    const collect = async () => {
+        if (dialect === "mysql") {
+            const [rows] = await pool.query(sql);
+            return rows.map((r) => String(r.blob_hash));
+        }
         const r = await pool.query(sql);
-        orphans = r.rows.map((row) => row.blob_hash);
-    }
-    if (orphans.length === 0)
-        return 0;
-    return legacyBlobIndex(config, dialect, pool).sweep(orphans);
+        return r.rows.map((row) => row.blob_hash);
+    };
+    return legacyBlobIndex(config, dialect, pool, namespace).sweep(collect, blobGcCutoffAt(Date.now()));
 }
 export function createSqlRetentionCallHooks(db, opts, input) {
     const deployment = createRetentionDeploymentHooks(db.dialect, opts, input);
@@ -151,7 +140,7 @@ export function createSqlRetentionExecutor(db, opts) {
         const hooks = createSqlRetentionCallHooks(db, opts, input);
         return { store: new SqlRetentionStore(db, { ...storeOpts, transactionHooks: hooks.hooks }), hooks, call: { domain: input.domain, cutoffMs: input.cutoffMs } };
     };
-    return {
+    return sealStoreObject({
         retention: reads.retention,
         listRetentionDomains: () => reads.listRetentionDomains(),
         previewRetention: (input) => reads.previewRetention(input),
@@ -171,7 +160,7 @@ export function createSqlRetentionExecutor(db, opts) {
             const one = forCall(input);
             return one.store.deleteOrphanToolResults(one.call);
         },
-    };
+    }, "sql-retention-executor", { listRetentionDomains: "exit", previewRetention: "exit", expireCheckpoints: "exit", deleteExpiredSessions: "exit", deleteOrphanToolResults: "exit" });
 }
 async function afterSessionErase(db, opts, sessions) {
     if (!opts.completionInbox || sessions.length === 0)
@@ -180,7 +169,7 @@ async function afterSessionErase(db, opts, sessions) {
 }
 export function createSqlSessionEraser(db, opts) {
     const storeOpts = { ...(opts.mailboxTables ? { sessionBoxScope: sessionTenantScope } : {}), ...(opts.logger !== undefined ? { logger: opts.logger } : {}) };
-    return {
+    return sealStoreObject({
         async erase(input) {
             const rows = createSessionRowsHook(db.dialect, opts, input.owner ?? "");
             const store = new SqlRetentionStore(db, { ...storeOpts, transactionHooks: { retention: { beforeDelete: rows.beforeDelete }, session: createSqlSessionWriteHooks(db) } });
@@ -201,7 +190,7 @@ export function createSqlSessionEraser(db, opts) {
                 }
             }
         },
-    };
+    }, "sql-session-eraser", { erase: "exit" });
 }
 export function assertCloudSnapshotBlobPosture(kind, config) {
     if (kind === "local" || config.snapshotBlobStore || config.snapshotBlobAllowSql)
@@ -226,21 +215,49 @@ const SQL_BLOB_POSTURE_FACTS = {
 export function buildSqlOneTimeMigrationInput(config) {
     return { lanes: deployedExecutionLanes(config), liveRunWindowMs: config.runStaleSec * 1000, identityBoundary: DEPLOYMENT_SHAPE_PREDICATES.identityBoundary.holds(config) };
 }
+function decisionStoreBoundOnce(held, records, make) {
+    if (held === undefined)
+        return make();
+    if (held.records !== records)
+        throw new Error("store backend: the workflow park decision store is already bound to another workflow record store — a backend keeps one decision store, fenced by the one record store every workflow record write goes through");
+    return held;
+}
+function sqlRecordFenceOf(records) {
+    if (records instanceof SqlWorkflowRunStore)
+        return records;
+    throw new Error("SQL store backend: the workflow park decision store's record fence must be this backend's SQL workflow record store (workflowRun()) — a decision row is written in the same transaction that locks the run's record row");
+}
+function policyStoreLoggerOf(onWarn) {
+    return onWarn !== undefined ? { warn: (msg, fields) => onWarn(msg, fields) } : createLogger();
+}
+export function sqlLandedAttendantsOf(db, history, policy) {
+    return createSqlLandedAttendantSeat(db, { history, policy });
+}
 class TiDBBackend {
     pool;
     config;
     observers;
+    onWarn;
     kind = "mysql";
-    constructor(pool, config, observers) {
+    constructor(pool, config, observers, onWarn) {
         this.pool = pool;
         this.config = config;
         this.observers = observers;
+        this.onWarn = onWarn;
+        this.blobNamespaceInst = config.snapshotBlobStore ? createSessionBlobNamespace(config.snapshotBlobStore) : undefined;
+    }
+    async ensureSchema() {
+        await ensureTidbSchema(this.pool);
+        if (this.blobNamespaceInst)
+            this.blobNamespaceInst.bind(await ensureSessionBlobClaimToken(mysqlDriver(this.pool)));
     }
-    ensureSchema() { return ensureTidbSchema(this.pool); }
     close() { return this.pool.end(); }
+    sessionBlobNamespace() { return this.blobNamespaceInst; }
+    blobNamespaceInst;
     run() { return (this.runStoreInst ??= new TiDBRunStore(this.pool, createRunStallWiring(this.config, this.observers))); }
     runStoreInst;
-    resumeAnchor() { return new TiDBResumeAnchorStore(this.pool); }
+    resumeAnchor() { return (this.resumeAnchorInst ??= new TiDBResumeAnchorStore(this.pool)); }
+    resumeAnchorInst;
     approvalExemption() { return new TiDBApprovalExemptionStore(this.pool); }
     approvalNonce() { return new TiDBApprovalNonceStore(this.pool); }
     orgDeliveryQuota() { return new TiDBOrgDeliveryQuotaStore(this.pool); }
@@ -248,12 +265,16 @@ class TiDBBackend {
     permissionRule() { return createSqlPermissionRuleStores(mysqlDriver(this.pool)); }
     sendFileLedger() { return new TiDBSendFileLedger(this.pool); }
     userInputLedger() { return new TiDBUserInputLedgerStore(this.pool); }
-    sessionPolicy(logger) { return new TiDBSessionPolicyStore(this.pool, countClientWriteOn, logger ?? createLogger()); }
-    fileHistory() { return new TiDBFileHistoryStore(this.pool, fileHistoryOptions(this.config)); }
+    sessionPolicy() { return (this.sessionPolicyInst ??= new TiDBSessionPolicyStore(this.pool, SQL_SESSION_ROOT_SEAT, policyStoreLoggerOf(this.onWarn))); }
+    sessionPolicyInst;
+    fileHistory() { return (this.fileHistoryInst ??= new TiDBFileHistoryStore(this.pool, fileHistoryOptions(this.config, this.sessionBlobNamespace()))); }
+    fileHistoryInst;
+    landedAttendants() { return (this.landedAttendantsInst ??= sqlLandedAttendantsOf(mysqlDriver(this.pool), this.fileHistory(), this.sessionPolicy())); }
+    landedAttendantsInst;
     memoryOptOutGrant() { return new TiDBMemoryOptOutGrantStore(this.pool); }
     sessionCaptureRecords() { return () => (this.captureRecordsInst ??= new TiDBSessionCaptureRecordStore(this.pool)); }
     captureRecordsInst;
-    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "mysql", this.pool); }
+    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "mysql", this.pool, this.sessionBlobNamespace()); }
     runOneTimeMigrations() { return runSqlOneTimeMigrations("mysql", this.pool, buildSqlOneTimeMigrationInput(this.config)); }
     workflowJournal() { return new TiDBWorkflowJournalStore(this.pool); }
     outcomeSink() { return new TiDBOutcomeLedger(this.pool); }
@@ -261,10 +282,12 @@ class TiDBBackend {
     completionInbox(onWarn) { return new TiDBWorkflowCompletionInbox(this.pool, onWarn); }
     notifyJournal() { return new TiDBWorkflowNotifyJournalStore(this.pool); }
     workflowAgentSessionIndex() { return new TiDBWorkflowAgentSessionIndex(this.pool); }
-    workflowParkDecisions() { return (this.parkDecisionsInst ??= new SqlWorkflowParkDecisionStore(this.run())); }
+    workflowParkDecisions(records) { return (this.parkDecisionsInst = decisionStoreBoundOnce(this.parkDecisionsInst, records, () => new SqlWorkflowParkDecisionStore(this.run(), sqlRecordFenceOf(records)))); }
     parkDecisionsInst;
     sharedMemoryStore(authorizer) { return new TiDBSharedMemoryStore(this.pool, authorizer); }
-    checkpoint(logger) { return new TiDBCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    cardScopeRootSeat = createCardScopeRootSeat();
+    bindCardScopeRoot(read) { this.cardScopeRootSeat.bind(read); }
+    checkpoint(logger) { return new TiDBCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep), cardScopeRoot: this.cardScopeRootSeat }); }
     checkpointReadView() { return this.checkpoint(); }
     toolResult() { return new TiDBToolResultStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     imageIndex() { return new TiDBImageIndex(this.pool); }
@@ -283,21 +306,40 @@ class TiDBBackend {
     pgPool() { return undefined; }
     async dbNowMs() { const [rows] = await this.pool.query("SELECT ROUND(UNIX_TIMESTAMP(NOW(3))*1000) AS ms"); return Number(rows[0]?.ms); }
 }
+sealStoreClass(TiDBBackend, "tidb-backend", {
+    ensureSchema: "boot", close: "boot", sessionBlobNamespace: "exit", run: "exit", resumeAnchor: "exit", approvalExemption: "exit", approvalNonce: "exit", orgDeliveryQuota: "exit",
+    approvalAsk: "exit", permissionRule: "exit", sendFileLedger: "exit", userInputLedger: "exit", sessionPolicy: "exit", fileHistory: "exit",
+    memoryOptOutGrant: "exit", sessionCaptureRecords: "exit", legacySnapshotBlobSweep: "exit", runOneTimeMigrations: "boot", workflowJournal: "exit",
+    outcomeSink: "exit", workflowRun: "exit", completionInbox: "exit", notifyJournal: "exit", workflowAgentSessionIndex: "exit", workflowParkDecisions: "exit",
+    sharedMemoryStore: "exit", checkpoint: "exit", checkpointReadView: "exit", toolResult: "exit", imageIndex: "exit", imageBake: "exit", leaderRun: "exit",
+    device: "exit", retention: "exit", sessionEraser: "exit", retentionLane: "exit", breaker: "exit", costQuota: "exit", rateLimiter: "exit", session: "exit",
+    adoptionLog: "exit", mysqlPool: "boot", pgPool: "boot", dbNowMs: "exit", landedAttendants: "exit", bindCardScopeRoot: "exit",
+});
 class PgBackend {
     pool;
     config;
     observers;
+    onWarn;
     kind = "pg";
-    constructor(pool, config, observers) {
+    constructor(pool, config, observers, onWarn) {
         this.pool = pool;
         this.config = config;
         this.observers = observers;
+        this.onWarn = onWarn;
+        this.blobNamespaceInst = config.snapshotBlobStore ? createSessionBlobNamespace(config.snapshotBlobStore) : undefined;
+    }
+    async ensureSchema() {
+        await ensurePgSchema(this.pool);
+        if (this.blobNamespaceInst)
+            this.blobNamespaceInst.bind(await ensureSessionBlobClaimToken(pgDriver(this.pool)));
     }
-    ensureSchema() { return ensurePgSchema(this.pool); }
     close() { return this.pool.end(); }
+    sessionBlobNamespace() { return this.blobNamespaceInst; }
+    blobNamespaceInst;
     run() { return (this.runStoreInst ??= new PgRunStore(this.pool, createRunStallWiring(this.config, this.observers))); }
     runStoreInst;
-    resumeAnchor() { return new PgResumeAnchorStore(this.pool); }
+    resumeAnchor() { return (this.resumeAnchorInst ??= new PgResumeAnchorStore(this.pool)); }
+    resumeAnchorInst;
     approvalExemption() { return new PgApprovalExemptionStore(this.pool); }
     approvalNonce() { return new PgApprovalNonceStore(this.pool); }
     orgDeliveryQuota() { return new PgOrgDeliveryQuotaStore(this.pool); }
@@ -305,12 +347,16 @@ class PgBackend {
     permissionRule() { return createSqlPermissionRuleStores(pgDriver(this.pool)); }
     sendFileLedger() { return new PgSendFileLedger(this.pool); }
     userInputLedger() { return new PgUserInputLedgerStore(this.pool); }
-    sessionPolicy(logger) { return new PgSessionPolicyStore(this.pool, countClientWriteOn, logger ?? createLogger()); }
-    fileHistory() { return new PgFileHistoryStore(this.pool, fileHistoryOptions(this.config)); }
+    sessionPolicy() { return (this.sessionPolicyInst ??= new PgSessionPolicyStore(this.pool, SQL_SESSION_ROOT_SEAT, policyStoreLoggerOf(this.onWarn))); }
+    sessionPolicyInst;
+    fileHistory() { return (this.fileHistoryInst ??= new PgFileHistoryStore(this.pool, fileHistoryOptions(this.config, this.sessionBlobNamespace()))); }
+    fileHistoryInst;
+    landedAttendants() { return (this.landedAttendantsInst ??= sqlLandedAttendantsOf(pgDriver(this.pool), this.fileHistory(), this.sessionPolicy())); }
+    landedAttendantsInst;
     memoryOptOutGrant() { return new PgMemoryOptOutGrantStore(this.pool); }
     sessionCaptureRecords() { return () => (this.captureRecordsInst ??= new PgSessionCaptureRecordStore(this.pool)); }
     captureRecordsInst;
-    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "pg", this.pool); }
+    legacySnapshotBlobSweep() { return legacySweepImpl(this.config, "pg", this.pool, this.sessionBlobNamespace()); }
     runOneTimeMigrations() { return runSqlOneTimeMigrations("pg", this.pool, buildSqlOneTimeMigrationInput(this.config)); }
     workflowJournal() { return new PgWorkflowJournalStore(this.pool); }
     outcomeSink() { return new PgOutcomeLedger(this.pool); }
@@ -318,10 +364,12 @@ class PgBackend {
     completionInbox(onWarn) { return new PgWorkflowCompletionInbox(this.pool, onWarn); }
     notifyJournal() { return new PgWorkflowNotifyJournalStore(this.pool); }
     workflowAgentSessionIndex() { return new PgWorkflowAgentSessionIndex(this.pool); }
-    workflowParkDecisions() { return (this.parkDecisionsInst ??= new SqlWorkflowParkDecisionStore(this.run())); }
+    workflowParkDecisions(records) { return (this.parkDecisionsInst = decisionStoreBoundOnce(this.parkDecisionsInst, records, () => new SqlWorkflowParkDecisionStore(this.run(), sqlRecordFenceOf(records)))); }
     parkDecisionsInst;
     sharedMemoryStore(authorizer) { return new PgSharedMemoryStore(this.pool, authorizer); }
-    checkpoint(logger) { return new PgCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
+    cardScopeRootSeat = createCardScopeRootSeat();
+    bindCardScopeRoot(read) { this.cardScopeRootSeat.bind(read); }
+    checkpoint(logger) { return new PgCheckpointStore(this.pool, logger, { retention: sqlStoreRetention(this.config.retentionSweep), cardScopeRoot: this.cardScopeRootSeat }); }
     checkpointReadView() { return this.checkpoint(); }
     toolResult() { return new PgToolResultStore(this.pool, { retention: sqlStoreRetention(this.config.retentionSweep) }); }
     imageIndex() { return new PgImageIndex(this.pool); }
@@ -340,6 +388,15 @@ class PgBackend {
     pgPool() { return this.pool; }
     async dbNowMs() { const res = await this.pool.query("SELECT ROUND(EXTRACT(EPOCH FROM now())*1000) AS ms"); return Number(res.rows[0]?.ms); }
 }
+sealStoreClass(PgBackend, "pg-backend", {
+    ensureSchema: "boot", close: "boot", sessionBlobNamespace: "exit", run: "exit", resumeAnchor: "exit", approvalExemption: "exit", approvalNonce: "exit", orgDeliveryQuota: "exit",
+    approvalAsk: "exit", permissionRule: "exit", sendFileLedger: "exit", userInputLedger: "exit", sessionPolicy: "exit", fileHistory: "exit",
+    memoryOptOutGrant: "exit", sessionCaptureRecords: "exit", legacySnapshotBlobSweep: "exit", runOneTimeMigrations: "boot", workflowJournal: "exit",
+    outcomeSink: "exit", workflowRun: "exit", completionInbox: "exit", notifyJournal: "exit", workflowAgentSessionIndex: "exit", workflowParkDecisions: "exit",
+    sharedMemoryStore: "exit", checkpoint: "exit", checkpointReadView: "exit", toolResult: "exit", imageIndex: "exit", imageBake: "exit", leaderRun: "exit",
+    device: "exit", retention: "exit", sessionEraser: "exit", retentionLane: "exit", breaker: "exit", costQuota: "exit", rateLimiter: "exit", session: "exit",
+    adoptionLog: "exit", mysqlPool: "boot", pgPool: "boot", dbNowMs: "exit", landedAttendants: "exit", bindCardScopeRoot: "exit",
+});
 export function localSessionRowsOf(backend) {
     return backend instanceof LocalBackend ? backend.session() : undefined;
 }
@@ -364,6 +421,7 @@ class LocalBackend {
     fileBackend;
     runStore;
     sessionStore;
+    workflowRunsSeat = createLocalWorkflowRunsSeat();
     resumeAnchorStore;
     approvalExemptionStore;
     approvalNonceStore;
@@ -399,11 +457,17 @@ class LocalBackend {
             stall: createRunStallWiring(config, observers),
         });
         const physicalRoot = this.fileBackend.root;
+        const checkpoints = this.fileBackend.checkpointStore;
+        const listCheckpoints = checkpoints.listBySession;
+        const ageOut = listCheckpoints !== undefined
+            ? { liveReferences: { checkpoints: { listBySession: (q) => listCheckpoints.call(checkpoints, q) }, agents: this.fileBackend.backgroundAgentStore, workflows: this.workflowRunsSeat } }
+            : {};
         this.sessionStore = new LocalSessionStore(createLocalSessionRepo(physicalRoot), this.runStore, physicalRoot, {
             log: createLogger(config.logLevel),
             durability: this.storeDeclaration.durability,
             placements: SESSION_PLACEMENTS,
             withdrawCheckpointCtx: (sessionId) => dropLocalCheckpointCtxStrict(physicalRoot, sessionId),
+            ...ageOut,
         });
         this.parkDecisionLedgerRoot = config.workflowRunStoreBackend === "memory" ? undefined : join(this.fileBackend.root, "workflows");
         this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
@@ -502,7 +566,12 @@ class LocalBackend {
             ...importedLayerRoot,
         };
     }
+    closing = false;
+    exclusiveDataRoot() {
+        return this.closing ? undefined : this.fileBackend.root;
+    }
     async close() {
+        this.closing = true;
         await this.sessionStore.dispose();
         this.runStore.dispose();
         this.resumeAnchorStore.dispose();
@@ -518,8 +587,10 @@ class LocalBackend {
         await this.fileBackend.dispose();
     }
     run() { return this.runStore; }
-    workflowParkDecisions() {
-        return (this.parkDecisionsInst ??= new LocalWorkflowParkDecisionStore(this.runStore, this.parkDecisionLedgerRoot));
+    workflowParkDecisions(records) {
+        if (records instanceof SqlWorkflowRunStore)
+            throw new Error("local store backend: the workflow park decision store's record fence must be the in-process record fence (FencedWorkflowRecordStore), not a SQL record store — the local backend keeps its decisions in this process");
+        return (this.parkDecisionsInst = decisionStoreBoundOnce(this.parkDecisionsInst, records, () => new LocalWorkflowParkDecisionStore(this.runStore, records, this.parkDecisionLedgerRoot)));
     }
     parkDecisionsInst;
     resumeAnchor() { return this.resumeAnchorStore; }
@@ -544,8 +615,11 @@ class LocalBackend {
             durability: this.storeDeclaration.durability,
             getActiveTaskId: (sessionId) => this.runStore.getActiveTaskId(sessionId),
             readSessionOwner: async (sessionId) => (await this.sessionStore.headOf(sessionId))?.owner,
+            cardScopeRoot: this.cardScopeRootSeat,
         }));
     }
+    cardScopeRootSeat = createCardScopeRootSeat();
+    bindCardScopeRoot(read) { this.cardScopeRootSeat.bind(read); }
     checkpoint() {
         const cs = this.checkpointStoreOf();
         if (!this.checkpointProbeWired) {
@@ -565,12 +639,15 @@ class LocalBackend {
     localStoreDeclaration() { return this.storeDeclaration; }
     fileUsageWindowStore() { return this.fileBackend.usageWindowStore; }
     fileHistory() { return this.fileBackend.fileHistoryStore; }
+    landedAttendants() { return (this.landedAttendantsInst ??= createLocalLandedAttendantSeat({ sessions: this.sessionStore, history: this.fileBackend.fileHistoryStore, policy: this.fileBackend.sessionPolicyStore, anchors: this.resumeAnchorStore })); }
+    landedAttendantsInst;
     memoryOptOutGrant() { return undefined; }
     sessionCaptureRecords() { return this.captureRecordsSource; }
     captureRecordsSource;
     workflowJournal() { return this.workflowJournalStore; }
     outcomeSink() { return this.outcomeSinkInst; }
     session() { return this.sessionStore; }
+    bindWorkflowRunReader(reader) { this.workflowRunsSeat.bind(reader); }
     toolResult() { return this.fileBackend.toolResultStore; }
     engineFileStores() {
         const fb = this.fileBackend;
@@ -638,6 +715,9 @@ class RefusedLocalBackend {
     async close() {
         await this.release();
     }
+    exclusiveDataRoot() {
+        return undefined;
+    }
     run() { return this.refused(); }
     resumeAnchor() { return this.refused(); }
     approvalExemption() { return this.refused(); }
@@ -649,6 +729,7 @@ class RefusedLocalBackend {
     userInputLedger() { return this.refused(); }
     sessionPolicy() { return this.refused(); }
     fileHistory() { return this.refused(); }
+    landedAttendants() { return this.refused(); }
     memoryOptOutGrant() { return this.refused(); }
     sessionCaptureRecords() { return this.refused(); }
     workflowJournal() { return this.refused(); }
@@ -659,6 +740,8 @@ class RefusedLocalBackend {
     toolResult() { return this.refused(); }
     fileUsageWindowStore() { return this.refused(); }
     localStoreDeclaration() { return this.refused(); }
+    bindWorkflowRunReader() { this.refused(); }
+    bindCardScopeRoot() { this.refused(); }
     mysqlPool() { return undefined; }
     pgPool() { return undefined; }
 }
@@ -669,12 +752,12 @@ export function createStoreBackend(config, onWarn, onError, observers) {
         if (!config.pg)
             return undefined;
         const pool = createPgPool(pgPoolOptions(config.pg, config.dbQueryTimeoutMs), onWarn);
-        return withRetiredSchemaProbe(new PgBackend(pool, config, observers), { dialect: "pg", pool }, { lanes: deployedExecutionLanes(config) });
+        return withRetiredSchemaProbe(new PgBackend(pool, config, observers, onWarn), { dialect: "pg", pool }, { lanes: deployedExecutionLanes(config) });
     }
     if (!config.tidb)
         return undefined;
     const pool = createTidbPool(config);
-    return withRetiredSchemaProbe(new TiDBBackend(pool, config, observers), { dialect: "mysql", pool }, { lanes: deployedExecutionLanes(config) });
+    return withRetiredSchemaProbe(new TiDBBackend(pool, config, observers, onWarn), { dialect: "mysql", pool }, { lanes: deployedExecutionLanes(config) });
 }
 function openAdmittedLocalBackend(config, admission, sinks) {
     let admitted = admission;
@@ -729,6 +812,16 @@ export async function openStoreBackendWithFallback(config, logger, observers, lo
             sqlEngine === undefined
                 ? await attempt()
                 : await openWithinWait(attempt, config.storeLockWaitMs, (w) => logger.warn("store_sql_open_wait", { engine: sqlEngine, endpoint: buildDisplaySafeUrl(sqlStoreCoordinatesAsUrl(config)), waitMs: w.waitMs, error: w.error }));
+        const namespace = backend?.sessionBlobNamespace?.();
+        if (namespace !== undefined) {
+            try {
+                await namespace.establish();
+            }
+            catch (refusal) {
+                await backend?.close().catch(() => undefined);
+                throw refusal;
+            }
+        }
     }
     catch (err) {
         void inFlight?.close().catch(() => undefined);
@@ -770,4 +863,75 @@ export function buildSqlStoreOpenRefusal(engine, endpoint, waitedMs, err) {
         next +
         `or run explicitly in memory with DB_BACKEND=memory (and remove the ${coords} coordinates).`);
 }
+sealStoreClass(WindowedSessionStorage, "windowed-session-storage", {
+    getMetadata: "exit", getLeafId: "exit", createEntryId: "exit", findEntries: "exit", getLabel: "exit", getPathToRoot: "exit", getEntries: "exit",
+    getFloorId: "exit", getReplayLoss: "exit", logMarkNow: "exit", getEntry: "exit", appendEntry: "exit", setLeafId: "exit",
+});
+sealStoreClass(TiDBBackgroundAgentStore, "tidb-background-agent-store", {
+    put: "exit", get: "exit", update: "exit", updateIf: "exit", listBySession: "exit", listByScope: "exit", delete: "exit", reap: "exit", listScopes: "exit",
+});
+sealStoreClass(PgBackgroundAgentStore, "pg-background-agent-store", {
+    put: "exit", get: "exit", update: "exit", updateIf: "exit", listBySession: "exit", listByScope: "exit", delete: "exit", reap: "exit", listScopes: "exit",
+});
+sealStoreClass(SqlBlobIndex, "sql-blob-index", { put: "exit", get: "exit", has: "exit", sweep: "exit" });
+sealStoreClass(SqlCheckpointStore, "sql-checkpoint-store", {
+    put: "exit", get: "exit", listBySession: "exit", resolve: "exit", reopen: "exit", recordExecutionOutcome: "exit", setPendingSteer: "exit", expire: "exit",
+    reap: "exit", reapExpired: "exit", listExpiredApprovalGates: "exit", listPending: "exit", listByScope: "exit", listPendingSessionIds: "exit",
+    findPendingTokenBySession: "exit", findCheckpointCandidatesForAsk: "exit", findDecidedApprovalsForBinding: "exit", peekScopeByToken: "exit",
+    peekPendingScope: "exit", hostSessionOfCard: "exit", putCtx: "exit", getCtx: "exit", rewriteCtxWhileClaimed: "exit", rewriteCtxRows: "exit", reapCtx: "exit",
+    deleteBySession: "exit", cardScopeRootOf: "exit",
+});
+sealStoreClass(SqlFileHistoryStore, "sql-file-history-store", {
+    trackEdit: "exit", annulTrack: "exit", snapshot: "exit", restore: "exit", canRestore: "exit", reap: "exit", deleteBySession: "exit", sweepOrphanBlobs: "exit",
+    adoptScope: "exit", exportHistory: "exit", importHistory: "exit", importFailureOf: "exit", prepareImport: "exit",
+    lockScopeOn: "in-store", publishImportOn: "in-store", deleteScopeOn: "in-store",
+});
+sealStoreClass(SqlBlobExchange, "sql-blob-exchange", { put: "exit", get: "exit", has: "exit" });
+sealStoreClass(SqlBlobLanding, "sql-blob-landing", { putAt: "exit", visibleAt: "exit" });
+sealStoreClass(TiDBMailboxStore, "tidb-mailbox-store", {
+    append: "exit", claimLease: "exit", ack: "exit", moveDecision: "exit", releaseLease: "exit", peekCount: "exit", drop: "exit", reap: "exit",
+    retireRecipient: "exit", listRetiredRecipients: "exit",
+});
+sealStoreClass(PgMailboxStore, "pg-mailbox-store", {
+    append: "exit", claimLease: "exit", ack: "exit", moveDecision: "exit", releaseLease: "exit", peekCount: "exit", drop: "exit", reap: "exit",
+    retireRecipient: "exit", listRetiredRecipients: "exit",
+});
+sealStoreClass(PgSessionStorage, "pg-session-storage", {
+    getMetadata: "exit", getLeafId: "exit", createEntryId: "exit", findEntries: "exit", getLabel: "exit", getPathToRoot: "exit", getEntries: "exit",
+    getFloorId: "exit", getReplayLoss: "exit", logMarkNow: "exit", getEntry: "exit", appendEntry: "exit", setLeafId: "exit", getEpochAnchor: "exit",
+});
+sealStoreObject(PgSessionStorage, "pg-session-storage-static", { wake: "exit" });
+sealStoreClass(PgSessionStore, "pg-session-store", {
+    acquire: "exit", register: "exit", registerWithReceipt: "exit", deleteSessionIf: "exit", placementOf: "exit", listPlaced: "exit", headOf: "exit",
+    touch: "exit", release: "exit", forget: "exit", fork: "exit", forkTo: "exit", exportEntries: "exit", listEntryIds: "exit", exportEntriesStream: "exit",
+    importEntries: "exit", replaceEntries: "exit", beginImportStaging: "exit", readStagedEntries: "exit", sweepStagingSessions: "exit", dispose: "exit",
+});
+sealStoreClass(PgStagingHandle, "pg-staging-handle", { appendBatch: "exit", commit: "exit", abort: "exit" });
+sealStoreClass(SqlRetentionStore, "sql-retention-store", {
+    listRetentionDomains: "exit", previewRetention: "exit", expireCheckpoints: "exit", deleteExpiredSessions: "exit", eraseSession: "exit",
+    deleteOrphanToolResults: "exit",
+});
+sealStoreClass(TiDBRosterStore, "tidb-roster-store", { record: "exit", resolve: "exit", list: "exit", releaseAgent: "exit", reapOlderThan: "exit" });
+sealStoreClass(PgRosterStore, "pg-roster-store", { record: "exit", resolve: "exit", list: "exit", releaseAgent: "exit", reapOlderThan: "exit" });
+sealStoreClass(SqlSessionPolicyStore, "sql-session-policy-store", {
+    getRules: "exit", listBySession: "exit", putRules: "exit", deleteBySession: "exit", discloseErased: "exit", isDupKeyError: "exit",
+    putRulesOn: "in-store", eraseOn: "in-store",
+});
+sealStoreClass(TiDBSessionStorage, "tidb-session-storage", {
+    getMetadata: "exit", getLeafId: "exit", createEntryId: "exit", findEntries: "exit", getLabel: "exit", getPathToRoot: "exit", getEntries: "exit",
+    getFloorId: "exit", getReplayLoss: "exit", logMarkNow: "exit", getEntry: "exit", appendEntry: "exit", setLeafId: "exit", getEpochAnchor: "exit",
+});
+sealStoreObject(TiDBSessionStorage, "tidb-session-storage-static", { wake: "exit" });
+sealStoreClass(TiDBSessionStore, "tidb-session-store", {
+    acquire: "exit", register: "exit", registerWithReceipt: "exit", deleteSessionIf: "exit", placementOf: "exit", listPlaced: "exit", headOf: "exit",
+    touch: "exit", release: "exit", forget: "exit", fork: "exit", forkTo: "exit", exportEntries: "exit", listEntryIds: "exit", exportEntriesStream: "exit",
+    importEntries: "exit", replaceEntries: "exit", beginImportStaging: "exit", readStagedEntries: "exit", sweepStagingSessions: "exit", dispose: "exit",
+});
+sealStoreClass(TiDBStagingHandle, "tidb-staging-handle", { appendBatch: "exit", commit: "exit", abort: "exit" });
+sealStoreClass(SqlToolResultStore, "sql-tool-result-store", { put: "exit", ownerOf: "exit", get: "exit", reap: "exit", deleteBySession: "exit" });
+sealStoreClass(TiDBUsageWindowStore, "tidb-usage-window-store", { charge: "exit", read: "exit" });
+sealStoreClass(PgUsageWindowStore, "pg-usage-window-store", { charge: "exit", read: "exit" });
+sealStoreClass(SqlWorkflowJournalStore, "sql-workflow-journal-store", {
+    append: "exit", load: "exit", locator: "exit", loadPage: "exit", resumeClaim: "exit", releaseResumeClaim: "exit", reapExpired: "exit",
+});
 //# sourceMappingURL=store-backend.js.map

package/dist/plugins/store-boundary.d.ts

@@ -0,0 +1,57 @@
+import type { SqlExec } from "./sql-driver.js";
+/** T 的公开成员里**一切可调用**的键(含可选成员、同步或 Promise 联合返回;`keyof` 天然不含 private / protected;getter 不是可调用成员)。 */
+export type CallableKeysOf<T> = {
+    [K in keyof T]-?: NonNullable<T[K]> extends (...a: never[]) => unknown ? K : never;
+}[keyof T];
+/** 出口表的闭集三词(见文件头注)。 */
+export type StoreExitWord = "exit" | "boot" | "in-store";
+/** 成员的首参是不是调用方借来的语句面(`SqlExec` 形:事务连接 / 它的 `query` 面)—— `in-store` 只许给这一形。首参可缺省 / 是别的型 ⇒ 不是。 */
+type LendsStatementFace<F> = F extends (first: infer P, ...rest: never[]) => unknown ? ([P] extends [SqlExec] ? true : false) : false;
+/** 一只店的出口表:每个公开可调用成员的去处(闭集三词,见文件头注;借语句面的成员 `exit | in-store`,其余 `exit | boot`)。 */
+export type StoreExitPlan<T> = Readonly<{
+    [K in CallableKeysOf<T>]: LendsStatementFace<NonNullable<T[K]>> extends true ? "exit" | "in-store" : "exit" | "boot";
+}>;
+/**
+ * `boot` 一词只许这些名字(闭集):只在起服阶段被调、它们的错进起服拒句(要库的原码 / 原句,`databaseAnswerCodesOf` 一类读者),或交出给起服装配的原始池。
+ *  · `ensureSchema` / `runOneTimeMigrations`:起服建表与一次性迁移(stage-01..04);
+ *  · `close`:停机时关池(错进停机日志);
+ *  · `mysqlPool` / `pgPool`:后端交给起服装配的原始池 —— 装配拿它铸的店各自封口(记忆引擎、会话审计、任务清单车道)。
+ */
+export declare const BOOT_METHOD_NAMES: ReadonlySet<string>;
+/** 封过的成员带的标记(值 = 它的 `site`):门读它判「这一只封过」;继承成员靠它断言基类先封。 */
+export declare const SEALED_STORE_MEMBER: unique symbol;
+/** 一次封口的登记(门读):店词、形(类 / 对象)、名字、出口表。对象形按店词只登记第一次(工厂每次调用都铸新对象,登记不随调用次数增长)。 */
+export interface StoreSealRecord {
+    readonly store: string;
+    readonly kind: "class" | "object";
+    readonly name: string;
+    readonly plan: Readonly<Record<string | symbol, StoreExitWord>>;
+}
+/** 本进程已登记的封口(门读;不可写)。 */
+export declare function storeSealRecords(): readonly StoreSealRecord[];
+/**
+ * 封一只店类:`plan` 里每个 `exit` 成员 —— 本类原型上**自有**的 ⇒ 包一层;继承来的 ⇒ 断言继承到的那一只已封(否则加载即抛:先封基类)。
+ * 封口行住在店类的定义旁边;`src/stores-sql/**` 的店类例外 —— 那个目录要能原样搬进 core 包(对本仓其余部分零依赖,`test/dependency-direction-gate.test.ts` R8),
+ * 店边界是本服务的事(运维日志座、对外句词表),所以它们的封口住在组合座 `plugins/store-backend.ts`(装配它们的那一处)。
+ * 形参读类的 `prototype`(不读构造签名):受保护 / 抽象构造器的店基类同样能封;出口表按原型的实例形 `P` 穷尽。
+ * 异步生成器方法照封(调用交回的生成器对象由封口同封,迭代中途的错同样过边界);同步生成器方法拒封(加载即抛:它的错在调用返回之后才发生,封口接不住)。
+ */
+export declare function sealStoreClass<P extends object>(ctor: {
+    readonly prototype: P;
+    readonly name: string;
+}, store: string, plan: StoreExitPlan<P>): void;
+/**
+ * 封一只对象(工厂产物 / 读器 / 事务对象 / 店类的静态面):原地包 `plan` 里每个 `exit` 的自有可调用属性,交回**同一引用**。
+ * 运行期另断言「对象自有的可调用属性 ⊆ 表的键」(普通对象;工厂的对象先 `satisfies` 接口保住具体类型;多出一个 ⇒ 封口时就抛)。表里的可选成员对象上可以没有。
+ * 类的静态面(构造器)同样经这一只封;它的穷尽只靠编译期的表(TS 私有的静态成员运行期看不出私有)。
+ */
+export declare function sealStoreObject<T extends object>(obj: T, store: string, plan: StoreExitPlan<T>): T;
+/**
+ * 封一只**导出的自由函数**出店口(它自己借连接、拨库,调用方是店外的装配 / 读面 —— 不是哪只已封店方法的体):交回同签名的包过的函数,
+ * 同步抛与拒绝都过边界。`site` 是 `<店>.<动词>` 的字面词。
+ */
+export declare function sealStoreFunction<A extends unknown[], R>(fn: (...a: A) => R, site: string): (...a: A) => R;
+/** 惰性异步可迭代的封口:迭代中途(取下一项 / 提前结束)的错同样过边界。交回一只新的可迭代(原可迭代只被它读;生成器的 `return` 值原样交回)。 */
+export declare function sealStoreIterable<E>(it: AsyncIterable<E>, site: string): AsyncGenerator<E, unknown, undefined>;
+export {};
+//# sourceMappingURL=store-boundary.d.ts.map