@sema-agent/server 7.151.0 → 7.152.0

package/dist/http/routes/session-sync.d.ts

@@ -9,8 +9,11 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type SessionRulesRecord, type FileHistoryExport } from "@sema-agent/core";
+import { type VisibleBlobs } from "../../session-sync.js";
 import { type ImportAnchor, type StagingHandle } from "../../session-sync-kernel.js";
+import { type ListFilter } from "../../owner-faces.js";
 import type { DurableOwnerKey } from "../../owner-brands.js";
+import type { SyncLanding } from "../../plugins/store-backend.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 import { type SessionRowPatch } from "../../session-row.js";
 import { type SessionFace } from "../../session-incarnation.js";
@@ -39,15 +42,24 @@ export type PendingStaging = {
     expectedOccupant: SessionFace | undefined;
     /** 开这张暂存时占下的导入租约的键({@link importLeaseKey});续期与放掉都按它,不再从会话 id 重算。 */
     leaseKey: string;
+    /** 第一阶段那一次可见性读的答案(落点 = 开暂存时门判的那一格):提交臂的文件历史重放只经它的取值口取字节 —— 许可集在第一阶段定,覆盖写的擦除不改它。 */
+    visible: VisibleBlobs;
 };
 /**
- * 导入租约的键 = 这次导入**落在哪一格属主上**(与提交的属主 CAS 同一格)+ 会话 id。一条读法:
- *  · id 被占着(活行 ∪ 在删行 —— 「被占着」的唯一读法,门读的 `occupant`)⇒ 落点是住客的属主格(`null` = 无主):所有碰得到这一行的调用方(属主、fleet、存量无主互认)共一把 —— 同一份会话上第二份在飞导入,谁发起的都 409;
- *  · id 空闲 ⇒ 还没有谁的会话,落点是这位调用方自己将成的属主(`importingPrincipal`):各占各的,先提交者得(提交的属主 CAS 要求那一格仍空着,输的那一份
- *    在提交前复判被拒)。一个主体的在飞导入既不挡、也不透给另一个主体 —— 租约键不含主体时,空闲 id 上任一主体都能占位,并从 409 读到「此 id 此刻有人在导」。
- * 键的主体只来自门读的 `occupant` 与 `importingPrincipal`(两者都派生自属主存取器的 `listFilterOf` 与门读的会话面,不另读调用方),且占租约在 `pushGateOk` 之后。
+ * 这次推送 / 拉取**落在哪一格**(落点)的唯一读法 —— 导入租约的键、blob 授予(`PUT …/sync/blobs/:hash`)、blob 可见性(第一阶段预检 · 重放取值 · `GET …/sync/history/blobs/:hash`)同读它:
+ *  · id 被占着(活行 ∪ 在删行 —— 「被占着」的唯一读法,门读的 `occupant`)⇒ 落点是住客的属主格(`null` = 无主):所有碰得到这一行的调用方(属主、fleet、存量无主互认)落在同一格;
+ *  · id 空闲 ⇒ 还没有谁的会话,落点是这位调用方自己将成的属主(fleet ⇒ 无主格;主体 ⇒ 主体):各落各的,先提交者得(提交的属主 CAS 要求那一格仍空着)。
+ * `occupied` 随落点走:只有被占着的 id,它的历史图才是 blob 的来历(空闲 id 上残留的图不是任何一位调用方持有过字节的证明)。
+ * 落点的主体只来自门读的 `occupant` 与 `listFilterOf` 的派生,不另读调用方;拉取口只在活行上放行(`pullGateOk`),那时 `occupant` 就是活行。
  */
-export declare function importLeaseKey(landingOwner: string | null, sessionId: string): string;
+export declare function landingOf(gate: {
+    readonly occupant: SessionFace | undefined;
+}, scope: ListFilter, sessionId: string): SyncLanding;
+/**
+ * 导入租约的键 = 这次导入的落点({@link landingOf}):落点属主格 + 会话 id。同一份会话上第二份在飞导入,谁发起的都 409(同一格);空闲 id 上一个主体的在飞导入既不挡、也不透给
+ * 另一个主体 —— 租约键不含落点属主格时,空闲 id 上任一主体都能占位,并从 409 读到「此 id 此刻有人在导」。占租约在 `pushGateOk` 之后。
+ */
+export declare function importLeaseKey(landing: SyncLanding): string;
 /** 一把导入租约:最后活动时刻 + 持有它的暂存 + 它守的会话 id(清扫与运维日志用,不从键里反解)。 */
 export type ImportLease = {
     at: number;

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

@@ -1,7 +1,7 @@
 import { once } from "node:events";
 import { sessionLogDigest, sessionLogDigestsComparable, validateFileHistoryExport } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
-import { FileHistoryUnreadableError, blobGetterOf, exportSessionManifest, exportedFileHistory } from "../../session-sync.js";
+import { FileHistoryUnreadableError, NO_VISIBLE_BLOBS, exportSessionManifest } from "../../session-sync.js";
 import { fileHistoryImportFace } from "../../plugins/landed-attendants.js";
 import * as facts from "../../capability-facts.js";
 import { classifySyncRelationshipByIds, createStagedLogFeed, MalformedImportEntryError, newStagingToken, readImportAnchors, SyncConflictError } from "../../session-sync-kernel.js";
@@ -23,8 +23,13 @@ import { defaultTaskRegistry } from "@sema-agent/core";
 import { SessionActiveRunError, SessionForkInProgressError, SessionWriterPresentError } from "../../execution-placement.js";
 import { probeSessionChildren, sessionTenantScope } from "../../session-children-retire.js";
 import { liveChildrenRefusal } from "./background.js";
-export function importLeaseKey(landingOwner, sessionId) {
-    return JSON.stringify([landingOwner, sessionId]);
+export function landingOf(gate, scope, sessionId) {
+    return gate.occupant !== undefined
+        ? { sessionId, owner: gate.occupant.owner, occupied: true }
+        : { sessionId, owner: scope.fleetWide ? null : scope.gateOwner, occupied: false };
+}
+export function importLeaseKey(landing) {
+    return JSON.stringify([landing.owner, landing.sessionId]);
 }
 export function createSessionSyncLocal() {
     const pendingStagings = new Map();
@@ -108,6 +113,7 @@ export async function handleSessionSync(req, res, match, ctx) {
             }
             const gateFace = gate.face;
             const owner = gateFace === undefined ? undefined : gateFace.owner;
+            const landing = landingOf(gate, scope, sessionId);
             const sendSessionAbsent = (reason) => refuse(syncEntry, res, reason);
             const pullGateOk = () => {
                 if (!gate.mayPull) {
@@ -199,7 +205,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 if (plan.wipe && !(await attendants.wipe(sessionId, landed)).landed)
                     return { kind: "gone", leg: "wipe" };
                 if (plan.fileHistory !== null && canReplayHistory) {
-                    const h = await attendants.replayHistory(sessionId, landed, plan.fileHistory, blobGetterOf(historyStore), { allowReplace: plan.allowReplace });
+                    const h = await attendants.replayHistory(sessionId, landed, plan.fileHistory, plan.getBlob, { allowReplace: plan.allowReplace });
                     if (!h.landed)
                         return { kind: "gone", leg: "file_history" };
                     if (!h.value.ok)
@@ -221,20 +227,20 @@ export async function handleSessionSync(req, res, match, ctx) {
             if (match.decl.id === "session-sync-manifest") {
                 if (!pullGateOk())
                     return;
-                let out;
+                let manifest;
                 try {
-                    out = await exportSessionManifest(sessionId, backend, historyStore);
+                    manifest = await exportSessionManifest(sessionId, backend, historyStore);
                 }
                 catch (e) {
                     if (sendSessionPolicyError(res, e) || sendPullUnreadable(req, res, deps.logger, e))
                         return;
                     throw e;
                 }
-                if (out === null) {
+                if (manifest === null) {
                     sendSessionAbsent("missing");
                     return;
                 }
-                await pullAnswer(() => sendJson(res, 200, { manifest: out.manifest }));
+                await pullAnswer(() => sendJson(res, 200, { manifest }));
                 return;
             }
             if (match.decl.id === "session-sync-entries") {
@@ -301,9 +307,9 @@ export async function handleSessionSync(req, res, match, ctx) {
                 return;
             }
             if (match.decl.id === "session-sync-history-blob") {
-                const blobs = facts.sessionSyncFileHistory(deps);
-                if (!blobs.available) {
-                    sendSessionSyncUnavailable(res, blobs.why);
+                const faces = facts.sessionSyncFileHistory(deps);
+                if (!faces.available) {
+                    sendSessionSyncUnavailable(res, faces.why);
                     return;
                 }
                 if (!pullGateOk())
@@ -317,25 +323,22 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 400, "request.id_invalid", "blob hash must be 64 lowercase-hex chars");
                     return;
                 }
-                const fs = blobs.historyStore;
-                const exchange = blobs.blobExchange;
-                let envelope;
+                let visible;
                 try {
-                    envelope = await exportedFileHistory(fs, sessionId);
+                    visible = await faces.blobs.visible(landing, [hash]);
                 }
                 catch (e) {
                     if (sendPullUnreadable(req, res, deps.logger, e))
                         return;
                     throw e;
                 }
-                const referenced = envelope !== null && envelope.tracked.some((t) => t.versions.some((v) => v.blobHash === hash));
-                if (!referenced) {
+                if (!visible.hashes.has(hash)) {
                     await pullAnswer(() => sendError(res, 404, "not_found.blob", "blob not found"));
                     return;
                 }
                 let bytes;
                 try {
-                    bytes = await exchange.get(hash);
+                    bytes = await visible.get(hash);
                 }
                 catch (e) {
                     if (sendPullUnreadable(req, res, deps.logger, e))
@@ -356,9 +359,9 @@ export async function handleSessionSync(req, res, match, ctx) {
             if (match.decl.id === "session-sync-blob-put") {
                 if (rateLimited(req, res))
                     return;
-                const blobs = facts.sessionSyncFileHistory(deps);
-                if (!blobs.available) {
-                    sendSessionSyncUnavailable(res, blobs.why);
+                const faces = facts.sessionSyncFileHistory(deps);
+                if (!faces.available) {
+                    sendSessionSyncUnavailable(res, faces.why);
                     return;
                 }
                 if (!pushGateOk())
@@ -369,7 +372,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     return;
                 }
                 const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
-                const put = await blobs.blobExchange.put(hash, new Uint8Array(body));
+                const put = await faces.blobs.put(landing, hash, new Uint8Array(body));
                 if (!put.ok) {
                     if (put.error.blobCap !== undefined) {
                         sendError(res, 413, "blob_too_large_for_sql", put.error.message, { wallSource: put.error.blobCap.wallSource });
@@ -471,15 +474,21 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 409, "conflict", "sync conflict", { relation: relA });
                     return;
                 }
+                let visible = NO_VISIBLE_BLOBS;
                 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) {
-                        await pushAnswer(() => sendMissingBlob(res));
-                        return;
+                    if (distinct.size > 0) {
+                        const faces = facts.sessionSyncFileHistory(deps);
+                        if (faces.available)
+                            visible = await faces.blobs.visible(landing, [...distinct]);
+                        if ([...distinct].some((h) => !visible.hashes.has(h))) {
+                            await pushAnswer(() => sendMissingBlob(res));
+                            return;
+                        }
                     }
                 }
                 let payloadVerified = false;
@@ -554,7 +563,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     }
                     let landedA;
                     try {
-                        landedA = await landAttendants(attendantsA, gateFace, { wipe: false, fileHistory, allowReplace: resolution === "overwrite-dst", policy, operator: operatorOk, anchors, owner: importingPrincipal, row });
+                        landedA = await landAttendants(attendantsA, gateFace, { wipe: false, fileHistory, getBlob: visible.get, allowReplace: resolution === "overwrite-dst", policy, operator: operatorOk, anchors, owner: importingPrincipal, row });
                     }
                     catch (e) {
                         if (sendSessionPolicyError(res, e))
@@ -582,7 +591,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     }));
                     return;
                 }
-                const leaseKey = importLeaseKey(gate.occupant !== undefined ? gate.occupant.owner : importingPrincipal, sessionId);
+                const leaseKey = importLeaseKey(landing);
                 const staleSecRaw = deps.config.syncImportLeaseStaleSec;
                 const staleSec = typeof staleSecRaw === "number" && Number.isFinite(staleSecRaw) ? staleSecRaw : 600;
                 const staleMs = staleSec * 1000;
@@ -605,7 +614,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 importLeases.set(leaseKey, { at: Date.now(), stagingId, sessionId });
                 pendingStagings.set(stagingId, {
                     handle, realSessionId: sessionId, owner: importingPrincipal, ...(resolution ? { resolution } : {}), operatorOk,
-                    fileHistory, policy, anchors, row, declaredEntryIds: entryIds, openedBy: ownerKeyOf(scope.gateOwner), expectedOccupant: gateFace, leaseKey,
+                    fileHistory, policy, anchors, row, declaredEntryIds: entryIds, openedBy: ownerKeyOf(scope.gateOwner), expectedOccupant: gateFace, leaseKey, visible,
                 });
                 sendJson(res, 200, { stagingId, relation: relA.relation });
                 return;
@@ -729,6 +738,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     const landedB = await landAttendants(attendantsB, committed.face, {
                         wipe: pending.resolution === "overwrite-dst" && (committed.relation === "fork" || committed.relation === "stale"),
                         fileHistory: pending.fileHistory,
+                        getBlob: pending.visible.get,
                         allowReplace: pending.resolution === "overwrite-dst",
                         policy: pending.policy,
                         operator: pending.operatorOk,
@@ -869,14 +879,6 @@ function sendFileHistoryReplayFailure(res, failure) {
     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 present = await blobFaces.blobExchange.has(referenced);
-    return referenced.find((h) => !present.has(h));
-}
 function sendSessionSyncUnavailable(res, why) {
     switch (why) {
         case "store_backend_absent":

package/dist/http/routes/sessions.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { SessionError, materializeA2aTools, materializeMcpTools, sanitizePathComponent } from "@sema-agent/core";
 import { a2aForScenario, mcpForScenario } from "../../web-admin-client/facade.js";
 import { HttpError, isUuidShape } from "../../security.js";
@@ -14,6 +15,7 @@ import { readWritableSessionPermissionRules } from "../../session-policy-wire.js
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, sseHeaders, httpErrorBody } from "../send.js";
 import { gatedPerson, gatedSubject, sendPrincipalRefusal } from "../principal-gate.js";
 import { personOf } from "../../owner-brands.js";
+import { scenarioRequestedBySubject } from "../../request-form.js";
 import { leafOfAdmittedHead, sessionFaceOfHead } from "../../session-incarnation.js";
 import { admitSessionById, admitSessionForDeletion, admitSessionRow, admitSessionView, admittedAsFleet, callerEntry, callerOf, deliverVerdict, enter, judgeSessionById, protocolEntry, readOwnerCell, readVisibleLatestRun, refuse, sessionOccupantUnchanged } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
@@ -23,6 +25,7 @@ import { projectSessionListRow } from "./sessions-list.js";
 import { readSessionRowPatch } from "../../session-row.js";
 import { forkPathOf, resolveExecutionContext } from "../execution-context.js";
 import { executionPlacementView } from "../../execution-placement.js";
+import { readSessionOccupant, refusalOccupantOf } from "../active-run-conflict.js";
 import { anchorReaderOf, resolveHistoryAnchor } from "../../history-anchor.js";
 import { engineRefusalAnswerOf } from "../engine-refusal.js";
 import { buildRewindFilesReply } from "../rewind-files-reply.js";
@@ -135,7 +138,7 @@ export async function handleSessions(req, res, match, ctx) {
             const ledgerHalf = lastLegMcp === undefined ? {} : { lastLegMcp };
             let scenarioName;
             try {
-                scenarioName = await deps.scenarioGate(principal, undefined);
+                ({ scenario: scenarioName } = await deps.scenarioGate(principal, scenarioRequestedBySubject(caller.subject, undefined)));
             }
             catch (e) {
                 if (!(e instanceof HttpError))
@@ -192,7 +195,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            const scenarioName = await deps.scenarioGate(principal, undefined);
+            const { scenario: scenarioName } = await deps.scenarioGate(principal, scenarioRequestedBySubject(gatedSubject(req, deps.config), undefined));
             const specs = a2aForScenario(deps.config.a2aPeers, scenarioName);
             if (!specs || specs.length === 0) {
                 sendJson(res, 200, { peers: [], asOf: new Date().toISOString() });
@@ -256,13 +259,21 @@ export async function handleSessions(req, res, match, ctx) {
             if (admittedHead === undefined)
                 return;
             const leafId = leafOfAdmittedHead(admittedHead.row);
-            const etag = `"${leafId ?? "empty"}"`;
+            const runs = facts.durableRuns(deps);
+            const occupant = runs.available ? await readSessionOccupant(runs.runStore, headSession) : undefined;
+            if (occupant !== undefined && occupant.activeTaskId !== null && !(await sessionOccupantUnchanged(headEntry, headFact.sessionStorage, headSession, admittedHead.row))) {
+                refuse(headEntry, res, "missing");
+                return;
+            }
+            const body = { sessionId: headSession, leafId, ...occupant };
+            const bytes = JSON.stringify(body);
+            const etag = `"${createHash("sha256").update(bytes).digest("base64url")}"`;
             if (req.headers["if-none-match"] === etag) {
                 res.writeHead(304, { etag }).end();
                 return;
             }
-            res.setHeader("etag", etag);
-            sendJson(res, 200, { sessionId: headSession, leafId });
+            res.writeHead(200, { "content-type": "application/json", etag });
+            res.end(bytes);
             return;
         }
     }
@@ -767,9 +778,9 @@ export async function handleSessions(req, res, match, ctx) {
             return;
         }
         const entryId = await resolveHistoryAnchor("rewindFilesTo", anchors, anchorReaderOf(req, deps, rewindEntry.caller), sessionId, read.to, sessionOwner, "to");
-        const activeTaskId = await deps.runStore?.getActiveTaskId(sessionId);
-        if (activeTaskId) {
-            sendError(res, 409, "conflict.session_active_run", `session has an active run (${activeTaskId}); its files cannot be rewound under it — wait for that run to end (or cancel it), then rewind`, { activeTaskId });
+        const holder = await deps.runStore?.getActiveTaskId(sessionId);
+        if (holder) {
+            sendError(res, 409, "conflict.session_active_run", `session has an active run (${holder}); its files cannot be rewound under it — wait for that run to end (or cancel it), then rewind`, await refusalOccupantOf(deps.runStore, holder));
             return;
         }
         let result;
@@ -883,7 +894,7 @@ export async function handleSessions(req, res, match, ctx) {
             const owner = deleteAdmitted.row.owner;
             const result = await purge(sessionId, owner);
             if ("active" in result) {
-                sendError(res, 409, "conflict.session_active_run", "session has an active run; cancel it before deleting", { activeTaskId: result.active });
+                sendError(res, 409, "conflict.session_active_run", "session has an active run; cancel it before deleting", await refusalOccupantOf(deps.runStore, result.active));
                 return;
             }
             if ("inProgress" in result) {

package/dist/http/routes/tasks.js

@@ -1,7 +1,7 @@
 import { redactErrorMessage, redactHead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { runWithVerification, runCascade, taskNotificationDedupKey, uuidv7 } from "@sema-agent/core";
 import { heldFor } from "../../peer-seat.js";
-import { beatRunHeartbeat, createRunAnchorWriter, graftParkToolCallId, heldParkOf, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, settleResumeAnchor, TurnAnchorCapture, HEARTBEAT_MS } from "../../runs.js";
+import { beatRunHeartbeat, createRunAnchorWriter, graftParkToolCallId, heldParkOf, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, TurnAnchorCapture, HEARTBEAT_MS } from "../../runs.js";
 import { commitParkRow } from "../../park-row-commit.js";
 import { atHostBoundary, failureCodeOf, sealResultForExit, outwardPlane } from "../../terminal.js";
 import { voidVerifierPauseCard } from "../../verifier-pause-card.js";
@@ -172,7 +172,7 @@ export async function handleTasks(req, res, match, ctx) {
             };
             const assembleApprovalLeg = (streamApprovalOn) => resolveApprovalLeg({ ...approvalLegInput(streamApprovalOn), nowMonotonicMs: performance.now() });
             const principal = prepared.auth?.subject;
-            const wiringOperatorFace = explicitOperatorOk(gatedPerson(req, deps.config), deps.config);
+            const wiringOperatorFace = explicitOperatorOk(gatedPerson(req, deps.config), deps.config, "operate");
             let wiringReceipt;
             const instructionLeg = createInstructionSelectionLeg();
             const legWiringSections = () => ({ instructions: instructionLeg.segment(), skills: prepared.legFacts?.skills });
@@ -236,7 +236,6 @@ export async function handleTasks(req, res, match, ctx) {
                     onDisconnect();
                 const replayGate = resolveStreamApprovalGate({
                     toolApprovalEnabled: Boolean(deps.toolApproval),
-                    streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                     backend: deps.backend,
                     checkpointStore: deps.checkpointStore,
                 });
@@ -291,25 +290,6 @@ export async function handleTasks(req, res, match, ctx) {
                     let durableLegId;
                     let durableHeartbeat;
                     const cancelledResult = (errorMessage, cause) => mintCancelledResult({ taskId: durableTaskId ?? "", sessionId: prepared.spec.sessionId, startedAtMs: streamLegStartedAt, message: errorMessage, cause });
-                    let userMsgEntryId;
-                    const promptCommit = createPromptCommitReader();
-                    let anchorPut = false;
-                    const putRewindAnchor = async () => {
-                        const entryId = userMsgEntryId;
-                        const write = createRunAnchorWriter({
-                            seat: deps.backend?.landedAttendants(),
-                            sessionId: prepared.spec.sessionId,
-                            owner: principal ?? null,
-                            promptKey: durableTaskId,
-                            witness: prepared.legFacts?.sessionWitness,
-                            occupantOf: sessionOccupantReadOf(deps.sessionStorage),
-                            leafOf: undefined,
-                        }).prompt;
-                        if (anchorPut || !entryId || write === undefined)
-                            return;
-                        anchorPut = true;
-                        await settleResumeAnchor((held) => write(entryId, held), { leg: "stream", kind: "prompt" });
-                    };
                     try {
                         if (deps.runStore) {
                             const tid = earlyDurableTid ?? uuidv7();
@@ -526,15 +506,32 @@ export async function handleTasks(req, res, match, ctx) {
                                     steerableRuns.set(durableTaskId, liveStream);
                                 prepared.acceptance.attachStream({ reachable: () => !closed && !res.writableEnded && !res.destroyed, write: (frame) => writeLiveFrame(res, { ...frame }) });
                                 const liveWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), prepared.legFacts?.sessionWitness);
+                                const anchor = new TurnAnchorCapture(undefined, "stream", createRunAnchorWriter({
+                                    seat: deps.backend?.landedAttendants(),
+                                    sessionId: prepared.spec.sessionId,
+                                    owner: principal ?? null,
+                                    promptKey: durableTaskId,
+                                    witness: prepared.legFacts?.sessionWitness,
+                                    occupantOf: sessionOccupantReadOf(deps.sessionStorage),
+                                    leafOf: undefined,
+                                }).prompt);
                                 for await (const ev of liveStream) {
                                     if (closed)
                                         break;
                                     for (const f of ev.type === "done" ? [...childText.cut(), ...topText.cut()] : topText.onEvent(ev))
                                         writeLiveFrame(res, f);
-                                    const promptEntryId = promptCommit(ev);
-                                    if (promptEntryId !== undefined)
-                                        userMsgEntryId = promptEntryId;
                                     const causeAtDone = ev.type === "done" ? ac.cause() : undefined;
+                                    switch (ev.type) {
+                                        case "human_input":
+                                            anchor.onHumanInput(ev);
+                                            break;
+                                        case "message_committed":
+                                            await anchor.onMessageCommitted(ev.role, ev.entryId);
+                                            break;
+                                        case "turn_end":
+                                            await anchor.onTurnEnd();
+                                            break;
+                                    }
                                     await deps.userInputLedger?.observeLegEvent(liveStream, ev);
                                     await prepared.acceptance.observe(ev);
                                     if (ev.type === "done")
@@ -552,7 +549,6 @@ export async function handleTasks(req, res, match, ctx) {
                                         }
                                         finalizeTaskResult(ev.result, principal, prepared.spec.objective);
                                         noteRunOutcome(finalResult);
-                                        await putRewindAnchor();
                                         if (!(durableTaskId && deps.runStore && deps.checkpointStore && heldCard !== undefined))
                                             settleFleet(outwardPlane(finalResult.terminal).status, fleetRunResiduals(finalResult, failureCodeOf(finalResult.terminal)));
                                         if (ledgerSink && finalResult) {
@@ -694,7 +690,6 @@ export async function handleTasks(req, res, match, ctx) {
                             : withElicit();
                         const streamApprovalOn = resolveStreamApprovalGate({
                             toolApprovalEnabled: Boolean(deps.toolApproval),
-                            streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
                             backend: deps.backend,
                             checkpointStore: deps.checkpointStore,
                         }).active;
@@ -708,14 +703,10 @@ export async function handleTasks(req, res, match, ctx) {
                                 abortSignal: ac.signal,
                                 sessionId: prepared.spec.sessionId,
                                 ...approvalLegOriginOf(prepared.execution),
-                                ...(streamApprovalOn
-                                    ? {
-                                        family: "approval_request",
-                                        transport: hitlTransport,
-                                        legKey: "",
-                                        ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}),
-                                    }
-                                    : { family: "tool_approval", transport: hitlTransport }),
+                                family: "approval_request",
+                                transport: hitlTransport,
+                                legKey: "",
+                                ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}),
                             }
                             : undefined;
                         if (deps.toolApproval) {
@@ -727,7 +718,8 @@ export async function handleTasks(req, res, match, ctx) {
                                     taskId: askTaskId,
                                     sessionId: prepared.spec.sessionId,
                                     ...approvalLegOriginOf(prepared.execution),
-                                    ...(streamApprovalOn ? { legKey: "", ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}) } : {}),
+                                    legKey: "",
+                                    ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}),
                                 });
                         }
                         const withApproval = () => approvalCtx && deps.toolApproval ? deps.toolApproval.runWithContext(approvalCtx, withQuestion) : withQuestion();
@@ -755,7 +747,6 @@ export async function handleTasks(req, res, match, ctx) {
                                 await releaseKeyIfZeroWorkRefusal(deps.runStore, durableTaskId, finalResult);
                             }
                             else {
-                                await putRewindAnchor();
                                 const pending = await deps.checkpointStore?.findPendingTokenBySession(prepared.spec.sessionId, undefined, { axis: "run" });
                                 const dcCause = ac.cause();
                                 if (pending) {

package/dist/http/routes/workflows.js

@@ -192,7 +192,7 @@ export async function handleWorkflowAgentSteer(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);
+        const trusted = explicitOperatorOk(principal, deps.config, "operate");
         const wfVerdict = await judgeWorkflowRun(steerEntry, runs.store, wfRunId);
         if (wfVerdict === "session_mismatch") {
             refuse(steerEntry, res, "session_mismatch");

package/dist/http/server.d.ts

@@ -169,11 +169,12 @@ export interface ServiceCoreDeps {
      * `GET /v1/sessions/:id/mcp` 与 `…/a2a` 两张会话面板 —— 的场景名都由它给,**点名与缺席都问**:点名 ⇒ 判在册 / allowlist,
      * 拒体(400 `scenario_unknown` 附在册词表 / 400 `scenario_not_allowed` 附 allowlist)与任务提交腿逐字同;缺席 ⇒ 指派链(中心 ruling 胜者,
      * 否则部署缺省),与这位主体 run 时同一读法(指派悬空 ⇒ 503 `state.scenario_assignment_unknown`,同提交腿)。中心配了却答不出这位主体的裁定 ⇒
-     * 点名与缺席同答 503 `state.scenario_assignment_unavailable`(同提交腿)。
+     * 点名与缺席同答 503 `state.scenario_assignment_unavailable`(同提交腿)。门的答是 `{ scenario, source }`(`ScenarioChoice`):上面三张面只取名字,
+     * `GET /v1/capabilities/scenario` 把整只答原样交给客户端(这次请求会生效哪只场景、它从哪一层来)—— 名字与来层只有门这一处铸。
      * 读面上这只门走**只读腿**(`createScenarioGate(…, "peek")`):问中心裁定时 center 抖动的那一拍,不替这个主体的真提交留下 fail-closed 降级项
      * (提交腿自己是 `"enforce"`)。
      * 🔴 **必填**:读口的场景名只有这一个来源,没有「缺接缝 ⇒ 读部署缺省 / 点名 404」这类第二种读法 —— 漏接是**编译错**(嵌入方自己装配时,工厂与它的型从包根导出:
-     * `createScenarioGate` / `ScenarioGate` / `ScenarioGateLeg` / `ScenarioGateSources`)。
+     * `createScenarioGate` / `ScenarioGate` / `ScenarioGateLeg` / `ScenarioGateSources` / `ScenarioChoice` / `ScenarioSource`)。
      */
     scenarioGate: import("../capabilities/scenarios.js").ScenarioGate;
     /**
@@ -321,7 +322,7 @@ export interface ServiceCoordinatorDeps {
     question?: QuestionCoordinator;
     /** [ref]/[ref]②: live tool-approval coordinator (core onAsk → CC three-choice card). Set when
      *  TOOL_APPROVAL_ENABLED. Wired onto the runner's onAsk seam AND consumed here by
-     *  `POST /v1/tool-approvals/:id/respond` + the per-run ALS wrap on the SYNC streaming leg (live-only by design —
+     *  the ask decision door (`POST /v1/tasks/:taskId/asks/:askId/decision`) + the per-run ALS wrap on the SYNC streaming leg (live-only by design —
      *  every other leg keeps core's fail-closed headless auto-deny, [ref]⑤/[ref]④). */
     toolApproval?: ToolApprovalCoordinator;
     /** [ref] 裁 (c) 审计半场:local 车道的 File ask **审计**读面(`GET /v1/approvals` 的 additive 键
@@ -944,6 +945,11 @@ export declare function createHttpServer(rawDeps: ServiceDeps): http.Server & {
     sessionNotifyDoor: SessionNotifyDoor;
     /** run 收场送达的转交(装配层把它接进 workflow 编排面完成送达的晚绑座;律见 `resume-legs.ts` 的 `handOverRunEndedDecisions`)。 */
     handOverRunEndedDecisions: (runId: string) => Promise<void>;
+    /**
+     * 本机控制 socket 那只 `http.Server`(建而不听):与本 server 同一只请求监听器,进门打通道标 `control-socket`(`request-channel.ts`),不挂设备 WS 的 upgrade 监听器。
+     * 开口(判 + 听)只经 `control-socket.ts` 的 `openControlSocket`;起服第 10 段在 TCP listen 之后开、收尾链与本 server 一起关。嵌入方不开 ⇒ 面缺席。
+     */
+    controlSocketServer: http.Server;
 };
 /** SSE: replay durable events after Last-Event-ID, then tail until the run is terminal (or stale). */
 /**

package/dist/http/server.js

@@ -1,5 +1,6 @@
 import http from "node:http";
 import { outwardPlane } from "../terminal.js";
+import { markControlSocketRequest } from "./request-channel.js";
 import { validatePendingSteer } from "@sema-agent/core";
 import {} from "../web-admin-client/facade.js";
 import { describeValueShape } from "@sema-agent/settings-schema";
@@ -28,7 +29,7 @@ import { parkDecisionStoreRefusal } from "../orchestration/workflow-park-decisio
 import { CHECKPOINT_CTX_SEALING_REQUIRED } from "./checkpoint-ctx.js";
 import { SERVING_LEASE_MEMBERSHIP_REQUIRED } from "../fleet/engine-signal.js";
 import { PARKED_REVIVE_EXECUTION_SEAT_REQUIRED } from "../parked-decide.js";
-import { a2aAudienceVerifiedSourceRefusal, operatorDeclarationRefusal } from "../config-invariants.js";
+import { a2aAudienceVerifiedSourceRefusal, operatorDeclarationRefusal, operatorRosterWellFormedRefusal } from "../config-invariants.js";
 import { retiredServiceDepsRefusal } from "./retired-service-deps.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
@@ -94,6 +95,12 @@ export function createHttpServer(rawDeps) {
             throw new Error(operatorDeclarationFailure);
         }
     }
+    {
+        const rosterFailure = operatorRosterWellFormedRefusal(deps.config);
+        if (rosterFailure !== undefined) {
+            throw new Error(rosterFailure);
+        }
+    }
     {
         const bridgeDeclared = configuredIdentitySources(deps.config).includes("sso");
         const verifierWired = deps.webAdminJwtVerifier !== undefined;
@@ -229,7 +236,7 @@ export function createHttpServer(rawDeps) {
     const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, decisionRowAdmits, resumePreempted, startFreshHostTurn, resumeWake, sessionNotifyDoor, handOverRunEndedDecisions } = createResumeLegs({ deps, runnerFor, idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints, counters, readJson, readRawBody, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, usageWindowDenied, admitRun, safeDecode, prepareSpec, finalizeTaskResult, ownerCostQuotaDenied, ownerFleetLeaseDenied, usageWindowDenialFor });
     const { denyExpiredApprovals, redeemParkedAsk } = createApprovalSweeps({ deps, resumeCheckpoint, decisionRowAdmits });
     const { handle } = createDispatch({ deps, noteActivity, routeCtxBase, counters });
-    const server = http.createServer((req, res) => {
+    const onRequest = (req, res) => {
         attachResponseLogger(res, deps.logger);
         void handle(req, res).catch((err) => {
             if (err instanceof HttpError) {
@@ -258,6 +265,11 @@ export function createHttpServer(rawDeps) {
             }
             sendOpenFaceFault(res, err);
         });
+    };
+    const server = http.createServer(onRequest);
+    const controlSocketServer = http.createServer((req, res) => {
+        markControlSocketRequest(req);
+        onRequest(req, res);
     });
     const deviceLane = facts.deviceLane(deps);
     if (deviceLane.available)
@@ -289,6 +301,6 @@ export function createHttpServer(rawDeps) {
         deps.planCacheProbe?.record(principal, objective, result.terminal.kind === "completed");
     }
     const isRunLiveOnThisReplica = (taskId) => liveRunIdsOf(inflightRuns, steerableRuns).has(taskId);
-    return Object.assign(server, { denyExpiredApprovals, isRunLiveOnThisReplica, redeemParkedAsk, sessionNotifyDoor, handOverRunEndedDecisions });
+    return Object.assign(server, { denyExpiredApprovals, isRunLiveOnThisReplica, redeemParkedAsk, sessionNotifyDoor, handOverRunEndedDecisions, controlSocketServer });
 }
 //# sourceMappingURL=server.js.map

package/dist/http/submit-ctx.d.ts

@@ -40,7 +40,7 @@ export declare function persistSubmitCtx(store: SubmitCtxStore, deps: {
  * 提交腿写续跑输入的入口(三个调用点同调这一只):体与标记按受理座提交时交出的那一份定(见文件头「体里的目标按哪一份写」),只写这一笔。
  * 写不进的处置与答复 = {@link persistSubmitCtx}(本函数只定体、不另判)。
  */
-export declare function persistSubmissionCtx(store: SubmitCtxStore, deps: Parameters<typeof persistSubmitCtx>[1], claim: Parameters<typeof persistSubmitCtx>[2], prepared: Pick<PreparedTaskSubmission, "body" | "auth" | "verify" | "acceptance" | "bodyFromScreenedCtx"> & Partial<Pick<PreparedTaskSubmission, "legFacts">> & {
+export declare function persistSubmissionCtx(store: SubmitCtxStore, deps: Parameters<typeof persistSubmitCtx>[1], claim: Parameters<typeof persistSubmitCtx>[2], prepared: Pick<PreparedTaskSubmission, "body" | "auth" | "verify" | "acceptance" | "bodyFromScreenedCtx" | "bodyPermissionModeWrite"> & Partial<Pick<PreparedTaskSubmission, "legFacts">> & {
     readonly spec: Pick<PreparedTaskSubmission["spec"], "sessionId" | "model">;
 }): Promise<SubmitCtxRefusal | typeof SUBMIT_CTX_CLAIM_LOST | undefined>;
 //# sourceMappingURL=submit-ctx.d.ts.map

package/dist/http/submit-ctx.js

@@ -7,6 +7,7 @@ import { limitFactsUnmeasured } from "../limit-refusal.js";
 import { serviceVersion } from "../service-version.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { DEFAULT_MODEL_REF } from "../model-select.js";
+import { submissionPermissionModeWrite } from "../permission-mode-admission.js";
 const WITHHELD_OBJECTIVE = "";
 export function objectiveWithheldIn(ctx) {
     return ctx.promptScreened === true;
@@ -79,6 +80,7 @@ export async function persistSubmissionCtx(store, deps, claim, prepared) {
         ...(prepared.legFacts?.projectContext !== undefined ? { projectContext: prepared.legFacts.projectContext } : {}),
         ...(prepared.legFacts?.memorySeed !== undefined ? { memorySeed: prepared.legFacts.memorySeed } : {}),
         writerVersion: serviceVersion(),
+        permissionModeWrite: prepared.bodyPermissionModeWrite !== undefined ? prepared.bodyPermissionModeWrite.stored : submissionPermissionModeWrite(prepared.body),
     });
 }
 //# sourceMappingURL=submit-ctx.js.map