@sema-agent/server 7.149.0 → 7.151.0

package/dist/http/routes/sessions.js

@@ -14,8 +14,8 @@ 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 { headReadOf, leafOfAdmittedHead, sessionFaceOfHead } from "../../session-incarnation.js";
-import { admitSessionById, admitSessionRow, admittedAsFleet, callerEntry, callerOf, deliverVerdict, enter, judgeSessionRow, protocolEntry, readOwnerCell, refuse, seesRun, sessionRowPresent } from "../owner-access.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";
 import * as facts from "../../capability-facts.js";
 import { rosterAgentId } from "./agents-roster.js";
@@ -67,11 +67,9 @@ async function readLastLegMcp(deps, sessionId, entry) {
     const runStore = deps.runStore;
     if (!runStore || sessionId === null)
         return undefined;
-    const latest = await runStore.latestRunForSession(sessionId);
+    const latest = await readVisibleLatestRun(entry, runStore, sessionId);
     if (latest === undefined)
         return undefined;
-    if (!seesRun(entry, latest.owner))
-        return undefined;
     const events = await runStore.getEvents(latest.taskId, 0);
     for (let i = events.length - 1; i >= 0; i--) {
         const ev = events[i];
@@ -87,26 +85,7 @@ async function readLastLegMcp(deps, sessionId, entry) {
 export async function handleSessions(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, safeDecode } = ctx.helpers;
-    const readOwnedSessionView = async (entry, sessionAudit, sessionId, readOpts) => {
-        const headOf = headReadOf(deps.sessionStorage);
-        if (headOf !== undefined) {
-            const head = await readOwnerCell(entry, sessionId, () => headOf(sessionId));
-            if ((await admitSessionRow(entry, res, deps.sessionStorage, sessionId, head)) === undefined)
-                return undefined;
-        }
-        let audit;
-        try {
-            audit = await sessionAudit(sessionId, readOpts);
-        }
-        catch (e) {
-            if (headOf !== undefined)
-                throw e;
-            throw new Error(`session view read failed before ownership could be established: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
-        }
-        if ((await admitSessionRow(entry, res, deps.sessionStorage, sessionId, audit)) === undefined)
-            return undefined;
-        return audit;
-    };
+    const readOwnedSessionView = (entry, sessionAudit, sessionId, readOpts) => admitSessionView(entry, res, deps.sessionStorage, sessionAudit, sessionId, readOpts);
     const sse = ctx.local.sessions;
     const { mcpStatusCache, a2aStatusCache } = ctx.local.sessions;
     {
@@ -262,8 +241,8 @@ export async function handleSessions(req, res, match, ctx) {
     }
     {
         if (match.decl.id === "session-head") {
-            const headOf = headReadOf(deps.sessionStorage);
-            if (!headOf) {
+            const headFact = facts.sessionOwnership(deps);
+            if (!headFact.available) {
                 sendError(res, 501, "capability.session_store_required", "session head probe requires a durable session store (DB_BACKEND=mysql|pg|local)");
                 return;
             }
@@ -273,8 +252,7 @@ export async function handleSessions(req, res, match, ctx) {
                 return;
             }
             const headEntry = callerEntry(req, deps, match.decl.id);
-            const headRead = await readOwnerCell(headEntry, headSession, () => headOf(headSession));
-            const admittedHead = await admitSessionRow(headEntry, res, deps.sessionStorage, headSession, headRead);
+            const admittedHead = await admitSessionById(headEntry, res, headFact.sessionStorage, headSession);
             if (admittedHead === undefined)
                 return;
             const leafId = leafOfAdmittedHead(admittedHead.row);
@@ -317,8 +295,6 @@ export async function handleSessions(req, res, match, ctx) {
                 return;
             }
             const evEntry = callerEntry(req, deps, match.decl.id);
-            const readHead = (id) => readOwnerCell(evEntry, id, () => evFact.sessionStorage.headOf(id));
-            const readOwner = async (id) => (await readHead(id))?.owner;
             const watch = evFact.watch;
             const evSession = safeDecode(match.params.sessionId);
             if (evSession === null) {
@@ -354,7 +330,7 @@ export async function handleSessions(req, res, match, ctx) {
                     return;
                 }
                 sse.sseOwnerLookups++;
-                const admissionP = readHead(evSession).then(async (head) => (!sessionRowPresent(head) ? undefined : { head, verdict: await judgeSessionRow(evEntry, evFact.sessionStorage, evSession, head) }));
+                const admissionP = judgeSessionById(evEntry, evFact.sessionStorage, evSession);
                 void admissionP.catch(() => undefined).then(() => { sse.sseOwnerLookups--; });
                 let stallTimer;
                 let admission;
@@ -381,12 +357,13 @@ export async function handleSessions(req, res, match, ctx) {
                     refuse(evEntry, res, "missing");
                     return;
                 }
-                if (deliverVerdict(evEntry, res, admission.verdict) === undefined) {
+                const evAdmitted = deliverVerdict(evEntry, res, admission);
+                if (evAdmitted === undefined) {
                     cleanup();
                     return;
                 }
-                leafOfAdmittedHead(admission.head);
-                const owner = admission.head.owner;
+                leafOfAdmittedHead(evAdmitted.row);
+                const owner = evAdmitted.row.owner;
                 const q = new URLSearchParams(match.search);
                 const lastLeafId = q.get("lastLeafId");
                 let first = true;
@@ -485,9 +462,9 @@ export async function handleSessions(req, res, match, ctx) {
                     }
                     ownerCheckPending = true;
                     ownerCheckStartedAt = Date.now();
-                    void readOwner(evSession).then((o) => {
+                    void sessionOccupantUnchanged(evEntry, evFact.sessionStorage, evSession, evAdmitted.row).then((same) => {
                         ownerCheckPending = false;
-                        if (!closed && o !== owner)
+                        if (!closed && !same)
                             onEnd();
                     }).catch(() => { ownerCheckPending = false; });
                 }, hbMs);
@@ -615,7 +592,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 } : {}),
@@ -706,14 +683,11 @@ export async function handleSessions(req, res, match, ctx) {
         const store = rowFact.sessionStorage;
         const sessionId = match.params.sessionId;
         const patchEntry = callerEntry(req, deps, match.decl.id);
-        const head = await store.headOf(sessionId);
-        if (head === undefined) {
-            refuse(patchEntry, res, "missing");
+        const patchAdmitted = await admitSessionById(patchEntry, res, store, sessionId);
+        if (patchAdmitted === undefined)
             return;
-        }
+        const head = patchAdmitted.row;
         const face = sessionFaceOfHead(sessionId, head);
-        if ((await admitSessionRow(patchEntry, res, store, sessionId, face)) === undefined)
-            return;
         leafOfAdmittedHead(head);
         const read = readSessionRowPatch(await readJson(req));
         if ("problem" in read) {
@@ -903,7 +877,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.id_invalid", "invalid session id (must be a canonical uuid)");
                 return;
             }
-            const deleteAdmitted = await admitSessionById(deleteEntry, res, deleteFact.gateStore, sessionId);
+            const deleteAdmitted = await admitSessionForDeletion(deleteEntry, res, deleteFact.sessionStorage, sessionId);
             if (deleteAdmitted === undefined)
                 return;
             const owner = deleteAdmitted.row.owner;
@@ -931,7 +905,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;
@@ -973,8 +947,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, createPromptCommitReader, settleResumeAnchor, 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";
@@ -21,7 +21,8 @@ import { writeLiveFrame, writeLiveHeartbeat } from "../live-frame.js";
 import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, createPromptManifestSeat, identityFields } from "../../trace/project.js";
 import { cascadeConfig, fillRunPreviewOnDelivery, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
-import { isReplayedOutcome, replayedOutcome, replayOfExistingRun } from "../submit-replay.js";
+import { answerReplay, isReplayedOutcome, replayedOutcome, replayOfExistingRun } from "../submit-replay.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";
@@ -32,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";
@@ -109,12 +110,12 @@ export async function handleTasks(req, res, match, ctx) {
         const idem = rawIdem ? submissionIdemOf(rawIdem, idemCallerOf(req, ctx), keyedBody) : undefined;
         const inflightKey = idem ? inflightKeyOf(idem, "sync") : undefined;
         const cached = inflightKey ? idemCache.peek(inflightKey) : undefined;
-        const keyedRow = idem && !cached && deps.runStore ? await deps.runStore.getRunByIdem(idem.key) : undefined;
-        if (keyedRow && deps.runStore) {
-            const replay = await replayOfExistingRun(keyedRow, { subject: submitter, idem }, "sync", deps, deps.runStore);
-            if (liveStream && replay.status === 200) {
-                sseHeaders(res, { "x-task-id": keyedRow.taskId });
-                writeMetaFrame(res, keyedRow.taskId, keyedRow.sessionId);
+        const keyedHit = idem && !cached && deps.runStore ? await readReplayHit(submitter, deps.config, deps.runStore, { idemKey: idem.key }, undefined) : undefined;
+        if (keyedHit && deps.runStore) {
+            const replay = await answerReplay(keyedHit, { subject: submitter, idem }, "sync", deps.runStore);
+            if (liveStream && replay.status === 200 && keyedHit.kind === "visible") {
+                sseHeaders(res, { "x-task-id": keyedHit.row.taskId });
+                writeMetaFrame(res, keyedHit.row.taskId, keyedHit.row.sessionId);
                 writeLiveFrame(res, doneFrameOfOutcome(replay));
                 res.end();
             }
@@ -294,13 +295,20 @@ export async function handleTasks(req, res, match, ctx) {
                     const promptCommit = createPromptCommitReader();
                     let anchorPut = false;
                     const putRewindAnchor = async () => {
-                        const store = deps.resumeAnchorStore;
-                        const key = durableTaskId;
                         const entryId = userMsgEntryId;
-                        if (anchorPut || !entryId || !key || !store)
+                        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(() => store.put(prepared.spec.sessionId, key, entryId, principal ?? null), { leg: "stream", kind: "prompt" });
+                        await settleResumeAnchor((held) => write(entryId, held), { leg: "stream", kind: "prompt" });
                     };
                     try {
                         if (deps.runStore) {
@@ -357,7 +365,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;
@@ -530,7 +538,7 @@ export async function handleTasks(req, res, match, ctx) {
                                     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);
@@ -800,7 +808,7 @@ export async function handleTasks(req, res, match, ctx) {
                             evict();
                         if (!runRowSettled && durableTaskId && deps.runStore) {
                             try {
-                                const row = await deps.runStore.getRun(durableTaskId);
+                                const row = await runFactsOf(deps.runStore, durableTaskId);
                                 if (row?.status === "running") {
                                     const pending = await deps.checkpointStore?.findPendingTokenBySession(prepared.spec.sessionId, undefined, { axis: "run" });
                                     const backstopCause = ac.cause();
@@ -938,7 +946,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) {
@@ -974,15 +982,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) {
@@ -1039,18 +1054,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, readVisibleRun, routeListFilter, runRowAt } 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";
@@ -42,7 +42,7 @@ export async function handleTraceUsage(req, res, match, ctx) {
         const traceEntry = enter(req, res, deps, match.decl.id);
         if (traceEntry === undefined)
             return;
-        const gateOwner = listFilterOf(traceEntry.face, traceEntry.caller).gateOwner;
+        const traceFilter = listFilterOf(traceEntry.face, traceEntry.caller);
         const runs = facts.durableRuns(deps);
         if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "trace API requires a durable run store (DB_BACKEND=mysql|pg|local)");
@@ -61,20 +61,20 @@ export async function handleTraceUsage(req, res, match, ctx) {
         }
         switch (match.decl.id) {
             case "task-trace-list":
-                await handleTaskList(res, runStore, query, gateOwner);
+                await handleTaskList(res, runStore, query, traceFilter);
                 return;
             case "task-trace-turns":
                 await handleTaskTurns(res, runStore, admittedRun, query);
                 return;
             case "task-trace-stream":
-                await streamTaskTrace(req, res, runStore, admittedRun, match.search);
+                await streamTaskTrace(req, res, runStore, traceEntry, admittedRun, match.search);
                 return;
             case "task-trace-artifacts":
                 await handleTaskArtifacts(res, runStore, admittedRun);
                 return;
             case "task-tool-result": {
                 const ownedRun = admittedRun;
-                const readRun = ownedRun !== undefined ? async () => ownedRun : () => readVisibleRun(traceEntry, runStore, taskId);
+                const readRun = ownedRun !== undefined ? async () => ownedRun : async () => (await readVisibleRun(traceEntry, runStore, taskId))?.row;
                 await handleToolResult(res, deps.toolResultStore, taskId, readRun, safeDecode(match.params.ref), query);
                 return;
             }
@@ -161,11 +161,12 @@ function decodeCursor(s, expectF) {
         return undefined;
     }
 }
-async function handleTaskList(res, runStore, query, forceOwner) {
+async function handleTaskList(res, runStore, query, filter) {
     const status = query.get("status") ?? undefined;
     const jobId = query.get("jobId") ?? undefined;
     const source = query.get("source") ?? undefined;
-    const owner = forceOwner != null ? forceOwner : (query.get("owner") ?? undefined);
+    const namedOwner = query.get("owner") ?? undefined;
+    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);
@@ -173,7 +174,7 @@ async function handleTaskList(res, runStore, query, forceOwner) {
         sendError(res, 400, "request.cursor_filter_mismatch", "cursor was issued under a different filter (status/jobId/source/owner) — restart from the first page without a cursor");
         return;
     }
-    const rows = await runStore.listRuns({ ...(status ? { status } : {}), ...(jobId ? { jobId } : {}), ...(source ? { source } : {}), ...(owner ? { owner } : {}), ...(cursor ? { cursor } : {}), limit: limit + 1 });
+    const rows = await listVisibleRuns(runStore, filter, namedOwner, { ...(status ? { status } : {}), ...(jobId ? { jobId } : {}), ...(source ? { source } : {}), ...(cursor ? { cursor } : {}), limit: limit + 1 });
     const hasMore = rows.length > limit;
     const page = hasMore ? rows.slice(0, limit) : rows;
     const tasks = page.map((r) => taskSummary(r));
@@ -216,8 +217,7 @@ async function handleToolResult(res, store, taskId, readRun, ref, query) {
     const run = await readRun();
     if (!run)
         return notFound();
-    const owner = store?.ownerOf ? await store.ownerOf(ref) : undefined;
-    const ownedByThisCaller = owner !== undefined && owner.sessionId === run.sessionId && (owner.taskId === undefined || owner.taskId === taskId);
+    const ownedByThisCaller = await toolResultRefOwned(store, ref, run);
     if (!ownedByThisCaller)
         return notFound();
     if (!store)
@@ -240,7 +240,7 @@ async function handleTaskTurns(res, runStore, run, query) {
     const nextCursor = eligible.length > limit && oldest ? String(oldest.seq) : undefined;
     sendJson(res, 200, { turns, ...(nextCursor ? { nextCursor } : {}), retainedFrom });
 }
-async function streamTaskTrace(req, res, runStore, admitted, search) {
+async function streamTaskTrace(req, res, runStore, entry, admitted, search) {
     const taskId = admitted.taskId;
     const lastId = Number(req.headers["last-event-id"] ?? new URLSearchParams(search).get("from") ?? 0);
     let from = Number.isFinite(lastId) ? lastId : 0;
@@ -264,11 +264,11 @@ async function streamTaskTrace(req, res, runStore, admitted, search) {
         }
     };
     while (!closed) {
-        const [events, raw] = await Promise.all([runStore.getEvents(taskId, from), runStore.getRun(taskId)]);
+        const [events, reread] = await Promise.all([runStore.getEvents(taskId, from), readVisibleRun(entry, runStore, taskId)]);
         write(events);
-        if (!raw)
+        if (!reread)
             break;
-        const run = await runRowAt("task-trace-stream", runStore, raw);
+        const run = reread.row;
         if (run.status !== "running") {
             write(await runStore.getEvents(taskId, from));
             if (!deliveredTerminal && isHolderDeathVerdict(run))

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

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { type WorkflowRun } from "@sema-agent/core";
 import { type Admit } from "../../trace/projection-table.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
+/** SVC-5 的 steer 路——`handle()` 里位置在 tasks/runs 之后(鉴权门之后),故是**独立**的域入口。 */
 /** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
  *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 export declare function handleWorkflows(req: IncomingMessage, res: ServerResponse, match: RouteMatch<WorkflowsRouteId>, ctx: RouteCtx): Promise<void>;

package/dist/http/routes/workflows.js

@@ -1,6 +1,6 @@
 import { persistedPlaneOf } from "../../terminal.js";
 import { z } from "zod";
-import { getWorkflowRun, subscribeWorkflow, deriveAgentDisplayStatus, callKeyOrdinal, runParkedOf, JOURNAL_INCOMPATIBLE_ERROR_CODE, WorkflowJournalIncompatibleError } from "@sema-agent/core";
+import { subscribeWorkflow, deriveAgentDisplayStatus, callKeyOrdinal, runParkedOf, JOURNAL_INCOMPATIBLE_ERROR_CODE, WorkflowJournalIncompatibleError } from "@sema-agent/core";
 import { redactSteerIn, STEER_IN_MAX_CHARS, STEER_IN_MAX_REQUEST_CHARS } from "../../orchestration/workflow-agent-steer.js";
 import { journalEntryOfCell, journalEntryPayload, journalRowPayloadOf } from "../../plugins/workflow-journal-payload.js";
 import { redactSecrets } from "../../trace/redact.js";
@@ -10,30 +10,18 @@ import { projectByTable } from "../../trace/projection-table.js";
 const JOURNAL_PROJECTION_MEMO_CAP = 1024;
 const journalProjectionMemo = new Map();
 import { sendJson, sendError, sseHeaders } from "../send.js";
-import { gatedSubject, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { explicitOperatorOk } from "../principal-gate.js";
 import { partsOf } from "../../owner-brands.js";
-import { taskSpecIdentityOf } from "../../engine-identity.js";
 import { assertNever } from "../route-ctx.js";
-import { callerOf, sessionAsserted } from "../owner-access.js";
+import { admitWorkflowRun, enter, judgeWorkflowRun, listVisibleWorkflows, refuse } from "../owner-access.js";
 import * as facts from "../../capability-facts.js";
 import { steerBodyKeyIssue } from "../../request-key-closure.js";
-function sendWorkflowAbsent(res) {
-    sendError(res, 404, "not_found.workflow", "workflow not found");
-}
-const WORKFLOW_SESSION_ASSERTION = {
-    "workflow-detail": { phase: "accept", label: "workflow.detail" },
-    "workflow-journal": { phase: "accept", label: "workflow.journal" },
-    "workflow-stream": { phase: "accept", label: "workflow.stream" },
-    "workflow-agent-steer": { phase: "accept", label: "workflow.agent-steer" },
-};
 export async function handleWorkflows(req, res, match, ctx) {
     const { deps } = ctx;
     {
-        const subject = gatedSubject(req, deps.config);
-        if (deps.config.requirePrincipal && !subject) {
-            sendPrincipalRefusal(res, req, deps.config);
+        const wfEntry = enter(req, res, deps, match.decl.id);
+        if (wfEntry === undefined)
             return;
-        }
         let journalStore;
         if (match.decl.id === "workflow-journal") {
             const journalFace = facts.workflowsJournal(deps);
@@ -49,7 +37,6 @@ export async function handleWorkflows(req, res, match, ctx) {
             return;
         }
         const runStore = runs.store;
-        const scope = taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)).principal ?? "default";
         const wfId = match.params.runId;
         const isStream = match.decl.id === "workflow-stream";
         if (match.decl.id === "workflows-list") {
@@ -57,7 +44,7 @@ export async function handleWorkflows(req, res, match, ctx) {
             const statusFilter = q.get("status");
             const limit = Math.min(100, Math.max(1, Number(q.get("limit") ?? 50) || 50));
             const sessionFilter = q.get("session");
-            const sessionRuns = await runStore.listByScope(scope, {
+            const sessionRuns = await listVisibleWorkflows(wfEntry, runStore, {
                 ...(statusFilter ? { status: statusFilter } : {}),
                 limit,
                 ...(sessionFilter !== null ? { session: sessionFilter } : {}),
@@ -71,15 +58,11 @@ export async function handleWorkflows(req, res, match, ctx) {
             sendJson(res, 200, { workflows: redacted });
             return;
         }
-        const run = await getWorkflowRun(runStore, wfId, scope);
-        if (!run || run.scope !== scope) {
-            sendWorkflowAbsent(res);
-            return;
-        }
-        if (!sessionAsserted(WORKFLOW_SESSION_ASSERTION[match.decl.id], req, run.originatingSessionId, callerOf(req, deps).operator)) {
-            sendWorkflowAbsent(res);
+        const wfAdmitted = await admitWorkflowRun(wfEntry, res, runStore, wfId);
+        if (wfAdmitted === undefined)
             return;
-        }
+        const run = wfAdmitted.row;
+        const scope = run.scope;
         if (match.decl.id === "workflow-journal") {
             if (journalStore === undefined)
                 throw new Error("workflow-journal reached without the workflowsJournal journal witness");
@@ -182,12 +165,11 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
             sendWorkflowsUnavailable(res, runs.why);
             return;
         }
-        const subject = gatedSubject(req, deps.config);
-        const principal = subject === undefined ? undefined : partsOf(subject).person;
-        if (deps.config.requirePrincipal && principal === undefined) {
-            sendPrincipalRefusal(res, req, deps.config);
+        const steerEntry = enter(req, res, deps, match.decl.id);
+        if (steerEntry === undefined)
             return;
-        }
+        const subject = steerEntry.caller.subject;
+        const principal = subject === undefined ? undefined : partsOf(subject).person;
         const wfRunId = safeDecode(match.params.runId);
         const label = safeDecode(match.params.label);
         if (wfRunId === null || label === null) {
@@ -211,14 +193,14 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
             return;
         }
         const trusted = explicitOperatorOk(principal, deps.config);
-        const ownerScope = taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)).principal ?? "default";
-        const wfRun = await getWorkflowRun(runs.store, wfRunId, ownerScope);
-        if (!trusted && !wfRun) {
-            sendWorkflowAbsent(res);
+        const wfVerdict = await judgeWorkflowRun(steerEntry, runs.store, wfRunId);
+        if (wfVerdict === "session_mismatch") {
+            refuse(steerEntry, res, "session_mismatch");
             return;
         }
-        if (wfRun && !sessionAsserted(WORKFLOW_SESSION_ASSERTION["workflow-agent-steer"], req, wfRun.originatingSessionId, callerOf(req, deps).operator)) {
-            sendWorkflowAbsent(res);
+        const wfRun = typeof wfVerdict === "object" ? wfVerdict.row : undefined;
+        if (!trusted && wfRun === undefined) {
+            refuse(steerEntry, res, wfVerdict === "missing" ? "missing" : "not_visible");
             return;
         }
         const sendNotRunningWf = (error) => sendError(res, 409, "steering.not_running", error);