@sema-agent/server 7.150.0 → 7.152.0

package/dist/plugins/replica-registration.d.ts

@@ -5,7 +5,7 @@ export declare const REPLICA_REGISTRATION_TABLE = "replica_registration";
  * 本构建的能力名单(常设、只增):每一条读停-迁-起证据的一次性迁移一个名。删码之后名字留着 —— 名单只增不减(钉:`test/replica-registration.test.ts`)。
  * 守卫读证据时传的名在型上就要在这里(`ReplicaCapability`):不在名单里的迁移读不了证据,编译期红。
  */
-export declare const REPLICA_CAPABILITIES: readonly ["M40", "M41", "M42", "M43", "M51"];
+export declare const REPLICA_CAPABILITIES: readonly ["M40", "M41", "M42", "M43", "M51", "M54"];
 export type ReplicaCapability = (typeof REPLICA_CAPABILITIES)[number];
 /** 留存视界(写者钟):登记早于此的别人的行在下一次登记时删。量级取远大于任一副本的寿命与副本间钟差。 */
 export declare const REPLICA_REGISTRATION_HORIZON_MS: number;

package/dist/plugins/replica-registration.js

@@ -2,7 +2,7 @@ import { hostname } from "node:os";
 import { processInstanceId } from "../process-instance.js";
 import { serviceVersion } from "../service-version.js";
 export const REPLICA_REGISTRATION_TABLE = "replica_registration";
-export const REPLICA_CAPABILITIES = ["M40", "M41", "M42", "M43", "M51"];
+export const REPLICA_CAPABILITIES = ["M40", "M41", "M42", "M43", "M51", "M54"];
 export const REPLICA_REGISTRATION_HORIZON_MS = 90 * 24 * 60 * 60 * 1000;
 export function buildThisReplicaRegistration() {
     return { instanceId: processInstanceId(), releaseLine: serviceVersion(), capabilities: REPLICA_CAPABILITIES, hostName: hostname(), pid: process.pid };

package/dist/plugins/resume-anchor-store-sql.d.ts

@@ -17,14 +17,23 @@
  */
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type SqlDriver } from "./sql-driver.js";
+import { type SqlDialect, type SqlDriver, type SqlExec } from "./sql-driver.js";
+/**
+ * 一条锚的写(幂等 upsert,主键 `(session_id, event_id)`)—— **语句源**,跑在调用方给的执行口上:落定段(`landed-attendants.ts`:段首锁根行判过住客,
+ * 同一事务)是生产里唯一的调用方;店的 {@link SqlResumeAnchorStore.put} 是夹具 / 契约面的同一句。
+ */
+export declare function putAnchorOn(exec: Pick<SqlExec, "query">, dialect: SqlDialect, sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
+/** 一只会话的锚全删(按 `session_id` 定址)—— 语句源(落定段的擦除腿与 E21 删除同一句)。返回删掉的行数。 */
+export declare function deleteAnchorsOn(exec: Pick<SqlExec, "query">, dialect: SqlDialect, sessionId: string): Promise<number>;
 /** Dual-dialect durable resume-at anchor map. See the file header for the dialect-delta ledger. */
 export declare class SqlResumeAnchorStore {
     protected readonly db: SqlDriver;
     constructor(db: SqlDriver);
     /** Pick the dialect's SQL text. Both statements stay written out at the call site ON PURPOSE. */
     private q;
-    /** Record/overwrite the anchor for one settled message boundary (idempotent upsert on the (session_id,event_id) PK). */
+    /** Record/overwrite the anchor for one settled message boundary (idempotent upsert on the (session_id,event_id) PK). **Not a production writer**:
+     *  the deployment's read face (`StoreBackend.resumeAnchor()`'s `ResumeAnchorStore`) carries no `put` — every production anchor write goes through the landed section
+     *  (`landed-attendants.ts`), which runs {@link putAnchorOn} after locking the session row and judging the occupant. Fixtures seed through this verb. */
     put(sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
     /** Resolve a shell-supplied eventId → the persisted SessionTreeEntry.id; undefined = unknown anchor. */
     resolve(sessionId: string, eventId: string, owner: string | null): Promise<string | undefined>;

package/dist/plugins/resume-anchor-store-sql.js

@@ -1,4 +1,13 @@
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
+import { sealStoreClass } from "./store-boundary.js";
+export async function putAnchorOn(exec, dialect, sessionId, eventId, entryId, owner) {
+    await exec.query(dialect === "mysql"
+        ? "INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES (?,?,?,?,?) ON DUPLICATE KEY UPDATE entry_id = VALUES(entry_id), owner = VALUES(owner)"
+        : "INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES ($1,$2,$3,$4,$5) ON CONFLICT (session_id, event_id) DO UPDATE SET entry_id = EXCLUDED.entry_id, owner = EXCLUDED.owner", [sessionId, eventId, entryId, owner, new Date()]);
+}
+export async function deleteAnchorsOn(exec, dialect, sessionId) {
+    return (await exec.query(dialect === "mysql" ? "DELETE FROM resume_anchor WHERE session_id = ?" : "DELETE FROM resume_anchor WHERE session_id = $1", [sessionId])).affected;
+}
 export class SqlResumeAnchorStore {
     db;
     constructor(db) {
@@ -8,9 +17,7 @@ export class SqlResumeAnchorStore {
         return this.db.dialect === "mysql" ? mysql : pg;
     }
     async put(sessionId, eventId, entryId, owner) {
-        await this.db.query(this.q("INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES (?,?,?,?,?) " +
-            "ON DUPLICATE KEY UPDATE entry_id = VALUES(entry_id), owner = VALUES(owner)", "INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES ($1,$2,$3,$4,$5) " +
-            "ON CONFLICT (session_id, event_id) DO UPDATE SET entry_id = EXCLUDED.entry_id, owner = EXCLUDED.owner"), [sessionId, eventId, entryId, owner, new Date()]);
+        await putAnchorOn(this.db, this.db.dialect, sessionId, eventId, entryId, owner);
     }
     async resolve(sessionId, eventId, owner) {
         const { rows } = await this.db.query(this.q("SELECT entry_id FROM resume_anchor WHERE session_id = ? AND event_id = ? AND owner <=> ?", "SELECT entry_id FROM resume_anchor WHERE session_id = $1 AND event_id = $2 AND owner IS NOT DISTINCT FROM $3"), [sessionId, eventId, owner]);
@@ -21,10 +28,10 @@ export class SqlResumeAnchorStore {
         return rows.map((r) => ({ eventId: String(r.event_id), entryId: String(r.entry_id), owner: r.owner == null ? null : String(r.owner) }));
     }
     async deleteBySession(sessionId) {
-        const res = await this.db.query(this.q("DELETE FROM resume_anchor WHERE session_id = ?", "DELETE FROM resume_anchor WHERE session_id = $1"), [sessionId]);
-        return res.affected;
+        return deleteAnchorsOn(this.db, this.db.dialect, sessionId);
     }
 }
+sealStoreClass(SqlResumeAnchorStore, "sql-resume-anchor-store", { put: "exit", resolve: "exit", listBySession: "exit", deleteBySession: "exit" });
 export class TiDBResumeAnchorStore extends SqlResumeAnchorStore {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/retention-lane-store-sql.js

@@ -1,4 +1,5 @@
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const RETENTION_AUDIT_TABLE = "retention_audit";
 export const RETENTION_HOLD_TABLE = "retention_hold";
 export const RETENTION_LEASE_TABLE = "retention_lease";
@@ -217,6 +218,9 @@ export class SqlRetentionLaneStore {
         }));
     }
 }
+sealStoreClass(SqlRetentionLaneStore, "sql-retention-lane-store", {
+    acquire: "exit", renew: "exit", release: "exit", setHold: "exit", setHoldAudited: "exit", holdInForce: "exit", appendAudit: "exit", listAudit: "exit",
+});
 export class TiDBRetentionLaneStore extends SqlRetentionLaneStore {
     constructor(pool) {
         super(mysqlDriver(pool));

package/dist/plugins/retention-sql.d.ts

@@ -1,6 +1,7 @@
 /**
- * 托管留存的两只 SQL 谓词 —— 执行器(`stores-sql/retention-store-sql.ts`,引擎座表那一半)与部署的事务内钩(`plugins/retention-deployment.ts`,
- * 部署表那一半)对**同一条域律**发谓词,只从这里取:一条律一个读法,两半不各写一份(分家的方向是多删或漏删)。
+ * 托管留存的三只 SQL 谓词 —— 执行器(`stores-sql/retention-store-sql.ts`,引擎座表那一半)与部署的事务内钩(`plugins/retention-deployment.ts`,
+ * 部署表那一半)对**同一条域律**发谓词,只从这里取:一条律一个读法,两半不各写一份(分家的方向是多删或漏删)。第三只 —— 会话树的活引用
+ * ({@link sessionLiveReferenceSql})—— 另有会话老化的两个读者(`plugins/session-store-sql.ts` 的老化候选面与老化围栏):自动老化不许比托管留存松。
  *
  * 域 = 租户键:`COALESCE(session_meta.owner, '')` / `checkpoint.scope` 原样;**空串 `''` = 无主(anonymous/dev)桶**,谓词写成
  * `(owner IS NULL OR owner = '')` —— 合并只发生在无主侧,永远伸不进一个真租户;拆成两个桶才会漏(NULL 那半永不被枚举)。
@@ -26,4 +27,21 @@ export declare function retentionIdSet(dialect: SqlDialect, col: string, ids: re
     sql: string;
     params: unknown[];
 };
+/**
+ * **会话树的活引用 —— SQL 谓词的唯一写法**(`sm` = `session_meta` 的别名;两方言一只函数)。
+ *
+ * 读者三只,同调这一只:托管留存的「可删候选」(否定)与「被保护计数」(肯定)(`stores-sql/retention-store-sql.ts` 的 `liveReferenceExists`)、会话老化的候选面与
+ * 老化围栏的锁内重判(`plugins/session-store-sql.ts`;会话种类的律在 `src/session-kind.ts`)。两份手抄必然在某次改动后分家,而分家的方向是**多删**(候选放宽、
+ * 计数收紧,两边都不会有人红)。local 店的同义判是 `plugins/local-session-live-reference.ts`。
+ *
+ * 腿的词表:活跑 claim / 挂起 park(pending 检查点)/ 活着的后台子代(running|parked,三根会话锚)/ 在跑的 workflow(`originatingSessionId` 住在 run blob 里 ⇒
+ * JSON 提取是真方言分叉)。fork 子代**结构上没有边**(理由见 `SqlRetentionStore.deleteExpiredSessions` 的头注)。
+ *
+ * 🔴 [ref] C18 追加的**第五条腿**(placed 分区,core 5.48 [ref] 义务 4 的 server 侧兑现):一只 `placement_kind` 在场的会话是某条委派的**转录**,它的删除权
+ * **独家**属于联合 reap(`reapDurableAgents`:先按 rev 条件删 agent 行、赢了才 `release` 终结转录;以及行已不在时的分区收割腿)。让视界腿也去删它会造出两个删除
+ * 权威,而它们的交叠恰好是这条义务要关死的那个状态:行还在、指着一份已经不存在的转录(core 的 `delegation.transcript_integrity` 通告说的就是它)。⇒ 把「placed」当成
+ * 一条**活引用**:候选谓词排除它,被保护计数同时把它记成 skipped(两侧共用本函数 ⇒ 不可能分家)。它不会因此永生:分区收割腿按 `backgroundAgentRetentionMs` 的
+ * 年龄 + 「行确实不在」联合判定后真删。
+ */
+export declare function sessionLiveReferenceSql(dialect: SqlDialect): string;
 //# sourceMappingURL=retention-sql.d.ts.map

package/dist/plugins/retention-sql.js

@@ -5,4 +5,15 @@ export function retentionDomainWhere(dialect, col, domain, pgIndex) {
 export function retentionIdSet(dialect, col, ids, pgIndex) {
     return dialect === "mysql" ? { sql: `${col} IN (${ids.map(() => "?").join(",")})`, params: [...ids] } : { sql: `${col} = ANY($${pgIndex}::text[])`, params: [ids] };
 }
+export function sessionLiveReferenceSql(dialect) {
+    const workflow = dialect === "mysql"
+        ? `EXISTS (SELECT 1 FROM workflow_run wr WHERE wr.status = 'running' AND JSON_UNQUOTE(JSON_EXTRACT(wr.run, '$.originatingSessionId')) = sm.session_id)`
+        : `EXISTS (SELECT 1 FROM workflow_run wr WHERE wr.status = 'running' AND wr.run::json->>'originatingSessionId' = sm.session_id)`;
+    return (`(sm.placement_kind IS NOT NULL` +
+        ` OR EXISTS (SELECT 1 FROM task_active ta WHERE ta.session_id = sm.session_id)` +
+        ` OR EXISTS (SELECT 1 FROM checkpoint c2 WHERE c2.session_id = sm.session_id AND c2.status = 'pending')` +
+        ` OR EXISTS (SELECT 1 FROM background_agent ba WHERE ba.status IN ('running','parked')` +
+        `   AND (ba.session_id = sm.session_id OR ba.parent_session_id = sm.session_id OR ba.root_session_id = sm.session_id))` +
+        ` OR ${workflow})`);
+}
 //# sourceMappingURL=retention-sql.js.map

package/dist/plugins/run-store-sql.d.ts

@@ -3,7 +3,7 @@ import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type UsageRow } from "../usage-analytics.js";
 import { type RunStallWiring, type ClaimFenced, type CreateRunOutcome, type FencedRun, type NewRunMeta, type RunIdemBinding, type RunListQuery, type RunRecord, type RunEvent, type PersistedTaskResult, type LatestRunRef, type SettledLegMemoryObservation } from "./store-contracts.js";
-import { type SqlDriver, type SqlTxConn } from "./sql-driver.js";
+import { type SqlDialect, type SqlDriver, type SqlTxConn } from "./sql-driver.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 import { type SpaceCommitClaim, type SpaceCommitReading, type SpaceCommitState } from "../workspace-space-commit.js";
 export type { RunRecord, RunEvent, LatestRunRef } from "./store-contracts.js";
@@ -12,6 +12,25 @@ export type { RunRecord, RunEvent, LatestRunRef } from "./store-contracts.js";
  * ({@link decodeResultColumn},投影须经 `jsonColumnText`);读不出 ⇒ `"unreadable"`(迁移跳过那一行、码列不动 —— 店的读腿对它照旧响亮拒)。
  */
 export declare function decodeRunResultCellM44(v: unknown, taskId: string): PersistedTaskResult | null | "unreadable";
+/** 「`running` × 心跳 × 判活窗」谓词的哪一侧:`live` = 窗内心跳过(停-迁-起证据读法选的那一批),`stale` = 窗外(死亡判决落的那一批)。 */
+export type RunHeartbeatSide = "live" | "stale";
+/**
+ * 🔴 **「`running` × 心跳 × 判活窗」谓词的唯一构造**(SQL 两方言):死亡判决的那一句({@link SqlRunStore} 的 `landStallVerdicts`:收割器与两处单行落判决)
+ * 与停-迁-起证据读法(`stop-then-start.ts` 的 `readOlderReplicaEvidence`)同调它 —— 同一个窗界、同一处 `>=` / `<` 边界,`task_run` 心跳比较在本仓只有这一处文本
+ * (源码门 `test/run-liveness-single-source-gate.test.ts`)。交回 WHERE 片段与它唯一的绑定参数(窗界)。
+ *
+ * **钟**:心跳由写者在绑定参数里送它自己的进程钟(本店每一句 `updated_at = ?` 都送 `new Date()`),池把它编成库里的值(MySQL 协议:池选项 `timezone: "Z"`
+ * ⇒ `DATETIME(3)` 里存 UTC 墙钟,`tidb-pool.ts` 的 `tidbPoolOptions`;PG:`TIMESTAMPTZ` 存绝对时刻)。窗界取同一种钟、经同一只池编码 —— `nowMs − windowMs` 作绑定参数,
+ * 不用库侧的 `NOW(3)`:它按会话时区答墙钟,会话时区不是 UTC 的库上与写者存下的 UTC 墙钟差出整个时区偏移(证据读法因此读空 = 守卫静默放行)。
+ * `placeholder` = 这一片段在整句里的 PG 占位符序号(MySQL 协议恒 `?`)。
+ */
+export declare function runningHeartbeatPredicate(dialect: SqlDialect, side: RunHeartbeatSide, at: {
+    readonly nowMs: number;
+    readonly windowMs: number;
+}, placeholder: number): {
+    readonly sql: string;
+    readonly param: Date;
+};
 export declare class SqlRunStore {
     readonly db: SqlDriver;
     private readonly stall;
@@ -70,7 +89,7 @@ export declare class SqlRunStore {
      */
     private settleDueHolderOn;
     /**
-     * 🔴 **死亡判决的那一句**(收割器与两处单行落判决共用一只语句构造):`running ∧ updated_at < cutoff` ⇒ `failed` / `result = NULL` / {@link RUN_STALLED_ERROR} /
+     * 🔴 **死亡判决的那一句**(收割器与两处单行落判决共用一只语句构造;条件 = {@link runningHeartbeatPredicate} 的 `stale` 一侧,与停-迁-起证据读法同一只):`running ∧ updated_at < 窗界` ⇒ `failed` / `result = NULL` / {@link RUN_STALLED_ERROR} /
      * `error_code = run.stalled`,同一事务放认领。两种作用域:
      *  · **全表**(`taskId` 缺席,收割器):放掉每条非活非停驻行的认领 + 孤儿认领(语义同修前);
      *  · **单行**(`AND task_id = ?`,观察口 / 认领冲突):只有命中 1 行才 `DELETE FROM task_active WHERE task_id = ?` —— 心跳或停驻抢先赢了 CAS ⇒ 0 行 ⇒ 认领不动。

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

@@ -12,6 +12,7 @@ import { isDupKeyError } from "./sql-errors.js";
 import { readDeletingTokenOn } from "./session-ext-table.js";
 import { readRunIdentityCells, runIdentityCells } from "../identity-source.js";
 import { decideSpaceCommitAbandon, decideSpaceCommitClaim, fenceSpaceCommitAtTerminal, spaceCommitStateOf } from "../workspace-space-commit.js";
+import { sealStoreClass } from "./store-boundary.js";
 function runRowCols(dialect) {
     return (`task_id, session_id, owner, status, ${jsonColumnText(dialect, "result")}, error, error_code, job_id, source, ` +
         "identity_source, identity_scope, identity_principal_inc, instance_id, leg_id, cancel_requested, objective_preview, created_at, updated_at");
@@ -60,6 +61,20 @@ function m44ErrorCodeReadSide(status, result, column) {
         return column;
     return persistedPlaneOf(result).errorCode ?? null;
 }
+export function runningHeartbeatPredicate(dialect, side, at, placeholder) {
+    const p = dialect === "mysql" ? "?" : `$${placeholder}`;
+    const param = new Date(at.nowMs - at.windowMs);
+    switch (side) {
+        case "live":
+            return { sql: `status = 'running' AND updated_at >= ${p}`, param };
+        case "stale":
+            return { sql: `status = 'running' AND updated_at < ${p}`, param };
+        default: {
+            const unhandled = side;
+            throw new Error(`runningHeartbeatPredicate: unknown side ${String(unhandled)}`);
+        }
+    }
+}
 export class SqlRunStore {
     db;
     stall;
@@ -188,7 +203,7 @@ export class SqlRunStore {
         let landed = 0;
         try {
             await this.txOn(conn, async (c) => {
-                landed = await this.landStallVerdicts(c, new Date(nowMs - windowMs), holderTaskId);
+                landed = await this.landStallVerdicts(c, { nowMs, windowMs }, holderTaskId);
             });
         }
         catch (err) {
@@ -199,11 +214,12 @@ export class SqlRunStore {
             this.stall.onVerdicts(landed);
         return landed > 0;
     }
-    async landStallVerdicts(conn, cutoff, taskId) {
+    async landStallVerdicts(conn, at, taskId) {
         const one = taskId !== undefined;
+        const stale = { mysql: runningHeartbeatPredicate("mysql", "stale", at, 2), pg: runningHeartbeatPredicate("pg", "stale", at, 2) };
         const { affected } = await conn.query(this.q(`UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', error_code = '${RUN_HOLDER_DEATH_CODES.stalled}', updated_at = ? ` +
-            `WHERE status = 'running' AND updated_at < ?${one ? " AND task_id = ?" : ""}`, `UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', error_code = '${RUN_HOLDER_DEATH_CODES.stalled}', updated_at = $1 ` +
-            `WHERE status = 'running' AND updated_at < $2${one ? " AND task_id = $3" : ""}`), one ? [new Date(), cutoff, taskId] : [new Date(), cutoff]);
+            `WHERE ${stale.mysql.sql}${one ? " AND task_id = ?" : ""}`, `UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', error_code = '${RUN_HOLDER_DEATH_CODES.stalled}', updated_at = $1 ` +
+            `WHERE ${stale.pg.sql}${one ? " AND task_id = $3" : ""}`), one ? [new Date(), stale[this.db.dialect].param, taskId] : [new Date(), stale[this.db.dialect].param]);
         if (one) {
             if (affected === 1)
                 await conn.query(this.q("DELETE FROM task_active WHERE task_id = ?", "DELETE FROM task_active WHERE task_id = $1"), [taskId]);
@@ -221,7 +237,7 @@ export class SqlRunStore {
         let landed = 0;
         try {
             await this.tx(async (conn) => {
-                landed = await this.landStallVerdicts(conn, new Date(nowMs - windowMs), row.taskId);
+                landed = await this.landStallVerdicts(conn, { nowMs, windowMs }, row.taskId);
             });
         }
         catch (err) {
@@ -596,10 +612,10 @@ export class SqlRunStore {
         }));
     }
     async reapStale() {
-        const cutoff = new Date(Date.now() - this.stall.windowMs());
+        const at = { nowMs: Date.now(), windowMs: this.stall.windowMs() };
         let reaped = 0;
         await this.tx(async (conn) => {
-            reaped = await this.landStallVerdicts(conn, cutoff);
+            reaped = await this.landStallVerdicts(conn, at);
         });
         if (reaped > 0)
             this.stall.onVerdicts(reaped);
@@ -635,6 +651,14 @@ export class SqlRunStore {
         return reaped;
     }
 }
+sealStoreClass(SqlRunStore, "sql-run-store", {
+    createRun: "exit", observeRun: "exit", fillObjectivePreview: "exit", requestCancel: "exit", isCancelRequested: "exit", requestPreempt: "exit",
+    isPreemptRequested: "exit", heartbeat: "exit", appendEvent: "exit", maxSeq: "exit", setTerminal: "exit", readSpaceCommit: "exit", claimSpaceCommit: "exit",
+    endSpaceCommit: "exit", abandonSpaceCommit: "exit", setSuspended: "exit", setNeedsReview: "exit", markResuming: "exit", whileHoldingClaim: "exit",
+    getActiveTaskId: "exit", getRun: "exit", getRunByIdem: "exit", releaseIdemKey: "exit", withdrawMintedRun: "exit", bindIdemBodyFingerprint: "exit",
+    listRuns: "exit", latestRunForSession: "exit", latestMemoryObservationForSession: "exit", deleteBySession: "exit", sourceSummary: "exit", usageScan: "exit",
+    retainedFrom: "exit", getEvents: "exit", reapStale: "exit", reapSuspended: "exit", failSuspendedWithExpiredCheckpoint: "exit",
+});
 export class TiDBRunStore extends SqlRunStore {
     constructor(pool, stall) {
         super(mysqlDriver(pool), stall);

package/dist/plugins/s3-presign.d.ts

@@ -1,4 +1,14 @@
+import { type ObjectStoreOp } from "../object-store-buckets.js";
+/** The signed URL's lifetime under row `op` — the ONE reading of the table's TTL column. A row with no `knob` has a fixed TTL: the table's number, and a
+ *  call that brings one is refused (its number would be a second source). A knob row takes `requested` (the configured value the call brings) clamped to
+ *  the row's `maxSec` (the row's policy cap) — a call that brings none, or a value that is not a positive number of seconds (`0` is no lifetime at all),
+ *  takes the row's `defaultSec` — the reading the `SESSION_SNAPSHOT_TTL_SEC` loader gives its `0` (any other non-positive spelling no longer loads: the configuration is refused) — and a row with no default needs a positive one.
+ *  Every row, one answer for the SigV4 ceiling ({@link SIGV4_PRESIGN_MAX_SEC}): a lifetime over it is refused, never clamped (the knobs are refused above it
+ *  when the configuration loads, so a call that gets here is a defect). */
+export declare function rowTtlSec(op: ObjectStoreOp, requested: number | undefined): number;
 export interface S3PresignParams {
+    /** The object-store action table row this request is (its action must be `method`). */
+    op: ObjectStoreOp;
     /** Base endpoint, e.g. `http://minio.minio.svc.cluster.local:9000` (the host the SANDBOX will reach). */
     endpoint: string;
     bucket: string;
@@ -8,6 +18,7 @@ export interface S3PresignParams {
     accessKey: string;
     secretKey: string;
     region?: string;
+    /** The configured TTL (seconds) of a knob row; a fixed-TTL row takes none (see {@link rowTtlSec}). */
     expiresSec?: number;
     /** Override the signing clock (tests). Defaults to now. */
     now?: Date;
@@ -33,6 +44,8 @@ export declare function presignS3BucketUrl(p: S3BucketPresignParams): string;
 /** ListObjectsV2 presign(D-1 孤儿对象 GC,clay 拍 2026-07-28):GET `/<bucket>/?list-type=2&prefix=…`。
  *  bucket 级 GET 是**列举能力**——只给 server 端 sweep 用,URL 绝不外发(与 copy 面同纪律)。 */
 export declare function presignS3ListUrl(p: {
+    /** The object-store action table row this listing is (a LIST row). */
+    op: ObjectStoreOp;
     endpoint: string;
     bucket: string;
     prefix: string;
@@ -45,6 +58,8 @@ export declare function presignS3ListUrl(p: {
     now?: Date;
 }): string;
 export interface S3CopyPresignParams {
+    /** The object-store action table row this copy is (a COPY row). */
+    op: ObjectStoreOp;
     /** INTERNAL endpoint — CopyObject is a SERVER-side request with adapter creds; never hand this URL out. */
     endpoint: string;
     /** Destination coordinates (the PUT target). */
@@ -69,4 +84,12 @@ export declare function presignS3CopyUrl(p: S3CopyPresignParams): {
     url: string;
     headers: Record<string, string>;
 };
+/** The URL of an object on an anonymous-read bucket (no signature, no expiry): `<endpoint>/<bucket>/<key>`, each key segment URI-encoded. `op` names
+ *  the table's anonymous GET row; any other row is refused. */
+export declare function buildPublicObjectUrl(p: {
+    op: ObjectStoreOp;
+    endpoint: string;
+    bucket: string;
+    key: string;
+}): string;
 //# sourceMappingURL=s3-presign.d.ts.map

package/dist/plugins/s3-presign.js

@@ -1,4 +1,30 @@
 import { createHash, createHmac } from "node:crypto";
+import { SIGV4_PRESIGN_MAX_SEC, objectStoreActionOf } from "../object-store-buckets.js";
+function assertRow(op, verb, signing) {
+    const row = objectStoreActionOf(op);
+    if (row.action !== verb)
+        throw new Error(`object-store seat: ${op} is a ${row.action} row — refusing to build a ${verb} request under it`);
+    if ((row.ttl === "unsigned") !== (signing === "anonymous")) {
+        throw new Error(`object-store seat: ${op} is ${row.ttl === "unsigned" ? "an anonymous" : "a signed"} row — refusing to build ${signing === "anonymous" ? "an anonymous" : "a signed"} URL under it`);
+    }
+}
+export function rowTtlSec(op, requested) {
+    const ttl = objectStoreActionOf(op).ttl;
+    if (ttl === "unsigned")
+        throw new Error(`object-store seat: ${op} is unsigned — it has no URL lifetime`);
+    if (ttl.knob === undefined) {
+        if (requested !== undefined)
+            throw new Error(`object-store seat: ${op} has a fixed TTL (${ttl.defaultSec} s, the table's) — refusing a call-site TTL of ${requested} s`);
+        return ttl.defaultSec;
+    }
+    const sec = requested !== undefined && requested > 0 ? requested : ttl.defaultSec;
+    if (sec === undefined)
+        throw new Error(`object-store seat: ${op} takes its TTL from ${ttl.knob} or its call — none was given`);
+    if (sec > SIGV4_PRESIGN_MAX_SEC) {
+        throw new Error(`object-store seat: ${op} was asked for a ${sec} s URL — a SigV4 presigned URL lives at most ${SIGV4_PRESIGN_MAX_SEC} s (7 days); ${ttl.knob} is refused above that when the configuration loads`);
+    }
+    return ttl.maxSec !== undefined ? Math.min(sec, ttl.maxSec) : sec;
+}
 function uriEncode(s, encodeSlash) {
     let out = "";
     for (const ch of Buffer.from(s, "utf8")) {
@@ -57,18 +83,21 @@ function presignCanonical(p) {
     return `${url.origin}${canonicalUri}?${canonicalQuery}&X-Amz-Signature=${signature}`;
 }
 export function presignS3Url(p) {
+    assertRow(p.op, p.method, "signed");
+    const expiresSec = rowTtlSec(p.op, p.expiresSec);
     if (p.key === "") {
         throw new Error("presignS3Url: refusing to sign an empty key (single-object contract) — use presignS3BucketUrl for bucket-level operations");
     }
     if (p.key.startsWith("/") || p.key.split("/").some((seg) => seg === "." || seg === "..")) {
         throw new Error(`presignS3Url: refusing to sign a key with a traversal segment: ${p.key}`);
     }
-    return presignCanonical({ ...p, canonicalUri: `/${uriEncode(p.bucket, true)}/${uriEncode(p.key, false)}` });
+    return presignCanonical({ ...p, expiresSec, canonicalUri: `/${uriEncode(p.bucket, true)}/${uriEncode(p.key, false)}` });
 }
 export function presignS3BucketUrl(p) {
     return presignCanonical({ ...p, canonicalUri: `/${uriEncode(p.bucket, true)}/` });
 }
 export function presignS3ListUrl(p) {
+    assertRow(p.op, "LIST", "signed");
     return presignCanonical({
         endpoint: p.endpoint,
         canonicalUri: `/${uriEncode(p.bucket, true)}/`,
@@ -76,7 +105,7 @@ export function presignS3ListUrl(p) {
         accessKey: p.accessKey,
         secretKey: p.secretKey,
         ...(p.region ? { region: p.region } : {}),
-        ...(p.expiresSec ? { expiresSec: p.expiresSec } : {}),
+        expiresSec: rowTtlSec(p.op, p.expiresSec),
         ...(p.now ? { now: p.now } : {}),
         extraQuery: {
             "list-type": "2",
@@ -87,6 +116,7 @@ export function presignS3ListUrl(p) {
     });
 }
 export function presignS3CopyUrl(p) {
+    assertRow(p.op, "COPY", "signed");
     for (const [label, key] of [
         ["destination", p.key],
         ["source", p.sourceKey],
@@ -105,10 +135,14 @@ export function presignS3CopyUrl(p) {
         accessKey: p.accessKey,
         secretKey: p.secretKey,
         ...(p.region !== undefined ? { region: p.region } : {}),
-        ...(p.expiresSec !== undefined ? { expiresSec: p.expiresSec } : {}),
+        expiresSec: rowTtlSec(p.op, p.expiresSec),
         ...(p.now !== undefined ? { now: p.now } : {}),
         signedHeaders: { "x-amz-copy-source": copySource },
     });
     return { url, headers: { "x-amz-copy-source": copySource } };
 }
+export function buildPublicObjectUrl(p) {
+    assertRow(p.op, "GET", "anonymous");
+    return `${p.endpoint.replace(/\/+$/, "")}/${p.bucket}/${p.key.split("/").map(encodeURIComponent).join("/")}`;
+}
 //# sourceMappingURL=s3-presign.js.map

package/dist/plugins/scenario-prefix-switch-m42.d.ts

@@ -24,7 +24,7 @@ export type ScenarioPrefixRefusalReason = "stored_prefix" | "older_replica";
 /**
  * M42 的起服拒。具名类型 + 机读码 + 拒因;继承 {@link StoreBootRefusalError}(SQL 开库的等待窗不重试它;隐式 local 的降级臂不吞)。一个字节没改(扫描只读,标记没写)。
  *  · `stored_prefix` —— 存量里有以保留前缀开头的身份(`hits` 逐来源点名);
- *  · `older_replica` —— 零命中,但有停-迁-起证据:更早版本的副本可能还在服务,扫描之后它还会收下这类身份 ⇒ 全停之后再起(`live` = 证据,带时刻)。
+ *  · `older_replica` —— 标记不在,而有停-迁-起证据(守卫段在扫描之前判):更早版本的副本可能还在服务,扫描之后它还会收下这类身份 ⇒ 全停之后再起(`live` = 证据,带时刻)。
  */
 export declare class ScenarioPrefixSwitchRefusedError extends StoreBootRefusalError {
     readonly reason: ScenarioPrefixRefusalReason;

package/dist/plugins/scenario-prefix-switch-m42.js

@@ -31,9 +31,9 @@ export class ScenarioPrefixSwitchRefusedError extends StoreBootRefusalError {
             case "older_replica":
                 if (live === undefined)
                     throw new Error("scenario-prefix-switch: an older_replica refusal carries its evidence");
-                return (`${SCENARIO_PREFIX_SWITCH_REFUSED_CODE}: no stored identity starts with the reserved prefix "${SCENARIO_SUBJECT_PREFIX}", but ${olderReplicaEvidenceSentence(live)} ` +
+                return (`${SCENARIO_PREFIX_SWITCH_REFUSED_CODE}: this version reserves the prefix "${SCENARIO_SUBJECT_PREFIX}" and checks stored identities for it once before recording a marker, but ${olderReplicaEvidenceSentence(live)} ` +
                     `— a replica of an earlier version may still be serving, and it accepts principals with that prefix, so a clean check now would not stay clean. ` +
-                    `Nothing was changed and no marker was written. ${stopThenStartAction(live.after)}`);
+                    `Nothing was scanned or changed and no marker was written. ${stopThenStartAction(live.after)}`);
             default: {
                 const unhandled = reason;
                 throw new Error(`scenario-prefix-switch: unknown refusal reason ${String(unhandled)}`);

package/dist/plugins/scheduler-support.d.ts

@@ -47,8 +47,8 @@ export interface SchedulerStoreLog {
  * 的 `record` 可能是任意内容 —— 只报下标):
  *  · `unreadable-file` ⇒ warn(整份文件不是 JSON 数组:读成零条,写者一律不写 —— 见 `mutateSchedulerStore`);
  *  · `malformed-record` ⇒ warn(这一条读不懂、被跳过;下一个写者落盘时它就没了);
- *  · `stale-session-record` ⇒ info(会话链上过期 ≥ 7 天的记录,读时丢、下一个写者落盘);
- *  · `one-time-migration` ⇒ info(SS-M3 的读时改写收据:durable 记录换上新键,下一个写者落盘)。
+ *  · `stale-session-record` ⇒ info(会话链上过期 ≥ 7 天的记录,读时丢、下一个写者落盘)。
+ * (settings-schema 26.0.0 删了调度店的读时重铸一步与它的收据臂:仍按会话链键存的 durable 记录逐字读出、不告警 —— 没有日志可写。)
  */
 export declare function logSchedulerWarnings(log: SchedulerStoreLog, path: string, warnings: readonly SchedulerParseWarning[]): void;
 /**

package/dist/plugins/scheduler-support.js

@@ -75,9 +75,6 @@ export function logSchedulerWarnings(log, path, warnings) {
             case "stale-session-record":
                 log.info("scheduler_store_record_stale", { path, index: w.index, id: w.id, note: "a session-chained record whose next run is ≥ 7 days past — dropped on read (the next write persists the drop)" });
                 break;
-            case "one-time-migration":
-                log.info("scheduler_store_record_migrated", { path, index: w.index, migration: w.receipt.migration, appliedAs: w.receipt.appliedAs, note: "settings-schema one-time migration rewrote this record on read (the next write persists it)" });
-                break;
             default: {
                 const unhandled = w;
                 throw new Error(`scheduler store: unknown read warning ${JSON.stringify(unhandled)}`);

package/dist/plugins/schema-consistency.d.ts

@@ -185,8 +185,10 @@ export declare function describeMismatchedTables(dialect: SqlDialect, mismatches
 /**
  * **升级清单**(多行;`[]` = 没有语句要部署者执行,清单不出):一次起服的拒句里「这只库此刻对本构建还差什么、先后顺序」一段。
  * 缺列拒、判活拒、一次性迁移的拒本来各报各的一段 —— 运维补一句再起、才撞上下一族(列册对账在迁移段之后时,第四次起服才拒出其余全部 ALTER)。
- * 清单把本构建对这一只库的全部动作写成一张:① 逐表的 ALTER(其下 {@link describeMismatchedTables} 的逐表段,全库一次列全)② 这只库**还欠**的停-迁-起迁移
- * ③ 起服。第 ② 步逐行问登记行的 `stopThenStart.owedOn`(一次性迁移文件静态依赖本文件,所以惰性载入)—— 那条迁移的守卫自己问的同一只判据,清单不另判:
+ * 清单把本构建对这一只库的全部动作写成一张:⓪ 这只库要求、本构建没有的能力(起服要求表 `serving_requirement` 里本构建能力名单之外的行;有才出,排在一切语句之前 ——
+ * 照清单补完语句也不会让本构建能在这里服务:库形对账与「谁可以服务」是两个事实,补列是在把那条迁移改掉的形补回去)① 逐表的 ALTER(其下 {@link describeMismatchedTables} 的逐表段,
+ * 全库一次列全)② 这只库**还欠**的停-迁-起迁移 ③ 起服。第 ⓪ 步与准入同一只读法(`serving-requirement.ts` 的 `unmetServingRequirements`);要求表不在 ⇒ 不出(那是准入的 `table_absent`,
+ * 清单不判);读抛 ⇒ 照出并如实说没读到。第 ② 步逐行问登记行的 `stopThenStart.owedOn`(一次性迁移文件静态依赖本文件,所以惰性载入)—— 那条迁移的守卫段自己问的同一只判据,清单不另判:
  * 已经走过它们的库(标记落了 / 部署格已搬 / 零行旧词)一条不欠 ⇒ 第 ② 步与它的「不可滚动」动作段都不出,起服是第 ② 步。某一条读不出欠不欠(探针读抛)⇒ 照列并如实说
  * 没读到(多停一次,不漏停)。`read` = 列册对账读列册的同一只无参读口。
  */

package/dist/plugins/schema-consistency.js

@@ -2,7 +2,9 @@ import { recordEnsureStatements } from "./schema-ensure-legs.js";
 import { readLiveColumns } from "./schema-live-columns.js";
 import { SCHEMA_MISMATCH_WAYS_OUT } from "./schema-drift-sentence.js";
 import { SCHEMA_MISMATCH_ERROR_CODE, SchemaMismatchRefusedError, StoreBootRefusalError } from "./store-contracts.js";
-import { stopThenStartAction } from "./stop-then-start-sentence.js";
+import { stopThenStartAction, unmetRequirementChecklistStep } from "./stop-then-start-sentence.js";
+import { SERVING_REQUIREMENT_TABLE, unmetServingRequirements } from "./serving-requirement.js";
+import { REPLICA_CAPABILITIES } from "./replica-registration.js";
 const QUOTES = new Set(["'", '"', "`"]);
 function stripComments(sql) {
     let out = "";
@@ -469,7 +471,11 @@ export async function describeUpgradeChecklist(read, dialect, mismatches) {
         if (owes)
             owed.push(`  - ${m.id}: ${m.reason}`);
     }
-    const steps = [["Run every statement printed below, each recipe in the order it is printed (a printed comment line marks a value only you can choose) — all tables at once, before anything else (this build never alters a database for you)."]];
+    const steps = [];
+    const requirements = await unmetRequirementsForChecklist(read, dialect);
+    if (requirements !== undefined)
+        steps.push(requirements);
+    steps.push(["Run every statement printed below, each recipe in the order it is printed (a printed comment line marks a value only you can choose) — all tables at once, before anything else (this build never alters a database for you)."]);
     if (owed.length > 0) {
         steps.push([
             "Stop-then-start one-time migrations this database still owes: this build runs them itself on its first boot (no statement from you), and each refuses to start — writing nothing — while a run on this database has",
@@ -484,6 +490,17 @@ export async function describeUpgradeChecklist(read, dialect, mismatches) {
         ...steps.flatMap((lines, i) => lines.map((l, k) => (k === 0 ? `  ${i + 1}. ${l}` : `     ${l}`))),
     ];
 }
+async function unmetRequirementsForChecklist(read, dialect) {
+    try {
+        if (!(await readLiveColumns(read, dialect)).has(SERVING_REQUIREMENT_TABLE))
+            return undefined;
+        const unmet = await unmetServingRequirements(read, { capabilities: REPLICA_CAPABILITIES });
+        return unmet.length === 0 ? undefined : unmetRequirementChecklistStep(unmet);
+    }
+    catch (err) {
+        return unmetRequirementChecklistStep([], err instanceof Error ? err.message : String(err));
+    }
+}
 export function describeSchemaMismatch(dialect, mismatches, checklist = []) {
     const lines = [
         `${SCHEMA_MISMATCH_ERROR_CODE}: the ${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} database does not match this build's schema — refusing to start.`,

package/dist/plugins/schema-indexes.js

@@ -20,6 +20,8 @@ export const CENTRAL_SCHEMA_INDEXES = [
     { table: "file_history_boundary_file", name: "idx_file_history_bf_key", columns: ["scope", "key_hash"] },
     { table: "file_history_boundary", name: "uq_file_history_boundary_seq", columns: ["scope", "publish_seq"], unique: true },
     { table: "file_history_blob", name: "idx_file_history_blob_created", columns: ["created_at"] },
+    { table: "file_history_blob_grant", name: "idx_file_history_blob_grant_granted", columns: ["granted_at"] },
+    { table: "file_history_blob_grant", name: "idx_file_history_blob_grant_blob", columns: ["blob_hash"] },
     { table: "workflow_run", name: "idx_wfrun_scope_created", columns: ["scope", "created_at_ms"] },
     { table: "workflow_run", name: "idx_wfrun_scope_status", columns: ["scope", "status"] },
     { table: "workflow_agent_session", name: "idx_wfagentsess_run", columns: ["run_id"] },

package/dist/plugins/send-file-ledger.d.ts

@@ -55,8 +55,8 @@ export declare class FileSendFileLedger implements SendFileLedger {
 }
 export interface LedgerRecordingDeps {
     ledger: SendFileLedger;
-    /** Best-effort reclaim of the uploaded object when the record fails (issuer.deleteObject). */
-    deleteObject: (bucket: string, key: string) => Promise<void>;
+    /** Best-effort reclaim of the uploaded object when the record fails (issuer.deleteObject; `track` = the link's track). */
+    deleteObject: (bucket: string, key: string, track: IssuedFileLink["track"]) => Promise<void>;
     warn?: (msg: string, meta?: Record<string, unknown>) => void;
     now?: () => number;
     newId?: () => string;

package/dist/plugins/send-file-ledger.js

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { AppendLog, ensureDir, uuidv7 } from "@sema-agent/core";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
+import { sealStoreClass } from "./store-boundary.js";
 export const SENDFILE_SINGLE_USER_SCOPE = "_";
 export class TiDBSendFileLedger {
     pool;
@@ -17,6 +18,7 @@ export class TiDBSendFileLedger {
         return rows.map((r) => rowToEntry(r));
     }
 }
+sealStoreClass(TiDBSendFileLedger, "tidb-send-file-ledger", { record: "exit", listByScope: "exit" });
 export class PgSendFileLedger {
     pool;
     constructor(pool) {
@@ -32,6 +34,7 @@ export class PgSendFileLedger {
         return res.rows.map(rowToEntry);
     }
 }
+sealStoreClass(PgSendFileLedger, "pg-send-file-ledger", { record: "exit", listByScope: "exit" });
 function rowToEntry(r) {
     return {
         id: String(r.id),
@@ -127,10 +130,10 @@ export function withLedgerRecording(send, deps) {
             let reclaimed = true;
             try {
                 try {
-                    await deps.deleteObject(link.bucket, link.key);
+                    await deps.deleteObject(link.bucket, link.key, link.track);
                 }
                 catch {
-                    await deps.deleteObject(link.bucket, link.key);
+                    await deps.deleteObject(link.bucket, link.key, link.track);
                 }
             }
             catch (de) {

package/dist/plugins/send-user-file.d.ts

@@ -1,5 +1,3 @@
-/** SigV4 physical ceiling (AWS: X-Amz-Expires max 604800s = 7 days). */
-export declare const PRESIGN_MAX_TTL_SEC = 604800;
 /**
  * Multi-tenant governance (clay ruling 2026-07-14, blackboard [ref]② variant a with a HASHED segment): every
  * object key carries a per-tenant SCOPE SEGMENT so tenants can be listed/revoked by prefix on the store itself,
@@ -102,8 +100,9 @@ export interface SendUserFileIssuer {
      *  semantics as issue() — prepare and finalize share ONE key, so the segment is fixed at prepare time. */
     prepareDirectUpload(filename: string | undefined, ttlSec?: number, scope?: string): PreparedDirectUpload;
     /** Best-effort object reclaim (ledger fail-loud path: an uploaded object whose ledger record failed would be
-     *  an unmanageable orphan — delete it). Signed DELETE against the INTERNAL endpoint with adapter creds. */
-    deleteObject(bucket: string, key: string): Promise<void>;
+     *  an unmanageable orphan — delete it). Signed DELETE against the INTERNAL endpoint with adapter creds. `track` = the link's track
+     *  (which object-store action row the delete is: the permanent track's bucket or the private one). */
+    deleteObject(bucket: string, key: string, track: IssuedFileLink["track"]): Promise<void>;
     /** The public endpoint web clients need for rendering context (bootstrap/capabilities透出). */
     readonly publicEndpoint: string | undefined;
 }