@sema-agent/server 7.150.0 → 7.152.0

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,8 +15,9 @@ 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, sessionOwnerUnchanged } from "../owner-access.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";
 import * as facts from "../../capability-facts.js";
 import { rosterAgentId } from "./agents-roster.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;
         }
     }
@@ -462,7 +473,7 @@ export async function handleSessions(req, res, match, ctx) {
                     }
                     ownerCheckPending = true;
                     ownerCheckStartedAt = Date.now();
-                    void sessionOwnerUnchanged(evEntry, evFact.sessionStorage, evSession, owner).then((same) => {
+                    void sessionOccupantUnchanged(evEntry, evFact.sessionStorage, evSession, evAdmitted.row).then((same) => {
                         ownerCheckPending = false;
                         if (!closed && !same)
                             onEnd();
@@ -592,7 +603,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendJson(res, 200, {
                     sessionId,
                     autoConsolidationArmed: deps.memoryAutoConsolidationArmed,
-                    ...(deps.memorySyncLeg !== undefined ? { memorySync: { parked: deps.memorySyncLeg.parked().map((p) => ({ scope: p.scope, wayOut: p.wayOut })) } } : {}),
+                    ...(deps.memorySyncLeg !== undefined ? { memorySync: { parked: deps.memorySyncLeg.parked() } } : {}),
                     ...(s.captureOptedOut !== undefined ? { captureOptedOut: s.captureOptedOut } : {}),
                     ...(s.committedCount !== undefined ? { committedCount: s.committedCount } : {}),
                     ...(s.foldedCount !== undefined ? { foldedCount: s.foldedCount } : {}),
@@ -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) {
@@ -905,7 +916,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.session_store_required", "session policy requires a session-store backend");
                 return;
             }
-            const store = policyFact.policyStore;
+            const store = policyFact.backend.sessionPolicy();
             const policyEntry = enter(req, res, deps, match.decl.id);
             if (policyEntry === undefined)
                 return;
@@ -947,8 +958,12 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const rules = read.rules;
             try {
-                const stored = await store.putRules(sessionId, target, rules, { ...(typeof body.expectedRev === "number" ? { expectedRev: body.expectedRev } : {}), operator });
-                sendJson(res, 200, { rules: stored });
+                const stored = await policyFact.backend.landedAttendants().putPolicy(sessionId, sessionFaceOfHead(sessionId, policyAdmitted.row), target, rules, { ...(typeof body.expectedRev === "number" ? { expectedRev: body.expectedRev } : {}), operator });
+                if (!stored.landed) {
+                    refuse(policyEntry, res, "missing");
+                    return;
+                }
+                sendJson(res, 200, { rules: stored.value });
             }
             catch (e) {
                 if (sendSessionPolicyError(res, e))

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, 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";
@@ -22,7 +22,7 @@ import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEve
 import { cascadeConfig, fillRunPreviewOnDelivery, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { answerReplay, isReplayedOutcome, replayedOutcome, replayOfExistingRun } from "../submit-replay.js";
-import { readReplayHit, runFactsOf } from "../owner-access.js";
+import { readReplayHit, runFactsOf, sessionOccupantReadOf } from "../owner-access.js";
 import { httpErrorCode, sendJson, sseHeaders } from "../send.js";
 import { collectSsePreamble } from "../sse-log.js";
 import { buildApprovalPreamble } from "../../approval-card.js";
@@ -33,7 +33,7 @@ import { SUBMISSION_CLAIM_FACE, commitExecutionContext, faultedAnswerOf } from "
 import { rootSessionAbsentAnswer } from "../execution-context.js";
 import { recheckClaimBeforeLaunch, startClaimHeartbeat } from "../claim-heartbeat.js";
 import { timeClaim } from "../claim-latency.js";
-import { commitSessionInheritEnv } from "../session-inherit-env.js";
+import { commitLegBindings } from "../../session-bindings.js";
 import { headerStr, gatedPerson, gatedSubject, explicitOperatorOk, runIdentityOf } from "../principal-gate.js";
 import { recoveredSubject } from "../../owner-faces.js";
 import { recordFailOpen } from "../../observability/fail-open.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,18 +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 store = deps.resumeAnchorStore;
-                        const key = durableTaskId;
-                        const entryId = userMsgEntryId;
-                        if (anchorPut || !entryId || !key || !store)
-                            return;
-                        anchorPut = true;
-                        await settleResumeAnchor(() => store.put(prepared.spec.sessionId, key, entryId, principal ?? null), { leg: "stream", kind: "prompt" });
-                    };
                     try {
                         if (deps.runStore) {
                             const tid = earlyDurableTid ?? uuidv7();
@@ -358,7 +345,7 @@ export async function handleTasks(req, res, match, ctx) {
                         writeTerminalFrame(doneFrameOfOutcome(claimFault));
                         return claimFault;
                     }
-                    commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
+                    commitLegBindings(deps, prepared.seat, prepared.spec.sessionId, prepared.legFacts?.sessionBindings);
                     markChildrenStoppedByUserOnAbort(ac.signal, durableTaskId ?? prepared.spec.sessionId, prepared.auth?.subject);
                     let ledgerSink;
                     let ledgerTerminal = false;
@@ -519,19 +506,36 @@ 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")
-                                        prepared.acceptance.settle(ev.result);
+                                        await prepared.acceptance.settle(ev.result);
                                     await liveWorkspace.observe(ev);
                                     if (ledgerSink)
                                         await manifestSeat?.drain(ledgerSink.append);
@@ -545,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) {
@@ -687,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;
@@ -701,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) {
@@ -720,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();
@@ -748,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) {
@@ -939,7 +937,7 @@ export async function handleTasks(req, res, match, ctx) {
                     catch (e) {
                         return faultedAnswerOf(e, SUBMISSION_CLAIM_FACE.faulted);
                     }
-                    commitSessionInheritEnv(deps, prepared.spec.sessionId, prepared.body);
+                    commitLegBindings(deps, prepared.seat, prepared.spec.sessionId, prepared.legFacts?.sessionBindings);
                     const syncCancelCtrl = createRunAbort(principal ?? null);
                     markChildrenStoppedByUserOnAbort(syncCancelCtrl.signal, durableTaskId ?? prepared.spec.sessionId, prepared.auth?.subject);
                     if (durableTaskId && deps.runStore) {
@@ -975,15 +973,22 @@ export async function handleTasks(req, res, match, ctx) {
                     counters.uncountedBillableInflight++;
                     try {
                         const heldDecisions = await heldWorkflowParkDecisions(deps, prepared.spec.sessionId);
-                        const compositionInternals = { ...heldDecisions, ...compositionLegRoot(prepared.legFacts?.registeredCwd) };
+                        const compositionInternals = { ...heldDecisions, ...compositionLegRoot(prepared.legFacts?.sessionBindings.cwd) };
                         const verifyLeg = (v) => runWithVerification(prepared.runner, specWithSignal, v, compositionInternals);
                         const cascadeLeg = () => runCascade(prepared.runner, specWithSignal, cascadeConfig(deps.config.cascadeLadder, prepared.spec.limits?.maxCostUsd), compositionInternals);
                         const plainLeg = async () => {
                             const stream = prepared.runner.runTaskStream(specWithSignal, undefined, heldDecisions);
                             const syncWorkspace = createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), prepared.legFacts?.sessionWitness);
-                            const anchorKey = durableTaskId;
-                            const anchorStore = deps.resumeAnchorStore;
-                            const anchor = new TurnAnchorCapture(undefined, "sync", anchorStore && anchorKey ? async (entryId) => { await anchorStore.put(prepared.spec.sessionId, anchorKey, entryId, principal ?? null); } : undefined);
+                            const anchorWriter = createRunAnchorWriter({
+                                seat: deps.backend?.landedAttendants(),
+                                sessionId: prepared.spec.sessionId,
+                                owner: principal ?? null,
+                                promptKey: durableTaskId,
+                                witness: prepared.legFacts?.sessionWitness,
+                                occupantOf: sessionOccupantReadOf(deps.sessionStorage),
+                                leafOf: undefined,
+                            });
+                            const anchor = new TurnAnchorCapture(undefined, "sync", anchorWriter.prompt);
                             for await (const ev of stream) {
                                 observeSyncLegEvent(ev);
                                 switch (ev.type) {
@@ -1040,18 +1045,18 @@ export async function handleTasks(req, res, match, ctx) {
                     const syncPlane = outwardPlane(result.terminal);
                     const syncHeld = heldParkOf(result);
                     if (syncHeld !== undefined && deps.checkpointStore && deps.runStore && durableTaskId) {
+                        await prepared.acceptance.settle(result);
                         const parked = await commitParkRow({
                             runStore: deps.runStore, taskId: durableTaskId, word: syncHeld.word, result: exitResult, card: { token: syncHeld.token, sessionId: prepared.spec.sessionId }, cards: deps.checkpointStore, leg: "sync",
                             legId: heldLegOf(durableLegId, durableTaskId), staleWindowMs: deps.config.runStaleSec * 1000,
                         });
-                        prepared.acceptance.settle(result);
                         if (parked.kind === "ended")
                             return { status: 200, body: withSyncSubmitKeys(parked.row !== undefined ? syncSubmitBodyOfRow(parked.row) : { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "failed" }) };
                         return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult, { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: syncHeld.word })) };
                     }
+                    await prepared.acceptance.settle(result);
                     if (durableTaskId && deps.runStore)
                         await deps.runStore.setTerminal(durableTaskId, syncPlane.status, exitResult, syncPlane.errorMessage ?? null);
-                    prepared.acceptance.settle(result);
                     finalizeTaskResult(result, principal, prepared.spec.objective);
                     noteRunOutcome(result);
                     return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult)) };

package/dist/http/routes/trace-usage.js

@@ -9,7 +9,7 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { filterFingerprint } from "../cursor-fingerprint.js";
 import { sendUnauthorized } from "../principal-gate.js";
-import { admitRunById, enter, entryIsFleet, listVisibleRuns, readVisibleRun, routeListFilter, runListOwnerOf, toolResultRefOwned } from "../owner-access.js";
+import { admitRunById, enter, entryIsFleet, listVisibleRuns, readVisibleRun, routeListFilter, listOwnerOf, toolResultRefOwned } from "../owner-access.js";
 import { listFilterOf } from "../../owner-faces.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -166,7 +166,7 @@ async function handleTaskList(res, runStore, query, filter) {
     const jobId = query.get("jobId") ?? undefined;
     const source = query.get("source") ?? undefined;
     const namedOwner = query.get("owner") ?? undefined;
-    const owner = runListOwnerOf(filter, namedOwner);
+    const owner = listOwnerOf(filter, namedOwner);
     const limit = Math.min(100, Math.max(1, Number(query.get("limit") ?? 50) || 50));
     const f = filterFingerprint([status, jobId, source, owner]);
     const cursor = decodeCursor(query.get("cursor"), f);

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

@@ -1,10 +1,11 @@
 import http from "node:http";
 import type { MemoryComplianceFaces, MemoryOriginFaces, SessionMemoryStatusFace } from "../memory-operator-faces.js";
 import type { SideQueryAccounting } from "../budget.js";
-import type { SessionPurgeOutcome } from "../session-deletion.js";
+import type { SessionAgeOutExpectation, SessionPurgeOutcome } from "../session-deletion.js";
 import type { IncomingMessage } from "node:http";
 import { type Runner, type RunnerDeps, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
 import type { ProjectContext } from "../project-context.js";
+import type { MemorySeed } from "../project-registry.js";
 import type { TaskRequestBody } from "./wire-types.js";
 import type { ServiceConfig } from "../config-types.js";
 import { type SessionMirrorRuling } from "../web-admin-client/facade.js";
@@ -12,7 +13,7 @@ import type { RestartSignal } from "@sema-agent/settings-schema/fleet";
 import { type AuthorizeInput, type OwnerAwareSessionStore } from "../security.js";
 import type { PeerDesk, PeerLease } from "../peer-seat.js";
 import type { ExecutionRoot, ResolvedTaskSpec } from "./execution-context.js";
-import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ResumeAnchorStore, ApprovalExemptionStore, ApprovalNonceStore, ServiceSessionPolicyStore, ServiceFileHistoryStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
+import type { RunStore, ImageIndex, ImageBake, CheckpointStoreFull, ApprovalExemptionStore, ApprovalNonceStore, ToolResultStoreFull, StoreBackend } from "../plugins/store-backend.js";
 import type { RuleConsentLane } from "../rules-consent.js";
 import { type MemorySyncAnswer, type MemorySyncRequest } from "../memory-sync.js";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
@@ -58,9 +59,9 @@ export interface RequestAuth {
     sessionId: string;
     memoryScope?: string;
     /** 142-S4:the SHAPE-VALIDATED **且已归一(小写)** 的 `body.projectId`(authorizer 的 core
-     *  `PROJECT_ID_REGEX` 门通过后折小写回传;[ref]/[ref] 宽读严写)。main.ts 拿它查 config.projects 的
-     *  defaultScopes(memory.scopes 种子)。resume 腿(checkpoint 重建 auth)缺席 — 回落持久化的
-     *  body.projectId(原始提交已验形),那条回落腿自己再折一次小写,两腿查同一个键。 */
+     *  `PROJECT_ID_REGEX` 门通过后折小写回传;[ref]/[ref] 宽读严写)。装配器拿它判 memory.scopes 种子项目(对提交者可见才算,
+     *  `project-registry.ts`)与这条腿的项目。resume 腿(checkpoint 重建 auth)缺席 — 项目回落持久化的
+     *  body.projectId(原始提交已验形,那条回落腿自己再折一次小写);种子不回落,读冻结的种子项目。 */
     resolvedProjectId?: string;
     /** authorizer 判过的头(`security.ts` `createAuthorizer` 交出;语义见 `AuthContext.head`)⇒ fresh 执行上下文的 `judged`。自建 authorizer 不给 = 解析器不比住客。 */
     head?: import("@sema-agent/core").SessionHead;
@@ -133,7 +134,9 @@ export interface ServiceCoreDeps {
      *  装配器在**全部折叠之后**经首跑同一只合并口 `withUnattendedLeg` 重挂那条腿(`default` + 按类作答的 onAsk)。只由续跑腿
      *  按服务端写的 ctx 位递,绝不从请求体读。
      *  `opts.projectContext`(项目上下文继承):续跑家族把提交腿冻结的那一份(`CheckpointCtx.projectContext`,服务端写)原样递回 —— 装配器在续跑腿上只重放它、不读登记簿;
-     *  新提交腿不递(装配器自己在头部判)。同样只由续跑腿按服务端写的 ctx 位递,绝不从请求体读。 */
+     *  新提交腿不递(装配器自己在头部判)。同样只由续跑腿按服务端写的 ctx 位递,绝不从请求体读。
+     *  `opts.memorySeed`(登记簿默认读层种子):续跑家族把提交腿冻结的种子(`CheckpointCtx.memorySeed`:种子项目 + 判出它的那一位观者,服务端写)原样递回 —— 装配器在续跑腿上
+     *  只认它(以冻结的观者经同一只可见性判读此刻的登记)、不推观者、不按存体的 `projectId` 现查;新提交腿不递(装配器自己在头部判)。只由续跑腿按服务端写的 ctx 位递,绝不从请求体读。 */
     /** `opts.execution`(必填):这条腿的执行上下文(`http/execution-context.ts`;只 `fresh` / `continuation` 两形,`root` 恒在)。装配器要用这条腿的根会话
      *  (场景设施的分区键、受理见证)读 `opts.execution.root` —— 它与 server 随后盖进 spec 的根是同一个值,装配器自己不写根。 */
     /** `opts.lease`(必填):这条腿的**宿主租约** —— 装配在它之下登记本腿交给引擎的对端声明(`peerDesk.declare(草稿, opts.lease)`)。
@@ -145,6 +148,7 @@ export interface ServiceCoreDeps {
         onNotice?: (notice: EngineNotice) => void;
         unattendedLeg?: true;
         projectContext?: ProjectContext;
+        memorySeed?: MemorySeed | null;
         lease: PeerLease;
         execution: ExecutionRoot;
     }) => ResolvedTaskSpec | Promise<ResolvedTaskSpec>;
@@ -165,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;
     /**
@@ -196,9 +201,6 @@ export interface ServiceCoreDeps {
 export interface ServiceStoreDeps {
     /** Durable async-run registry + event log (S1/S2). Enables /v1/runs when present. */
     runStore?: RunStore;
-    /** E18 resume-at: the eventId→entryId anchor map (tidb/pg/local). Present whenever a backend is — resolveSpec
-     *  resolves body.resumeAt(eventId)→entryId, the run lifecycle captures per-turn anchors, E21 purges them. */
-    resumeAnchorStore?: ResumeAnchorStore;
     /** Per-session approval exemption store — enables decide body `remember:"session"` + the
      *  exemptions list/revoke surfaces on /v1/approvals. The ask-gate probe is wired separately (main.ts). */
     approvalExemptionStore?: ApprovalExemptionStore;
@@ -215,9 +217,6 @@ export interface ServiceStoreDeps {
      *  封不了就不落,没有「明文照写」的第二种装配。嵌入方:`checkpointCtxSealing: await ensureCheckpointCtxSealing(sealedKeyDir)`
      *  (保管目录要跨重启持久、多副本各副本是同一份钥匙,否则封它的那把钥匙不在 ⇒ 409 `conflict.checkpoint_ctx_unsealable` `reason:"key_not_held"`)。 */
     checkpointCtxSealing?: import("./checkpoint-ctx.js").CheckpointCtxSealing;
-    /** E6 durable SessionPolicyStore (operator-tightened per-session tool rules). Enables PUT/GET /v1/sessions/:id/policy
-     *  when present; core reads the rules at prepare-time (subtract-only) via RunnerDeps.sessionPolicyStore (wired separately). */
-    sessionPolicyStore?: ServiceSessionPolicyStore;
     /** [ref] tool-results 读面([ref] 请求,core [ref] `buildToolResultRef` 到货):`GET /v1/tasks/:id/
      *  tool-results/:ref` 的数据源 —— 与 RunnerDeps 侧的 offload 店**同实例**(main.ts 的 `toolResultStore`,
      *  即「durable 后端在场」那一只;无 backend 部署里 Runner 用的内存兜底 `runnerOffloadStore` **不接**这里)。
@@ -225,14 +224,6 @@ export interface ServiceStoreDeps {
      *  与 unknown-ref / 归属不符两臂**同形** 404 才是防 oracle 的收口([ref] 的「另定」项按防 oracle 收紧)。
      *  这是本组「absent ⇒ 501 诚实缺席」通例的**唯一具名例外**,例外理由即上一句。 */
     toolResultStore?: ToolResultStoreFull;
-    /** [ref] per-edited-file rewind history store. Present ⇒ the rewind capabilities are advertised; core uses it
-     *  via RunnerDeps.fileHistoryStore (first-touch tracking + per-turn boundaries + tracked-set restore, ANY
-     *  env). Also the 2c history-transfer store (exportHistory/importHistory + blob negotiation faces).
-     *  🔴 [ref]:这是装配单点 `assembleFileHistory` 的**店**(后端在即在,与 `FILE_HISTORY_CAPTURE` 无关 —— 旋钮只关捕获,
-     *  落在 core 的 `RunnerDeps.fileHistoryCapture` 上)。rewind 族四位与 2c sync 路由族跟它走;能力词 `fileHistoryCapture`
-     *  = `fileHistoryCaptureOf(本键, config.fileHistoryCapture)`(与 core 捕获位同一只判定)。
-     *  擦除(E21 / 孤儿 blob GC)不读本键,读 boot 侧的擦除脸。 */
-    fileHistoryStore?: ServiceFileHistoryStore;
     /** D-1 通用文件上传(clay 拍 2026-07-27:独立附件 store,不骑 snapshot blob 面):enables
      *  POST/GET/DELETE /v1/attachments*。缺席 ⇒ 501(与其他可选 store 面同姿)。绑定/物化半场在
      *  main.ts(resolveSpec + env factory 包装);本面只管上传/取回/删除三动词 + server 权威上限。 */
@@ -331,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 键
@@ -423,11 +414,11 @@ export interface ServiceSeamDeps {
      */
     deviceEnrollment?: import("../device-enrollment.js").DeviceEnrollment;
     /**
-     * [ref] × 7.106.0 合并复审 X1:host 车道会话登记簿的 `inheritEnv` **写口**(`boot/execution-env.ts` 的 `setSessionInheritEnv`)。
-     * 唯一调用者 = `http/session-inherit-env.ts` 的 `commitSessionInheritEnv`(四个 run 认领点在认领之后调;判据与残余见那只文件)。
-     * 缺席 = 本部署不是 host 车道(没有工厂读这一格)⇒ 提交点 no-op。装配 = `boot/stage-10-http-server.ts`(host 车道才给)。
+     * 会话登记簿的**绑定写座**(`boot/execution-env.ts` `createSessionScopedRegistries`:cwd / shellEnv / inheritEnv 三格写一笔、按回执撤一笔)。
+     * 唯一写者 = `session-bindings.ts` 的 `commitLegBindings`(四个 run 认领点在认领之后调);唯一撤回者 = 提交出口(`submission-exit.ts`,
+     * 写了之后才收场 `refused` 的提交)。律与残余见 `session-bindings.ts` 头注。缺席(夹具 / 嵌入方没接)= 没有登记簿 ⇒ 提交点 no-op。
      */
-    bindSessionInheritEnv?: import("./session-inherit-env.js").SessionInheritEnvCommitCtx["bindSessionInheritEnv"];
+    sessionBindings?: import("../session-bindings.js").SessionBindingSeat;
     /**
      * 会话登记簿四表(cwd / shellEnv / inheritEnv / 属主,`boot/execution-env.ts` `createSessionScopedRegistries` 的 `dropSessionOf`)按**住客**清掉一只 ——
      * 记下的住客恰是交来的化身才清、答 `true`。读者只有提交出口(`submission-exit.ts`):被拒提交铸下的会话撤回之后清(同 id 的下一位已登记、写下的条目不动)。
@@ -442,12 +433,14 @@ export interface ServiceSeamDeps {
     } & Record<string, unknown>) | undefined>;
     /** E21 删除协调器(会话三态 活 → 在删 → 没了,`session-deletion.ts`):删会话的对话史与服务自己的 run 账 / 检查点 / 卸载结果等全部挂靠行,一次调用。
      *  结局 = {@link SessionPurgeOutcome}(删了 / 不在 · 围栏判到认领 · 子代预检拒 · 被接管)。点亮 DELETE /v1/sessions/:id。 */
-    purgeSession?: (sessionId: string, owner: string | null) => Promise<SessionPurgeOutcome>;
+    purgeSession?: (sessionId: string, owner: string | null, opts?: {
+        readonly ageOut?: SessionAgeOutExpectation;
+    }) => Promise<SessionPurgeOutcome>;
     /** [ref]③(b): read a BACKGROUND agent-handle child's final report / current status out of the core
      *  TaskRegistry (the same face the TaskOutput tool reads — agent handles are NEVER in the run store).
      *  Wired in main.ts to `defaultTaskRegistry.pollTask` (non-blocking). Access is the REGISTRATION tuple:
      *  owner = the parent run's taskId (resume legs register children under the sessionId — the registry's
-     *  sessionScoped arm matches via `access.sessionId`), scope = the run's principal ?? "default". */
+     *  sessionScoped arm matches via `access.sessionId`), scope = the run owner's engine-identity cell (`engineScopeOfOwner`). */
     subagentTaskOutput?: (handle: string, access: {
         owner: string;
         scope: string;
@@ -724,7 +717,7 @@ export interface ServiceDeploymentDeps {
      */
     deploymentModPackages?: number;
     /**
-     * 会话 → 调用方登记的工作目录(提交体 `cwd` 的唯一写口 `setSessionCwd` 写的那一张进程内表,`boot/execution-env.ts` `createSessionScopedRegistries`)。
+     * 会话 → 登记的工作目录(受理的提交经绑定写座 {@link ServiceDeps.sessionBindings} 写的那一张进程内表,`boot/execution-env.ts` `createSessionScopedRegistries`)。
      * **只读**,读者只有 run 外回退口(`POST /v1/sessions/:id/rewind-files`):host 工厂按 `effectiveHostWorkspace(本表.get(会话), ctx)` 定根(`execution-env.ts`
      * host 臂),口在交引擎之前用**同一只函数、同一份入参**问「工厂这一次会不会落到一只用完即删的临时目录」—— 会 ⇒ 拒,不让台账说恢复了而项目没动。
      * 缺席(夹具 / 嵌入方没接)⇒ 读作「没有登记」⇒ host 车道上口拒(fail-closed)。
@@ -950,6 +943,13 @@ export declare function createHttpServer(rawDeps: ServiceDeps): http.Server & {
     redeemParkedAsk: ParkedAskRedeem;
     /** 会话通知门(装配层把它接进场景层后台完成 sink 的晚绑座;门与律见 `session-notify-door.ts`)。 */
     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;
@@ -226,10 +233,10 @@ export function createHttpServer(rawDeps) {
     const { quotaExceeded, ownerCostQuotaDenied, ownerFleetLeaseDenied, ownerLeaseDenied, ownerQuotaDenied, leaseDenied, usageWindowDenialFor, usageWindowDenied, rateLimited, safeDecode, readJson, readRawBody } = createRequestGuards({ deps });
     const { prepareSpec } = createAdmission({ deps, readJson, runnerFor });
     const { admitRun } = createRunConcurrencyGate({ deps, inflightRuns, steerableRuns });
-    const { routeCtxBase, resumeCheckpoint, driveResumeIntoRunLog, driveResumeLeg, decisionRowAdmits, resumePreempted, startFreshHostTurn, resumeWake, sessionNotifyDoor } = 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 { 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 });
+    return Object.assign(server, { denyExpiredApprovals, isRunLiveOnThisReplica, redeemParkedAsk, sessionNotifyDoor, handOverRunEndedDecisions, controlSocketServer });
 }
 //# sourceMappingURL=server.js.map