@sema-agent/server 7.151.0 → 7.152.0

package/dist/stores-sql/file-history-store-sql.js

@@ -1,20 +1,28 @@
 import { createHash } from "node:crypto";
 import { captureFileBackupViaEnv, applyFileRestoreViaEnv, fileHistoryModeProvenDifferent, worldStillMatchesMint, annulProofFailure, boundaryPublishVerdict, fileHistoryDescribeTrackKey, fileHistoryTrackKeyOf, fileHistoryResolveTrackKey, fileHistoryExportDigest, validateFileHistoryExport, resolveFileHistoryRetention, fileHistoryBoundariesToKeep, } from "@sema-agent/core";
-import { BlobTooLargeError, SqlBlobIndex } from "./blob-index-sql.js";
+import { BlobTooLargeError, SqlBlobIndex, blobGcCutoffAt, hashBatches } from "./blob-index-sql.js";
 import { mysqlDriver, pgDriver } from "../plugins/sql-driver.js";
 import { isMissingColumnError, retryOnDeadlock, SqlArbitrationLostError } from "../plugins/sql-errors.js";
 import { probedMissingColumnRefusal } from "../plugins/schema-drift-sentence.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { foldCaughtFailure } from "../file-history-disclosure.js";
 export const FILE_HISTORY_BLOB_TABLE = "file_history_blob";
-export const FILE_HISTORY_BLOB_KEY_PREFIX = "file-history/";
+export const FILE_HISTORY_BLOB_GRANT_TABLE = "file_history_blob_grant";
+export const FILE_HISTORY_SCOPED_TABLES = [
+    "file_history_boundary_file",
+    "file_history_boundary",
+    "file_history_reaped_entry",
+    "file_history_version",
+    "file_history_tracked",
+    FILE_HISTORY_BLOB_GRANT_TABLE,
+    "file_history_scope",
+];
 const sha256hex = (s) => createHash("sha256").update(s).digest("hex");
 const truthy = (v) => v === true || v === 1 || v === "1";
 class StagedRefGoneError extends Error {
 }
 class ScopeSentinelVanishedError extends SqlArbitrationLostError {
 }
-const FILE_HISTORY_SCOPED_TABLES = ["file_history_boundary_file", "file_history_boundary", "file_history_reaped_entry", "file_history_version", "file_history_tracked", "file_history_scope"];
 function reapedEntryRefusal(entryId) {
     return {
         ok: false,
@@ -24,14 +32,89 @@ function reapedEntryRefusal(entryId) {
         },
     };
 }
+export class SqlBlobExchange {
+    blobs;
+    constructor(blobs) {
+        this.blobs = blobs;
+    }
+    async put(hash, bytes) {
+        if (sha256hex(bytes) !== hash) {
+            return { ok: false, error: { code: "adopt_failed", message: `blob ${hash}: the bytes do not hash to this address — nothing stored`, permanence: "terminal" } };
+        }
+        try {
+            await this.blobs.put(hash, bytes);
+            return { ok: true };
+        }
+        catch (err) {
+            if (err instanceof BlobTooLargeError)
+                return { ok: false, error: { code: "adopt_failed", message: err.message, permanence: "terminal", blobCap: { wallSource: err.cap.source } } };
+            const f = foldCaughtFailure(err, "sql-blob-exchange.put");
+            return { ok: false, error: { code: "snapshot_failed", message: `blob ${hash} write/upload failed: ${f.text}`, ...f.fault } };
+        }
+    }
+    get(hash) {
+        return this.blobs.get(hash);
+    }
+    has(hashes) {
+        return this.blobs.has([...hashes]);
+    }
+}
+export class SqlBlobLanding {
+    db;
+    exchange;
+    constructor(db, exchange) {
+        this.db = db;
+        this.exchange = exchange;
+    }
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
+    }
+    static ownerKey(landing) {
+        return landing.owner ?? "";
+    }
+    async putAt(landing, hash, bytes) {
+        const stored = await this.exchange.put(hash, bytes);
+        if (!stored.ok)
+            return stored;
+        try {
+            await this.db.query(this.q(`INSERT INTO ${FILE_HISTORY_BLOB_GRANT_TABLE} (scope, landing_owner, blob_hash, granted_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE granted_at = GREATEST(granted_at, VALUES(granted_at))`, `INSERT INTO ${FILE_HISTORY_BLOB_GRANT_TABLE} (scope, landing_owner, blob_hash, granted_at) VALUES ($1,$2,$3,$4) ON CONFLICT (scope, landing_owner, blob_hash) DO UPDATE SET granted_at = GREATEST(${FILE_HISTORY_BLOB_GRANT_TABLE}.granted_at, EXCLUDED.granted_at)`), [landing.sessionId, SqlBlobLanding.ownerKey(landing), hash, new Date()]);
+            return { ok: true };
+        }
+        catch (err) {
+            const f = foldCaughtFailure(err, "sql-blob-landing.putAt");
+            return { ok: false, error: { code: "snapshot_failed", message: `blob ${hash} was stored but its upload grant could not be recorded: ${f.text}`, ...f.fault } };
+        }
+    }
+    async visibleAt(landing, hashes) {
+        const wanted = new Set(hashes);
+        if (wanted.size === 0)
+            return new Set();
+        const candidates = new Set();
+        if (landing.occupied) {
+            const graph = await this.db.query(this.q("SELECT DISTINCT blob_hash FROM file_history_version WHERE scope = ? AND blob_hash IS NOT NULL", "SELECT DISTINCT blob_hash FROM file_history_version WHERE scope = $1 AND blob_hash IS NOT NULL"), [landing.sessionId]);
+            for (const r of graph.rows) {
+                const h = String(r.blob_hash);
+                if (wanted.has(h))
+                    candidates.add(h);
+            }
+        }
+        const ungranted = [...wanted].filter((h) => !candidates.has(h));
+        for (const batch of hashBatches(ungranted)) {
+            const ph = batch.map((_, i) => (this.db.dialect === "mysql" ? "?" : `$${i + 3}`)).join(",");
+            const granted = await this.db.query(this.q(`SELECT blob_hash FROM ${FILE_HISTORY_BLOB_GRANT_TABLE} WHERE scope = ? AND landing_owner = ? AND blob_hash IN (${ph})`, `SELECT blob_hash FROM ${FILE_HISTORY_BLOB_GRANT_TABLE} WHERE scope = $1 AND landing_owner = $2 AND blob_hash IN (${ph})`), [landing.sessionId, SqlBlobLanding.ownerKey(landing), ...batch]);
+            for (const r of granted.rows)
+                candidates.add(String(r.blob_hash));
+        }
+        if (candidates.size === 0)
+            return new Set();
+        return this.exchange.has([...candidates]);
+    }
+}
 export class SqlFileHistoryStore {
     db;
     pool;
-    blobExchange = {
-        put: (hash, bytes) => this.putExchangedBlob(hash, bytes),
-        get: (hash) => this.blobs.get(hash),
-        has: (hashes) => this.blobs.has([...hashes]),
-    };
+    blobExchange;
+    blobLanding;
     blobs;
     spentAttempts = new Set();
     activeAttempts = new Set();
@@ -45,6 +128,8 @@ export class SqlFileHistoryStore {
             ...(opts?.blobSqlMaxBytes !== undefined ? { maxBytes: opts.blobSqlMaxBytes } : {}),
             ...(opts?.log !== undefined ? { log: opts.log } : {}),
         });
+        this.blobExchange = new SqlBlobExchange(this.blobs);
+        this.blobLanding = new SqlBlobLanding(this.db, this.blobExchange);
         this.boundaryKeep = resolveFileHistoryRetention(this.db.dialect === "mysql" ? "TiDBFileHistoryStore" : "PgFileHistoryStore", opts?.retention);
     }
     q(mysql, pg) {
@@ -607,26 +692,12 @@ export class SqlFileHistoryStore {
         return total;
     }
     async sweepOrphanBlobs() {
-        const { rows } = await this.db.query("SELECT blob_hash FROM file_history_blob WHERE blob_hash NOT IN (SELECT blob_hash FROM file_history_version WHERE blob_hash IS NOT NULL)");
-        const orphans = rows.map((r) => String(r.blob_hash));
-        if (orphans.length === 0)
-            return 0;
-        return this.blobs.sweep(orphans);
-    }
-    async putExchangedBlob(hash, bytes) {
-        if (sha256hex(bytes) !== hash) {
-            return { ok: false, error: { code: "adopt_failed", message: `blob ${hash}: the bytes do not hash to this address — nothing stored`, permanence: "terminal" } };
-        }
-        try {
-            await this.blobs.put(hash, bytes);
-            return { ok: true };
-        }
-        catch (err) {
-            if (err instanceof BlobTooLargeError)
-                return { ok: false, error: { code: "adopt_failed", message: err.message, permanence: "terminal", blobCap: { wallSource: err.cap.source } } };
-            const f = foldCaughtFailure(err, "sql-file-history-store.putExchangedBlob");
-            return { ok: false, error: { code: "snapshot_failed", message: `blob ${hash} write/upload failed: ${f.text}`, ...f.fault } };
-        }
+        const cutoff = blobGcCutoffAt(Date.now());
+        return this.blobs.sweep(async () => {
+            await this.db.query(this.q(`DELETE FROM ${FILE_HISTORY_BLOB_GRANT_TABLE} WHERE granted_at < ?`, `DELETE FROM ${FILE_HISTORY_BLOB_GRANT_TABLE} WHERE granted_at < $1`), [cutoff]);
+            const { rows } = await this.db.query(`SELECT blob_hash FROM ${FILE_HISTORY_BLOB_TABLE} WHERE blob_hash NOT IN (SELECT blob_hash FROM file_history_version WHERE blob_hash IS NOT NULL) AND blob_hash NOT IN (SELECT blob_hash FROM ${FILE_HISTORY_BLOB_GRANT_TABLE})`);
+            return rows.map((r) => String(r.blob_hash));
+        }, cutoff);
     }
     async adoptScope(fromScope, toScope) {
         try {
@@ -874,6 +945,7 @@ export async function assertFileHistorySchema(query, dialect) {
         ["file_history_scope", "SELECT scope, created_at_ms FROM file_history_scope WHERE 1=0"],
         ["file_history_reaped_entry", "SELECT scope, entry_id, reaped_at_ms FROM file_history_reaped_entry WHERE 1=0"],
         [FILE_HISTORY_BLOB_TABLE, `SELECT blob_hash, byte_len, bytes, created_at FROM ${FILE_HISTORY_BLOB_TABLE} WHERE 1=0`],
+        [FILE_HISTORY_BLOB_GRANT_TABLE, `SELECT scope, landing_owner, blob_hash, granted_at FROM ${FILE_HISTORY_BLOB_GRANT_TABLE} WHERE 1=0`],
     ];
     for (const [table, sql] of probes) {
         try {

package/dist/stores-sql/retention-store-sql.js

@@ -3,6 +3,7 @@ import { incarnationFromCell } from "../session-incarnation.js";
 import { MANAGED_RETENTION } from "../plugins/retention-declaration.js";
 import { retentionDomainWhere, retentionIdSet, sessionLiveReferenceSql } from "../plugins/retention-sql.js";
 import { dropMailboxBoxOn } from "./mailbox-store-sql.js";
+import { FILE_HISTORY_SCOPED_TABLES } from "./file-history-store-sql.js";
 import { SEALED_EVENT, eraseSessionPolicyRowsOn } from "./session-policy-store-sql.js";
 export const RETENTION_TOMBSTONE_TABLE = "retention_tombstone";
 export const TIDB_RETENTION_TOMBSTONE_STATEMENTS = [
@@ -352,15 +353,8 @@ export class SqlRetentionStore {
                 });
             }
         }
-        for (const [table, col] of [
-            ["file_history_tracked", "scope"],
-            ["file_history_version", "scope"],
-            ["file_history_boundary", "scope"],
-            ["file_history_boundary_file", "scope"],
-            ["file_history_scope", "scope"],
-            ["file_history_reaped_entry", "scope"],
-        ]) {
-            const s = set(col, 1);
+        for (const table of FILE_HISTORY_SCOPED_TABLES) {
+            const s = set("scope", 1);
             await conn.query(`DELETE FROM ${table} WHERE ${s.sql}`, s.params);
         }
         if (this.opts.sessionBoxScope !== undefined) {

package/dist/task-settings.d.ts

@@ -122,11 +122,12 @@ export declare function planReviewDecisionExitsPlan(decision: "approve" | "edit"
  * 新体 `{ ...body, permissionMode: entry.effective }`,调用方的对象不改;bundle 的 `settings.permissions.defaultMode` 不动 —— 顶层赢过它
  * ({@link effectivePermissionMode} 的优先序),再改它就是同一语义的第二个写者。披露这一折的通告(`entry-mode-clamp-notice.ts`)读的也是同一份 `entry`。
  *
- * 调用点两个,都是受理判官的入口一步(`permission-mode-admission.ts`,同一只 `bodyEntry`):提交口 `stampSubmissionEntryMode`(`http/admission.ts` 的 `prepareSpec` 调它:
- * 值形门全部判完之后、`resolveSpec` 之前 —— 那一份体就是首跑装配读的体,也是 `buildCheckpointCtx` 持久化的体)与续跑口 `stampReplayEntryMode`(`http/resume-legs.ts`
- * 的 `replayCtxOf`:停驻 run 的存储体被重放之前过一次**现**地板,地板的出口词原样;钳过的体随 CAS 赢点写回)。装配腿不读地板;每一腿读一次地板、写进体,
- * run 的模式词仍只有存储体一个源。另外两个写者是 `plan_review` 写回(`http/resume-legs.ts` `drivePlanReview`,判据 {@link planReviewDecisionExitsPlan};
- * 写下的是 plan 地板的出口词)与在飞 run 的切档口写回(`http/routes/run-permission-mode.ts`,写的是同一只判官准入的词)。
+ * 调用点一个:提交口 `stampSubmissionEntryMode`(`permission-mode-admission.ts`,受理判官的入口一步 `bodyEntry`;`http/admission.ts` 的 `prepareSpec` 调它:
+ * 值形门全部判完之后、`resolveSpec` 之前 —— 那一份体就是首跑装配读的体,也是 `buildCheckpointCtx` 持久化的体,写据 `submission` 记下它的顶层原值)。
+ * 存储体那一格的其余写者都经同一模块的改写口 `withStoredPermissionMode`(一笔换词、换写据):续跑口(`stampReplayEntryMode`,`http/resume-legs.ts` 的 `replayCtxOf`:
+ * 停驻 run 的存储体被重放之前过一次**现**地板 —— 同一只 `bodyEntry`;写据说那一格是地板的出口写下的且仍是它写下的那一格 ⇒ 原样;钳过的体随 CAS 赢点写回)、
+ * `plan_review` 写回(`http/resume-legs.ts` `drivePlanReview`,判据 {@link planReviewDecisionExitsPlan};plan 地板的出口)与在飞 run 的切档口写回
+ * (`http/routes/run-permission-mode.ts`,写的是同一只判官准入的词)。装配腿不读地板;每一腿读一次地板、写进体,run 的模式词仍只有存储体一个源。
  * 热改 `AUTONOMY` 对之后的提交、切档与停驻 run 的下一次续跑都生效。地板的属主是 `runtime-governance.ts` 的 `autonomyModeFloor`。
  */
 export declare function stampEntryPermissionMode<B extends {

package/dist/task-settings.js

@@ -1,7 +1,7 @@
 import { combinePolicies, parseRuleText, resolveReasoningProfile, rankOf, isThinkingLevel, RUN_WORKFLOW_TOOL_NAME, PERMISSION_MODES, isPermissionMode, ruleToolGrammarOf, hostChildEnvProblem, } from "@sema-agent/core";
 import { judgeUnmatchableToolNames } from "./config.js";
 import { NAME_TABLE_BEHAVIOR } from "./namespaced-rule-name.js";
-import { entryProblem } from "./entry-problems.js";
+import { HOME_UNRESOLVABLE, entryProblem } from "./entry-problems.js";
 import { MAX_PERMISSION_RULES_PER_LIST, RULE_ROOTS, allowListEntryOk, createRuleListPolicy, ruleListEntryOk, ruleRootOf, ruleSetsOf, ruleSourceOf, ruleTextOf } from "./permission-rule-list.js";
 import { allowLayerEntryCountIssue, describeAllowLayerOverCap } from "./rule-entry-list.js";
 import { limitRefusal } from "./limit-refusal.js";
@@ -498,7 +498,7 @@ export function rulePolicyBucketsRefusal(permissions, bases) {
                             `the engine never guesses one: without a home base the rule resolves to "unreadable" and every matching call stops to ask, so it guards nothing. ` +
                             `Spell the path absolutely (${"Edit(//abs/path/**)"} form), declare the lane's home with REMOTE_EXEC_HOME_DIR, or run the task on a lane whose home this worker knows.`,
                     };
-                    problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.${field}`, name, "home_unresolvable"));
+                    problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.${field}`, name, HOME_UNRESOLVABLE));
                 }
             }
         }
@@ -513,7 +513,7 @@ export function rulePolicyBucketsRefusal(permissions, bases) {
                         `it is the SEMA_CONFIG_DIR forwarded into the sandbox, else .sema under the execution environment's home, and this lane's home is unknown; the engine never guesses one. ` +
                         `Spell the path absolutely (${"Read(//abs/path/**)"} form), forward SEMA_CONFIG_DIR into the sandbox env, declare the lane's home with REMOTE_EXEC_HOME_DIR, or run the task on a lane whose home this worker knows.`,
                 };
-                problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.${field}`, name, "home_unresolvable"));
+                problems.push(entryProblem(SETTINGS_RULE_REFUSAL_CODE, `settings.${field}`, name, HOME_UNRESOLVABLE));
             }
         }
     }