@sema-agent/server 7.132.0 → 7.134.0

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";
@@ -13,11 +13,12 @@ import { streamSseLog } from "../sse-log.js";
 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 { ASK_DECISION_CONSUMER_ABSENT, approvalPreambleReplays, outcomeOfDecidedRow, resolveStreamApprovalGate } from "../../tool-approval.js";
+import { readRunDeclaredFamilies } from "../run-declared-families.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 +36,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 +83,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);
@@ -108,17 +110,26 @@ function sendHandleMiss(res, run, thisInstanceId) {
     }
     return false;
 }
-async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
+async function streamRunEvents(req, res, deps, runStore, taskId, sessionId, staleMs) {
     await streamSseLog(req, res, {
         preamble: async (signal) => {
             const gate = resolveStreamApprovalGate({
                 toolApprovalEnabled: Boolean(deps.toolApproval),
                 streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                 backend: deps.backend,
-                parkFacility: deps.checkpointStore !== undefined,
+                checkpointStore: deps.checkpointStore,
             });
             if (!gate.active)
                 return [];
+            const declaredFamilies = await readRunDeclaredFamilies(gate.checkpointStore, sessionId, (where) => deps.logger?.warn?.("approval_preamble_declaration_unreadable", { taskId, where, face: "run.events" }));
+            if (!approvalPreambleReplays({
+                streamApprovalOn: gate.active,
+                windowMs: deps.config.streamApproval?.windowMs,
+                windowMarginMs: deps.config.streamAskWindowMarginMs,
+                declaredFamilies,
+            })) {
+                return [];
+            }
             const store = gate.askStore;
             const rows = await store.listPendingByTask(taskId, signal);
             const { frames, skipped, dropped } = buildApprovalPreamble(rows, Date.now(), deps.config.streamApproval.replayMax);
@@ -254,7 +265,7 @@ export async function handleRuns(req, res, match, ctx) {
         if (!runSessionAcceptOk(req, res, run, match.decl.id === "run-events" ? "run.events" : "run.poll"))
             return;
         if (match.decl.id === "run-events") {
-            await streamRunEvents(req, res, deps, runStore, taskId, deps.config.runStaleSec * 1000);
+            await streamRunEvents(req, res, deps, runStore, taskId, run.sessionId, deps.config.runStaleSec * 1000);
         }
         else {
             sendJson(res, 200, await readRunFace(deps, runStore, run));
@@ -399,18 +410,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 +435,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,
@@ -623,11 +623,15 @@ export async function handleRuns(req, res, match, ctx) {
                 const leafId = await Promise.resolve(deps.sessionStorage.getLeafId(run.sessionId)).catch(() => undefined);
                 if (leafId === undefined || leafId === null)
                     return;
-                const resumeRead = await readResumeCtx(cs.getCtx(run.sessionId));
+                const resumeRead = await readResumeCtx(cs.getCtx(run.sessionId), { sessionId: run.sessionId, opener: deps.checkpointCtxSealing });
                 if (resumeRead.kind === "corrupt") {
                     mintResult.corruptCtxWhere = resumeRead.where;
                     return;
                 }
+                if (resumeRead.kind === "unsealable") {
+                    mintResult.unsealableCtx = resumeRead;
+                    return;
+                }
                 if (resumeRead.kind === "absent") {
                     mintResult.noResumeCtx = true;
                     return;
@@ -651,10 +655,13 @@ export async function handleRuns(req, res, match, ctx) {
                     createdAt: Date.now(),
                     sourceTaskId: taskId,
                 });
-                const stillRead = await readResumeCtx(cs.getCtx(run.sessionId));
-                if (stillRead.kind === "corrupt") {
-                    await withdrawWakeCard(wakeToken, cpScope, "resume_context_corrupt");
-                    mintResult.corruptCtxWhere = stillRead.where;
+                const stillRead = await readResumeCtx(cs.getCtx(run.sessionId), { sessionId: run.sessionId, opener: deps.checkpointCtxSealing });
+                if (stillRead.kind === "corrupt" || stillRead.kind === "unsealable") {
+                    await withdrawWakeCard(wakeToken, cpScope, stillRead.kind === "corrupt" ? "resume_context_corrupt" : "resume_context_unsealable");
+                    if (stillRead.kind === "corrupt")
+                        mintResult.corruptCtxWhere = stillRead.where;
+                    else
+                        mintResult.unsealableCtx = stillRead;
                     return;
                 }
                 if (stillRead.kind !== "ok") {
@@ -691,6 +698,10 @@ export async function handleRuns(req, res, match, ctx) {
                 sendError(res, 500, "corrupt", "run already ended and this session's stored resume context cannot be read — nothing was queued. Ask whoever operates this deployment to repair or remove the row named in `where` before steering this session again.", { where: mintResult.corruptCtxWhere });
                 return;
             }
+            if (mintResult.unsealableCtx !== undefined) {
+                sendError(res, 409, "conflict.checkpoint_ctx_unsealable", "run already ended and this session's stored resume context holds credentials this server cannot unseal (reason says why) — nothing was queued, because POST /v1/sessions/:id/wake could not resume it; restore the sealed-key directory that sealed them, restart this server (it reads its keys only at startup) and steer again, or submit a new task instead", { field: mintResult.unsealableCtx.field, reason: mintResult.unsealableCtx.reason });
+                return;
+            }
             if (mintResult.unservable !== undefined) {
                 deps.logger?.warn?.("steer_wake_park_refused_stored_body", { taskId, sessionId: run.sessionId, ...storedBodyReplayLogFields(mintResult.unservable) });
                 const { status, body: { error, errorCode, ...rest } } = storedBodyReplayAnswer(mintResult.unservable, serviceVersion(), false);
@@ -724,18 +735,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 +759,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 +877,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 +927,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 +937,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 +1142,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 +1158,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 +1241,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 +1260,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 +1279,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 +1307,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 +1345,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 +1384,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 +1394,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 decidedAtMs: row.decidedAtMs,
                 ...(storedActor ? { actor: storedActor } : {}),
                 ...decisionNoteEcho(row),
+                ...noteReceipt(row),
             });
         };
         const sendTerminal = (row) => {
@@ -1519,7 +1465,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 +1552,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 +1622,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.d.ts

@@ -34,8 +34,9 @@ export type PendingStaging = {
     declaredEntryIds: string[];
     /** The principal that opened this staging — a different caller may not drive it (404, no oracle). */
     openedBy: string | null;
-    /** Fleet-wide caller (ops on-behalf) — bypasses the openedBy identity check (like the route's owner gates). */
-    openedFleetWide: boolean;
+    /** The owner cell the gate judged when it opened this staging (`ownerOf` reading: `undefined` = no such session) — the commit lands only on
+     *  this same cell (`StagedCommitOptions.expectedOwner`, `session-sync-kernel.ts`); `owner` above (the re-stamped importing principal) is derived from it for a fleet caller. */
+    expectedOwner: string | null | undefined;
 };
 /** 单域独占状态 + 它的两个操作。每个 server 实例一份。 */
 export interface SessionSyncLocal {

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

@@ -5,11 +5,10 @@ import { StringDecoder } from "node:string_decoder";
 import { exportSessionManifest, fileHistoryImportFace, replayFileHistory, replayPolicyRecords, wipeSessionAttendants } from "../../session-sync.js";
 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 { isUuidShape, legacyUnownedSessionOk, sessionOwnerCellOf } from "../../security.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";
+import { fleetViewOf, gatedPrincipal, explicitOperatorOk, sendUnauthorized, sessionCallerOf } from "../principal-gate.js";
 const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
 const SYNC_NDJSON_LINE_MAX_BYTES = 8 * 1024 * 1024;
 const SYNC_IMPORT_BATCH = 500;
@@ -35,7 +34,7 @@ export function createSessionSyncLocal() {
 }
 export async function handleSessionSync(req, res, match, ctx) {
     const { deps } = ctx;
-    const { readJson, readRawBody, safeDecode, sessionOwnerScopeForWrite, rateLimited } = ctx.helpers;
+    const { readJson, readRawBody, safeDecode, rateLimited } = ctx.helpers;
     const { pendingStagings, importLeases, touchImportLease, cleanupStaging } = ctx.local.sessionSync;
     {
         {
@@ -45,7 +44,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 return;
             }
             const { backend, sessionStorage, historyStore } = sync;
-            const scope = sessionOwnerScopeForWrite(req);
+            const scope = fleetViewOf(req, deps, "write");
             if (!scope.fleetWide && scope.gateOwner === null) {
                 sendUnauthorized(res, "identity");
                 return;
@@ -55,23 +54,25 @@ export async function handleSessionSync(req, res, match, ctx) {
                 sendError(res, 400, "request.id_invalid", "invalid session id (must be a canonical uuid)");
                 return;
             }
-            const gateFace = await sessionStorage.sessionFaceOf(sessionId);
+            const judgeSessionGate = async () => {
+                const face = await sessionStorage.sessionFaceOf(sessionId);
+                const mayTouch = face !== undefined && (scope.fleetWide || face.owner === scope.gateOwner || legacyUnownedSessionOk(deps.config.requirePrincipal, sessionCallerOf(req, deps), await sessionOwnerCellOf(sessionStorage, sessionId, face.owner)));
+                return { face, mayPull: mayTouch, mayPush: face === undefined || mayTouch };
+            };
+            const gate = await judgeSessionGate();
+            const gateFace = gate.face;
             const owner = gateFace === undefined ? undefined : gateFace.owner;
-            const ownsOrFleet = (o) => scope.fleetWide || o === scope.gateOwner;
+            const sendSessionAbsent = () => sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
             const pullGateOk = () => {
-                if (owner === undefined) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
-                    return false;
-                }
-                if (!ownsOrFleet(owner)) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                if (!gate.mayPull) {
+                    sendSessionAbsent();
                     return false;
                 }
                 return true;
             };
             const pushGateOk = () => {
-                if (owner !== undefined && !ownsOrFleet(owner)) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                if (!gate.mayPush) {
+                    sendSessionAbsent();
                     return false;
                 }
                 return true;
@@ -94,7 +95,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     throw e;
                 }
                 if (out === null) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                    sendSessionAbsent();
                     return;
                 }
                 sendJson(res, 200, { manifest: out.manifest });
@@ -115,7 +116,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const it = await sessionStorage.exportEntriesStream(sessionId, afterSeq === undefined ? undefined : { afterSeq });
                 if (it === null) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                    sendSessionAbsent();
                     return;
                 }
                 res.writeHead(200, { "content-type": "application/x-ndjson", "transfer-encoding": "chunked" });
@@ -187,17 +188,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 +216,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 +307,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,14 +382,14 @@ 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;
                 importLeases.set(sessionId, { at: Date.now(), stagingId });
                 pendingStagings.set(stagingId, {
                     handle, realSessionId: sessionId, owner: importingPrincipal, ...(resolution ? { resolution } : {}), operatorOk,
-                    fileHistory, policy, anchors, row, declaredEntryIds: entryIds, openedBy: scope.gateOwner, openedFleetWide: scope.fleetWide,
+                    fileHistory, policy, anchors, row, declaredEntryIds: entryIds, openedBy: scope.gateOwner, expectedOwner: owner,
                 });
                 sendJson(res, 200, { stagingId, relation: relA.relation });
                 return;
@@ -412,7 +405,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 404, "not_found.staging", "staging not found");
                     return;
                 }
-                if (!pending.openedFleetWide && !scope.fleetWide && pending.openedBy !== scope.gateOwner) {
+                if (!scope.fleetWide && pending.openedBy !== scope.gateOwner) {
                     sendError(res, 404, "not_found.staging", "staging not found");
                     return;
                 }
@@ -494,7 +487,23 @@ export async function handleSessionSync(req, res, match, ctx) {
                         return;
                     throw e;
                 }
-                const activeAtCommit = await deps.runStore?.getActiveTaskId(sessionId);
+                let mayPushAtCommit;
+                let activeAtCommit;
+                try {
+                    mayPushAtCommit = (await judgeSessionGate()).mayPush;
+                    activeAtCommit = mayPushAtCommit ? await deps.runStore?.getActiveTaskId(sessionId) : undefined;
+                }
+                catch (e) {
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
+                    throw e;
+                }
+                if (!mayPushAtCommit) {
+                    await pending.handle.abort().catch(() => undefined);
+                    cleanupStaging(stagingId);
+                    sendSessionAbsent();
+                    return;
+                }
                 if (activeAtCommit) {
                     await pending.handle.abort().catch(() => undefined);
                     cleanupStaging(stagingId);
@@ -502,7 +511,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     return;
                 }
                 try {
-                    const committed = await pending.handle.commit(pending.owner, pending.resolution ? { resolution: pending.resolution } : undefined);
+                    const committed = await pending.handle.commit(pending.owner, { expectedOwner: pending.expectedOwner, ...(pending.resolution ? { resolution: pending.resolution } : {}) });
                     if (pending.resolution === "overwrite-dst" && (committed.relation === "fork" || committed.relation === "stale")) {
                         await wipeSessionAttendants({ fileHistoryStore: historyStore, sessionPolicyStore: deps.sessionPolicyStore, resumeAnchorStore: deps.resumeAnchorStore }, sessionId);
                     }
@@ -532,15 +541,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 +560,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;

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

@@ -2,7 +2,7 @@
  * [ref] A9 域模块 —— 会话列表 / 发件链接列表。
  *
  * 路由:`GET /v1/sessions`(CC /resume picker,keyset 分页)、`GET /v1/sendfile-links`。
- * owner-scope 与 trace 列表同一权威模型(system/traceToken=fleet-wide,principal=钉住本人)。本域零可变状态。
+ * owner-scope 与 trace 列表同一权威模型(`fleetViewOf` 读档:service 凭据不报主体 / 只读 trace 凭据 / dev-open = fleet-wide;带验过的主体 = 钉住那位主体)。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type SessionListItem } from "../../security.js";