@sema-agent/server 7.150.0 → 7.151.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,10 +41,11 @@ 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 { 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, FILE_HISTORY_BLOB_KEY_PREFIX, SqlFileHistoryStore } from "../stores-sql/file-history-store-sql.js";
+import { createLocalLandedAttendantSeat, createSqlLandedAttendantSeat } from "./landed-attendants.js";
 import { SqlBlobIndex } from "../stores-sql/blob-index-sql.js";
 import { MinioBlobBackend } from "./blob-backend.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
@@ -51,8 +53,8 @@ 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 +64,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 +85,13 @@ 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";
 export function createRunStallWiring(config, observers) {
     const count = observers?.runStallVerdicts;
     return { windowMs: () => config.runStaleSec * 1000, onVerdicts: (landed) => count?.(landed) };
@@ -151,7 +160,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 +180,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 +189,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 +210,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 +235,42 @@ 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;
     }
     ensureSchema() { return ensureTidbSchema(this.pool); }
     close() { return this.pool.end(); }
     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,8 +278,12 @@ 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))); }
+    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;
@@ -261,7 +295,7 @@ 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) }); }
@@ -283,21 +317,33 @@ 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", 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",
+});
 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;
     }
     ensureSchema() { return ensurePgSchema(this.pool); }
     close() { return this.pool.end(); }
     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,8 +351,12 @@ 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))); }
+    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;
@@ -318,7 +368,7 @@ 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) }); }
@@ -340,6 +390,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", 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",
+});
 export function localSessionRowsOf(backend) {
     return backend instanceof LocalBackend ? backend.session() : undefined;
 }
@@ -364,6 +423,7 @@ class LocalBackend {
     fileBackend;
     runStore;
     sessionStore;
+    workflowRunsSeat = createLocalWorkflowRunsSeat();
     resumeAnchorStore;
     approvalExemptionStore;
     approvalNonceStore;
@@ -399,11 +459,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);
@@ -518,8 +584,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; }
@@ -565,12 +633,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;
@@ -649,6 +720,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 +731,7 @@ class RefusedLocalBackend {
     toolResult() { return this.refused(); }
     fileUsageWindowStore() { return this.refused(); }
     localStoreDeclaration() { return this.refused(); }
+    bindWorkflowRunReader() { this.refused(); }
     mysqlPool() { return undefined; }
     pgPool() { return undefined; }
 }
@@ -669,12 +742,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;
@@ -770,4 +843,73 @@ 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",
+});
+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(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

package/dist/plugins/store-boundary.js

@@ -0,0 +1,139 @@
+import { storeBoundaryFault } from "../terminal.js";
+export const BOOT_METHOD_NAMES = new Set(["ensureSchema", "runOneTimeMigrations", "close", "mysqlPool", "pgPool"]);
+export const SEALED_STORE_MEMBER = Symbol("sema.sealedStoreMember");
+const SEALS = new Map();
+export function storeSealRecords() {
+    return [...SEALS.values()];
+}
+const STORE_WORD = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+export function sealStoreClass(ctor, store, plan) {
+    assertStoreWord(store);
+    const proto = ctor.prototype;
+    if (SEALS.has(`class:${store}`))
+        throw new Error(`store-boundary: store word ${store} is already sealed — every sealed producer has its own word`);
+    for (const key of Reflect.ownKeys(plan)) {
+        const word = plan[key];
+        assertWord(store, key, word);
+        if (word !== "exit")
+            continue;
+        const own = Object.getOwnPropertyDescriptor(proto, key);
+        if (own !== undefined) {
+            if (typeof own.value !== "function")
+                throw new Error(`store-boundary: ${store}.${String(key)} is not a method on ${ctor.name}.prototype (an accessor or a field cannot be sealed in place)`);
+            assertNotGenerator(store, key, own.value);
+            Object.defineProperty(proto, key, { ...own, value: sealedMember(own.value, `${store}.${String(key)}`) });
+            continue;
+        }
+        const inherited = proto[key];
+        if (typeof inherited !== "function")
+            throw new Error(`store-boundary: ${store}.${String(key)} is not a method reachable from ${ctor.name}.prototype`);
+        if (inherited[SEALED_STORE_MEMBER] === undefined) {
+            throw new Error(`store-boundary: ${store}.${String(key)} is inherited by ${ctor.name} from an unsealed base — seal the base class first`);
+        }
+    }
+    SEALS.set(`class:${store}`, { store, kind: "class", name: ctor.name, plan: Object.freeze({ ...plan }) });
+}
+export function sealStoreObject(obj, store, plan) {
+    assertStoreWord(store);
+    const planKeys = new Set(Reflect.ownKeys(plan));
+    if (typeof obj !== "function") {
+        for (const key of Reflect.ownKeys(obj)) {
+            const d = Object.getOwnPropertyDescriptor(obj, key);
+            if (d !== undefined && typeof d.value === "function" && !planKeys.has(key)) {
+                throw new Error(`store-boundary: ${store} has a callable member ${String(key)} that its exit plan does not list`);
+            }
+        }
+    }
+    for (const key of planKeys) {
+        const word = plan[key];
+        assertWord(store, key, word);
+        if (word !== "exit")
+            continue;
+        const d = Object.getOwnPropertyDescriptor(obj, key);
+        if (d === undefined)
+            continue;
+        if (typeof d.value !== "function")
+            throw new Error(`store-boundary: ${store}.${String(key)} is not a callable own property`);
+        if (d.value[SEALED_STORE_MEMBER] !== undefined)
+            continue;
+        assertNotGenerator(store, key, d.value);
+        if (d.writable !== true && d.configurable !== true)
+            throw new Error(`store-boundary: ${store}.${String(key)} is frozen and cannot be sealed`);
+        Object.defineProperty(obj, key, { ...d, value: sealedMember(d.value, `${store}.${String(key)}`) });
+    }
+    if (!SEALS.has(`object:${store}`))
+        SEALS.set(`object:${store}`, { store, kind: "object", name: store, plan: Object.freeze({ ...plan }) });
+    return obj;
+}
+export function sealStoreFunction(fn, site) {
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.[A-Za-z][A-Za-z0-9]*$/.test(site))
+        throw new Error(`store-boundary: site ${JSON.stringify(site)} is not <store word>.<verb>`);
+    return sealedMember(fn, site);
+}
+export async function* sealStoreIterable(it, site) {
+    try {
+        return yield* it;
+    }
+    catch (err) {
+        throw storeBoundaryFault(err, site);
+    }
+}
+function sealedMember(fn, site) {
+    const sealed = function (...args) {
+        try {
+            const out = fn.apply(this, args);
+            const then = thenOf(out);
+            if (then === undefined)
+                return sealedYield(out, site);
+            return Reflect.apply(then, out, [
+                (value) => sealedYield(value, site),
+                (err) => {
+                    throw storeBoundaryFault(err, site);
+                },
+            ]);
+        }
+        catch (err) {
+            throw storeBoundaryFault(err, site);
+        }
+    };
+    Object.defineProperty(sealed, "name", { value: fn.name, configurable: true });
+    Object.defineProperty(sealed, "length", { value: fn.length, configurable: true });
+    Object.defineProperty(sealed, SEALED_STORE_MEMBER, { value: site });
+    return sealed;
+}
+function thenOf(v) {
+    if (v === null || (typeof v !== "object" && typeof v !== "function"))
+        return undefined;
+    const then = Reflect.get(v, "then");
+    return typeof then === "function" ? then : undefined;
+}
+function sealedYield(value, site) {
+    let tag;
+    try {
+        tag = Object.prototype.toString.call(value);
+    }
+    catch (err) {
+        throw storeBoundaryFault(err, site);
+    }
+    return tag === "[object AsyncGenerator]" ? sealStoreIterable(value, site) : value;
+}
+function assertStoreWord(store) {
+    if (!STORE_WORD.test(store))
+        throw new Error(`store-boundary: store word ${JSON.stringify(store)} is not a lowercase dashed word`);
+}
+function assertWord(store, key, word) {
+    if (word === "exit" || word === "in-store")
+        return;
+    if (word === "boot") {
+        if (typeof key === "string" && BOOT_METHOD_NAMES.has(key))
+            return;
+        throw new Error(`store-boundary: ${store}.${String(key)} is marked boot but is not a boot lifecycle name (${[...BOOT_METHOD_NAMES].join(" / ")})`);
+    }
+    throw new Error(`store-boundary: ${store}.${String(key)} has exit word ${JSON.stringify(word)} (expected exit | boot | in-store)`);
+}
+function assertNotGenerator(store, key, fn) {
+    if (fn.constructor?.name === "GeneratorFunction") {
+        throw new Error(`store-boundary: ${store}.${String(key)} is a synchronous generator method — its failures happen after the call returns, where the seal cannot see them`);
+    }
+}
+//# sourceMappingURL=store-boundary.js.map

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

@@ -21,6 +21,7 @@
 import type { PeerSessionTempo, TaskResult, TaskStatus } from "@sema-agent/core";
 import type { RunIdentity } from "../identity-source.js";
 import type { SessionUnreadable } from "../session-error-wire.js";
+import type { SessionKind } from "../session-kind.js";
 import type { ReadDenyFloorSummary } from "../read-deny-floor-notice.js";
 /**
  * **File 店族的 boot 期拒启基类**([ref];把 `RunStoreStrictHydrateError` 的那条论证升成一条族规)。
@@ -616,6 +617,22 @@ export interface SessionSummary {
     /** fork 谱系:建这一行的那次 fork 的源会话 id(core `SessionMetadata.forkedFrom` 原词)—— present-iff 这一行是 fork 建的、且建于谱系落地之后(更早的 fork 不回填:源已不可知)。
      *  三店从行上读(谱系的唯一读法 `session-incarnation.ts` 的 `forkLineageOfRow`);来源住客(`forkedFromIncarnation`)不上列表行。wire 半场见 `security.ts SessionListItem.forkedFrom`(同名同义)。 */
     forkedFrom?: string;
+    /** 会话种类(律 `session-kind.ts`):present-iff 这只会话由一次带 `sessionKind` 的提交建下;顶层行缺席(恒不铸 null)。三店从行上读(唯一解码 `sessionKindFromCell`)。
+     *  wire 半场见 `security.ts SessionListItem.sessionKind`(同名同义)。 */
+    sessionKind?: SessionKind;
+}
+/** 列表面的查询形(`listSessions` / `listSessionRows` 同一形;三只会话店与路由同读)。`sessionKind` = 视图(律 `session-kind.ts`:缺席 = 缺省视图,只列无种类的会话)。 */
+export interface SessionListQuery {
+    owner?: string;
+    /** [ref] 窄互认第二臂的第三条件(SQL 孪生里是 `owner IS NULL` 谓词;local 店是同义的 `owner === null` 放行)。 */
+    includeUnowned?: boolean;
+    cursor?: {
+        lastActivityAt: string;
+        sessionId: string;
+    };
+    limit: number;
+    q?: string;
+    sessionKind?: SessionKind;
 }
 /**
  * run 账里「每会话的 run 投影」的五位([ref] 四位 + [ref] 预览位)—— 会话列表行上出自 run 行的那一半: