@sema-agent/server 7.132.0 → 7.133.0

package/dist/http/routes/rules.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { sendJson, sendError, sendHttpError } from "../send.js";
+import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { createLogger } from "../../observability/logger.js";
 import { RULE_IMPORT_RETRY_AFTER_SEC, RULE_SCOPE_REFUSAL_SENTENCE, MAX_RULE_SCOPE_CHARS, buildCcImportLayerRootRefusal, parseRuleScope, serializeRuleScope } from "../../rules-consent.js";
-import { CONTROL_AND_BIDI_CHARS } from "../../text-bidi.js";
-import { HttpError } from "../../security.js";
+import { hasControlOrBidi } from "@sema-agent/settings-schema";
 import { MAX_RULE_TEXT_CHARS, RULE_BEHAVIORS, isValidDurableScope } from "@sema-agent/core";
 import { PERSISTED_RULE_MATCHES, isPersistedRuleTool, isDirectWritableRuleBehavior } from "../../permission-rule-vocab.js";
 const logger = createLogger();
@@ -37,8 +36,7 @@ const CcImportPrepareBodySchema = z
 function ccImportRootRefused(layer) {
     return !isValidDurableScope({ kind: "project", root: layer.root });
 }
-const TICKET_CONTROL_CHARS_RE = new RegExp(`[${CONTROL_AND_BIDI_CHARS}]`);
-const TicketStringSchema = z.string().min(1).max(190).refine((t) => !TICKET_CONTROL_CHARS_RE.test(t));
+const TicketStringSchema = z.string().min(1).max(190).refine((t) => !hasControlOrBidi(t));
 const CcImportRedeemBodySchema = z.object({ ticket: TicketStringSchema }).strict();
 const LocalImportAddSchema = z
     .object({
@@ -107,18 +105,7 @@ export async function handleRules(req, res, match, ctx) {
         await handleRuleList(res, match.search, principal, lane, deps.config);
         return;
     }
-    let rawBody;
-    try {
-        rawBody = await readJson(req);
-    }
-    catch (err) {
-        if (err instanceof HttpError && err.status !== 400) {
-            sendHttpError(res, err);
-            return;
-        }
-        sendError(res, 400, "request.body_shape", "body must be valid JSON");
-        return;
-    }
+    const rawBody = await readJson(req);
     if (match.decl.id === "rules-revoke") {
         await handleRuleRevoke(res, rawBody, principal, lane, deps.config);
         return;
@@ -216,7 +203,7 @@ function resolveTargetPrincipal(requested, caller, config) {
         return { ok: true, principal: caller };
     if (!facts.operatorLane({ config }).available)
         return { ok: false, why: "operator_principals_empty" };
-    if (!explicitOperatorOk(caller, config.operatorPrincipals))
+    if (!explicitOperatorOk(caller, config))
         return { ok: false, why: "not_operator" };
     return { ok: true, principal: requested };
 }

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

@@ -133,6 +133,11 @@ export declare const RUN_VERBS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/tool-approvals/:id/respond";
     readonly methods: readonly ["POST"];
+}, {
+    readonly id: "tool-approval-read";
+    readonly pattern: RegExp;
+    readonly label: "/v1/tool-approvals/:id";
+    readonly methods: readonly ["GET"];
 }, {
     readonly id: "task-ask-decision";
     readonly pattern: RegExp;

package/dist/http/routes/runs.js

@@ -5,7 +5,7 @@ import { uuidv7, mintCheckpointToken, CheckpointError, policyCannotAnswer, valid
 import { isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
 import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-sql.js";
 import { redactSecrets } from "../../trace/redact.js";
-import { HttpError, isUuidV7, encodeCheckpointScope } from "../../security.js";
+import { isUuidV7, encodeCheckpointScope } from "../../security.js";
 import { redactSteerIn, STEER_IN_MAX_CHARS, STEER_IN_MAX_REQUEST_CHARS } from "../../orchestration/workflow-agent-steer.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
 import { idemCallerOf, idemKeyOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
@@ -14,10 +14,10 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames, readClosedWordSeat, storedCardDemandsAPerson } from "../../approval-card.js";
 import { heldAskOf, liveSettledBy, readDecidedBy, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, DECIDED_BY_OUTSIDE_CLOSED_SET, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
 import { ASK_DECISION_CONSUMER_ABSENT, outcomeOfDecidedRow, resolveStreamApprovalGate } from "../../tool-approval.js";
-import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
+import { MAX_DECISION_NOTE_CHARS, noteLandedOnRow, noteRecordedReceipt } from "../../approval-ask-machine.js";
 import { causeOfAskRow } from "../../approval-deny-reasons.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
-import { sendJson, sendError, sendHttpError, sseHeaders } from "../send.js";
+import { invalidJsonError, sendJson, sendError, sendHttpError, sseHeaders } from "../send.js";
 import { mintCancelledResult } from "../../run-cancel-context.js";
 import { acceptedInputKindOf } from "../../user-input-ledger.js";
 import { INJECTION_TIERS } from "../../trace/injection-tier.js";
@@ -35,6 +35,7 @@ import { storedBodyReplayAnswer, storedBodyReplayLogFields } from "../checkpoint
 import { serviceVersion } from "../../service-version.js";
 import { storedBodyReplayRefusal } from "../stored-body-replay.js";
 import { steerBodyKeyIssue } from "../../request-key-closure.js";
+import { fieldConflictFacts } from "../../field-conflict.js";
 const STEER_PRIORITY_WORDS = INJECTION_TIERS.map((tier) => `'${tier}'`);
 const STEER_PRIORITY_UNION = STEER_PRIORITY_WORDS.join(" | ");
 const STEER_PRIORITY_CHOICES = STEER_PRIORITY_WORDS.length <= 2 ? STEER_PRIORITY_WORDS.join(" or ") : `${STEER_PRIORITY_WORDS.slice(0, -1).join(", ")}, or ${STEER_PRIORITY_WORDS[STEER_PRIORITY_WORDS.length - 1]}`;
@@ -81,7 +82,7 @@ async function subagentReadGate(req, res, ctx, runId, search) {
         sendPrincipalRefusal(res, req, deps.config);
         return null;
     }
-    const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+    const trusted = explicitOperatorOk(principal, deps.config);
     const run = await deps.runStore.getRun(runId);
     if (!run) {
         sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
@@ -399,18 +400,7 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         }
         const taskId = match.params.taskId;
-        let body;
-        try {
-            body = ((await readJson(req)) ?? {});
-        }
-        catch (e) {
-            if (e instanceof HttpError) {
-                sendHttpError(res, e);
-                return;
-            }
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = ((await readJson(req)) ?? {});
         if (typeof body.text !== "string" || body.text.length === 0) {
             sendError(res, 400, "request.body_shape", `body must be { text: string (non-empty), mode?: 'all' | 'one-at-a-time', priority?: ${STEER_PRIORITY_UNION} }`);
             return;
@@ -435,7 +425,7 @@ export async function handleRuns(req, res, match, ctx) {
         const steerIdemRaw = headerStr(req.headers["idempotency-key"]);
         const steerInputId = steerIdemRaw ? `idem-${idemKeyOf(steerIdemRaw, idemCallerOf(req, ctx), "run").slice(0, 32)}` : undefined;
         const messageId = steerInputId ?? uuidv7();
-        const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const trusted = explicitOperatorOk(principal, deps.config);
         const steerInput = () => ({
             text,
             trusted,
@@ -724,18 +714,7 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         }
         const taskId = match.params.taskId;
-        let interruptRaw;
-        try {
-            interruptRaw = await readJson(req);
-        }
-        catch (e) {
-            if (e instanceof HttpError) {
-                sendHttpError(res, e);
-                return;
-            }
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const interruptRaw = await readJson(req);
         const interruptNormalized = interruptRaw === null || interruptRaw === undefined ? {} : interruptRaw;
         if (typeof interruptNormalized !== "object" || Array.isArray(interruptNormalized)) {
             sendError(res, 400, "request.body_shape", "body must be {} (bare halt: cut the in-flight turn and stop the run at this boundary) or { text: string (non-empty) } (cut + steer: the text reaches the model after the cut)");
@@ -759,7 +738,7 @@ export async function handleRuns(req, res, match, ctx) {
         const interruptIdemRaw = headerStr(req.headers["idempotency-key"]);
         const interruptInputId = interruptIdemRaw ? `idem-${idemKeyOf(interruptIdemRaw, idemCallerOf(req, ctx), "run").slice(0, 32)}` : uuidv7();
         const interruptMessageId = interruptInputId;
-        const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const trusted = explicitOperatorOk(principal, deps.config);
         if (!interruptBare) {
             try {
                 validatePendingSteer({ text, trusted, inputId: interruptInputId });
@@ -877,28 +856,17 @@ export async function handleRuns(req, res, match, ctx) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
         }
-        const operator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const operator = explicitOperatorOk(principal, deps.config);
         if (!operator && !runOwnerOk(req, res, run.owner))
             return;
         if (!runSessionAcceptOk(req, res, run, "run.compact"))
             return;
-        let compactBody;
-        try {
-            const parsed = await readJson(req);
-            if (parsed === null || typeof parsed !== "object") {
-                sendError(res, 400, "request.invalid_json", "body must be a JSON object when present");
-                return;
-            }
-            compactBody = parsed;
-        }
-        catch (e) {
-            if (e instanceof HttpError) {
-                sendHttpError(res, e);
-                return;
-            }
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
+        const parsed = await readJson(req);
+        if (parsed === null || typeof parsed !== "object") {
+            sendHttpError(res, invalidJsonError("not_object"));
             return;
         }
+        const compactBody = parsed;
         if (compactBody.instructions !== undefined && (typeof compactBody.instructions !== "string" || compactBody.instructions.length === 0 || [...compactBody.instructions].length > 2_048)) {
             sendError(res, 400, "request.field_invalid", "instructions must be a non-empty string of at most 2048 characters (code points) when present — the engine caps compaction instructions there");
             return;
@@ -938,18 +906,7 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         }
         const taskId = match.params.taskId;
-        let body;
-        try {
-            body = ((await readJson(req)) ?? {});
-        }
-        catch (e) {
-            if (e instanceof HttpError) {
-                sendHttpError(res, e);
-                return;
-            }
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = ((await readJson(req)) ?? {});
         if (typeof body.toolCallId !== "string" || body.toolCallId.length === 0 || body.toolCallId.length > 256) {
             sendError(res, 400, "request.body_shape", "body must be { toolCallId: string (non-empty, ≤256 chars) }");
             return;
@@ -959,7 +916,7 @@ export async function handleRuns(req, res, match, ctx) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
         }
-        const operator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const operator = explicitOperatorOk(principal, deps.config);
         if (!operator && !runOwnerOk(req, res, run.owner))
             return;
         if (!runSessionAcceptOk(req, res, run, "run.detach"))
@@ -1164,18 +1121,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 400, "request.path_malformed", "malformed subagent path (invalid percent-encoding)");
             return;
         }
-        let body;
-        try {
-            body = ((await readJson(req)) ?? {});
-        }
-        catch (e) {
-            if (e instanceof HttpError) {
-                sendHttpError(res, e);
-                return;
-            }
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = ((await readJson(req)) ?? {});
         if (typeof body.content !== "string" || body.content.length === 0) {
             sendError(res, 400, "request.body_shape", "body must be { content: string (non-empty) }");
             return;
@@ -1191,7 +1137,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 413, "steer.content_too_large", `content exceeds ${STEER_IN_MAX_REQUEST_CHARS} characters (got ${body.content.length}); note only the first ${STEER_IN_MAX_CHARS} are delivered anyway`);
             return;
         }
-        const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const trusted = explicitOperatorOk(principal, deps.config);
         const run = await runStore.getRun(runId);
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
@@ -1274,14 +1220,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const id = match.params.id;
-        let body;
-        try {
-            body = await readJson(req);
-        }
-        catch {
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = await readJson(req);
         const { status, body: respBody } = elicitFact.coordinator.respond(id, principal, body);
         sendJson(res, status, respBody);
         return;
@@ -1300,19 +1239,12 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const id = match.params.id;
-        let body;
-        try {
-            body = await readJson(req);
-        }
-        catch {
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = await readJson(req);
         const { status, body: respBody } = questionFact.coordinator.respond(id, principal, body);
         sendJson(res, status, respBody);
         return;
     }
-    if (match.decl.id === "tool-approval-respond") {
+    if (match.decl.id === "tool-approval-respond" || match.decl.id === "tool-approval-read") {
         if (rateLimited(req, res))
             return;
         const approvalFact = facts.toolApproval(deps);
@@ -1326,15 +1258,13 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const id = match.params.id;
-        let body;
-        try {
-            body = await readJson(req);
-        }
-        catch {
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
+        if (match.decl.id === "tool-approval-read") {
+            const { status, body: respBody } = await approvalFact.coordinator.readApproval(id, principal);
+            sendJson(res, status, respBody);
             return;
         }
-        const { status, body: respBody } = await approvalFact.coordinator.respond(id, principal, body, req);
+        const body = await readJson(req);
+        const { status, body: respBody } = await approvalFact.coordinator.respond(id, principal, body, req, { readRootGrantAccepted: facts.readRootGrant(deps).available });
         const retryAfterSec = respBody.retryAfterSec;
         if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0) {
             res.setHeader("retry-after", String(Math.ceil(retryAfterSec)));
@@ -1356,14 +1286,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
-        let rawBody;
-        try {
-            rawBody = await readJson(req);
-        }
-        catch {
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const rawBody = await readJson(req);
         const parsedBody = AskDecisionBodySchema.safeParse(rawBody);
         if (!parsedBody.success) {
             const retired = retiredDecisionKeyFacts(rawBody);
@@ -1401,7 +1324,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const ownerOk = row0.owner === null || (principal !== undefined && row0.owner === principal);
-        const operatorOk = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const operatorOk = explicitOperatorOk(principal, deps.config);
         if (!ownerOk && !operatorOk) {
             askNotFound();
             return;
@@ -1440,6 +1363,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return true;
         };
         const decisionNoteEcho = (row) => (row.decisionNote === null ? {} : { decisionNote: row.decisionNote });
+        const noteReceipt = (row) => noteRecordedReceipt(body.note, noteLandedOnRow(body.note, row.decisionNote));
         const replayDecided = (row) => {
             const storedActor = projectDecisionActor(row.decisionActor);
             sendJson(res, 200, {
@@ -1449,6 +1373,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 decidedAtMs: row.decidedAtMs,
                 ...(storedActor ? { actor: storedActor } : {}),
                 ...decisionNoteEcho(row),
+                ...noteReceipt(row),
             });
         };
         const sendTerminal = (row) => {
@@ -1519,7 +1444,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         if (body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row0.cardJson)), decidedBy)) {
-            sendError(res, 400, "request.field_conflict", POLICY_CANNOT_ALLOW_PERSON_ASK);
+            sendError(res, 400, "request.field_conflict", POLICY_CANNOT_ALLOW_PERSON_ASK, fieldConflictFacts("policy_person_ask", ["decidedBy", "decision"]));
             return;
         }
         let outcome;
@@ -1606,6 +1531,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             ...(forwarded ? { updatedInputForwarded: true } : {}),
             ...(settled === 0 ? { consumerState: ASK_DECISION_CONSUMER_ABSENT } : {}),
             ...decisionNoteEcho(outcome.row),
+            ...noteReceipt(outcome.row),
         });
         return;
     }
@@ -1675,6 +1601,7 @@ export const RUN_VERBS_ROUTES = [
     { id: "elicitation-respond", pattern: /^\/v1\/elicitations\/(?<id>[^/]+)\/respond$/, label: "/v1/elicitations/:id/respond", methods: ["POST"] },
     { id: "question-respond", pattern: /^\/v1\/questions\/(?<id>[^/]+)\/respond$/, label: "/v1/questions/:id/respond", methods: ["POST"] },
     { id: "tool-approval-respond", pattern: /^\/v1\/tool-approvals\/(?<id>[^/]+)\/respond$/, label: "/v1/tool-approvals/:id/respond", methods: ["POST"] },
+    { id: "tool-approval-read", pattern: /^\/v1\/tool-approvals\/(?<id>[^/]+)$/, label: "/v1/tool-approvals/:id", methods: ["GET"] },
     { id: "task-ask-decision", pattern: /^\/v1\/tasks\/(?<taskId>[^/]+)\/asks\/(?<askId>[^/]+)\/decision$/, label: "/v1/tasks/:id/asks/:askId/decision", methods: ["POST"] },
 ];
 //# sourceMappingURL=runs.js.map

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

@@ -6,8 +6,7 @@ import { exportSessionManifest, fileHistoryImportFace, replayFileHistory, replay
 import * as facts from "../../capability-facts.js";
 import { classifySyncRelationshipByIds, SyncConflictError } from "../../session-sync-kernel.js";
 import { isUuidShape } from "../../security.js";
-import { sqlBlobCapRefusalText } from "../../plugins/blob-backend.js";
-import { sendJson, sendError, sendSessionError, sendSessionPolicyError, msg } from "../send.js";
+import { sendJson, sendError, sendSessionError, sendSessionPolicyError, logRequestError, msg } from "../send.js";
 import { buildDisplaySafeUrl } from "../../trace/redact.js";
 import { gatedPrincipal, explicitOperatorOk, sendUnauthorized } from "../principal-gate.js";
 const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
@@ -187,17 +186,16 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const fs = blobs.historyStore;
                 const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
-                const sqlCap = deps.snapshotBlobSqlCap?.();
-                if (sqlCap !== undefined && body.byteLength > sqlCap.capBytes) {
-                    sendError(res, 413, "blob_too_large_for_sql", sqlBlobCapRefusalText(body.byteLength, sqlCap), { wallSource: sqlCap.source });
-                    return;
-                }
                 if (createHash("sha256").update(body).digest("hex") !== hash) {
                     sendError(res, 400, "request.hash_mismatch", "blob hash mismatch");
                     return;
                 }
                 const put = await fs.putBlob(hash, new Uint8Array(body));
                 if (!put.ok) {
+                    if (put.error.code === "blob_too_large_for_sql") {
+                        sendError(res, 413, "blob_too_large_for_sql", put.error.message, { wallSource: put.error.wallSource });
+                        return;
+                    }
                     sendError(res, 502, put.error.code, "blob store write failed");
                     return;
                 }
@@ -216,14 +214,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                         }
                     }).catch(() => { });
                 }
-                let body;
-                try {
-                    body = (await readJson(req));
-                }
-                catch {
-                    sendError(res, 400, "request.invalid_json", "invalid JSON body");
-                    return;
-                }
+                const body = (await readJson(req));
                 if (!Array.isArray(body.entryIds) || !body.entryIds.every((x) => typeof x === "string")) {
                     sendError(res, 400, "request.field_invalid", "entryIds must be an array of strings");
                     return;
@@ -314,7 +305,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                             return;
                         }
                     }
-                    const opOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config.operatorPrincipals);
+                    const opOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config);
                     if (deps.sessionPolicyStore) {
                         try {
                             await replayPolicyRecords(deps.sessionPolicyStore, sessionId, policy, opOk);
@@ -389,7 +380,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     }
                 }
                 const importingPrincipal = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
-                const operatorOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config.operatorPrincipals);
+                const operatorOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config);
                 const token = randomBytes(8).toString("hex");
                 const handle = sessionStorage.beginImportStaging(sessionId, token);
                 const stagingId = handle.stagingId;
@@ -532,15 +523,18 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendJson(res, 200, { relation: committed.relation });
                 }
                 catch (e) {
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
                     if (e instanceof SyncConflictError) {
-                        await pending.handle.abort().catch(() => undefined);
-                        cleanupStaging(stagingId);
                         sendError(res, 409, "conflict", "sync conflict", { relation: e.relation });
                         return;
                     }
-                    cleanupStaging(stagingId);
                     if (sendSessionPolicyError(res, e))
                         return;
+                    if (sendSessionError(res, e, "import")) {
+                        logRequestError(deps.logger, req, e);
+                        return;
+                    }
                     throw e;
                 }
                 return;
@@ -548,14 +542,7 @@ export async function handleSessionSync(req, res, match, ctx) {
             if (match.decl.id === "session-sync-plan") {
                 if (!pushGateOk())
                     return;
-                let body;
-                try {
-                    body = (await readJson(req));
-                }
-                catch {
-                    sendError(res, 400, "request.invalid_json", "invalid JSON body");
-                    return;
-                }
+                const body = (await readJson(req));
                 if (!Array.isArray(body.entryIds) || !body.entryIds.every((x) => typeof x === "string")) {
                     sendError(res, 400, "request.field_invalid", "entryIds must be an array of strings");
                     return;