@sema-agent/server 7.138.0 → 7.140.0

package/dist/http/routes/devices.js

@@ -3,8 +3,12 @@ import { explicitOperatorOk, gatedPrincipal, sendPrincipalRefusal } from "../pri
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { DEVICE_PLATFORM_OS, DEVICE_PUBKEY_MAX_BYTES, DEVICE_TEXT_LIMITS, assertDeviceIdShape, assertDevicePubkeyShape, assertRootSessionIdShape, isDeviceAbsolutePath, sameDeviceOwner, } from "../../device-store.js";
+import { boundDeviceOf } from "../../execution-placement.js";
+import { defaultTaskRegistry } from "@sema-agent/core";
+import { probeSessionChildren, sessionChildrenScope } from "../../session-children-retire.js";
+import { liveChildrenRefusal } from "./background.js";
 import { DEFAULT_ENROLL_TOKEN_TTL_SEC } from "../../device-enrollment.js";
-import { deviceOwnerDomainOf } from "../device-placement.js";
+import { deviceOwnerDomainOf } from "../execution-context.js";
 import { echoKeyName } from "../../request-key-closure.js";
 const DEVICE_NOT_FOUND_MESSAGE = "device not found";
 const NO_DEVICE_DOMAIN_MESSAGE = "device management needs a caller domain: this credential carries no verified tenant scope claim (registry auth-bridge JWT `scope`) and is not an explicit operator — connect through the registry auth bridge, or configure OPERATOR_PRINCIPALS";
@@ -32,9 +36,6 @@ function deviceListRow(row, online) {
         ...(row.lastSeenAtMs !== null ? { lastSeenAt: new Date(row.lastSeenAtMs).toISOString() } : {}),
     };
 }
-function boundDeviceOf(row) {
-    return { deviceId: row.deviceId, rev: row.rev, boundAt: new Date(row.boundAtMs).toISOString() };
-}
 function sendDeviceRejection(res, rej) {
     if (rej.retryAfterSec !== undefined)
         res.setHeader("retry-after", String(rej.retryAfterSec));
@@ -112,7 +113,6 @@ function parseEnrollBody(res, body) {
 export async function handleDevices(req, res, match, ctx) {
     switch (match.decl.id) {
         case "devices-list":
-        case "device-session":
         case "device-session-rebind":
         case "device-enroll-tokens":
         case "device-enroll":
@@ -248,31 +248,19 @@ export async function handleDevices(req, res, match, ctx) {
         return;
     }
     const rootSessionId = decoded;
-    if (match.decl.id === "device-session") {
-        if (!operator && domain === undefined) {
-            sendError(res, 403, "auth.forbidden", NO_DEVICE_DOMAIN_MESSAGE);
-            return;
-        }
-        const binding = await store.getSessionBinding(rootSessionId);
-        if (!binding || (!operator && !sameDeviceOwner(binding.owner, domain))) {
-            sendDeviceNotFound(res);
-            return;
-        }
-        sendJson(res, 200, { rootSessionId, boundDevice: boundDeviceOf(binding) });
-        return;
-    }
     if (!operator && domain === undefined) {
         sendError(res, 403, "auth.forbidden", NO_DEVICE_DOMAIN_MESSAGE);
         return;
     }
-    const binding = await store.getSessionBinding(rootSessionId);
-    if (!binding || (!operator && !sameDeviceOwner(binding.owner, domain))) {
+    const placement = await enrollment.readPlacement(rootSessionId);
+    const binding = placement === undefined ? undefined : boundDeviceOf(placement.cell);
+    if (placement === undefined || !binding || (!operator && !sameDeviceOwner(binding.owner, domain))) {
         sendDeviceNotFound(res);
         return;
     }
     const body = (await readJson(req));
     if (typeof body !== "object" || body === null || typeof body.toDeviceId !== "string" || body.expectedRev === undefined) {
-        sendError(res, 400, "request.body_shape", "body must be { toDeviceId: string, expectedRev: number } — expectedRev is the binding rev read from GET /v1/devices/sessions/{rootSessionId} (explicit prior state; two concurrent operators must not silently stomp each other)");
+        sendError(res, 400, "request.body_shape", "body must be { toDeviceId: string, expectedRev: number } — expectedRev is the device rev read from GET /v1/sessions/{sessionId}/execution-placement (explicit prior state; two concurrent operators must not silently stomp each other)");
         return;
     }
     if (typeof body.expectedRev !== "number" || !Number.isInteger(body.expectedRev) || body.expectedRev < 0) {
@@ -295,16 +283,24 @@ export async function handleDevices(req, res, match, ctx) {
         sendError(res, 409, "device.rebind_active_run", "this session has a non-terminal run — rebinding now would leave in-flight work addressed at another workspace; cancel the run (or let it finish), then retry", { activeTaskId });
         return;
     }
-    const result = await store.rebindSession({ rootSessionId, toDeviceId, expectedRev, owner: binding.owner });
+    const tree = await probeSessionChildren({ agentStore: deps.backgroundAgentStore, checkpointStore: deps.checkpointStore, registry: defaultTaskRegistry }, rootSessionId, sessionChildrenScope(placement.occupant.owner));
+    if (tree.liveChildren.length > 0) {
+        sendError(res, 409, "device.rebind_active_run", "this session still has background agents running or waiting on an approval under it — rebinding now would leave them addressed at the old device; retire them (POST retirePath) or let them finish, then retry", liveChildrenRefusal(rootSessionId, tree.liveChildren));
+        return;
+    }
+    const result = await store.rebindDeviceExecution({ root: rootSessionId, occupant: placement.occupant, owner: binding.owner, expectedRev, targetDeviceId: toDeviceId });
     switch (result.outcome) {
         case "rebound":
         case "idempotent":
-            sendJson(res, 200, { rootSessionId, deviceId: result.row.deviceId, rev: result.row.rev, workspaceCarryover: "none" });
+            sendJson(res, 200, { rootSessionId, deviceId: result.device.id, rev: result.device.rev, workspaceCarryover: "none" });
             return;
         case "rev_conflict":
-            sendError(res, 409, "device.rebind_rev_conflict", "expectedRev does not match the binding's current rev — the session↔device binding changed since it was read; re-read it and retry with currentRev", { currentRev: result.row.rev });
+            sendError(res, 409, "device.rebind_rev_conflict", "expectedRev does not match the binding's current rev — the session↔device binding changed since it was read; re-read it and retry with currentRev", { currentRev: result.device.rev });
+            return;
+        case "active_run":
+            sendError(res, 409, "device.rebind_active_run", "this session has a non-terminal run — rebinding now would leave in-flight work addressed at another workspace; cancel the run (or let it finish), then retry", { activeTaskId: result.activeTaskId });
             return;
-        case "binding_not_found":
+        case "gone":
         case "device_not_found":
             sendDeviceNotFound(res);
             return;
@@ -321,7 +317,6 @@ export const DEVICES_ROUTES = [
     { id: "device-enroll", path: "/v1/devices/enroll", credentialGated: ["POST"], methods: ["POST"] },
     { id: "device-revoke", pattern: /^\/v1\/devices\/(?<deviceId>[^/]+)\/revoke$/, label: "/v1/devices/:deviceId/revoke", methods: ["POST"] },
     { id: "device-session-rebind", pattern: /^\/v1\/devices\/sessions\/(?<rootSessionId>[^/]+)\/rebind$/, label: "/v1/devices/sessions/:id/rebind", methods: ["POST"] },
-    { id: "device-session", pattern: /^\/v1\/devices\/sessions\/(?<rootSessionId>[^/]+)$/, label: "/v1/devices/sessions/:id", credentialGated: ["GET"], methods: ["GET"] },
     { prefix: "/v1/devices/", credentialGated: ["POST"] },
 ];
 //# sourceMappingURL=devices.js.map

package/dist/http/routes/memory-bundle.js

@@ -4,6 +4,7 @@ import { sentMemoryStoreRefusal } from "../memory-store-refusal-reply.js";
 import { buildOriginFencedBundle, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import * as facts from "../../capability-facts.js";
 export const MEMORY_BUNDLE_EXPORT_PATH = "/v1/memory/export";
 export const MEMORY_BUNDLE_IMPORT_PATH = "/v1/memory/import";
@@ -34,6 +35,8 @@ function codeOf(err) {
     return typeof code === "string" ? code : undefined;
 }
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     const code = codeOf(err);
     if (code !== undefined && sentCoreCode(res, code, err instanceof Error ? err.message : String(err)))
         return true;

package/dist/http/routes/memory-compliance.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { erasureInputSmugglesPrototypeKey } from "../../memory-operator-faces.js";
 import { sentMemoryComplianceFailure } from "../memory-compliance-failure-reply.js";
+import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
@@ -12,6 +13,8 @@ const EraseRequestSchema = z.object({
     allowUnevidenced: z.boolean().optional(),
 });
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     if (sentMemoryComplianceFailure(res, err, { kind: "operator" }, ctx.deps.logger))
         return true;
     ctx.deps.logger?.warn?.(`memory_compliance_${face}_failed`, { err: String(err) });
@@ -53,8 +56,12 @@ export async function handleMemoryCompliance(req, res, match, ctx) {
                 sendError(res, 400, "request.id_invalid", "invalid memory entry id");
                 return;
             }
+            const query = new URLSearchParams(match.search);
+            const at = readLayerSeat(res, query.has("scope"), query.get("scope"));
+            if (at === null)
+                return;
             try {
-                sendJson(res, 200, await faces.provenanceOf(entryId));
+                sendJson(res, 200, await (at !== undefined ? faces.provenanceOf(entryId, at) : faces.provenanceOf(entryId)));
             }
             catch (err) {
                 if (!sentClassifiedFailure(res, ctx, "provenance", err))

package/dist/http/routes/memory-consolidation.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal, sendOperatorPrincipalsRequired } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -101,7 +102,15 @@ export async function handleMemoryConsolidation(req, res, match, ctx) {
             const q = new URLSearchParams(match.search).get("scope") ?? undefined;
             const decided = decideScope(q, faces.scopes);
             const scope = "scope" in decided ? decided.scope : undefined;
-            const row = scope !== undefined ? faces.lastRun(scope) : undefined;
+            let row;
+            try {
+                row = scope !== undefined ? faces.lastRun(scope) : undefined;
+            }
+            catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
+                throw err;
+            }
             sendJson(res, 200, {
                 enabled: true,
                 seat: faces.seat,
@@ -144,6 +153,8 @@ export async function handleMemoryConsolidation(req, res, match, ctx) {
                 sendJson(res, 200, buildRunSummary(r));
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 const coreCode = codeOf(err);
                 if (coreCode !== undefined) {
                     sendError(res, 409, "memory.consolidation_refused", `memory consolidation refused (${coreCode}): ${err instanceof Error ? err.message : String(err)}`);

package/dist/http/routes/memory-origin.js

@@ -3,6 +3,7 @@ import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { sentMemoryStoreRefusal } from "../memory-store-refusal-reply.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
+import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -49,6 +50,8 @@ function codeOf(err) {
     return typeof code === "string" ? code : undefined;
 }
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     if (face === "clear") {
         const coreCode = codeOf(err);
         if (coreCode !== undefined && sentClearCode(res, coreCode, err instanceof Error ? err.message : String(err)))
@@ -157,8 +160,12 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
             return;
         }
         case "memory-origin-clearances": {
+            const query = new URLSearchParams(match.search);
+            const at = readLayerSeat(res, query.has("scope"), query.get("scope"));
+            if (at === null)
+                return;
             try {
-                sendJson(res, 200, { clearances: faces.listClearances().map(buildClearanceRowWire) });
+                sendJson(res, 200, { clearances: (at !== undefined ? faces.listClearances(at) : faces.listClearances()).map(buildClearanceRowWire) });
             }
             catch (err) {
                 if (!sentClassifiedFailure(res, ctx, "clearances", err))
@@ -182,8 +189,13 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
                 sendError(res, 400, "request.body_shape", "invalid memory origin clearance request — expected an object with a non-empty `requestId` and a `reason` string (whether an EMPTY reason is acceptable is the engine's judgment, not this layer's)");
                 return;
             }
+            const body = raw;
+            const at = readLayerSeat(res, Object.prototype.hasOwnProperty.call(body, "scope"), body.scope);
+            if (at === null)
+                return;
             try {
-                const receipt = await faces.clear(entryId, { requestId: parsed.data.requestId, reason: parsed.data.reason });
+                const input = { requestId: parsed.data.requestId, reason: parsed.data.reason };
+                const receipt = await (at !== undefined ? faces.clear(entryId, input, at) : faces.clear(entryId, input));
                 ctx.deps.logger?.info?.("memory_origin_cleared", {
                     principal: principal ?? null,
                     entryId,

package/dist/http/routes/memory-policy.js

@@ -5,6 +5,7 @@ import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js"
 import { parseProjectLayerKey } from "../../project-layer-key.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 const ORG_PREFIX = "org:";
 export const MEMORY_EXPORT_MAX_LIMIT = 500;
 function encodeExportCursor(c) {
@@ -121,6 +122,8 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 });
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 deps.logger?.warn?.("memory_export_failed", { scope, err: String(err) });
                 sendError(res, 500, "internal.error", "memory export failed");
             }
@@ -158,6 +161,8 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 sendJson(res, 200, out);
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 deps.logger?.warn?.("memory_sync_failed", { scope, peer: parsed.value.peer, err: String(err) });
                 sendError(res, 500, "internal.error", "memory sync failed");
             }

package/dist/http/routes/session-sync.js

@@ -18,6 +18,10 @@ import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import { readSessionRulesRecords, describeSessionRulesRecordProblem } from "../../session-policy-wire.js";
 import { readSessionPinned, readSessionTitle } from "../../session-row.js";
 import { sessionFaceOfHead } from "../../session-incarnation.js";
+import { defaultTaskRegistry } from "@sema-agent/core";
+import { SessionActiveRunError, SessionForkInProgressError, SessionWriterPresentError } from "../../execution-placement.js";
+import { probeSessionChildren, sessionChildrenScope } from "../../session-children-retire.js";
+import { liveChildrenRefusal } from "./background.js";
 export function createSessionSyncLocal() {
     const pendingStagings = new Map();
     const importLeases = new Map();
@@ -90,7 +94,46 @@ export async function handleSessionSync(req, res, match, ctx) {
             const replaySessionRow = async (row, face) => {
                 if (Object.keys(row).length === 0)
                     return true;
-                return face !== undefined && (await sessionStorage.patchSessionMeta(sessionId, row, face)) !== undefined;
+                if (face === undefined)
+                    return false;
+                const replayed = await sessionStorage.writeSessionRowCells(sessionId, row, { writer: "replay", row: { row: face } });
+                switch (replayed.kind) {
+                    case "written":
+                        return true;
+                    case "absent":
+                        return false;
+                    default: {
+                        const unreachable = replayed;
+                        throw new Error(`session-sync row replay: no answer for the row write outcome ${JSON.stringify(unreachable)}`);
+                    }
+                }
+            };
+            const liveChildrenOf = async (face) => face === undefined
+                ? []
+                : (await probeSessionChildren({ agentStore: deps.backgroundAgentStore, checkpointStore: deps.checkpointStore, registry: defaultTaskRegistry }, sessionId, sessionChildrenScope(face.owner))).liveChildren;
+            const activityOf = async (face) => {
+                const activeTaskId = await deps.runStore?.getActiveTaskId(sessionId);
+                if (activeTaskId)
+                    return { kind: "run", activeTaskId };
+                const liveChildren = await liveChildrenOf(face);
+                return liveChildren.length > 0 ? { kind: "children", liveChildren } : undefined;
+            };
+            const sendActivity = (activity, moment) => {
+                switch (activity.kind) {
+                    case "run":
+                        if (moment === "open")
+                            sendError(res, 409, "session_active", "session has an active run; sync after it settles", { activeTaskId: activity.activeTaskId });
+                        else
+                            sendError(res, 409, "session_active", "session started an active run while the import streamed; sync after it settles", { activeTaskId: activity.activeTaskId });
+                        return;
+                    case "children":
+                        sendError(res, 409, "session_active", "session still has background agents running or waiting on an approval under it; retire them (POST retirePath) or let them finish, then sync", liveChildrenRefusal(sessionId, activity.liveChildren));
+                        return;
+                    default: {
+                        const unhandled = activity;
+                        throw new Error(`session sync: unknown session activity ${JSON.stringify(unhandled)}`);
+                    }
+                }
             };
             const canReplayHistory = fileHistoryImportFace(historyStore) !== undefined;
             const replayHistory = async (envelope, allowReplace) => {
@@ -339,15 +382,56 @@ export async function handleSessionSync(req, res, match, ctx) {
                     if (!payloadVerified)
                         digestSaysDiffer = true;
                 }
+                const placed = gateFace === undefined ? undefined : await sessionStorage.executionPlacement?.read(sessionId);
+                if (placed !== undefined) {
+                    switch (placed.cell.role) {
+                        case "absent":
+                        case "mirror":
+                            break;
+                        case "writer":
+                            sendSessionWriter(res);
+                            return;
+                        case "forking":
+                            sendError(res, 409, "conflict.fork_in_progress", new SessionForkInProgressError(sessionId).message);
+                            return;
+                        default: {
+                            const unknownRole = placed.cell;
+                            throw new Error(`session sync: unknown execution placement ${JSON.stringify(unknownRole)}`);
+                        }
+                    }
+                }
+                const activeNow = await activityOf(gateFace);
+                if (activeNow !== undefined) {
+                    sendActivity(activeNow, "open");
+                    return;
+                }
                 if (relA.relation === "identical" && !digestSaysDiffer) {
-                    if (fileHistory !== null && canReplayHistory) {
-                        if (resolution === "overwrite-dst") {
-                            const activeNow = await deps.runStore?.getActiveTaskId(sessionId);
-                            if (activeNow) {
-                                sendError(res, 409, "session_active", "session has an active run; sync after it settles", { activeTaskId: activeNow });
+                    const seat = sessionStorage.executionPlacement;
+                    if (seat !== undefined) {
+                        if (gateFace === undefined) {
+                            sendError(res, 409, "conflict", "sync conflict");
+                            return;
+                        }
+                        const mirrored = await seat.markMirror(sessionId, gateFace);
+                        switch (mirrored.outcome) {
+                            case "mirrored":
+                                break;
+                            case "writer":
+                                sendSessionWriter(res);
+                                return;
+                            case "gone":
+                                sendError(res, 409, "conflict", "sync conflict");
+                                return;
+                            case "active":
+                                sendActivity({ kind: "run", activeTaskId: mirrored.activeTaskId }, "open");
                                 return;
+                            default: {
+                                const unhandled = mirrored;
+                                throw new Error(`session sync: unknown mirror outcome ${JSON.stringify(unhandled)}`);
                             }
                         }
+                    }
+                    if (fileHistory !== null && canReplayHistory) {
                         const failed = await replayHistory(fileHistory, resolution === "overwrite-dst");
                         if (failed !== undefined) {
                             sendFileHistoryReplayFailure(res, failed);
@@ -380,11 +464,6 @@ export async function handleSessionSync(req, res, match, ctx) {
                     });
                     return;
                 }
-                const activeTaskId = await deps.runStore?.getActiveTaskId(sessionId);
-                if (activeTaskId) {
-                    sendError(res, 409, "session_active", "session has an active run; sync after it settles", { activeTaskId });
-                    return;
-                }
                 const heldLease = importLeases.get(sessionId);
                 if (heldLease) {
                     const staleSecRaw = deps.config.syncImportLeaseStaleSec;
@@ -511,8 +590,9 @@ export async function handleSessionSync(req, res, match, ctx) {
                 let mayPushAtCommit;
                 let activeAtCommit;
                 try {
-                    mayPushAtCommit = (await judgeSessionGate()).mayPush;
-                    activeAtCommit = mayPushAtCommit ? await deps.runStore?.getActiveTaskId(sessionId) : undefined;
+                    const gateAtCommit = await judgeSessionGate();
+                    mayPushAtCommit = gateAtCommit.mayPush;
+                    activeAtCommit = mayPushAtCommit ? await activityOf(gateAtCommit.face) : undefined;
                 }
                 catch (e) {
                     await pending.handle.abort().catch(() => undefined);
@@ -525,10 +605,10 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendSessionAbsent();
                     return;
                 }
-                if (activeAtCommit) {
+                if (activeAtCommit !== undefined) {
                     await pending.handle.abort().catch(() => undefined);
                     cleanupStaging(stagingId);
-                    sendError(res, 409, "session_active", "session started an active run while the import streamed; sync after it settles", { activeTaskId: activeAtCommit });
+                    sendActivity(activeAtCommit, "streamed");
                     return;
                 }
                 try {
@@ -567,6 +647,18 @@ export async function handleSessionSync(req, res, match, ctx) {
                         sendError(res, 409, "conflict", "sync conflict", { relation: e.relation });
                         return;
                     }
+                    if (e instanceof SessionWriterPresentError) {
+                        sendSessionWriter(res);
+                        return;
+                    }
+                    if (e instanceof SessionForkInProgressError) {
+                        sendError(res, 409, "conflict.fork_in_progress", e.message);
+                        return;
+                    }
+                    if (e instanceof SessionActiveRunError) {
+                        sendActivity({ kind: "run", activeTaskId: e.activeTaskId }, "streamed");
+                        return;
+                    }
                     if (sendSessionPolicyError(res, e))
                         return;
                     if (sendSessionError(res, e, "import")) {
@@ -635,6 +727,9 @@ function sendPullUnreadable(req, res, logger, e) {
         }
     }
 }
+function sendSessionWriter(res) {
+    sendError(res, 409, "conflict.session_writer", "this session is written on this deployment (its execution placement is a writer here) — an import cannot turn it into a read-only mirror; fork it to push your copy, or pull instead; nothing was written");
+}
 function sendMissingBlob(res) {
     sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
 }

package/dist/http/routes/sessions.d.ts

@@ -74,6 +74,12 @@ export declare const SESSIONS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/sessions/:id/$verb";
     readonly methods: readonly ["GET"];
+}, {
+    readonly id: "session-execution-placement";
+    readonly pattern: RegExp;
+    readonly label: "/v1/sessions/:id/execution-placement";
+    readonly credentialGated: readonly ["GET"];
+    readonly methods: readonly ["GET"];
 }, {
     readonly id: "session-events";
     readonly pattern: RegExp;