@sema-agent/server 7.144.0 → 7.146.0

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

@@ -8,7 +8,7 @@ import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprin
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 import { joinFromStore, splitForStore } from "./wiring-section-codec.js";
-import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { readRunIdentityCells, runIdentityCells } from "../identity-source.js";
 import { createInProcessSpaceCommitTable, fenceSpaceCommitAtTerminal, SPACE_COMMIT_RECORD_SCHEMA } from "../workspace-space-commit.js";
@@ -352,9 +352,12 @@ export class FileRunStore {
             }
         }
     }
-    persist(r) {
+    writeRunFile(r) {
         mkdirSync(this.runDir(r.taskId), { recursive: true });
         atomicWriteFile(this.tmpDir, this.runJsonPath(r.taskId), `${JSON.stringify(this.toDisk(r))}\n`);
+    }
+    persist(r) {
+        this.writeRunFile(r);
         this.runs.set(r.taskId, r);
     }
     eventLogFor(taskId) {
@@ -427,6 +430,13 @@ export class FileRunStore {
             this.byIdem.set(idemKey, taskId);
         return { ok: true };
     }
+    async fillObjectivePreview(taskId, preview) {
+        const r = this.runs.get(taskId);
+        if (!r || r.objectivePreview !== null)
+            return;
+        this.writeRunFile({ ...r, objectivePreview: preview });
+        r.objectivePreview = preview;
+    }
     async requestCancel(taskId, owner) {
         const r = this.runs.get(taskId);
         if (!r || !ownerEq(r.owner, owner) || r.status !== "running")
@@ -1097,17 +1107,6 @@ export class FileRunStore {
             }
         }
     }
-    migrateLegacyHolderDeathCodes() {
-        let migrated = 0;
-        for (const r of this.runs.values()) {
-            const code = readLegacyHolderDeathCode(r);
-            if (code === null || r.errorCode === code)
-                continue;
-            this.persist({ ...r, errorCode: code });
-            migrated += 1;
-        }
-        return migrated;
-    }
     sessionIdsWithRuns() {
         return new Set([...this.runs.values()].map((r) => r.sessionId));
     }

package/dist/plugins/fork-routing-session-store.d.ts

@@ -34,7 +34,7 @@
  */
 import { type SessionStore, type AcquiredSession, type SessionHead, type SessionStoreSummary, type SessionPlacement, type PlacedSessionRow } from "@sema-agent/core";
 import type { ExecutionPlacementSeat } from "../execution-placement.js";
-import type { ForkToFn } from "./session-fork.js";
+import type { ForkPlacement, ForkToFn } from "./session-fork.js";
 /** acquire 选项形(core 5.48 SessionStore 契约):[ref] placement=受信 spawner 的分区建会话声明。 */
 type AcquireOpts = {
     requireExisting?: boolean;
@@ -86,7 +86,11 @@ export declare class ForkRoutingSessionStore implements SessionStore {
     unpin(sessionId: string): void | Promise<void>;
     noteTaskRun(sessionId: string, taskId: string, runId?: string): void | Promise<void>;
     list(): Promise<SessionStoreSummary[]>;
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    /** `opts.placement`(后台 fork 子代的转录进委派分区)原样交给做这次 fork 的那只店 —— 落不落由那只店的声明判(host 声明了分区就落;瞬态店不声明 ⇒ 忽略),
+     *  本类不判第二次(声明面从 host 逐字转发,引擎据它决定交不交元组)。 */
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     get size(): number;
     dispose(): void | Promise<void>;
 }

package/dist/plugins/fork-routing-session-store.js

@@ -191,10 +191,10 @@ export class ForkRoutingSessionStore {
     list() {
         return this.transient.list?.() ?? Promise.resolve([]);
     }
-    async fork(sourceId, owner) {
+    async fork(sourceId, owner, opts) {
         const routed = this.route.get(sourceId);
         const tryFork = async (store, where) => {
-            const forked = (await store.fork?.(sourceId, owner)) ?? null;
+            const forked = (await store.fork?.(sourceId, owner, opts)) ?? null;
             if (forked !== null) {
                 this.remember(sourceId, where);
                 this.remember(forked, where);

package/dist/plugins/imported-layer-root-retirement.d.ts

@@ -16,9 +16,10 @@
  * 一律问**店**:它能叫出名字的每一只桶,判据在桶里判(不在桶外按「谁可能有」预筛)。
  *  · SQL:规则表里的每一只桶(`listRuleBucketOwners`,按 `owner_key` 分页)。不从审批记录推 —— 收编把规则桶整桶改键到新身份、审批史留在旧身份名下,
  *    从记录推出的属主集在收编之后漏掉新桶。
- *  · File:引擎的 File 分区后端**没有**列桶口(桶文件按属主名的单向摘要命名),本步能叫出名字的只有本店导入记录点名过的属主
- *    (`FileRuleApprovalRecordStore.importRecordOwners`;`imported-cc` 只由导入记录派生,记录是只增日志)。**已知缺口(如实)**:引擎的本地数据根收编
- *    把一只桶改名到一个没有任何导入记录点名的身份之后,那只桶本步叫不出、不读 —— 等引擎给 File 分区后端一个列桶口再收。
+ *  · File:本店导入记录点名过的属主(`FileRuleApprovalRecordStore.importRecordOwners`;`imported-cc` 只由导入记录派生,记录是只增日志)∪ 引擎 File 分区后端
+ *    自己列得出名字的属主(`FileDurableRulePartitionProvider.listBucketOwners().owners`:本机属主那只桶,与收编标记点名的身份 —— 收编把桶改名到一个没有任何
+ *    导入记录点名的身份之后,那只桶照样被叫出来、被读)。**已知缺口(如实)**:桶文件按属主名的单向摘要命名,记录与收编标记都叫不出属主的桶本步不读;
+ *    引擎给的「叫不出名字的桶数」(`unnamedBuckets`)只认本机属主那只桶与收编标记、把导入记录点名过的桶也算进去,不是本步的缺数 —— 不报它(报了会把读过的桶说成没读)。
  *
  * ## 写在哪里(一处)
  * 墓碑经**这只桶自己的写面**落(`writerOf(partition).apply({ kind: "tighten-delete" })`,引擎的写面契约)—— SQL 两孪生走 `SqlDurableRulePartition` 的那只
@@ -30,10 +31,11 @@
  * 列桶 / 解析桶 / 读桶 / 取点 / 写面**抛** ⇒ 原样抛:起服拒,收据账里已提交的墓碑随拒因交出(与本段其余各步同一条路)。例外两条,都由店的判官按抛出物的**类**判(不按文案):
  * 取点时店说这只桶**在写它的那一步里没了**(`source.isVanishedBucket`:另一只副本删桶恰落在这一窗)⇒ 无可退役、点名跳过 `vanished`(桶都没了,它什么都不放行);
  * 另一条是解析桶(属主 → 分区)或读桶时**店的唯一判官整桶拒**了
- * 这只桶(解析与读同一条律、同一只判官;`source.isWholeBucketRefusal`:确定性判决,引擎读侧对它同样整桶拒、它什么都不放行;SQL = 读腿真往外交的那两类 —— 判官四道的拒与某只 JSON 列的体读不出)
- * ⇒ 点名跳过 `bucket_unreadable`,接着读下一只桶(一只读不出的桶不挡别的桶,也不挡起服);一次读失败(连接 / 超时)
- * 证明不了以后也读不出,所以它**不**归这一类 —— 跳过它就是让那几行在读恢复之后照旧放行。File 店没有这种判决证据(引擎的 File 分区对损坏与 I/O 失败抛同一种错,
- * 解析时读收编标记也是:一次 EIO 与一份坏标记同一种错)⇒ 那一侧解析 / 读桶抛一律起服拒。另两种店**答了**却做不了的(没有写面或写面拒 / 并发争不过)⇒ 点名跳过,下一次起服再试,其间那几行照旧放行,每次起服都点名。
+ * 这只桶(解析与读同一条律、同一只判官;`source.isWholeBucketRefusal`:确定性判决,引擎读侧对它同样整桶拒、它什么都不放行;SQL = 读腿真往外交的那两类 —— 判官四道的拒与某只 JSON 列的体读不出;
+ * File = 引擎 File 分区的拒码 `permission_rules.bucket_damaged`〔同一份字节每次读都同样拒〕)
+ * ⇒ 点名跳过 `bucket_unreadable`,接着读下一只桶(一只读不出的桶不挡别的桶,也不挡起服);一次读失败(连接 / 超时;File 的拒码 `permission_rules.bucket_unreadable`,
+ * 带系统错名 `errno`)证明不了以后也读不出,所以它**不**归这一类 —— 跳过它就是让那几行在读恢复之后照旧放行。File 解析时读收编标记的拒(标记自己的拒,不带桶拒码)同样不归这一类 ⇒ 起服拒。
+ * 另两种店**答了**却做不了的(没有写面或写面拒 / 并发争不过)⇒ 点名跳过,下一次起服再试,其间那几行照旧放行,每次起服都点名。
  */
 import { type DurableRulePartitionProvider, type PersistedRule, type RuleAdd, type RuleOwner } from "@sema-agent/core";
 /** 一只被退役的导入 add 所在的行(一行一条读数)。**不带规则正文**(与 M11 同一条纪律:规则正文不出店)—— 桶键 + 工具名足够让运维去列举面对上它。 */
@@ -77,6 +79,6 @@ export interface ImportedLayerRootRetirementSource {
 }
 /** 判据(引擎 §5.14 那一句,逐字):这一行里该退役的 add;不选 ⇒ 空。 */
 export declare function importedLayerRootAddsOf(row: PersistedRule): readonly RuleAdd[];
-/** 跑一遍:读记录点名的每只桶(按桶键去重),退役判据选中的 add。读数随每次提交记进 `into`。 */
+/** 跑一遍:读店叫得出名字的每只桶(`candidateOwners()`,见头注「读哪些桶」;两源有重 ⇒ 按桶键去重),退役判据选中的 add。读数随每次提交记进 `into`。 */
 export declare function retireImportedLayerRootAllows(source: ImportedLayerRootRetirementSource, into: ImportedLayerRootReadings): Promise<void>;
 //# sourceMappingURL=imported-layer-root-retirement.d.ts.map

package/dist/plugins/local-checkpoint-store.d.ts

@@ -1,5 +1,5 @@
 import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
 import { type FencedRun, type InProcessClaimFence } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 export interface LocalCheckpointStoreOptions {
@@ -91,6 +91,15 @@ export declare class LocalCheckpointStore {
     private ensureScopesRebuilt;
     /** All still-pending checkpoints across the registered scopes (summary + full row via get). */
     private pendings;
+    /**
+     * 一条会话的待决行 —— **只读这条会话自己的行**(本店停驻行读者的那一条律:一行的字节只坏它自己那一行;决断不许因为别的会话的一行坏行而失败)。
+     * 读口 = core 店的 `listBySession`(按会话取行,一行读不出的行答 `unreadable` 而不是整页失败、也不是跳过;它不经 scope 注册表、不投摘要);
+     * `unreadable` 的行经 `get(token)` 取原行(core 店的 `get` 原样拷出,不判形)—— 它仍是这条会话的一张待决行,选不选它由下游的门型绑定判
+     * ({@link pickPendingRow}:门型读不出 ⇒ 不命中,与 SQL 孪生 `gate_kind IN (…)` 对 NULL 同向),续不续由续跑的第一级(core 判官)答。
+     * 修前三个按会话的读口(`findPendingTokenBySession` / `peekPendingScope` / `deleteBySession`)走 {@link pendings} 的整店枚举,而那一路经 core 的
+     * `listByScope` 投摘要 —— 同库任何一行摘要读不动(缺 `state`)⇒ 整只枚举抛,别人那张好卡的决断也 500。
+     */
+    private sessionPendings;
     /** Operator approval queue — the same NON-secret card as the SQL twins (never the token). */
     /** 每一只待决 checkpoint 的会话(去重;不按门型过滤 —— 理由与 SQL 孪生 `listPendingSessionIds` 逐字同,见那里)。 */
     listPendingSessionIds(): Promise<string[]>;
@@ -157,9 +166,11 @@ export declare class LocalCheckpointStore {
      * 语义与存在理由的唯一属主 = SQL 侧 `peekScopeByToken` 顶注。
      *
      * ⚠️ 形差如实记:SQL 孪生那口是真「轻读」(只 SELECT scope 一列),本形没有列可选 —— core 的 File 店
-     * 只给 `get(token)`,所以这里读的是**整行**。后果对本形无害:本形的 `get()` 没有行级拒(两只孪生 7.144.0 起都不按版本拒 ——
-     * 本引擎续不续由 core 判官在续跑时答;本形连 SQL 孪生剩下的坏体一臂也没有,唯一的读不动形是账本重放级 = 整店同时读不动,
-     * `findPendingTokenBySession` 先抛),所以「行体读得出而 scope 读不出」这一支在本形结构上不存在。哪天本形补了行级拒,这里要跟着改成不碰行体的读。
+     * 只给 `get(token)`,所以这里读的是**整行**。后果对本形无害:本形的 `get()` 没有行级拒、也不判形(两只孪生 7.144.0 起都不按版本拒 ——
+     * 本引擎续不续由 core 判官在续跑时答),原样拷出一行。读不动的形有两层:整店级 = 账本重放抛(认不出的事件种类等 ⇒ 整只店装不起来);
+     * 单行级也存在 —— 按会话的读口({@link sessionPendings})走 core 店的 `listBySession`,摘要读不出的那一行答 `unreadable`(读口不抛,行经 `get(token)` 取原行)。
+     * 即便如此,「行体读得出而 scope 读不出」这一支在本形仍结构上不存在:`scope` 是账本重放认一行的门(`token` / `scope` / `status` 皆字符串)里的成员,
+     * 门不过的行重放时被跳过并披露、根本不进店;进了店的行,行体其余成员损成什么样,`get(token)?.scope` 都是字符串。哪天本形补了行级拒、或 core 放宽重放的那道门,这里要跟着改成不碰行体的读。
      */
     peekScopeByToken(token: CheckpointToken): Promise<string | null | undefined>;
     /** `undefined` = no pending row; else the owner scope (local scopes are always strings — never null).
@@ -210,7 +221,7 @@ export declare class LocalCheckpointStore {
      */
     rewriteCtxWhileClaimed(sessionId: string, taskId: string, ctx: SealedCheckpointCtx, legHolds: (run: FencedRun) => boolean): Promise<CtxClaimRewrite>;
     /**
-     * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
+     * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-face.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
      * 逐档读(信封经读腿**同一只**判形 —— 读不出 ⇒ 计数、跳过、**不删**),`rewrite` 交回新体 ⇒ 信封原样(`sessionId` / `updatedAt` 不动:收割按 `updatedAt` 判)
      * 只换 `ctx`,经写腿同一只形闸、同一只原子写落回原档。封签绑的是信封里的 `sessionId`(与 `getCtx` 认行的那一格同一个)。
      * 数据根独占 + 起服在任何读写者之前跑 ⇒ 本车道没有并发写者,不需要 CAS;没有一行装不下这回事(`tooLarge` 恒 0)。

package/dist/plugins/local-checkpoint-store.js

@@ -5,8 +5,9 @@ import { durableRowIdentity } from "../checkpoint-identity.js";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
-import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, candidateIdentityOf, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
+import { CHECKPOINT_LIST_LIMITS, FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
+import { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
+import { approvalDecisionOfWinner, boundedRuleOffers, boundedToolInput, candidateIdentityOf, pendingRowPrecedes, queueRowGateKind, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-face.js";
 import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
 import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
@@ -160,6 +161,24 @@ export class LocalCheckpointStore {
         }
         return out;
     }
+    async sessionPendings(sessionId, scope) {
+        if (sessionId === "")
+            return [];
+        const out = [];
+        let after;
+        do {
+            const page = await this.inner.listBySession({ sessionId, status: "pending", ...(scope !== undefined ? { scope } : {}), ...(after !== undefined ? { after } : {}), limit: CHECKPOINT_LIST_LIMITS.session.max });
+            for (const row of page.rows) {
+                const token = row.kind === "row" ? row.checkpoint.token : row.token;
+                const cp = row.kind === "row" ? row.checkpoint : await this.inner.get(row.token);
+                if (cp === null || cp.status !== "pending" || (scope !== undefined && cp.scope !== scope))
+                    continue;
+                out.push({ token, cp });
+            }
+            after = page.next;
+        } while (after !== undefined);
+        return out;
+    }
     async listPendingSessionIds() {
         return [...new Set((await this.pendings()).map(({ cp }) => cp.sessionId))];
     }
@@ -200,7 +219,7 @@ export class LocalCheckpointStore {
         return rows.sort((a, b) => (b.riskDescriptor?.severity ?? 0) - (a.riskDescriptor?.severity ?? 0) || a.createdAt - b.createdAt);
     }
     async findPendingTokenBySession(sessionId, scope, binding) {
-        return this.pickPendingRow(await this.pendings(scope || undefined), sessionId, binding)?.token ?? null;
+        return this.pickPendingRow(await this.sessionPendings(sessionId, scope || undefined), sessionId, binding)?.token ?? null;
     }
     pickPendingRow(rows, sessionId, binding) {
         let best;
@@ -292,7 +311,7 @@ export class LocalCheckpointStore {
         return (await this.inner.get(token))?.scope;
     }
     async peekPendingScope(sessionId, binding) {
-        return this.pickPendingRow(await this.pendings(), sessionId, binding)?.cp.scope;
+        return this.pickPendingRow(await this.sessionPendings(sessionId), sessionId, binding)?.cp.scope;
     }
     async reapExpired(cutoff) {
         let n = 0;
@@ -415,8 +434,8 @@ export class LocalCheckpointStore {
             return 0;
         }
         let n = 0;
-        for (const { token, cp } of await this.pendings()) {
-            if (cp.sessionId === sessionId && (await this.inner.expire(token, cp.scope)))
+        for (const { token, cp } of await this.sessionPendings(sessionId)) {
+            if (await this.inner.expire(token, cp.scope))
                 n++;
         }
         const p = join(this.ctxDir, ctxFileOf(sessionId));

package/dist/plugins/local-session-store.d.ts

@@ -2,13 +2,13 @@ import { FileSessionRepo, type AcquiredSession, type PlacedSessionRow, type Sess
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { z } from "zod";
 import { StoreBootRefusalError, type SessionRunClaimSource, type SessionRunRollupSource, type SessionSummary } from "./store-contracts.js";
-import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
+import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowAnswer, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type LocalArchiveKeptStamped, type LocalArchiveUnreadable } from "./one-time-migrations.js";
 import { type Logger } from "../observability/logger.js";
 import { type SessionFace } from "../session-incarnation.js";
 import { type ExecutionLane } from "../execution-lane-caps.js";
 import { type ExecutionPlacementSeat, type LocalPlacementBackfillSeat } from "../execution-placement.js";
-import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
+import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
 import type { SessionWorkspace } from "../session-workspace.js";
 import { type StagedCommitOptions, type StagingHandle, type SyncRelation } from "../session-sync-kernel.js";
@@ -348,8 +348,9 @@ export declare class LocalSessionStore implements SessionStore {
      */
     headOf(sessionId: string): Promise<SessionHead | undefined>;
     /**
-     * 引擎仓存档的头(core `SessionRepo.headOf`:日志首记录与尾,不重放)—— 本店读存档头的**唯一**一处。存档头在本店只有两种读法:叶子(读内容的人要的那一格)
-     * 与行代号(换装 / 一次性迁移的 `expect.row`、迁移判「有没有、读不读得出」);属主 / 建档时刻 / 谱系从不从这里读(规则一,行事实只住边档)。
+     * 引擎仓存档的头(core `SessionRepo.headOf`:日志首记录与尾,不重放)—— 本店读存档头的**唯一**一处。存档头在本店只有三种读法:叶子(读内容的人要的那一格)、
+     * 行代号(换装 / 一次性迁移的 `expect.row`、迁移判「有没有、读不读得出」)与带戳判({@link assertArchiveAnonymous};读的是存档的**形** —— 头上有没有属主戳 —— 不是属主事实);
+     * 属主 / 建档时刻 / 谱系作为行事实从不从这里读(规则一,行事实只住边档)。
      */
     private archiveHeadOf;
     /**
@@ -490,14 +491,41 @@ export declare class LocalSessionStore implements SessionStore {
      *  无主」)一个字节不动,没被记下的也不在这里替它记成无主:打开不是一个属主事实(7.119.0 前这一腿把「不知道」记成进程内存里的 null,重启即失)。 */
     private openForItselfHeld;
     /**
-     * 带 placement 的按 id 首建(锁内一形,调用方持这只会话的写锁、已判过存档不在且不是 fork 创建的格)。写序 = **判别位先落**:先建存档(引擎文件 repo 把元组写进行头、
-     * 首写不可变),再写会话元数据那一格(化身新铸;属主 = `placement.owner` 原样 —— core 7.62.0 [ref] 盒义务 7:委派树的属主是引擎判的,店只记、不推断;
-     * 唯一读法 `placedSessionOwnerOf`,在建存档之前判,坏值 ⇒ 响亮拒、一个字节不写;SQL 孪生同调)。崩在两笔之间 = 存档在而格缺 = 一只 placed 行、属主从没被记下
-     * (读作无主;本店没有回填臂 —— M23 的扫描与回写是 SQL 语句,只在两只 SQL 店跑 —— 这一行在具名树的停驻挂点被否决、响亮,匿名树 `null === null` 照放;SQL 孪生的同形由 M23 在窗内回填)。
-     * 格已在而存档不在(登记先落了格、存档还没建 —— 一只普通会话的行)⇒ `placement_refused`(SQL 孪生:登记过的行在,带 placement 的建读回缺席元组,同一判)。
-     * 建后读回准入(镜像方向):别的进程(同一数据根上的 run-local 腿)在这一刻抢先建了同 id 的存档 ⇒ repo 返回的是那一只 ⇒ 元组缺席 / 异组 ⇒ 响亮拒。
+     * 带 placement 的按 id 首建(锁内一形,调用方持这只会话的写锁、已判过存档不在且不是 fork 创建的格)。写序 = **格先、存档后**(与登记先记属主再建存档、fork 先写目标格再拷存档、
+     * 导入先落格再导条目同一序;普通 acquire 的两条首建 —— 无 id 新建、按 id 缺档新建 —— 仍是存档先、格后:那两处写的属主是「无主」,崩在两笔之间留下的存档补铸后同样读作无主,
+     * 与「登记为无主」只在 M10 认领窗内有别,不在本条):
+     *  1. 会话元数据那一格:化身新铸;属主 = `placement.owner` 原样(core 7.62.0 [ref] 盒义务 7:委派树的属主是引擎判的,店只记、不推断;唯一读法 `placedSessionOwnerOf`,
+     *     坏值 ⇒ 响亮拒、一个字节不写;SQL 孪生把它与元组写进同一条 INSERT);建档时刻同一笔写(铸行点律);
+     *  2. 存档:元组 = `placement` 去掉属主(`SessionPlacementRecord` 没有属主 —— core 自己的店同样只把元组交给 repo),不交属主(引擎仓是匿名内容仓)。
+     * 崩在两笔之间 ⇒ 格在而存档不在 = 一次没建完的建行(与登记 / fork / 导入崩溃留下的同一族;不是 placed 行:不上列表、不进分区枚举、`requireExisting` ⇒ not_found、
+     * 同 id 再带 placement 建 ⇒ 下面那一判 `placement_refused`)—— 没有任何一刻盘上是「placed 存档在而格缺」(属主从没被记下)。保证到进程崩溃为止(那一格改名落定在建存档之前;
+     * 不另加 fsync 屏障,与另外三个建行点同)。
+     * 「placed 存档在而格缺」此后只剩三个来源,都照旧读作无主(补铸的格不写属主:属主没有事实可写),在具名树的停驻挂点被否决、响亮,匿名树 `null === null` 照放 ——
+     * ① 7.144.x 及更早崩在两笔之间留下的存量行(当年存档先建;不回填:行头属主格是空的,元组里那一份属主是本店当年漏进去的未声明成员,不作来源);
+     * ② `release` 删了格、没删存档就崩(判别位最后删;它的 agent 行已先删,没有复活腿会碰它,重发 release / 分区收割收完);③ 同一数据根上 run-local 腿经 core 店写下的 placed 存档
+     * (core 形:属主在行头,本店不读行头属主)。SQL 孪生的存量无主 placed 行由 M23 在窗内回填。
+     * 格已在而存档不在(登记先落了格、存档还没建 —— 一只普通会话的行;或本条崩在两笔之间留下的格)⇒ `placement_refused`(SQL 孪生:登记过的行在,带 placement 的建读回缺席元组,同一判)。
+     * 建后读回准入(镜像方向):别的写者在这一刻抢先建了同 id 的存档 ⇒ repo 返回的是那一只 ⇒ 元组缺席 / 异组 ⇒ 响亮拒。
+     * 第 2 步失败时那一格撤不撤,按「这只 id 上的存档是不是本次的」判,先认确证、说不准才问盘:
+     *  · 确证不是本次的 ⇒ {@link withdrawCreatedCell} 撤(留着它 = 一只属主落在别人存档上的格):读回准入拒(读到的就是 create 交回那一只存档的元组)·
+     *    core 的 create 抛 `conflict`(它判的「别的写者在存在判与写之间抢先落盘」);确证不被之后的读推翻;
+     *  · 说不准(create 抛别的故障 —— 可能在行头已落盘之后,core 的 create 写完行头还要开追加日志;读元数据抛)⇒ 问盘({@link holdsThisPlacement}):本次元组下的 placed 存档
+     *    ⇒ 那一格就是它的属主事实,留着(撤了正是「placed 存档在而格缺」);不在 / 普通 / 别的元组 ⇒ 撤;读不出 ⇒ 留着(残格惰性;撤了可能丢属主 —— 别的写者同一刻抢建同 id
+     *    又恰好不是 `conflict` 的那一形;数据根锁之下没有第二个进程,进程内同 id 的写者都排在这只会话的写锁上,这一形只有注入造得出,如实登记不另设臂)。
+     * 确证两臂同理是防线:这一节在写锁里、打开刚答「不在」,正常路上 create 交回的就是本次建的那一只。
+     * 撤完(或留下)之后上抛第 2 步的那一只故障。
      */
     private createPlacedHeld;
+    /**
+     * 带 placement 的建行第 2 步说不准地失败之后,盘上这只 id 是不是本次元组下的 placed 存档 —— 判据就是读回准入那一只(`admitSessionPlacement`:缺席 / 普通 / 异组 ⇒ 不是;
+     * 它是纯比较,只抛 `placement_refused`),读的是 {@link placementProbe}(行头上的元组,唯一一读)。读不出(`corrupt_session` / `storage`)⇒ 答「是」(见调用方)。
+     */
+    private holdsThisPlacement;
+    /**
+     * 格先、存档后的建行点(fork 的目标 · 带 placement 的建行)建存档那一步失败时,撤回第一步刚写的那一格(调用方持这只会话的写锁):撤得回 ⇒ 返回,调用方原样上抛那只故障;
+     * 撤不回 ⇒ 两只故障同句点名(句子由调用方给,带出路),原故障挂在 `cause` —— 留下的格就是崩在两步之间的那一形。
+     */
+    private withdrawCreatedCell;
     /**
      * Idempotently record a session's owner — never overwrites a RECORDED owner (incl. a recorded `null`, "registered ownerless";
      * mirrors TiDBSessionStore.register's first-write rule). TiDB parity: register INSERTs a session_meta row so the session EXISTS
@@ -556,6 +584,17 @@ export declare class LocalSessionStore implements SessionStore {
         limit: number;
         q?: string;
     }): Promise<SessionSummary[]>;
+    /** {@link listSessions} 带每行的住客(属主 + 化身那一格,与行同一刻读)—— `OwnerAwareSessionStore.listSessionRows`;化身不进行本身。 */
+    listSessionRows(opts: {
+        owner?: string;
+        includeUnowned?: boolean;
+        cursor?: {
+            lastActivityAt: string;
+            sessionId: string;
+        };
+        limit: number;
+        q?: string;
+    }): Promise<Array<SessionRowAnswer<SessionSummary>>>;
     /** 列表行要读的边档一次装齐(lastActivity / 标题 / 置顶 / 会话元数据);各自记忆化,只有第一次真读盘。 */
     private loadRowSidecars;
     /** 列表行上的属主:那一格的属主(没有格 / 属主从没被记下 ⇒ null —— 与 `headOf(id)?.owner` 同答;列表不补铸缺的格,`headOf` 在第一次读时补)。 */
@@ -583,8 +622,11 @@ export declare class LocalSessionStore implements SessionStore {
      *  修前把参数原样写进新格:`fork(owned, null)` 铸出一份匿名的有主历史。
      *  拷**已提交**的叶(契约):在飞的 assistant 轮不进孩子 —— 分叉点只有引擎那一只判官(core 7.55.0 起包根导出的 `settledForkOptions`),本店把唤醒出来的源会话交给它、
      *  把它的答案原样交给引擎自己的 `repo.fork`(与 core 内存店 `TtlSessionStore.fork` 同一条调用链);两只 SQL 孪生同读它(`session-fork.ts`)。钉:
-     *  core 店契约盒的 `[fork]` 格(`test/session-store-contract-kit.test.ts`)。 */
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+     *  core 店契约盒的 `[fork]` 格(`test/session-store-contract-kit.test.ts`)。
+     *  `opts.placement`(后台 fork 子代的转录)= fork 进委派分区:见 {@link forkToHeld} 的建行点。 */
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     /**
      * **fork 续写的店契约**(local 一形;规则与结果闭集在 `session-fork.ts`,SQL 孪生同义):
      *  · **两把写锁**:按 id 字典序依次取源与目标的写锁(锁不可重入;同 id 只取一把)—— 同 id 的每个写者(删除 / 登记 / 导入 / 按 id 首建 / 别的 fork)都在目标那把锁里,
@@ -594,11 +636,20 @@ export declare class LocalSessionStore implements SessionStore {
      *    (不交属主 —— 引擎仓匿名;子存档的属主格抄自源存档,源匿名 ⇒ 子匿名)。
      *    崩在两步之间 = fork 创建的格而存档不在 = `forking`:普通取用一律 {@link SessionForkInProgressError};同键重试在两把锁内补拷存档、答 `replayed`。
      *    拷贝抛错(不是崩溃)⇒ 撤掉刚写的目标格再上抛(撤不掉 ⇒ 留下的就是 `forking`,与崩在中间同形);
-     *  · **撞已在** ⇒ 按目标格的属主与 fork 键分类({@link classifyForkTarget})。
+     *  · **fork 进委派分区**(`target.placement`,只在声明了分区的店落;没声明 ⇒ 忽略、照常 fork):元组随引擎 `repo.fork` 落进子存档行头 —— 与带 placement 的建行
+     *    ({@link createPlacedHeld})同一处、同一形(存档行头,first-write 不可变,`placedAt` 由 repo 铸);行的属主仍是上面那一读(元组不带属主)。建后读回准入同
+     *    `createPlacedHeld`(镜像方向:repo 交回的行没带这一组元组 ⇒ `placement_refused`):拒了就删掉刚拷的存档、再撤目标格(**存档先删、格后撤** —— 崩在中间留下的是
+     *    「格在而存档不在」的惰性残格;反过来会留下一份没有属主格的有主历史拷贝),删不掉 ⇒ 两只故障同句点名、出路随句;
+     *  · **撞已在** ⇒ 按目标格的属主与 fork 键分类({@link classifyForkTarget});placed 目标永不带键(型面互斥)⇒ 永不 `replayed`。
      */
     forkTo(sourceId: string, owner: string | null, target: ForkTarget): Promise<ForkToOutcome | null>;
     /** {@link forkTo} 的锁内一形(调用方持源与目标两把写锁)。 */
     private forkToHeld;
+    /**
+     * fork 进委派分区的建后读回准入(锁内,调用方持目标的写锁、刚拷完存档):判据 = 引擎那一只 `admitSessionPlacement`(镜像方向,读 repo 交回的那一份行头元组,零额外读),
+     * 与 {@link createPlacedHeld} 的读回同一判。拒 ⇒ 存档先删、目标格后撤(见 {@link forkToHeld} 注),再原样上抛那只 `placement_refused`;删不掉 ⇒ 同码、两只故障同句点名。
+     */
+    private admitForkedPlacement;
     /** 2c session-sync — EXPORT a session's full durable entry log (core `SessionRepo.exportEntries`; the
      *  in-memory/file repo holds the whole log so there is no floor to bypass). null if the source is unknown / the
      *  underlying repo lacks the optional seam. The owner is NOT exported — import re-stamps it. */
@@ -648,7 +699,7 @@ export declare class LocalSessionStore implements SessionStore {
      *  ③ 内容,按写口的动词(唯一读法在下面这一只 switch;这里不读那一格、不判属主,只换**内容**;交给引擎仓的属主恒缺席 —— 规则一):
      *    · `create` / `judged`(导入):原地换锁里读到的那一份存档的日志(没有存档 ⇒ 导入新建一只,匿名),以锁里读到的存档头为 `expect.row`(**行代号**:
      *      读与写之间存档换了一代 ⇒ 引擎仓拒 `conflict`;它判不出同一代里的追加)。匿名导入只换匿名存档的日志 —— 仍带属主戳的存档(更早的版本写下、一次性迁移 M33
-     *      改写不了的,或跳版升上来的)到不了这里:暂存提交在一切「谁赢」的判之前就以具名拒答了它({@link assertArchiveAnonymousHeld},唯一的一读);`create` 落在没有存档的名上,`replace` 先清存档。
+     *      改写不了的,或跳版升上来的)到不了这里:暂存提交在一切「谁赢」的判之前就以具名拒答了它({@link assertArchiveAnonymous});`create` 落在没有存档的名上,`replace` 先清存档。
      *      读存档、校验、存档判与写在引擎仓里是一步,抛在哪一处内容都一个字节没动 ⇒ 撤回 ②({@link withdrawImportCell}:行原样 —— 净零写,SQL 孪生的事务回滚同义)再原样上抛;
      *    · `replace`(接口句「先清既有对话日志,再导入」):先清掉内容存档(不带 `expect` —— 带了就得先读它的头,读不出的存档就清不掉),再导入一只新存档。
      *      清不可撤:清过之后导入再抛(I/O 故障),内容就没了,行留 ② 落下的 mirror(只读方向,下次推送补齐)—— 已发版本的 replace 同形(删后导入)。
@@ -695,16 +746,24 @@ export declare class LocalSessionStore implements SessionStore {
     /** Drop a finished/aborted local staging handle from the registry (called by the handle on commit/abort). */
     forgetStaging(stagingId: string): void;
     /**
-     * 带戳存档的唯一一判(调用方持这只会话的写锁;只读、零写):这份存档的头仍记着属主戳(更早的版本导入 / 换装写下的,一次性迁移 M33 改写不了的,或跳版升上来的)⇒
-     * {@link StampedSessionArchiveError}。引擎导入律不让匿名导入替换带戳存档,本店不重写、不绕 —— 只让拒带对的出路(fork 的源另有一读,同一只具名拒,见 {@link forkTo})。
-     * 这是「这份存档的日志根本换不了」的判,所以排在一切「谁赢」的判之前({@link commitStagedImport}):换不了的存档上谈不上同步冲突或载荷分叉,
-     * 那两条拒的出路(带同意重来)都是死路 —— 唯一的出路在这一句里。
-     */
-    private assertArchiveAnonymousHeld;
+     * **带戳存档拒绝判的唯一一读**(fork 与改日志的推送问「这份存档的头仍记着属主戳吗」只此一处,也是 {@link StampedSessionArchiveError} 在本店的唯一铸点;只读、零写;
+     * 一次性迁移 M33 为改写存档而读头 / 整行是窗内的另一件事,窗关即删):这份存档的头仍记着属主戳
+     * (更早的版本导入 / 换装写下的,一次性迁移 M33 改写不了的,或跳版升上来的)⇒ 抛那只具名拒。引擎的 fork 会把戳抄给子存档、引擎导入律不让匿名导入替换带戳存档,
+     * 本店不重写、不绕 —— 只让拒带对的出路(删掉会话后重推)。读的是存档的**形**(「这不是本店的存档形」),不是属主事实(属主读行那一格);读口是 {@link archiveHeadOf}
+     * (core `SessionRepo.headOf` 契约:与 `open()` 读到的头同一读)。没有存档的 id ⇒ 放行(没有存档就没有戳)。
+     * 三处问它,问的时刻不同、答案同一个:
+     *  · {@link forkTo} 的源 —— 在写目标格之前(持源与目标两把写锁);
+     *  · {@link commitStagedImport} —— 这一提交要换日志,排在一切「谁赢」的判之前(持这只会话的写锁):换不了日志的存档上谈不上同步冲突或载荷分叉,
+     *    那两条拒的出路(带同意重来)都是死路,唯一的出路在这一句里;
+     *  · 会话同步导入的**第一阶段**(`http/routes/session-sync.ts`,经 `OwnerAwareSessionStore.assertArchiveAnonymous` 这一缝,不持锁):按 id 分类出 fork / stale 又没带同意时,
+     *    通用冲突指的出路同样是「带同意重来」⇒ 先问这一口,不等第二轮。不持锁的一问是早拒(此刻的答案),权威的一问是提交里持锁的那一问 —— 同一个事实的两次读。
+     * 只有 local 店有带戳存档这一形;SQL 孪生没有 ⇒ 不交这一口(调用方按「没有带戳存档」处置)。
+     */
+    assertArchiveAnonymous(sessionId: string): Promise<void>;
     /**
      * {@link LocalStagingHandle.commit} 的整段 —— **一次持锁**(这只会话的写锁,{@link withSessionWriteLock}):属主 CAS(此刻的属主格 = 这次导入的门判过的那一格,
      * 否则抛 {@link StagedCommitOwnerChangedError},一个字节不写;在判目的端日志之前判,SQL 孪生同序)→ 分区判 → 提交时重新分类(目的端此刻的日志 vs staged)→
-     * 这一提交要换日志(不是「id 与内容都相同」那一支)⇒ 带戳存档判({@link assertArchiveAnonymousHeld};只有 local 店有带戳存档,SQL 孪生没有这一步)→
+     * 这一提交要换日志(不是「id 与内容都相同」那一支)⇒ 带戳存档判({@link assertArchiveAnonymous};只有 local 店有带戳存档,SQL 孪生没有这一步)→
      * 拒未经同意的 fork / stale / 载荷分叉(带戳判在它们之前:带戳存档上日志换不了,同步冲突与载荷分叉的出路 —— 带同意重来 —— 无从谈起)→ 本处写者拒 → 换装(导入写序 ①②③,落点 `judged` = 上面这一判;化身与 fork 键按换装律沿用)或 identical 且内容相同时日志不动、
      * 行照样落(② 那一格:重戳属主 + mirror)→ 两支同记新近(推送即活动)→ **在同一次持锁里**
      * 读出落定的会话面交回。锁放下之前谁也换不掉这一位住客,所以交回的面就是这次提交落下的那一位(SQL 孪生在提交事务里读同一行,同义);

package/dist/plugins/local-session-store.js

@@ -1022,12 +1022,51 @@ export class LocalSessionStore {
         if (this.metaCellOf(sessionId) !== undefined) {
             throw new SessionError("placement_refused", `session ${sessionId} is already registered as an ordinary session — refusing to create a subagent transcript on its id`);
         }
-        const owner = placedSessionOwnerOf(sessionId, placement);
-        const session = await this.repo.create({ id: sessionId, placement });
-        await this.writeMeta(sessionId, (before) => (before === undefined ? { incarnation: mintSessionIncarnation(), owner, createdAt: rowBornNow() } : undefined));
-        admitSessionPlacement(sessionId, (await session.getMetadata()).placement, opts, placementCapabilityOf(this));
+        const { owner: treeOwner, ...tuple } = placement;
+        const owner = placedSessionOwnerOf(sessionId, { owner: treeOwner });
+        const created = await this.writeMeta(sessionId, (before) => (before === undefined ? { incarnation: mintSessionIncarnation(), owner, createdAt: rowBornNow() } : undefined));
+        if (!created)
+            throw new SessionError("storage", `LocalSessionStore: session ${sessionId} gained a session-meta cell under its own write lock — refusing to guess`);
+        const stuck = (cause, drop) => `LocalSessionStore: creating the subagent transcript ${sessionId} failed (${cause}) and its session-meta cell could not be withdrawn (${drop}) — the cell stays on disk and a placed create on this id is refused; delete the session to clear it`;
+        const unsure = async (err) => {
+            const foreign = err instanceof SessionError && err.code === "conflict";
+            if (foreign || !(await this.holdsThisPlacement(sessionId, opts)))
+                await this.withdrawCreatedCell(sessionId, err, stuck);
+            throw err;
+        };
+        const session = await this.repo.create({ id: sessionId, placement: tuple }).catch(unsure);
+        const persisted = await session.getMetadata().then((meta) => meta.placement, unsure);
+        try {
+            admitSessionPlacement(sessionId, persisted, opts, placementCapabilityOf(this));
+        }
+        catch (err) {
+            await this.withdrawCreatedCell(sessionId, err, stuck);
+            throw err;
+        }
         return this.handOut(sessionId, session);
     }
+    async holdsThisPlacement(sessionId, opts) {
+        const probe = await this.placementProbe(sessionId);
+        if (probe.state === "unusable")
+            return true;
+        try {
+            admitSessionPlacement(sessionId, probe.state === "placed" ? probe.record : undefined, opts, placementCapabilityOf(this));
+            return true;
+        }
+        catch (e) {
+            if (e instanceof SessionError && e.code === "placement_refused")
+                return false;
+            throw e;
+        }
+    }
+    async withdrawCreatedCell(sessionId, cause, stuck) {
+        try {
+            await this.dropMeta(sessionId);
+        }
+        catch (dropErr) {
+            throw new SessionError("storage", stuck(cause instanceof Error ? cause.message : String(cause), dropErr instanceof Error ? dropErr.message : String(dropErr)), cause instanceof Error ? cause : undefined);
+        }
+    }
     async register(sessionId, owner) {
         await this.withSessionWriteLock(sessionId, async () => {
             await this.meta.ensureLoaded();
@@ -1067,6 +1106,9 @@ export class LocalSessionStore {
         });
     }
     async listSessions(opts) {
+        return (await this.listSessionRows(opts)).map((a) => a.row);
+    }
+    async listSessionRows(opts) {
         await this.loadRowSidecars();
         const rows = [];
         for (const header of await this.rowHeaders())
@@ -1077,16 +1119,18 @@ export class LocalSessionStore {
             const owner = this.ownerCellOf(row.sessionId);
             if (opts.owner !== undefined && owner !== opts.owner && !(opts.includeUnowned === true && owner === null))
                 continue;
-            all.push(await this.summaryOf(row, rollups));
+            const meta = this.metaCellOf(row.sessionId);
+            const incarnation = meta === undefined ? undefined : incarnationFromCell(row.sessionId, meta.incarnation, "absent");
+            all.push({ row: await this.summaryOf(row, rollups), occupant: { owner, incarnation } });
         }
         const qlc = opts.q?.toLowerCase();
-        const filtered = qlc ? all.filter((r) => r.objectivePreview?.toLowerCase().includes(qlc)) : all;
-        filtered.sort((a, b) => a.lastActivityAt !== b.lastActivityAt
+        const filtered = qlc ? all.filter(({ row: r }) => r.objectivePreview?.toLowerCase().includes(qlc)) : all;
+        filtered.sort(({ row: a }, { row: b }) => a.lastActivityAt !== b.lastActivityAt
             ? (a.lastActivityAt < b.lastActivityAt ? 1 : -1)
             : (a.sessionId < b.sessionId ? 1 : -1));
         const c = opts.cursor;
         const after = c
-            ? filtered.filter((r) => r.lastActivityAt < c.lastActivityAt || (r.lastActivityAt === c.lastActivityAt && r.sessionId < c.sessionId))
+            ? filtered.filter(({ row: r }) => r.lastActivityAt < c.lastActivityAt || (r.lastActivityAt === c.lastActivityAt && r.sessionId < c.sessionId))
             : filtered;
         return after.slice(0, opts.limit);
     }
@@ -1150,8 +1194,8 @@ export class LocalSessionStore {
             return null;
         }
     }
-    async fork(sourceId, owner) {
-        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner);
+    async fork(sourceId, owner, opts) {
+        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner, opts);
     }
     async forkTo(sourceId, owner, target) {
         await this.meta.ensureLoaded();
@@ -1171,31 +1215,29 @@ export class LocalSessionStore {
                 return null;
             throw e;
         }
-        if (((await source.getMetadata()).owner ?? null) !== null)
-            throw new StampedSessionArchiveError(sourceId);
+        await this.assertArchiveAnonymous(sourceId);
         const forkOptions = await settledForkOptions(source);
         const forkOwner = forkOwnerOf(owner, this.metaCellOf(sourceId)?.owner);
         const existing = this.metaCellOf(target.id);
         const targetArchived = await this.existsInRepo(target.id);
-        const copy = () => this.repo.fork(sourceMeta, { ...forkOptions, id: target.id });
+        const placement = this.placements !== undefined ? target.placement : undefined;
+        const copy = () => this.repo.fork(sourceMeta, { ...forkOptions, id: target.id, ...(placement !== undefined ? { placement } : {}) });
         if (existing === undefined && !targetArchived) {
             const created = await this.writeMeta(target.id, (before) => before !== undefined
                 ? undefined
                 : { incarnation: mintSessionIncarnation(), ...(forkOwner !== undefined ? { owner: forkOwner } : {}), ...(target.key !== undefined ? { forkKey: target.key } : {}), createdAt: rowBornNow(), forkedFrom: sourceId });
             if (!created)
                 throw new SessionError("storage", `LocalSessionStore: fork target ${target.id} gained a session-meta cell under its own write lock — refusing to guess`);
+            let forked;
             try {
-                await copy();
+                forked = await copy();
             }
             catch (err) {
-                try {
-                    await this.dropMeta(target.id);
-                }
-                catch (dropErr) {
-                    throw new SessionError("storage", `LocalSessionStore: fork into ${target.id} failed while copying (${err instanceof Error ? err.message : String(err)}) and its target cell could not be withdrawn (${dropErr instanceof Error ? dropErr.message : String(dropErr)}) — the target stays in the fork-in-progress state; retry the same fork or delete the session`, err instanceof Error ? err : undefined);
-                }
+                await this.withdrawCreatedCell(target.id, err, (cause, drop) => `LocalSessionStore: fork into ${target.id} failed while copying (${cause}) and its target cell could not be withdrawn (${drop}) — the target stays in the fork-in-progress state; retry the same fork or delete the session`);
                 throw err;
             }
+            if (placement !== undefined)
+                await this.admitForkedPlacement(target.id, forked, placement);
             return { outcome: "created", id: target.id };
         }
         const out = classifyForkTarget(target, { owner: existing?.owner, forkKey: existing?.forkKey }, forkOwner);
@@ -1203,6 +1245,21 @@ export class LocalSessionStore {
             await copy();
         return out;
     }
+    async admitForkedPlacement(sessionId, forked, placement) {
+        try {
+            admitSessionPlacement(sessionId, (await forked.getMetadata()).placement, { placement }, placementCapabilityOf(this));
+        }
+        catch (refusal) {
+            try {
+                await this.repo.delete({ id: sessionId, createdAt: "" });
+            }
+            catch (left) {
+                throw new SessionError("placement_refused", `${refusal instanceof Error ? refusal.message : String(refusal)} — and the copy ${sessionId} this fork created could not be removed (${left instanceof Error ? left.message : String(left)}); delete the session by id`, refusal instanceof Error ? refusal : undefined);
+            }
+            await this.withdrawCreatedCell(sessionId, refusal, (cause, drop) => `LocalSessionStore: a placed fork into ${sessionId} was refused (${cause}); its copy was removed but its session-meta cell could not be withdrawn (${drop}) — the cell stays on disk, inert; delete the session to clear it`);
+            throw refusal;
+        }
+    }
     async exportEntries(sessionId) {
         if (!this.repo.exportEntries)
             return null;
@@ -1338,7 +1395,7 @@ export class LocalSessionStore {
     forgetStaging(stagingId) {
         this.stagings.delete(stagingId);
     }
-    async assertArchiveAnonymousHeld(sessionId) {
+    async assertArchiveAnonymous(sessionId) {
         if (((await this.archiveHeadOf(sessionId))?.owner ?? null) !== null)
             throw new StampedSessionArchiveError(sessionId);
     }
@@ -1354,7 +1411,7 @@ export class LocalSessionStore {
             const rel = classifySyncRelationshipByIds(staged.map((e) => e.id), dstEntries === null ? null : dstEntries.map((e) => e.id));
             const contentEqual = rel.relation === "identical" && identicalIdsAlsoIdenticalContent(staged, dstEntries);
             if (!contentEqual)
-                await this.assertArchiveAnonymousHeld(sessionId);
+                await this.assertArchiveAnonymous(sessionId);
             if ((rel.relation === "fork" || rel.relation === "stale") && opts.resolution !== "overwrite-dst") {
                 throw new SyncConflictError(sessionId, rel);
             }