@sema-agent/server 7.133.0 → 7.135.0

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

@@ -12,7 +12,7 @@
  * 因此**导入两口**只认已验明的 principal,连 `explicitOperatorOk` 的旁路都不给:一个 operator 想给
  * 自己导规则,用他自己的 principal 走同一条路即可(那时他就是租户)。
  *
- * 🔴 **`POST /v1/rules` 是撤销口的对偶,不是导入口的简写**(S-511):它写的只有**收紧**方向
+ * 🔴 **`POST /v1/rules` 是撤销口的对偶,不是导入口的简写**([ref]):它写的只有**收紧**方向
  * (deny/ask),而收紧不需要同意仪式 —— 与撤销为什么不需要是同一条理由(core `removePersistedRule`
  * 头注逐字:「a host may narrow on a user's behalf, it may not widen」)。放宽(allow)仍然只有两条路:
  * 一张卡上的人点头,或一次显式的 settings 导入。方向表在 `permission-rule-vocab.ts`,不在本文件。

package/dist/http/routes/rules.js

@@ -6,8 +6,8 @@ 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 { 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";
+import { IMPORTED_SETTINGS_LAYERS, MAX_RULE_TEXT_CHARS, PERSISTED_RULE_MATCHES, RULE_ADD_ORIGINS, RULE_BEHAVIORS, isValidDurableScope } from "@sema-agent/core";
+import { isPersistedRuleTool, isDirectWritableRuleBehavior } from "../../permission-rule-vocab.js";
 const logger = createLogger();
 export const RULES_CC_IMPORT_PREPARE_PATH = "/v1/rules/cc-import/prepare";
 export const RULES_CC_IMPORT_REDEEM_PATH = "/v1/rules/cc-import/redeem";
@@ -23,7 +23,7 @@ const CcImportPrepareBodySchema = z
     layers: z
         .array(z
         .object({
-        layer: z.enum(["userSettings", "projectSettings", "localSettings"]),
+        layer: z.enum(IMPORTED_SETTINGS_LAYERS),
         path: z.string().min(1).max(1024),
         root: z.string().max(1024),
         content: z.string().max(MAX_LAYER_CONTENT_CHARS),
@@ -41,7 +41,7 @@ const CcImportRedeemBodySchema = z.object({ ticket: TicketStringSchema }).strict
 const LocalImportAddSchema = z
     .object({
     dot: z.object({ actor: z.string().min(1).max(190), counter: z.number().int().nonnegative().safe() }).strict(),
-    origin: z.enum(["user", "imported-cc", "starter"]),
+    origin: z.enum(RULE_ADD_ORIGINS),
     createdAt: z.string().min(1).max(64),
 })
     .strict();

package/dist/http/routes/runs.js

@@ -3,6 +3,7 @@ import { redactHead, redactLedgerEventForRead } from "../../observability/run-te
 import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, policyCannotAnswer, validatePendingSteer, TASK_OUTPUT_REPLAY_KINDS, isSystemInjectionPriority } from "@sema-agent/core";
 import { isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
+import { askRowCarriesOwner } from "../../plugins/approval-ask-store-sql.js";
 import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-sql.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { isUuidV7, encodeCheckpointScope } from "../../security.js";
@@ -13,7 +14,7 @@ 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 { ASK_DECISION_CONSUMER_ABSENT, approvalPreambleReplays, outcomeOfDecidedRow, presentedApprovalFrameFamily, resolveStreamApprovalGate } from "../../tool-approval.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";
@@ -32,6 +33,7 @@ import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { readResumeCtx } from "../resume-ctx-read.js";
 import { storedBodyReplayAnswer, storedBodyReplayLogFields } from "../checkpoint-ctx.js";
+import { headReadOf } from "../../session-incarnation.js";
 import { serviceVersion } from "../../service-version.js";
 import { storedBodyReplayRefusal } from "../stored-body-replay.js";
 import { steerBodyKeyIssue } from "../../request-key-closure.js";
@@ -116,10 +118,18 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
                 toolApprovalEnabled: Boolean(deps.toolApproval),
                 streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                 backend: deps.backend,
-                parkFacility: deps.checkpointStore !== undefined,
+                checkpointStore: deps.checkpointStore,
             });
             if (!gate.active)
                 return [];
+            if (!approvalPreambleReplays({
+                streamApprovalOn: gate.active,
+                windowMs: deps.config.streamApproval?.windowMs,
+                windowMarginMs: deps.config.streamAskWindowMarginMs,
+                declaredFamilies: new Set([presentedApprovalFrameFamily(gate.active)]),
+            })) {
+                return [];
+            }
             const store = gate.askStore;
             const rows = await store.listPendingByTask(taskId, signal);
             const { frames, skipped, dropped } = buildApprovalPreamble(rows, Date.now(), deps.config.streamApproval.replayMax);
@@ -560,7 +570,8 @@ export async function handleRuns(req, res, match, ctx) {
             }
             return;
         }
-        if (deps.checkpointStore && deps.sessionStorage?.getLeafId) {
+        const sessionHeadOf = headReadOf(deps.sessionStorage);
+        if (deps.checkpointStore && sessionHeadOf) {
             const activeTaskId = await runStore.getActiveTaskId?.(run.sessionId).catch(() => undefined);
             if (activeTaskId !== undefined && activeTaskId !== null && activeTaskId !== taskId) {
                 sendNotRunning(`run is ${run.status} and its session has an ACTIVE run (${activeTaskId}) — steer that run instead`);
@@ -610,14 +621,18 @@ export async function handleRuns(req, res, match, ctx) {
                     mintResult.duplicateKey = true;
                     return;
                 }
-                const leafId = await Promise.resolve(deps.sessionStorage.getLeafId(run.sessionId)).catch(() => undefined);
+                const leafId = await sessionHeadOf(run.sessionId).then((h) => h?.leafId).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;
@@ -641,10 +656,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") {
@@ -681,6 +699,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);
@@ -1432,6 +1454,10 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 });
                 return;
             }
+            if (hit && !askRowCarriesOwner(hit, row0.owner)) {
+                askNotFound();
+                return;
+            }
             if (hit && hit.state === "DECIDED") {
                 if (!syncLiveFromDecidedRow(hit))
                     return;
@@ -1450,7 +1476,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         let outcome;
         const releaseEditMark = body.decision === "approve" && hasUpdatedInput ? deps.toolApproval?.markEditedDecisionInFlight(askId) : undefined;
         try {
-            outcome = await askStore.decideAsk(askId, row0.batchId, {
+            outcome = await askStore.decideAsk(askId, row0.batchId, row0.owner, {
                 decision: body.decision,
                 decisionActor: actor,
                 decisionNote: body.note ?? null,
@@ -1466,13 +1492,16 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 hadIdempotencyKey: body.idempotencyKey !== undefined,
                 error: err instanceof Error ? err.message : String(err ?? ""),
             });
+            let confirmedOutOfScope = false;
             if (releaseEditMark !== undefined &&
                 body.idempotencyKey !== undefined &&
                 deps.toolApproval &&
                 deps.toolApproval.editedDecisionInFlightCount(askId) === 1) {
                 try {
                     const confirmed = await withDeadline(askStore.getAsk(askId), ASK_DECISION_CONFIRM_TIMEOUT_MS, "getAsk(ambiguous-commit-confirm)");
-                    if (confirmed !== null &&
+                    if (confirmed !== null && !askRowCarriesOwner(confirmed, row0.owner))
+                        confirmedOutOfScope = true;
+                    else if (confirmed !== null &&
                         confirmed.state === "DECIDED" &&
                         confirmed.decision === body.decision &&
                         confirmed.idempotencyKey === body.idempotencyKey &&
@@ -1485,6 +1514,10 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     deps.logger?.warn?.("ask_decision_edit_confirm_failed", { taskId, askId, error: confirmErr instanceof Error ? confirmErr.message : String(confirmErr ?? "") });
                 }
             }
+            if (confirmedOutOfScope) {
+                askNotFound();
+                return;
+            }
             if (body.idempotencyKey !== undefined) {
                 sendError(res, 500, "internal.error", "the ask decision store failed around commit — the decision MAY already be persisted; retry with the same idempotencyKey to replay it instead of colliding with it");
             }

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 (head-read reading `headOf(id)?.owner`: `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

@@ -2,13 +2,13 @@ import { once } from "node:events";
 import { randomBytes, createHash } from "node:crypto";
 import { sessionLogDigest, sessionLogDigestsComparable, StreamingImportValidator, validateFileHistoryExport } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
-import { exportSessionManifest, fileHistoryImportFace, replayFileHistory, replayPolicyRecords, wipeSessionAttendants } from "../../session-sync.js";
+import { FileHistoryUnreadableError, blobGetterOf, exportSessionManifest, exportedFileHistory, 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 { 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;
@@ -16,6 +16,7 @@ import { SHA256_HEX_RE } from "../../digest-form.js";
 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";
 export function createSessionSyncLocal() {
     const pendingStagings = new Map();
     const importLeases = new Map();
@@ -34,7 +35,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;
     {
         {
@@ -44,7 +45,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;
@@ -54,23 +55,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 = sessionFaceOfHead(sessionId, await sessionStorage.headOf(sessionId));
+                const mayTouch = face !== undefined && (scope.fleetWide || face.owner === scope.gateOwner || legacyUnownedSessionOk(deps.config, 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;
@@ -80,6 +83,11 @@ export async function handleSessionSync(req, res, match, ctx) {
                     return true;
                 return face !== undefined && (await sessionStorage.patchSessionMeta(sessionId, row, face)) !== undefined;
             };
+            const canReplayHistory = fileHistoryImportFace(historyStore) !== undefined;
+            const replayHistory = async (envelope, allowReplace) => {
+                const r = await replayFileHistory(historyStore, sessionId, envelope, blobGetterOf(historyStore), { allowReplace });
+                return r.ok ? undefined : r;
+            };
             if (match.decl.id === "session-sync-manifest") {
                 if (!pullGateOk())
                     return;
@@ -88,12 +96,12 @@ export async function handleSessionSync(req, res, match, ctx) {
                     out = await exportSessionManifest(sessionId, backend, historyStore);
                 }
                 catch (e) {
-                    if (sendSessionPolicyError(res, e))
+                    if (sendSessionPolicyError(res, e) || sendFileHistoryUnreadable(res, e))
                         return;
                     throw e;
                 }
                 if (out === null) {
-                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                    sendSessionAbsent();
                     return;
                 }
                 sendJson(res, 200, { manifest: out.manifest });
@@ -114,7 +122,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" });
@@ -154,8 +162,16 @@ export async function handleSessionSync(req, res, match, ctx) {
                     return;
                 }
                 const fs = blobs.historyStore;
-                const envelope = typeof fs.exportHistory === "function" ? await fs.exportHistory(sessionId) : null;
-                const referenced = envelope !== null && envelope !== undefined && envelope.tracked.some((t) => t.versions.some((v) => v.blobHash === hash));
+                let envelope;
+                try {
+                    envelope = await exportedFileHistory(fs, sessionId);
+                }
+                catch (e) {
+                    if (sendFileHistoryUnreadable(res, e))
+                        return;
+                    throw e;
+                }
+                const referenced = envelope !== null && envelope.tracked.some((t) => t.versions.some((v) => v.blobHash === hash));
                 if (!referenced) {
                     sendError(res, 404, "not_found.blob", "blob not found");
                     return;
@@ -273,6 +289,17 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 409, "conflict", "sync conflict", { relation: relA });
                     return;
                 }
+                if (fileHistory !== null) {
+                    const distinct = new Set();
+                    for (const t of fileHistory.tracked)
+                        for (const v of t.versions)
+                            if (v.blobHash !== null)
+                                distinct.add(v.blobHash);
+                    if (await firstMissingBlob(facts.sessionSyncFileHistory(deps), [...distinct]) !== undefined) {
+                        sendMissingBlob(res);
+                        return;
+                    }
+                }
                 let payloadVerified = false;
                 let digestSaysDiffer = false;
                 if (relA.relation === "identical" && srcLogDigest !== undefined) {
@@ -288,8 +315,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                         digestSaysDiffer = true;
                 }
                 if (relA.relation === "identical" && !digestSaysDiffer) {
-                    const blobFaces = facts.sessionSyncFileHistory(deps);
-                    if (fileHistory !== null && blobFaces.available && fileHistoryImportFace(blobFaces.historyStore)) {
+                    if (fileHistory !== null && canReplayHistory) {
                         if (resolution === "overwrite-dst") {
                             const activeNow = await deps.runStore?.getActiveTaskId(sessionId);
                             if (activeNow) {
@@ -297,11 +323,9 @@ export async function handleSessionSync(req, res, match, ctx) {
                                 return;
                             }
                         }
-                        const getBlobA = (h) => blobFaces.historyStore.getBlob(h);
-                        const r = await replayFileHistory(blobFaces.historyStore, sessionId, fileHistory, getBlobA, { allowReplace: resolution === "overwrite-dst" });
-                        const failCode = r.ok ? undefined : r.error.code === "not_found" ? "missing_blob" : r.error.code;
-                        if (!r.ok) {
-                            sendError(res, 422, failCode, `file history import failed (${r.error.code})`);
+                        const failed = await replayHistory(fileHistory, resolution === "overwrite-dst");
+                        if (failed !== undefined) {
+                            sendFileHistoryReplayFailure(res, failed);
                             return;
                         }
                     }
@@ -354,31 +378,6 @@ export async function handleSessionSync(req, res, match, ctx) {
                         return;
                     }
                 }
-                const fss = historyStore;
-                if (fileHistory !== null && fileHistoryImportFace(fss) !== undefined) {
-                    const distinct = new Set();
-                    for (const t of fileHistory.tracked)
-                        for (const v of t.versions)
-                            if (v.blobHash !== null)
-                                distinct.add(v.blobHash);
-                    const all = [...distinct];
-                    if (typeof fss.hasBlobs === "function") {
-                        const present = await fss.hasBlobs(all);
-                        const missing = all.find((h) => !present.has(h));
-                        if (missing !== undefined) {
-                            sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
-                            return;
-                        }
-                    }
-                    else if (typeof fss.getBlob === "function") {
-                        for (const hash of all) {
-                            if (!(await fss.getBlob(hash))) {
-                                sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
-                                return;
-                            }
-                        }
-                    }
-                }
                 const importingPrincipal = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
                 const operatorOk = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config);
                 const token = randomBytes(8).toString("hex");
@@ -387,7 +386,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 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;
@@ -403,11 +402,10 @@ 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;
                 }
-                const getBlob = (h) => historyStore.getBlob ? historyStore.getBlob(h) : Promise.resolve(undefined);
                 const validator = new StreamingImportValidator();
                 let lineBuf = "";
                 let pendingBatch = [];
@@ -485,7 +483,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);
@@ -493,15 +507,14 @@ 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);
                     }
-                    if (pending.fileHistory !== null && fileHistoryImportFace(historyStore)) {
-                        const r = await replayFileHistory(historyStore, sessionId, pending.fileHistory, getBlob, { allowReplace: pending.resolution === "overwrite-dst" });
-                        const failCode = r.ok ? undefined : r.error.code === "not_found" ? "missing_blob" : r.error.code;
-                        if (!r.ok) {
-                            sendError(res, 422, failCode, `file history import failed (${r.error.code})`);
+                    if (pending.fileHistory !== null && canReplayHistory) {
+                        const failed = await replayHistory(pending.fileHistory, pending.resolution === "overwrite-dst");
+                        if (failed !== undefined) {
+                            sendFileHistoryReplayFailure(res, failed);
                             cleanupStaging(stagingId);
                             return;
                         }
@@ -556,6 +569,40 @@ export async function handleSessionSync(req, res, match, ctx) {
         }
     }
 }
+function sendFileHistoryUnreadable(res, e) {
+    if (!(e instanceof FileHistoryUnreadableError))
+        return false;
+    const permanence = e.failure.permanence;
+    const advice = permanence === "transient" ? "the history store judged the fault transient: retry later" : permanence === "terminal" ? "the history store judged the fault permanent: retrying will not help until the store is repaired" : "the history store did not judge whether retrying can help";
+    sendError(res, 503, "state.file_history_unreadable", `this session's file history cannot be read whole (${e.failure.code}), so nothing was exported — ${advice}`, permanence === undefined ? undefined : { permanence });
+    return true;
+}
+function sendMissingBlob(res) {
+    sendError(res, 422, "missing_blob", "missing blob; PUT all referenced blobs before import");
+}
+function sendFileHistoryReplayFailure(res, failure) {
+    if (failure.missingBlob !== undefined) {
+        sendMissingBlob(res);
+        return;
+    }
+    const { code, permanence } = failure.error;
+    sendError(res, 422, code, `file history import failed (${code})`, permanence === undefined ? undefined : { permanence });
+}
+async function firstMissingBlob(blobFaces, referenced) {
+    if (referenced.length === 0)
+        return undefined;
+    if (!blobFaces.available)
+        return referenced[0];
+    const store = blobFaces.historyStore;
+    if (typeof store.hasBlobs === "function") {
+        const present = await store.hasBlobs([...referenced]);
+        return referenced.find((h) => !present.has(h));
+    }
+    for (const hash of referenced)
+        if (!(await store.getBlob(hash)))
+            return hash;
+    return undefined;
+}
 function sendSessionSyncUnavailable(res, why) {
     switch (why) {
         case "store_backend_absent":

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";

package/dist/http/routes/sessions-list.js

@@ -1,16 +1,15 @@
 import { isUuidV7, legacyUnownedAmnestyOpen } from "../../security.js";
 import { sendJson, sendError } from "../send.js";
-import { sendUnauthorized } from "../principal-gate.js";
+import { fleetViewOf, sendUnauthorized } from "../principal-gate.js";
 import { filterFingerprint } from "../cursor-fingerprint.js";
 import { sessionTempoOfRunStatus } from "../../plugins/store-contracts.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 export async function handleSessionsList(req, res, match, ctx) {
     const { deps } = ctx;
-    const { isFleetWide, sessionOwnerScope } = ctx.helpers;
     switch (match.decl.id) {
         case "sessions-list": {
-            const { fleetWide, gateOwner } = sessionOwnerScope(req);
+            const { fleetWide, gateOwner } = fleetViewOf(req, deps, "read");
             if (!fleetWide && gateOwner === null) {
                 sendUnauthorized(res, "identity");
                 return;
@@ -21,12 +20,12 @@ export async function handleSessionsList(req, res, match, ctx) {
                 return;
             }
             const lister = listing.lister;
-            const includeUnowned = !fleetWide && legacyUnownedAmnestyOpen(deps.config.requirePrincipal, gateOwner);
+            const includeUnowned = !fleetWide && legacyUnownedAmnestyOpen(deps.config, gateOwner);
             await handleSessionList(res, lister, new URLSearchParams(match.search), gateOwner, includeUnowned);
             return;
         }
         case "sendfile-links": {
-            const { fleetWide, gateOwner } = sessionOwnerScope(req);
+            const { fleetWide, gateOwner } = fleetViewOf(req, deps, "read");
             if (!fleetWide && gateOwner === null) {
                 sendUnauthorized(res, "identity");
                 return;