@sema-agent/server 7.142.0 → 7.144.0

package/dist/plugins/one-time-migrations.js

@@ -9,7 +9,7 @@ import { ensureIndexes } from "./ensure-index.js";
 import { createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, isJsonColumnBodyProblem, jsonColumnText, jsonColumnTextExpr, readNonNullJsonValueColumn, readOpaqueJsonValueColumn, } from "./sql-json-column.js";
 import { incarnationFromCell, sessionFaceFromRow } from "../session-incarnation.js";
 import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError } from "./store-contracts.js";
-import { PERMISSION_RULE_TABLE, purgeUndurableScopeRows } from "./permission-rule-store-sql.js";
+import { PERMISSION_RULE_TABLE, SqlDurableRulePartitionProvider, isSqlBucketRefusal, isSqlBucketVanished, listRuleBucketOwners, purgeUndurableScopeRows } from "./permission-rule-store-sql.js";
 import { SESSION_RULES_COLUMN } from "./session-rules-column.js";
 import { readJsonObjectColumn } from "./sql-json-column.js";
 import { retireStoredCardWords } from "../retired-card-words.js";
@@ -18,6 +18,7 @@ import { CLAIM_OWNERLESS_PLACED_SQL, claimOwnerlessParams, isOrphanSessionOwner,
 import { MAILBOX_KEYED_TABLES, mailboxKeyDeleteSql, storedMailboxKeyless } from "./mailbox-store-sql.js";
 import { SESSION_META_PLACEMENT_COLUMNS, backfillWriterStatement, countOrphanBindingsStatement, migrateDeviceBindingsStatement } from "./execution-placement-sql.js";
 import { APPROVAL_ASK_ENDING_CAUSE_COLUMN, APPROVAL_ASK_EXECUTION_LANE_COLUMN, APPROVAL_ASK_PARK_TRIGGER_COLUMN, APPROVAL_ASK_TABLE } from "./approval-ask-store-sql.js";
+import { retireImportedLayerRootAllows } from "./imported-layer-root-retirement.js";
 import { isUnusableArchive } from "../execution-placement.js";
 const RETIRED_SESSION_RULE_BUCKETS = ["commandAllow", "commandDeny"];
 export function buildMigrationReceipts() {
@@ -63,6 +64,8 @@ export function buildMigrationReceipts() {
         askCauseColumnsChanged: 0,
         askParkTriggersMoved: 0,
         askJournalRecordsUpgraded: 0,
+        importedLayerRootAllowsRetired: [],
+        importedLayerRootBucketsSkipped: [],
     };
 }
 function completedReport(r) {
@@ -116,7 +119,9 @@ function changedAnything(r) {
         r.localArchiveSnapshotsRecovered > 0 ||
         r.askCauseColumnsChanged > 0 ||
         r.askParkTriggersMoved > 0 ||
-        r.askJournalRecordsUpgraded > 0);
+        r.askJournalRecordsUpgraded > 0 ||
+        r.importedLayerRootAllowsRetired.length > 0 ||
+        r.importedLayerRootBucketsSkipped.length > 0);
 }
 function readingsSnapshot(r) {
     return {
@@ -131,6 +136,8 @@ function readingsSnapshot(r) {
         executionPlacementSessionsUnreadable: [...r.executionPlacementSessionsUnreadable],
         localArchivesKeptStamped: [...r.localArchivesKeptStamped],
         localArchivesUnreadable: [...r.localArchivesUnreadable],
+        importedLayerRootAllowsRetired: [...r.importedLayerRootAllowsRetired],
+        importedLayerRootBucketsSkipped: [...r.importedLayerRootBucketsSkipped],
     };
 }
 function receiptSentence(r) {
@@ -141,6 +148,7 @@ function receiptSentence(r) {
         ...r.undurableScopeRuleRows.map((x) => `removed ${x.kind} in permission-rule bucket ${x.ownerKey} (${x.behavior} ${x.tool}, scope root ${JSON.stringify(x.scopeRoot)})`),
         ...r.sessionRuleRowsWithOldGrammarEntries.map((x) => `${x.policyKey} (session ${x.sessionId}): toolAllowDropped=${JSON.stringify(x.toolAllowDropped)}`),
         ...r.sessionRuleRowsWithUnreadableDeny.map((x) => `${x.policyKey} (session ${x.sessionId}): left as stored, toolDenyUnreadable=${JSON.stringify(x.toolDenyUnreadable)}${x.retiredBuckets !== undefined ? `, retiredBuckets=${JSON.stringify(x.retiredBuckets)}` : ""}`),
+        ...r.importedLayerRootAllowsRetired.map((x) => `retired ${x.addsRetired} imported add(s) of an allow ${x.tool} rule in permission-rule bucket ${x.ownerKey} (${x.stillLive ? "the rule stays in effect through another approval" : "the rule no longer takes effect"})`),
     ];
     return [counts.join(", "), ...rows].filter((part) => part !== "").join("; ");
 }
@@ -396,17 +404,17 @@ export const ONE_TIME_MIGRATIONS = [
         introducedIn: "7.133.0",
         releasedOn: "2026-10-21",
         removableAfter: "2026-11-20",
-        removal: "删 migrateOn 的 M23 步(`inheritPlacedSessionOwners`:placed ∧ 属主 NULL 的行按 session_id 键集分页单趟扫描 + 同一条语句连读根 / 父两行 + 按认领句回写属主)与 `PLACED_OWNER_SCAN_PAGE` / `placedOwnerScanSql` / `scannedPlacement` / `scannedFaces` / `scannedPlacedSources`(`isOrphanSessionOwner` 若再无别的读者一并删);" +
-            "**同窗同删的另一半**(认领:按律给升级前写下的无主子代行写属主 —— 停驻挂点对宿主无主行做的就是本条对那一行的单行步):`delegated-session-owner.ts` 的 `CLAIM_OWNERLESS_PLACED_SQL` / `claimOwnerlessParams` / `OwnerlessClaim` / " +
-            "`settleDelegatedOwner` 的认领一步(删后它只剩树比对与属主比对)/ `DelegationTreeStore.claimOwnerless`," +
-            "两只 SQL 店(`tidb-session-store.ts` / `pg-session-storage.ts`)与 local 店(`local-session-store.ts` 的 `claimOwnerless` 字段与 `claimOwnerlessPlaced`)的 `claimOwnerless`、`CachingSessionStore` 的转发、`OwnerAwareSessionStore.claimOwnerless`、`delegatedOwnerHostOf` 对它的「与 `placementOf` 同在或同缺」;" +
+        removal: "删 migrateOn 的 M23 步(`inheritPlacedSessionOwners`:placed ∧ 属主 NULL 的行按 session_id 键集分页单趟扫描 + 同一条语句连读根 / 父两行 + 按认领句回写属主)与 `PLACED_OWNER_SCAN_PAGE` / `placedOwnerScanSql` / `scannedPlacement` / `scannedFaces` / `scannedPlacedSources`;" +
+            "**同窗同删的另一半**(旧律的判据与写句 —— 7.144.0 起建行与停驻挂点都不再读它们,M23 是唯一读者):`delegated-session-owner.ts` 头注 M23 一节与 `judgeDelegatedOwner` / `inheritedOwnerOf` / `ownerSourcesOf` / " +
+            "`orphanSessionOwner` / `isOrphanSessionOwner` / `SourceOwnerReading` / `InheritedOwner` / `PlacementSources` / `CLAIM_OWNERLESS_PLACED_SQL` / `claimOwnerlessParams`;" +
             "报告、日志行与 `NO_SQL_MIGRATIONS` 的 `placedSessionOwnersInherited` / `placedSessionOwnersOrphaned` / `placedSessionOwnersRemaining` 与 `placed_session_owners_orphaned` 那一行 warn;" +
             "`test/one-time-migrations.test.ts` 的 M23 组与 `test/one-time-migrations-db-integration.test.ts` 的 M23 格。" +
-            "**不随本条删**:属主为 NULL 的 placed 行只对 fleet 调用方放行(`security.ts` 的 `ownerlessRowOpen` / `sessionOwnerCellOf` 与各门读 `placementOf` 的那一次)—— 那是常设的读面律",
+            "**不随本条删**:`ORPHAN_SESSION_OWNER_PREFIX` 与它在 `security.ts` 保留主体前缀里的登记(已落库的行可能带哨兵,永久保留);" +
+            "属主为 NULL 的 placed 行只对 fleet 调用方放行(`security.ts` 的 `ownerlessRowOpen` / `sessionOwnerCellOf` 与各门读 `placementOf` 的那一次)—— 那是常设的读面律",
         afterRemoval: "会话面的读面律(常设,不随本条删)接住:跳过了带本条的版本直接升的库里,属主为 NULL 的存量 placed 子代行只对 fleet 调用方放行(出示 service 凭据、不报主体;dev-open)," +
             "其余调用方答 404(与别人的行同体)—— 出路是升级时先过一次带本条的版本,或运维按 `placement_root_session_id`(缺则 `placement_parent_session_id`)那一行的属主手工回填、" +
-            "推不出的写一个任何主体都不匹配的值;停驻挂点读到无主的宿主子代行 ⇒ 回到比对的既有臂:无主 ≠ 律给的属主 ⇒ 停驻否决(fail-closed,响亮;出路同上);" +
-            "建行那一笔的继承律不随本条删(那是常设的写法,不是迁移)",
+            "推不出的写一个任何主体都不匹配的值;停驻挂点只比对宿主行属主与引擎交来的属主(复活腿交那一行自己的属主),不写无主行;" +
+            "建行那一笔记 `placement.owner` 不随本条删(那是常设的写法 —— core 盒义务 7,不是迁移)",
         reportKeys: ["placedSessionOwnersInherited", "placedSessionOwnersOrphaned", "placedSessionOwnersRemaining"],
     },
     {
@@ -563,7 +571,7 @@ export const ONE_TIME_MIGRATIONS = [
             "`local_archive_kept_stamped` / `local_archive_unreadable` 两行 warn、读数行 note 里的 M33 句与头注 M33 段;`test/local-archive-owner.test.ts` 里标题含 `P3` / `P4` / `P5` / `P6` / `F1` / `F2` / `F3` 的格与 `legacyRoot` / `writeArchive` / `boot` / `M33_ZERO` / `m33Of` 助手。" +
             "**不随本条删**:行格的 `createdAt` / `forkedFrom` 两键(常设的数据形)、`LocalArchiveSnapshotsPresentError` / `assertNoArchiveSnapshots` / `LOCAL_ARCHIVE_SNAPSHOT_DIR` 与 `LocalBackend.ensureSchema` 里调它的那一句、" +
             "`session-error-wire.ts` 的 `StampedSessionArchiveError` / `STAMPED_SESSION_ARCHIVE_SENTENCE` / `sessionErrorWireOf` 与本店两处带戳判(fork 的源、改日志推送的落点)、行上缺建档时刻的 F 类读法(`server.local-session-row.created-at-absent`)",
-        afterRemoval: "三只常设臂接住:① 数据根下的快照目录非空 ⇒ 拒启(`config.local_archive_snapshot_present`,点名文件与两条出路);② 跳过了带本条的版本直接升的数据根(或本条留着的存档),带属主戳的存档被 fork 与改日志的推送同一只具名拒(409 `conflict` + 固定句,零写 / 行格净零写)," +
+        afterRemoval: "三只常设臂接住:① 数据根下的快照目录非空 ⇒ 拒启(`config.local_archive_snapshot_present`,点名文件与两条出路);② 跳过了带本条的版本直接升的数据根(或本条留着的存档),带属主戳的存档被 fork 与改日志的推送同一只具名拒(409 `conflict.session_archive_stamped` + 固定句,零写 / 行格净零写)," +
             "读 / 续跑 / 拉取照常 —— 出路 = 删掉会话后重推,或升级时先过一次带本条的版本并在窗内起服;③ 行上没有建档时刻的格(同一类数据根)⇒ 列表 / 会话视图 / 交出的元数据读纪元(F 类 tag 计数)",
         reportKeys: ["localArchiveRowFactsBackfilled", "localArchivesAnonymized", "localArchivesKeptStamped", "localArchivesUnreadable", "localArchiveSnapshotsRecovered"],
     },
@@ -583,6 +591,47 @@ export const ONE_TIME_MIGRATIONS = [
             "② local —— 信封号 1 的日志记录走 File 问账店「认不出的信封号」拒启(`unknown envelope version`,点名文件与出路:用写下它的那一版起服一次,或移开文件)",
         reportKeys: ["askCauseColumnsChanged", "askParkTriggersMoved", "askJournalRecordsUpgraded"],
     },
+    {
+        id: "M35",
+        introducedIn: "7.143.0",
+        releasedOn: "2026-10-31",
+        removableAfter: "2026-11-30",
+        removal: "删 `config-root-migration.ts` 整只文件与两个入口的调用(`boot/stage-02-web-admin-pull.ts` 目录信任判官之后、`run-local.ts` 同一位置各两行 + import);" +
+            "`test/env-model-table-gate.test.ts` 里标题以 `迁移` 起头的那一组;部署文档里「起服自动铸 config.env-models.json」那一句。" +
+            "**不随本条删**:模型面闸 `env-model-table-gate.ts`、`LocalConfigProvider` 读决定(etag 覆盖)、目录信任判官的根级文档名单(常设)",
+        afterRemoval: "常设的模型面闸接住:跳过了带本条的版本直接升的本地根(或运行记录在场而决定缺席的根),决定缺席读作 kept ⇒ env 模型表已声明时管模型面的本地目录被组拒 " +
+            "`config.catalog_replaces_env_models`,拒句点名被顶替的 env 模型与两条出路(在配置根写 `config.env-models.json` = `{\"envModels\":\"replaced\"}`,或撤掉 MODEL_ID / MODEL_CHEAP_ID)",
+        reportKeys: [],
+    },
+    {
+        id: "M36",
+        introducedIn: "7.143.0",
+        releasedOn: "2026-10-31",
+        removableAfter: "2026-11-30",
+        removal: "**删码前提**:本服务已不支持回滚到引擎 7.61.0 之前的版本(更早的引擎的导入门会重新铸出这种 add,本条要在每次起服把它们收掉)—— 窗关时仍支持这种回滚 ⇒ 本行两格顺延(改日期,并在本注里写明为什么),不删。" +
+            "删什么:`src/plugins/imported-layer-root-retirement.ts` 整个文件;migrateStepsOn 的 M36 步(规则表与 `grammar` 列的在场探针 + 对 `retireImportedLayerRootAllows` 的调用)与握锁连接上的 `query` 口" +
+            "(`LockedMigrationDb` 与 `mysqlDb` / `pgDb` 里的那一员,若届时再无别的步骤用它);`permission-rule-store-sql.ts` 的 `listRuleBucketOwners` / `isSqlBucketRefusal` / `isSqlBucketVanished` / `RuleBucketVanishedError`(取点那一句的具名类,届时若再无别的读者按类判它,收回成裸错)/ `IMPORT_RECORD_KIND`;" +
+            "`permission-rule-store-file.ts` 的 `FileRuleApprovalRecordStore.importRecordOwners`;`store-backend.ts` 的 `LocalBackend.runOneTimeMigrations` 里 M36 那一腿(规则目录在场判与那一处调用)与报告两键的那两行;" +
+            "本文件的 `createSqlImportedLayerRootSource` 与 `importedLayerRootAllowsRetired` / `importedLayerRootBucketsSkipped`(报告 / 收据 / `changedAnything` / `readingsSnapshot` / `readingFields` / `receiptSentence` / `NO_SQL_MIGRATIONS` 的排除表)、" +
+            "`imported_layer_root_allow_retired` / `imported_layer_root_bucket_skipped` 两行 warn 与 `importedLayerRootSkipNote`、读数行 note 里的 M36 句与头注 M36 段;" +
+            "`test/imported-layer-root-retirement.test.ts`、`test/imported-layer-root-retirement-db-integration.test.ts`(连同 `scripts/db-integration-files.json` 里它那一行)与 `test/helpers/imported-layer-root-fixture.ts` 整文件。" +
+            "**不随本条删**:`SqlDurableRulePartitionProvider` 收「方言 + 执行口」的那一形(`BucketSql`;常设,池照旧满足它)",
+        afterRemoval: "没有响亮臂(如实):删码之后,跳过了带本条的版本直接升的库(或回滚到引擎 7.61.0 之前、在其上又导入过的库),存量的这种全局 `/x` allow 照旧在每个项目根放行,本服务不再点名 —— " +
+            "出路 = 升级时先过一次带本条的版本并起服;或运维列出桶里出处为导入(`adds[].origin` = `imported-cc`)、scope 为全局、从 `/` 写起的 allow(`GET /v1/rules`)并撤掉(`DELETE /v1/rules`,撤的是这条规则的全部批准)",
+        reportKeys: ["importedLayerRootAllowsRetired", "importedLayerRootBucketsSkipped"],
+    },
+    {
+        id: "M37",
+        introducedIn: "7.143.0",
+        releasedOn: "2026-10-31",
+        removableAfter: "2026-11-30",
+        removal: "删 `approval-card.ts` 的 `renameRetiredSourceKey` 与 `readStoredCardEnvelope` 里调它的那一步(回到直接把传入的那一只交 M18 改写)、" +
+            "fail-open tag `server.approval-card.retired-card-key-read`(`observability/fail-open.ts` 与 `docs/FAIL-OPEN-CENSUS.md` 那一行)、" +
+            "`test/approval-card-source-key-m37.test.ts` 整只文件、本文件头注 M37 段",
+        afterRemoval: "既有坏行臂接住(响亮,不再改名):仍带旧键的存卡(跳过了带本条的版本直接升的库、窗关之后还在写的 7.142.x 副本)整卡读不出 —— 断连重放跳过 + 一次 warn、" +
+            "幂等重入走 park、回决口按要人",
+        reportKeys: [],
+    },
 ];
 export function migrationWindowOpen(window, today) {
     return window.removableAfter === null || today <= window.removableAfter;
@@ -633,6 +682,10 @@ export const NO_SQL_MIGRATIONS = {
 };
 function mysqlDb(conn) {
     return {
+        async query(sql, params) {
+            const [r] = await conn.query(sql, params === undefined ? [] : [...params]);
+            return Array.isArray(r) ? { rows: r, affected: 0 } : { rows: [], affected: Number(r.affectedRows ?? 0) };
+        },
         async rows(sql, params) {
             const [rows] = params === undefined ? await conn.query(sql) : await conn.query(sql, [...params]);
             return rows;
@@ -645,6 +698,10 @@ function mysqlDb(conn) {
 }
 function pgDb(client) {
     return {
+        async query(sql, params) {
+            const r = await client.query(sql, params === undefined ? [] : [...params]);
+            return { rows: r.rows, affected: r.rowCount ?? 0 };
+        },
         async rows(sql, params) {
             const r = params === undefined ? await client.query(sql) : await client.query(sql, [...params]);
             return r.rows;
@@ -675,6 +732,9 @@ async function columnExists(db, dialect, table, column) {
     const sql = `SELECT 1 AS present FROM information_schema.columns WHERE table_schema = ${scope} AND table_name = '${table}' AND column_name = '${column}'`;
     return (await db.rows(sql)).length > 0;
 }
+export function createSqlImportedLayerRootSource(exec) {
+    return { candidateOwners: () => listRuleBucketOwners(exec), durable: new SqlDurableRulePartitionProvider(exec), isWholeBucketRefusal: isSqlBucketRefusal, isVanishedBucket: isSqlBucketVanished };
+}
 export async function runSqlOneTimeMigrations(dialect, pool, input) {
     return dialect === "mysql" ? withMysqlLock(pool, (db) => migrateOn(db, "mysql", input)) : withPgLock(pool, (db) => migrateOn(db, "pg", input));
 }
@@ -734,6 +794,9 @@ async function migrateStepsOn(db, dialect, receipts, input) {
         await inheritPlacedSessionOwners(db, dialect, receipts);
     if ((await tableExists(db, dialect, PERMISSION_RULE_TABLE)) && (await columnExists(db, dialect, PERMISSION_RULE_TABLE, "grammar")))
         await purgeUndurableScopeRows(db, dialect, receipts);
+    if ((await tableExists(db, dialect, PERMISSION_RULE_TABLE)) && (await columnExists(db, dialect, PERMISSION_RULE_TABLE, "grammar"))) {
+        await retireImportedLayerRootAllows(createSqlImportedLayerRootSource({ dialect, query: (sql, params) => db.query(sql, params) }), receipts);
+    }
     await moveWorkflowJournalScope(db, dialect, receipts);
     if (await tableExists(db, dialect, RETIRED_BREAKER_TABLE))
         await dropRetiredBreakerTable(db, dialect, receipts);
@@ -1624,10 +1687,10 @@ export async function inheritPlacedSessionOwners(db, dialect, receipts) {
             const sessionId = String(r.session_id);
             after = sessionId;
             const incarnation = incarnationFromCell(sessionId, r.incarnation);
-            const judged = judgeDelegatedOwner(sessionId, scannedPlacement(r), scannedFaces(r));
-            const owner = judged.inherited.owner;
+            const inherited = judgeDelegatedOwner(sessionId, scannedPlacement(r), scannedFaces(r));
+            const owner = inherited.owner;
             if (owner === null) {
-                if (judged.inherited.kind === "inherited" && scannedPlacedSources(r).has(judged.inherited.from))
+                if (inherited.kind === "inherited" && scannedPlacedSources(r).has(inherited.from))
                     receipts.placedSessionOwnersRemaining += 1;
                 continue;
             }
@@ -1687,6 +1750,8 @@ function readingFields(r) {
         askCauseColumnsChanged: r.askCauseColumnsChanged,
         askParkTriggersMoved: r.askParkTriggersMoved,
         askJournalRecordsUpgraded: r.askJournalRecordsUpgraded,
+        importedLayerRootAllowsRetired: r.importedLayerRootAllowsRetired.length,
+        importedLayerRootBucketsSkipped: r.importedLayerRootBucketsSkipped.length,
     };
 }
 export function logOneTimeMigrations(log, backend, report) {
@@ -1744,7 +1809,11 @@ export function logOneTimeMigrations(log, backend, report) {
             "M34: the approval ask table's single cause column denied_reason — the reason a row was moved to the delivery surface while it is PARKING or PARKED, " +
             "the reason it ended without a human answer while it is VOID or DENIED, overwritten by the second when a parked row was closed — renamed ending_cause, " +
             "a column park_trigger added, and the word on PARKING and PARKED rows moved into park_trigger; on the local backend the approval ask journal is rewritten " +
-            "once with record envelope 2, its envelope-1 records read with the same meaning). Each step " +
+            "once with record envelope 2, its envelope-1 records read with the same meaning; " +
+            "M36: allow approvals that an import before engine 7.61.0 stored as global rules from a settings file's user-layer path written from `/` — which the user layer reads at its " +
+            "configuration directory and a global rule reads at every task's project root — retired by tombstones naming exactly those approvals (a rule that also holds an approval a person " +
+            "gave directly stays in effect; deny and ask rules are never retired), one imported_layer_root_allow_retired line per rule; a bucket that could not be read or written, or that another replica deleted while it was being written, is named by an " +
+            "imported_layer_root_bucket_skipped line on every boot). Each step " +
             "runs on every boot until its window closes (the release that introduced it + 30 days; the per-step date is in " +
             "removableAfter, null while that release is not published yet) and is deleted in the first minor after that — start a " +
             "version that still carries a step at least once before upgrading past its deletion.",
@@ -1789,7 +1858,7 @@ function logReceiptRows(log, backend, r) {
             ...(row.errno !== undefined ? { errno: row.errno } : {}),
             note: "a local session that has runs (and either no session-metadata cell — it was written before the cell existed and has not been read since — or a fork-created cell) has an archive the server cannot read, " +
                 "so its execution placement could not be backfilled. The session was skipped and nothing was written or changed: boot is not blocked, and every request that needs the " +
-                "session keeps answering the archive's own fault (fault names it: corrupt_session = the session header cannot be read; invalid_session = the stored log's structure is broken; " +
+                "session keeps answering the archive's own fault (fault names it: corrupt_session = the session header cannot be read, or the stored log does not form one tree; " +
                 "storage = reading the archive file itself failed — errno names it, e.g. EACCES = no permission, EIO = disk I/O error, ERR_STRING_TOO_LONG = the file is too large to read) until the " +
                 "archive file under the data root's sessions directory is readable again — restored from a kept copy, or (storage) its permissions or disk repaired; the next boot then backfills its placement as for any other session. " +
                 "(Removing the archive file ends the warning but places nothing: the session then no longer exists on this server — except a fork-created session, whose cell stays and reads as a fork that has not landed: retry the same fork, or delete the session.) The session is named on every boot until then",
@@ -1847,6 +1916,23 @@ function logReceiptRows(log, backend, r) {
             note: removedRuleRowNote(row.kind),
         });
     }
+    for (const row of r.importedLayerRootAllowsRetired) {
+        log.warn("imported_layer_root_allow_retired", {
+            backend,
+            ownerKey: row.ownerKey,
+            tool: row.tool,
+            addsRetired: row.addsRetired,
+            stillLive: row.stillLive,
+            note: "an allow rule imported from a settings file's user layer by an import before engine 7.61.0 was written from `/` — the user layer reads such a path at its own configuration " +
+                "directory — and was stored as a global rule, which reads it at every task's project root: it let that path be acted on in every project without a question. A one-time migration " +
+                "retired the imported approval of it (a tombstone naming exactly that approval). stillLive false = the rule no longer takes effect and an action it covered asks again; stillLive true = " +
+                "the rule stays in effect through another approval of it (one a person gave directly). To carry the rule again, spell its directory out (`//<directory>/…`, or `~/<path>` under the home) " +
+                "and approve it again. This line is written once, by the boot that retired it — keep it; the rule text is not on it (list the bucket's rules to see what remains)",
+        });
+    }
+    for (const bucket of r.importedLayerRootBucketsSkipped) {
+        log.warn("imported_layer_root_bucket_skipped", { backend, ownerKey: bucket.ownerKey, reason: bucket.reason, why: bucket.why, note: importedLayerRootSkipNote(bucket.reason) });
+    }
     for (const bucket of r.undurableScopeRuleBucketsUnreadable) {
         log.warn("permission_rule_bucket_unreadable", {
             backend,
@@ -1925,6 +2011,23 @@ export async function runAndLogOneTimeMigrations(log, backend) {
     }
     logOneTimeMigrations(log, backend.kind, report);
 }
+function importedLayerRootSkipNote(reason) {
+    const head = "the one-time retirement of allow approvals that an import before engine 7.61.0 stored as global rules from a user-layer path written from `/` (read at every project root) did not finish in this permission-rule bucket: ";
+    switch (reason) {
+        case "bucket_unreadable":
+            return `${head}the bucket could not be read. The read path refuses such a bucket in whole as well, so none of its rules takes effect; once it is repaired, the next boot retires what it selects. Named on every boot until then`;
+        case "vanished":
+            return `${head}the bucket was deleted (by another replica) while this step was writing to it. Nothing is left to retire and none of its rules takes effect; not a boot refusal`;
+        case "not_writable":
+            return `${head}it holds approvals the retirement selects, but no tombstone could be written (the bucket is served read-only — a rule-store adoption in progress — or the store refused the tombstone), so those allow rules keep taking effect at every project root. Finish the adoption or repair the store and restart; named on every boot until then`;
+        case "contended":
+            return `${head}every write lost to a concurrent writer. Those allow rules keep taking effect until a later boot retires them; named on every boot until then`;
+        default: {
+            const unknown = reason;
+            throw new Error(`M36: no log sentence for skip reason ${JSON.stringify(unknown)}`);
+        }
+    }
+}
 function removedRuleRowNote(kind) {
     switch (kind) {
         case "rule":

package/dist/plugins/org-delivery-quota-store.d.ts

@@ -101,7 +101,7 @@ export declare class SqlOrgDeliveryQuotaStore implements OrgDeliveryQuotaStore {
     take(fromScope: string, toScope: string, policy: OrgDeliveryQuotaPolicy): Promise<boolean>;
     /**
      * 一个记账事务:库钟先读(池上一条值语句,不在事务里留普通 SELECT),判过 ⇒ 提交,判拒 ⇒ 回滚(零残留)。
-     * 🔴 **引擎判了死锁 ⇒ 整事务重来**(有界,`isDeadlockError` 是全仓唯一的可重试锁故障判据):被挑中的一方已整事务回滚、锁全放,
+     * 🔴 **引擎判了死锁 ⇒ 整事务重来**(`retryOnDeadlock`:全仓唯一的重来写法、唯一的上界与判据):被挑中的一方已整事务回滚、锁全放,
      * 重来时读-判-写全部重做,语义等价。真 InnoDB(REPEATABLE READ)上这条路是真的:窗前进时按收件人前缀删旧对偶行要取范围 / 间隙锁,
      * 两位相邻收件人同时翻窗、各自往两人之间的间隙里插新对偶行 ⇒ 互等(TiDB 无间隙锁、PG 读已提交不取间隙锁)。谁当牺牲者是引擎的任意选择,
      * 抛给调用方等于把一次内部仲裁当成投递失败。锁等待超时**不**重来(延迟信号,照抛)。

package/dist/plugins/org-delivery-quota-store.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { atomicWriteFile, ensureDir } from "@sema-agent/core";
 import { mysqlDriver, pgDriver, sqlDbNowMs } from "./sql-driver.js";
-import { isDeadlockError } from "./sql-errors.js";
+import { retryOnDeadlock } from "./sql-errors.js";
 import { alignedWindow } from "../observability/cost-quota.js";
 export const ORG_DELIVERY_SENDER_QUOTA_TABLE = "org_delivery_sender_quota";
 export const ORG_DELIVERY_RECIPIENT_QUOTA_TABLE = "org_delivery_recipient_quota";
@@ -122,7 +122,6 @@ export class FileOrgDeliveryQuotaStore extends MemoryOrgDeliveryQuotaStore {
         atomicWriteFile(this.tmpDir, this.path, `${JSON.stringify(snapshot)}\n`);
     }
 }
-const DEADLOCK_RETRY_LIMIT = 3;
 export class SqlOrgDeliveryQuotaStore {
     db;
     constructor(db) {
@@ -138,16 +137,7 @@ export class SqlOrgDeliveryQuotaStore {
         return this.inTx(ORG_DELIVERY_RECIPIENT_QUOTA_TABLE, policy, (conn, at) => this.takeIn(conn, fromScope, toScope, at, policy));
     }
     async inTx(table, policy, body) {
-        for (let tries = 0;; tries++) {
-            try {
-                return await this.inTxOnce(table, policy, body);
-            }
-            catch (err) {
-                if (tries < DEADLOCK_RETRY_LIMIT && isDeadlockError(this.db.dialect, err))
-                    continue;
-                throw err;
-            }
-        }
+        return retryOnDeadlock(this.db.dialect, () => this.inTxOnce(table, policy, body));
     }
     async inTxOnce(table, policy, body) {
         const at = quotaWindowStart(await sqlDbNowMs(this.db, table), policy.windowMs);

package/dist/plugins/park-commit-watch.d.ts

@@ -28,7 +28,7 @@ import type { CheckpointStore } from "@sema-agent/core";
 /**
  * 一只**已提交**的审批停车行说它握着哪些调用(停车行自己的陈述,原样,不是推断):
  *  · `sessionId` —— 行停住的会话 `cp.sessionId`(执行这次调用的会话:委派 / 后台子代的行落在**子会话**上)。core 铸行用的是 prepare-task 的
- *    同一个 `sessionId`,它也是同一次调用的 ask 上的 `sourceTaskId`(`askSourceIdentity`)⇒ 订阅者按**相等**配,不做别名(车 SO:
+ *    同一个 `sessionId`,它也是同一次调用的 ask 上的 `sourceSessionId`(`askSourceIdentity`)⇒ 订阅者按**相等**配,不做别名(车 SO:
  *    调用 id 只在 run 内唯一,宿主会话若当子代的等价别名,宿主停车行会冒充子代的提交);
  *  · `toolCallIds` —— 停在门前的那只调用(`pendingAction.toolCallId`)∪ 同一条助手消息里**尚未执行**的调用
  *    (`batchToolCallIds − completedCallIds`,core d.ts「#k+1..N are still pending」):那些调用随这一行一起被持久挂起,

package/dist/plugins/permission-rule-store-file.d.ts

@@ -2,7 +2,7 @@ import { FileDurableRulePartitionProvider, type RuleApprovalRecord, type RuleApp
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./permission-rule-store-sql.js";
 import type { PermissionRuleStoreBundle } from "../rules-consent.js";
 import type { Logger } from "../observability/logger.js";
-import { type RuleCandidate } from "@sema-agent/core";
+import { type RuleCandidate, type RuleOwner } from "@sema-agent/core";
 /**
  * `RuleApprovalRecordStore` 的 File 形。
  *
@@ -26,6 +26,13 @@ export declare class FileRuleApprovalRecordStore implements RuleApprovalRecordSt
     get(id: string): Promise<RuleApprovalRecord | StaleRuleApprovalRecord | undefined>;
     create(record: RuleApprovalRecord): Promise<void>;
     cas(id: string, expectRev: number, next: RuleApprovalRecord): Promise<boolean>;
+    /**
+     * 一次性迁移 M36(窗口见 `plugins/one-time-migrations.ts` 登记表)在 File 店能叫出名字的桶:本店**导入记录**点名过的每一个属主(去重)。
+     * 引擎 File 分区的桶文件按属主名的单向摘要命名、分区后端没有列桶口,记录是本店唯一叫得出桶属主的地方(SQL 店直接列规则表;File 侧的缺口见
+     * `imported-layer-root-retirement.ts` 头注)。上一形的记录(Stale 信封)读不出种类 ⇒ 属主读得出就算上(多读一只桶零写,少读一只会漏)。
+     * 损坏闸合着 ⇒ 抛(读不全记录就叫不全桶;与本面其余口同一条 fail-closed)。
+     */
+    importRecordOwners(): Promise<RuleOwner[]>;
     /** 与 SQL 侧同名方法同义(超帽拒绝时收掉 `prepareCcImport` 已落盘的那条 pending 记录)。
      *  `state === "pending"` 是硬的:已确认/已兑付的记录是一次真人同意的审计事实。 */
     discardPendingRecord(recordId: string): Promise<boolean>;
@@ -87,6 +94,8 @@ export declare class FileRuleImportTicketStore {
      *  那一条:过期只挡开始一次兑付,不挡做完一次已经开始的)。抢到之后**换一代认领**。 */
     reclaim(ticketId: string, principal: string, purpose: RuleTicketPurpose, minClaimAgeMs: number): Promise<RuleTicketReclaimResult>;
 }
+/** 三面束在数据根下的目录名(唯一一处;束在第一次装配时建它 —— 没开过规则店的数据根下没有它)。 */
+export declare const FILE_PERMISSION_RULE_DIR = "permission-rules";
 /** local 车道的三面束 + 生命周期。`dispose()` 释放 core File durable 分区 provider 的写锁(见 {@link createFilePermissionRuleStores})。 */
 export interface FilePermissionRuleStores extends PermissionRuleStoreBundle {
     durable: FileDurableRulePartitionProvider;

package/dist/plugins/permission-rule-store-file.js

@@ -4,7 +4,7 @@ import { readdirSync } from "node:fs";
 import { performance } from "node:perf_hooks";
 import { FileDurableRulePartitionProvider, AppendLog, ensureDir, } from "@sema-agent/core";
 import { z } from "zod";
-import { DurableRuleScopeSchema, RuleOfferColumn, buildRulePayloadHash, recordOwnerOf, refusedOwnerSentence } from "./permission-rule-store-sql.js";
+import { DurableRuleScopeSchema, IMPORT_RECORD_KIND, RuleOfferColumn, buildRulePayloadHash, recordOwnerOf, refusedOwnerSentence } from "./permission-rule-store-sql.js";
 import { replayJsonlGuarded } from "../observability/corrupt-read-seat.js";
 import { EDITED_RULE_BREADTH_WARNING_CODES, RULE_APPROVAL_KINDS, RULE_APPROVAL_RECORD_SCHEMA, RULE_APPROVAL_STATES, RULE_BEHAVIORS, readRuleOwner } from "@sema-agent/core";
 const RuleDotSchema = z.object({ actor: z.string().min(1), counter: z.number().int().nonnegative().safe() }).strict();
@@ -173,6 +173,18 @@ export class FileRuleApprovalRecordStore {
         this.rows.set(id, structuredClone(next));
         return true;
     }
+    async importRecordOwners() {
+        this.gate.assertUsable();
+        const owners = [];
+        for (const r of this.rows.values()) {
+            if (!("staleSchema" in r) && r.kind !== IMPORT_RECORD_KIND)
+                continue;
+            const owner = recordOwnerOf(r);
+            if (owner !== undefined)
+                owners.push(owner);
+        }
+        return owners;
+    }
     async discardPendingRecord(recordId) {
         this.gate.assertUsable();
         const cur = this.rows.get(recordId);
@@ -319,8 +331,9 @@ export class FileRuleImportTicketStore {
         return { ok: true, approvalId: row.approvalId, payloadHash: row.payloadHash, claimId };
     }
 }
+export const FILE_PERMISSION_RULE_DIR = "permission-rules";
 export function createFilePermissionRuleStores(root, opts) {
-    const dir = join(root, "permission-rules");
+    const dir = join(root, FILE_PERMISSION_RULE_DIR);
     ensureDir(dir);
     const durable = opts?.onError ? new FileDurableRulePartitionProvider(dir, opts.onError) : new FileDurableRulePartitionProvider(dir);
     const approvals = new FileRuleApprovalRecordStore(dir, opts?.warn);

package/dist/plugins/permission-rule-store-sql.d.ts

@@ -158,6 +158,8 @@ export declare function buildRuleBucketChecksum(body: {
     /** 这只桶的行写在哪一版规则文法里(`SESSION_RULES_GRAMMAR` 的数);缺席 = 存量无戳行(列 NULL)。 */
     grammar?: number;
 }): string;
+/** 一只桶要的全部 SQL 能力:方言 + 一只执行口(池,或一次性迁移握着锁的那一条连接 —— M36 在那条连接上经同一只写面落墓碑)。 */
+type BucketSql = Pick<SqlDriver, "dialect" | "query">;
 /**
  * SQL 双方言的 {@link DurableRulePartitionProvider} —— [ref] 里的 **durable 分区后端**
  * (`user` + `project` 两源的 OR-Set CRDT),**不是**引擎接缝本身:
@@ -170,7 +172,7 @@ export declare function buildRuleBucketChecksum(body: {
 export declare class SqlDurableRulePartitionProvider implements DurableRulePartitionProvider {
     private readonly db;
     private readonly now;
-    constructor(db: SqlDriver, now?: () => number);
+    constructor(db: BucketSql, now?: () => number);
     forPrincipal(principal: string | undefined): DurableRulePartition;
     forLocalOwner(): DurableRulePartition;
 }
@@ -182,6 +184,33 @@ export declare function recordOwnerOf(record: {
     readonly owner?: unknown;
     readonly principal?: unknown;
 }): RuleOwner | undefined;
+/**
+ * 一次性迁移 M36(窗口见 `plugins/one-time-migrations.ts` 登记表)要读的桶:**规则表里的每一只桶**(按 `owner_key` 分页,与 M11 同一只走法)。
+ * 不从审批记录推:收编腿把规则桶整桶改键到新身份、而审批史按 D2 留在旧身份名下(`src/adoption/plan.ts` 的 `permission_rule#owner_key` 腿与
+ * `permission-rule-approval-history` 一员)—— 从记录推出的属主集在收编之后漏掉新桶。属主读法只有引擎的 `readRuleOwner`(与本店读口同一只);
+ * 读不出属主的行不点名任何可解析的桶(读腿同样解析不到它),不返回。`db` 是池或迁移握锁的那一条连接。
+ */
+export declare function listRuleBucketOwners(db: Pick<SqlDriver, "dialect" | "query">): Promise<RuleOwner[]>;
+/**
+ * 取 dot 那一步「建行之后、读行之前」这只桶被并发删掉了(另一只副本删桶恰落在这一窗里)。具名类 ⇒ 调用方按类判(M36 退役读作「无可退役」),不按文案。
+ */
+export declare class RuleBucketVanishedError extends Error {
+    readonly ownerKey: string;
+    constructor(ownerKey: string);
+}
+/** 这只抛出物是不是本店的「桶在写它的那一步里没了」({@link RuleBucketVanishedError})。 */
+export declare function isSqlBucketVanished(e: unknown): boolean;
+/**
+ * 这只读桶抛出物是不是**本店读腿的整桶拒** —— 判的是读腿({@link SqlDurableRulePartition} 的 `list` / 写的读基)**真往外交的**那两类,不是判官内部的抛出形:
+ *  · {@link BucketRefusedError} —— 判官四道(文法戳 / 指纹 / 行的 behavior / 引擎校验器)的拒;
+ *  · {@link StoreCorruptError} —— 某只 JSON 列的体读不出(`not-json` / `malformed`),读腿在 {@link refusingUnreadableColumns} 把判官抛的列错误折成的店拒绝契约。
+ * 两类都是这一行的确定性判决:原样再读也读不出,读腿对它同样整桶拒(零规则),所以它什么都不放行。
+ * 别的抛出物**不是**这一类:连接 / 超时 / 权限(一次读失败证明不了以后也读不出);以及仍以 {@link SqlJsonColumnError} 穿出读腿的唯一一形 `not-text`
+ * (列没按文本投影:读腿与解码点漂了,是码缺陷不是坏数据 —— 按列错误类判它会把一次码漂读成「这只桶坏了」)。
+ */
+export declare function isSqlBucketRefusal(e: unknown): boolean;
+/** 导入记录的种类词(引擎闭集 `RULE_APPROVAL_KINDS` 的一员;`imported-cc` 出处由它派生)。 */
+export declare const IMPORT_RECORD_KIND = "import";
 /** 写口拒句(两只店同一句):属主引擎读不出,记录不落。 */
 export declare function refusedOwnerSentence(recordId: string): string;
 /**
@@ -542,4 +571,5 @@ export interface PermissionRuleStores {
     reapExpired(nowMs: number): Promise<number>;
 }
 export declare function createSqlPermissionRuleStores(db: SqlDriver, now?: () => number): PermissionRuleStores;
+export {};
 //# sourceMappingURL=permission-rule-store-sql.d.ts.map

package/dist/plugins/permission-rule-store-sql.js

@@ -6,7 +6,7 @@ import { isMissingColumnError } from "./sql-errors.js";
 import { describeProbedTableDrift } from "./schema-drift-sentence.js";
 import { canonicalJsonStringify } from "@sema-agent/core";
 import { ensureIndexes } from "./ensure-index.js";
-import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn, SqlJsonColumnError } from "./sql-json-column.js";
+import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn, SqlJsonColumnError, StoreCorruptError } from "./sql-json-column.js";
 import { redactSecrets } from "../trace/redact.js";
 export function writerOfSqlRuleStore(store) {
     const w = Reflect.get(store, PERMISSION_RULE_WRITER);
@@ -508,7 +508,7 @@ class SqlDurableRulePartition {
                 const { rows } = await this.db.query(this.q(`SELECT actor, counter, grammar FROM ${PERMISSION_RULE_TABLE} WHERE owner_key = ?`, `SELECT actor, counter, grammar FROM ${PERMISSION_RULE_TABLE} WHERE owner_key = $1`), [this.ownerKey]);
                 const row = rows[0];
                 if (row === undefined)
-                    throw new Error(`permission_rule bucket ${this.ownerKey} vanished while minting a dot`);
+                    throw new RuleBucketVanishedError(this.ownerKey);
                 readBucketStamp(this.ownerKey, row.grammar);
                 const cur = Number(row.counter);
                 const next = cur + 1;
@@ -593,6 +593,39 @@ export class SqlDurableRulePartitionProvider {
 export function recordOwnerOf(record) {
     return readRuleOwner(record.owner ?? { kind: "principal", principal: record.principal });
 }
+export async function listRuleBucketOwners(db) {
+    const owners = [];
+    let after = "";
+    for (;;) {
+        const { rows } = await db.query(db.dialect === "mysql"
+            ? `SELECT owner_key, owner_kind, principal FROM ${PERMISSION_RULE_TABLE} WHERE owner_key > ? ORDER BY owner_key LIMIT ${UNDURABLE_PURGE_PAGE}`
+            : `SELECT owner_key, owner_kind, principal FROM ${PERMISSION_RULE_TABLE} WHERE owner_key > $1 ORDER BY owner_key LIMIT ${UNDURABLE_PURGE_PAGE}`, [after]);
+        for (const row of rows) {
+            after = String(row["owner_key"]);
+            const principal = row["principal"] === null || row["principal"] === undefined ? undefined : String(row["principal"]);
+            const owner = readRuleOwner({ kind: row["owner_kind"], ...(principal !== undefined ? { principal } : {}) });
+            if (owner !== undefined)
+                owners.push(owner);
+        }
+        if (rows.length < UNDURABLE_PURGE_PAGE)
+            return owners;
+    }
+}
+export class RuleBucketVanishedError extends Error {
+    ownerKey;
+    constructor(ownerKey) {
+        super(`permission_rule bucket ${ownerKey} vanished while minting a dot`);
+        this.name = "RuleBucketVanishedError";
+        this.ownerKey = ownerKey;
+    }
+}
+export function isSqlBucketVanished(e) {
+    return e instanceof RuleBucketVanishedError;
+}
+export function isSqlBucketRefusal(e) {
+    return e instanceof BucketRefusedError || e instanceof StoreCorruptError;
+}
+export const IMPORT_RECORD_KIND = "import";
 export function refusedOwnerSentence(recordId) {
     return `refusing to create approval record ${recordId}: its owner is not one the engine reads as an owner (a principal name must be a non-blank string; the kind must be a member of the owner set) — nothing was written`;
 }

package/dist/plugins/pg-session-storage.d.ts

@@ -3,7 +3,6 @@ import type { Pool, PoolClient } from "pg";
 import type { SessionSummary } from "./store-contracts.js";
 import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
-import { type OrphanOwnerLog } from "../delegated-session-owner.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
 import type { SessionWorkspace } from "../session-workspace.js";
@@ -71,26 +70,19 @@ export declare class PgSessionStore implements SessionStore {
     readonly durability: "durable";
     /** In-flight acquisitions keyed by id, so concurrent acquire(sameId) in one process share one. */
     private readonly pending;
-    /** 委派子代孤行那一行 warn 的去处(TiDB 孪生同格)。 */
-    private readonly log;
     /** 执行席(TiDB 孪生同格;实现与语句的唯一属主 = `execution-placement-sql.ts`,本店只交自己的池)。 */
     readonly executionPlacement: ExecutionPlacementSeat;
     /** 本店的池包成的 SqlDriver(TiDB 孪生同格):执行席与会话行格写原语的事务都经它借连接。 */
     private readonly db;
     constructor(pool: Pool, opts?: {
-        readonly log?: OrphanOwnerLog;
         readonly retention?: RetentionDeclaration;
     });
     acquire(sessionId?: string, opts?: PlacementAcquireOpts): Promise<AcquiredSession>;
     private load;
     /** Idempotently create a session_meta row with an owner (core `SessionStore.register`). Existing owner is never overwritten. */
     register(sessionId: string, owner: string | null): Promise<void>;
-    /** acquire 的建行(唯一一处;[ref] 委派继承律,只住在 `createPlacedSessionRow`,本店交既有读写口 —— TiDB 孪生同名方法同注)。 */
+    /** acquire 的建行(唯一一处;placed 会话的属主 = `placement.owner` 原样,core 7.62.0 [ref] 盒义务 7 —— TiDB 孪生同名方法同注)。 */
     private createOnAcquire;
-    /** [ref] 委派继承律的认领口(TiDB 孪生 {@link TiDBSessionStore.claimOwnerless} 同义;句 = `CLAIM_OWNERLESS_PLACED_SQL`,规则在 `delegated-session-owner.ts`)。 */
-    claimOwnerless(sessionId: string, incarnation: string, owner: string): Promise<boolean>;
-    /** 若干来源行的会话面(属主 + 化身)一次读回(TiDB 孪生同义;活住客的投影 `sessionFaceFromRow`,空化身 ⇒ 响亮拒)。 */
-    private sourceFaces;
     /** The one session_meta INSERT. Existing owner is never overwritten.
      *  [ref]:`placement` 与行同一条 INSERT;`DO NOTHING` 臂 ⇒ 已存在行的元组永不被重写(first-write 不可变)。 */
     private insertMeta;

package/dist/plugins/pg-session-storage.js

@@ -10,8 +10,6 @@ import { pgSafeJsonStringify } from "./pg-safe-json.js";
 import { toIso } from "./sql-row-helpers.js";
 import { placementCapabilityOf, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SESSION_DURABILITY, SESSION_PLACEMENTS, } from "./session-placement.js";
 import { contentForkRelation, fastForwardSharedContentDiverged } from "../session-sync-content.js";
-import { CLAIM_OWNERLESS_PLACED_SQL, claimOwnerlessParams, createPlacedSessionRow } from "../delegated-session-owner.js";
-import { createLogger } from "../observability/logger.js";
 import { classifySyncRelationshipByIds, SyncConflictError, StagedCommitOwnerChangedError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
 import { isPgUniqueViolation } from "./sql-errors.js";
 import { BASELINE_IO_DEADLINE_MS, decodeInstructionSource, encodeInstructionSource } from "../instruction-source-notice.js";
@@ -19,7 +17,7 @@ import { SESSION_META_WORKSPACE_COLUMN, decodeSessionWorkspaceCell, encodeSessio
 import { MANAGED_RETENTION, UNMANAGED_RETENTION } from "./retention-store-sql.js";
 import { SESSION_META_INCARNATION_COLUMN, carriedRowCells, headFromRow, incarnationFromCell, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { ensureIndexes } from "./ensure-index.js";
-import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue } from "./session-ownership.js";
+import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue, placedSessionOwnerOf } from "./session-ownership.js";
 import { selectForkRows } from "@sema-agent/core";
 import { FORK_LOG_ROW_SHAPE, ForkTargetUnsettledError, classifyForkTarget, forkByFreshId, forkPointOf } from "./session-fork.js";
 import { pgDriver } from "./sql-driver.js";
@@ -191,12 +189,10 @@ export class PgSessionStore {
     placements = SESSION_PLACEMENTS;
     durability = SESSION_DURABILITY;
     pending = new Map();
-    log;
     executionPlacement;
     db;
     constructor(pool, opts = {}) {
         this.pool = pool;
-        this.log = opts.log ?? createLogger();
         this.retention = opts.retention ?? UNMANAGED_RETENTION;
         this.db = pgDriver(pool);
         this.executionPlacement = createSqlExecutionPlacementSeat(this.db);
@@ -244,20 +240,7 @@ export class PgSessionStore {
         await this.insertMeta(sessionId, owner, undefined);
     }
     async createOnAcquire(sessionId, placement) {
-        if (placement === undefined)
-            return this.insertMeta(sessionId, null, undefined);
-        await createPlacedSessionRow(sessionId, placement, {
-            readFaces: (ids) => this.sourceFaces(ids),
-            insert: (owner) => this.insertMeta(sessionId, owner, placement),
-            readOwner: async () => (await this.headOf(sessionId))?.owner,
-        }, this.log);
-    }
-    async claimOwnerless(sessionId, incarnation, owner) {
-        return ((await this.pool.query(CLAIM_OWNERLESS_PLACED_SQL.pg, [...claimOwnerlessParams(sessionId, incarnation, owner)])).rowCount ?? 0) > 0;
-    }
-    async sourceFaces(ids) {
-        const res = await this.pool.query(`SELECT session_id, owner, incarnation FROM session_meta WHERE session_id IN (${ids.map((_, i) => `$${i + 1}`).join(", ")})`, [...ids]);
-        return new Map(res.rows.map((r) => [String(r.session_id), sessionFaceFromRow(String(r.session_id), r.owner ?? null, r.incarnation)]));
+        await this.insertMeta(sessionId, placement === undefined ? null : placedSessionOwnerOf(sessionId, placement), placement);
     }
     async insertMeta(sessionId, owner, placement) {
         const now = new Date();