@sema-agent/server 7.141.0 → 7.143.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";
@@ -17,7 +17,8 @@ import { redactSecrets } from "../trace/redact.js";
 import { CLAIM_OWNERLESS_PLACED_SQL, claimOwnerlessParams, isOrphanSessionOwner, judgeDelegatedOwner } from "../delegated-session-owner.js";
 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_EXECUTION_LANE_COLUMN, APPROVAL_ASK_TABLE } from "./approval-ask-store-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() {
@@ -60,6 +61,11 @@ export function buildMigrationReceipts() {
         localArchivesKeptStamped: [],
         localArchivesUnreadable: [],
         localArchiveSnapshotsRecovered: 0,
+        askCauseColumnsChanged: 0,
+        askParkTriggersMoved: 0,
+        askJournalRecordsUpgraded: 0,
+        importedLayerRootAllowsRetired: [],
+        importedLayerRootBucketsSkipped: [],
     };
 }
 function completedReport(r) {
@@ -110,7 +116,12 @@ function changedAnything(r) {
         r.localArchivesAnonymized > 0 ||
         r.localArchivesKeptStamped.length > 0 ||
         r.localArchivesUnreadable.length > 0 ||
-        r.localArchiveSnapshotsRecovered > 0);
+        r.localArchiveSnapshotsRecovered > 0 ||
+        r.askCauseColumnsChanged > 0 ||
+        r.askParkTriggersMoved > 0 ||
+        r.askJournalRecordsUpgraded > 0 ||
+        r.importedLayerRootAllowsRetired.length > 0 ||
+        r.importedLayerRootBucketsSkipped.length > 0);
 }
 function readingsSnapshot(r) {
     return {
@@ -125,6 +136,8 @@ function readingsSnapshot(r) {
         executionPlacementSessionsUnreadable: [...r.executionPlacementSessionsUnreadable],
         localArchivesKeptStamped: [...r.localArchivesKeptStamped],
         localArchivesUnreadable: [...r.localArchivesUnreadable],
+        importedLayerRootAllowsRetired: [...r.importedLayerRootAllowsRetired],
+        importedLayerRootBucketsSkipped: [...r.importedLayerRootBucketsSkipped],
     };
 }
 function receiptSentence(r) {
@@ -135,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("; ");
 }
@@ -561,6 +575,63 @@ export const ONE_TIME_MIGRATIONS = [
             "读 / 续跑 / 拉取照常 —— 出路 = 删掉会话后重推,或升级时先过一次带本条的版本并在窗内起服;③ 行上没有建档时刻的格(同一类数据根)⇒ 列表 / 会话视图 / 交出的元数据读纪元(F 类 tag 计数)",
         reportKeys: ["localArchiveRowFactsBackfilled", "localArchivesAnonymized", "localArchivesKeptStamped", "localArchivesUnreadable", "localArchiveSnapshotsRecovered"],
     },
+    {
+        id: "M34",
+        introducedIn: "7.142.0",
+        releasedOn: "2026-10-30",
+        removableAfter: "2026-11-29",
+        removal: "删 migrateStepsOn 的 M34 步(`splitApprovalAskCauseColumns`、`RETIRED_ASK_CAUSE_COLUMN`、`renameAskCauseColumnSql`)与本文件的 `askCauseColumnsChanged` / `askParkTriggersMoved` / `askJournalRecordsUpgraded`" +
+            "(报告 / 收据 / `changedAnything` / `readingFields` / `NO_SQL_MIGRATIONS` 与读数行 note 里的 M34 句、头注 M34 段);`approval-ask-store-file.ts` 的 v1 读侧半场 " +
+            "(`translateJournalV1Record`、`JOURNAL_V1_ENVELOPE`、`V1_ENDING_STATES` / `V1_TRIGGER_STATES`、`replayRecord` 里认 v1 的那两行与 `journalV1Records`)与 local 腿 `upgradeJournalEnvelope`、" +
+            "`store-backend.ts` 的 `LocalBackend.runOneTimeMigrations` 里报 `askJournalRecordsUpgraded` 的那一行;`test/approval-ask-store-db-integration.test.ts` 的 M34 组与 " +
+            "`test/approval-ask-cause-columns.test.ts` 里标题含 ⑤ 与 local 腿读数的格。**不随本条删**:两列与它们的列定义(`APPROVAL_ASK_ENDING_CAUSE_COLUMN` / `APPROVAL_ASK_PARK_TRIGGER_COLUMN`)、" +
+            "两只读口(`askRowEndingCause` / `askRowParkTrigger`)、信封号 2 与「认不出的信封号 ⇒ 拒启」那一臂(常设的数据形)",
+        afterRemoval: "两只常设臂接住:① SQL —— 删码同版把 `approval_ask.denied_reason` 加进退役 schema 判据(`schema-consistency.ts` 的跳版库探针,先于建表)⇒ 跳过了带本条的版本直接升的库响亮拒启," +
+            "出路 = 先在带本条的版本起服一次让迁移走完,再升(列册对账见幽灵列 / 缺列同样拒启,但它的拒句给的是加列,不是这一出路 —— 所以退役判据要在删码同版加上);" +
+            "② 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;
@@ -606,9 +677,15 @@ export const NO_SQL_MIGRATIONS = {
     deviceBindingsMoved: 0,
     deviceBindingsOrphaned: 0,
     deviceBindingTablesDropped: 0,
+    askCauseColumnsChanged: 0,
+    askParkTriggersMoved: 0,
 };
 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;
@@ -621,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;
@@ -651,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));
 }
@@ -701,6 +785,7 @@ async function migrateStepsOn(db, dialect, receipts, input) {
         : "UPDATE task_run SET error_code = $1 WHERE status = 'failed' AND error_code IS NULL AND (error = $2 OR error LIKE $3)", [RUN_HOLDER_DEATH_CODES.orphaned, RUN_ORPHANED_ERROR, `${RUN_ORPHANED_ERROR} (%`]);
     await migrateShadowedRuleKey(db, dialect, receipts);
     await migrateRetiredCardWords(db, dialect, receipts);
+    await splitApprovalAskCauseColumns(db, dialect, receipts);
     await reshapeWorkflowParkIndex(db, dialect, receipts);
     await migrateSessionRuleGrammar(db, dialect, receipts);
     await repairParkedRows(db, dialect, receipts);
@@ -709,12 +794,37 @@ 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);
     await dropRejectedMailboxKeys(db, dialect, receipts);
     await switchExecutionPlacement(db, dialect, receipts, input);
 }
+const RETIRED_ASK_CAUSE_COLUMN = "denied_reason";
+function renameAskCauseColumnSql(dialect) {
+    return dialect === "mysql"
+        ? `ALTER TABLE ${APPROVAL_ASK_TABLE} CHANGE COLUMN ${RETIRED_ASK_CAUSE_COLUMN} ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.mysql}`
+        : `ALTER TABLE ${APPROVAL_ASK_TABLE} RENAME COLUMN ${RETIRED_ASK_CAUSE_COLUMN} TO ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.name}`;
+}
+export async function splitApprovalAskCauseColumns(db, dialect, receipts) {
+    if (!(await tableExists(db, dialect, APPROVAL_ASK_TABLE)))
+        return;
+    const has = (column) => columnExists(db, dialect, APPROVAL_ASK_TABLE, column);
+    if (await has(RETIRED_ASK_CAUSE_COLUMN)) {
+        await execUntil(db, renameAskCauseColumnSql(dialect), async () => !(await has(RETIRED_ASK_CAUSE_COLUMN)) && (await has(APPROVAL_ASK_ENDING_CAUSE_COLUMN.name)));
+        receipts.askCauseColumnsChanged += 1;
+    }
+    if (!(await has(APPROVAL_ASK_PARK_TRIGGER_COLUMN.name))) {
+        await execUntil(db, `ALTER TABLE ${APPROVAL_ASK_TABLE} ADD COLUMN ${APPROVAL_ASK_PARK_TRIGGER_COLUMN[dialect]}`, () => has(APPROVAL_ASK_PARK_TRIGGER_COLUMN.name));
+        receipts.askCauseColumnsChanged += 1;
+    }
+    receipts.askParkTriggersMoved += await db.exec(`UPDATE ${APPROVAL_ASK_TABLE} SET ${APPROVAL_ASK_PARK_TRIGGER_COLUMN.name} = ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.name} ` +
+        `WHERE state IN ('PARKING', 'PARKED') AND ${APPROVAL_ASK_PARK_TRIGGER_COLUMN.name} IS NULL AND ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.name} IS NOT NULL`);
+    await db.exec(`UPDATE ${APPROVAL_ASK_TABLE} SET ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.name} = NULL WHERE state IN ('PARKING', 'PARKED') AND ${APPROVAL_ASK_ENDING_CAUSE_COLUMN.name} IS NOT NULL`);
+}
 const RETIRED_DEVICE_BINDING_TABLE = "device_session";
 const PARKED_DEVICE_BINDING_TABLE = "device_session_retired";
 const BINDING_COLUMNS = "root_session_id, device_id, owner_tenant, owner_subject, bound_at, rev";
@@ -1637,6 +1747,11 @@ function readingFields(r) {
         localArchivesKeptStamped: r.localArchivesKeptStamped.length,
         localArchivesUnreadable: r.localArchivesUnreadable.length,
         localArchiveSnapshotsRecovered: r.localArchiveSnapshotsRecovered,
+        askCauseColumnsChanged: r.askCauseColumnsChanged,
+        askParkTriggersMoved: r.askParkTriggersMoved,
+        askJournalRecordsUpgraded: r.askJournalRecordsUpgraded,
+        importedLayerRootAllowsRetired: r.importedLayerRootAllowsRetired.length,
+        importedLayerRootBucketsSkipped: r.importedLayerRootBucketsSkipped.length,
     };
 }
 export function logOneTimeMigrations(log, backend, report) {
@@ -1690,7 +1805,15 @@ export function logOneTimeMigrations(log, backend, report) {
             "that still carried an importer's owner stamp were rewritten as anonymous with every entry kept as it was (a snapshot of the log is written before each rewrite " +
             "and removed after it; an interrupted rewrite is finished from the snapshot on the next boot); an archive whose log the import check refuses, whose re-import would " +
             "change its content, or whose read skipped unreadable records is left byte for byte as it was and named by a local_archive_kept_stamped line, and a session whose " +
-            "archive header cannot be read is named by a local_archive_unreadable line). Each step " +
+            "archive header cannot be read is named by a local_archive_unreadable line; " +
+            "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; " +
+            "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.",
@@ -1793,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,
@@ -1871,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/remote-env-device.d.ts

@@ -314,21 +314,18 @@ export declare class RemoteDeviceExecutionEnv implements RemoteExecutionEnv {
  * 🔴 **工厂认设备不认住客**(读口一只 = 会话店执行席 `seat.read(root)`,与解析器 / 换绑门 / 执行放置读面 / 准入链同一只读):按 placement 根读**当前**格,
  * 与这条腿带来的设备句柄 `honor` 比,不同即 typed 拒。判序(一次行读):
  *   root  = ctx.placementRootSessionId                       // 空 ⇒ config.placement_root_invalid
- *   honor = ctx.resumeWorkspace?.deviceId
+ *   honor = ctx.placementTarget?.deviceId                    // 引擎交来的放置围栏(这条腿必须落在哪台设备上)
  *   cell  = seat.read(root).cell                             // 行不在 / 格缺 / mirror / writer(device, ∅) ⇒ device.not_bound(唯一读法 `boundDeviceOf`)
  *   honor ≠ undefined ∧ 格上设备 ≠ honor                    ⇒ device.identity_mismatch(句点名两台,零连接)
  *   readDeviceForAdmission(格上设备, 格上属主)
  * 工厂**不**读 `task_run`、不读子代分区行、不按 `ctx.taskId`、不比化身、不比属主(住客谓词只用于写与 judged 复核,不是工厂的读者)。
- * 续跑腿(core 7.54.0 [ref] r3 / [ref],`ExecutionEnvFactoryContext.resumeWorkspace`):行记下了设备 ⇒ 本工厂**只**在那台设备上铸 —— 根此刻绑的不是它(换绑过)
- * ⇒ `device.identity_mismatch`(换绑后赎回的同一个词,零新码);不连另一台、不改道(新设备没有那个工作区)。「绑的就是它但现在不在线」与新跑同形:
- * 构造成功、`connect()` 回 typed `device.offline`(从不连别的设备)。行没记设备(早于该字段的行)⇒ 引擎已命名的「行未记设备 ⇒ 普通路由」臂,按根读当前格。
- * 句柄(`workspaceHandle()`)恒报连接真到达的设备,不抄 `resumeWorkspace`。
- *
- * 🔴 **过渡期(条件句)**:新派后代腿的放置句柄(引擎在 `ExecutionEnvFactoryContext` 上的放置工作区字段,`honor` 的第二来源)**只在本仓所基的引擎版本带它时**
- * 进判序;本仓今天所基的引擎上下文没有这个字段 ⇒ `honor` 只取续跑腿的 `resumeWorkspace`,新派后代腿按根读当前格。本仓**不**注入任何替代见证、不造任何行
- * (修在源头)。敞口(在那个字段到货之前成立):活过父 turn 的后台子代,在根换绑之后新派的腿会落到根当前设备 —— 换绑半边由换绑门的子代活性判关闭(归换绑门那一车),
- * 删除半边另有票。字段到货后的形:`honor = ctx.resumeWorkspace?.deviceId ?? <放置句柄>.deviceId`,放置句柄的 provider 不是本车道 ⇒ 装配拒(`config.placement_root_invalid` 同级)。
- * 本仓任何文本不得宣称工厂「一律按住客定址」。
+ * 围栏(`ExecutionEnvFactoryContext.placementTarget`,引擎每条腿一个答案):派生它的那条腿的环境报过的目标 —— 委派子代 / 工作流 agent / 被唤醒的
+ * 保留 agent 带唤醒腿的目标,级联后续阶 / 验证腿带第一条腿的目标,续跑腿带检查点行记下的目标。围栏点名了设备 ⇒ 本工厂**只**在那台设备上铸 ——
+ * 根此刻绑的不是它(换绑过)⇒ `device.identity_mismatch`(换绑后赎回的同一个词,零新码);不连另一台、不改道(新设备没有那个工作区)。
+ * 「绑的就是它但现在不在线」与新跑同形:构造成功、`connect()` 回 typed `device.offline`(从不连别的设备)。围栏缺席(顶层首腿,或派生它的腿
+ * 不是远端环境)或不点名设备 ⇒ 普通路由,按根读当前格。围栏的 `provider` 不进判序(引擎的回执也只比设备)。
+ * 句柄(`workspaceHandle()`)恒报连接真到达的设备,不抄围栏;引擎拿这份报告复核每条带围栏的腿(不符 ⇒ 续跑腿 `resume.env_failed`、
+ * 其余腿 `config.placement_not_honored`,都在腿跑之前)—— 本工厂在连接之前就拒,那两个词只在报告与围栏真不一致时出现。
  */
 export declare function deviceExecutionEnvFactory(deps: DeviceEnvFactoryDeps): ExecutionEnvFactory;
 /**

package/dist/plugins/remote-env-device.js

@@ -17,6 +17,7 @@ export const DEVICE_OUTCOME_TO_FILE_ERROR = {
     is_directory: "is_directory",
     liveness_no_output: "unknown",
     name_too_long: "name_too_long",
+    symlink_loop: "symlink_loop",
     not_directory: "not_directory",
     not_found: "not_found",
     not_supported: "not_supported",
@@ -40,6 +41,7 @@ export const DEVICE_OUTCOME_TO_EXEC_ERROR = {
     is_directory: "unknown",
     liveness_no_output: "liveness_no_output",
     name_too_long: "unknown",
+    symlink_loop: "unknown",
     not_directory: "unknown",
     not_found: "unknown",
     not_supported: "shell_unavailable",
@@ -771,6 +773,7 @@ const OUTCOME_TO_REMOTE_ERROR = {
     is_directory: "unknown",
     liveness_no_output: "liveness_no_output",
     name_too_long: "unknown",
+    symlink_loop: "unknown",
     not_directory: "unknown",
     not_found: "unknown",
     not_supported: "unsupported",
@@ -806,10 +809,10 @@ export function deviceExecutionEnvFactory(deps) {
             throw deviceFactoryRefusal(DEVICE_ERROR_CODES.NOT_BOUND, `device lane: no device binding for placement root ${rootSessionId} [${DEVICE_ERROR_CODES.NOT_BOUND}] — ` +
                 "the submit-time admission chain must bind the root session to a device before a run reaches the factory (v2 §4.3.2)");
         }
-        const honor = ctx.resumeWorkspace?.deviceId;
+        const honor = ctx.placementTarget?.deviceId;
         if (honor !== undefined && honor !== binding.id) {
-            throw deviceFactoryRefusal(DEVICE_ERROR_CODES.IDENTITY_MISMATCH, `device lane: this resume rebuilds the workspace on device ${honor}, but placement root ${rootSessionId} is now bound to ${binding.id} [${DEVICE_ERROR_CODES.IDENTITY_MISMATCH}] — ` +
-                "a parked call does not follow a rebind (the new device has no copy of that workspace); finish or cancel the parked task, then start it again on the device now bound");
+            throw deviceFactoryRefusal(DEVICE_ERROR_CODES.IDENTITY_MISMATCH, `device lane: this leg is placed on device ${honor} (the device the work it continues ran on), but placement root ${rootSessionId} is now bound to ${binding.id} [${DEVICE_ERROR_CODES.IDENTITY_MISMATCH}] — ` +
+                "work already under way does not follow a rebind (the new device has no copy of that workspace); finish or cancel the running or parked task, then start it again on the device now bound");
         }
         const view = await deps.store.readDeviceForAdmission(binding.id, binding.owner);
         if (!view) {