@sema-agent/server 7.115.0 → 7.116.0

package/dist/http/routes/runs.js

@@ -2,7 +2,7 @@ import { persistedPlaneOf } from "../../terminal.js";
 import { memoRedactedRead, memoRedactTerminalResult, redactErrorMessage, redactHead, redactLedgerEventForRead, redactTerminalResult } from "../../observability/run-terminal.js";
 import { z } from "zod";
 import { uuidv7, mintCheckpointToken, CheckpointError, validatePendingSteer, TASK_OUTPUT_REPLAY_KINDS } from "@sema-agent/core";
-import { isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, isTerminalRunStatus, isParkedRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
 import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-sql.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { HttpError, verifiedPrincipal, isUuidV7, encodeCheckpointScope } from "../../security.js";
@@ -24,6 +24,7 @@ import { mintCancelledResult } from "../../run-cancel-context.js";
 import { buildCrossSliceUsage, readResourceWindow } from "../../resource-window.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import { ActorAssertionWire } from "@sema-agent/settings-schema";
+import * as facts from "../../capability-facts.js";
 import { assertNever } from "../route-ctx.js";
 import { mintAndDriveDurableRun } from "../durable-run-leg.js";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
@@ -167,10 +168,12 @@ export async function handleRuns(req, res, match, ctx) {
     const { prepareSpec } = ctx.legs;
     const source = ctx.req.source;
     if (match.decl.id === "runs-submit") {
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const rawIdem = headerStr(req.headers["idempotency-key"]);
         const idemKey = rawIdem ? scopedIdempotencyKey(rawIdem, source, gatedPrincipal(req, deps.config)) : undefined;
         const cached = idemKey ? idemCache.peek(idemKey) : undefined;
@@ -191,16 +194,18 @@ export async function handleRuns(req, res, match, ctx) {
         return;
     }
     if (match.decl.id === "run-detail" || match.decl.id === "run-events") {
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const taskId = match.params.taskId;
         if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
@@ -210,7 +215,7 @@ export async function handleRuns(req, res, match, ctx) {
         if (!runSessionAcceptOk(req, res, run, match.decl.id === "run-events" ? "run.events" : "run.poll"))
             return;
         if (match.decl.id === "run-events") {
-            await streamRunEvents(req, res, deps, deps.runStore, taskId, deps.config.runStaleSec * 1000);
+            await streamRunEvents(req, res, deps, runStore, taskId, deps.config.runStaleSec * 1000);
         }
         else {
             const stale = run.status === "running" && Date.now() - new Date(run.updatedAt).getTime() > deps.config.runStaleSec * 1000;
@@ -221,8 +226,8 @@ export async function handleRuns(req, res, match, ctx) {
             let events;
             let eventsUnavailable = false;
             if (needCost || needSuggestions || resourceWindow !== undefined) {
-                if (deps.runStore.getEvents) {
-                    events = await deps.runStore.getEvents(taskId, 0).catch(() => {
+                if (runStore.getEvents) {
+                    events = await runStore.getEvents(taskId, 0).catch(() => {
                         eventsUnavailable = true;
                         return [];
                     });
@@ -262,7 +267,7 @@ export async function handleRuns(req, res, match, ctx) {
                 result: isTerminalRunStatus(run.status) ? memoRedactTerminalResult("run.result", run.result ?? undefined) : redactTerminalResult(run.result ?? undefined),
                 supervisorCost,
                 suggestions,
-                errorCode: stale ? undefined : (persistedPlaneOf(run.result).errorCode ?? undefined),
+                errorCode: stale ? RUN_HOLDER_DEATH_CODES.stalled : (persistedPlaneOf(run.result).errorCode ?? run.errorCode ?? undefined),
                 error: stale ? "run stalled (instance lost?)" : isTerminalRunStatus(run.status) ? memoRedactedRead("run.error", run.error ?? undefined, redactErrorMessage) : redactErrorMessage(run.error ?? undefined),
                 jobId: run.jobId ?? undefined,
                 source: run.source ?? undefined,
@@ -273,16 +278,18 @@ export async function handleRuns(req, res, match, ctx) {
         return;
     }
     if (match.decl.id === "run-cancel") {
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
         const taskId = match.params.taskId;
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
@@ -291,7 +298,7 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         if (!runSessionAcceptOk(req, res, run, "run.cancel"))
             return;
-        const rs = deps.runStore;
+        const rs = runStore;
         const cancelSuspended = async () => {
             const cs = deps.checkpointStore;
             let note = "cancelled while suspended (pending approval settled)";
@@ -363,16 +370,16 @@ export async function handleRuns(req, res, match, ctx) {
             sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", cancelRequested: false, note });
         };
         if (run.status === "running") {
-            let flagged = await deps.runStore.requestCancel(taskId, run.owner);
+            let flagged = await runStore.requestCancel(taskId, run.owner);
             const CANCEL_RECLASSIFY_ATTEMPTS = 3;
             for (let attempt = 0; !flagged; attempt++) {
-                const now = await deps.runStore.getRun(taskId);
+                const now = await runStore.getRun(taskId);
                 if (now !== undefined && isParkedRunStatus(now.status)) {
                     await cancelSuspended();
                     return;
                 }
                 if (now?.status === "running" && attempt < CANCEL_RECLASSIFY_ATTEMPTS) {
-                    flagged = await deps.runStore.requestCancel(taskId, run.owner);
+                    flagged = await runStore.requestCancel(taskId, run.owner);
                     continue;
                 }
                 if (now?.status === "running") {
@@ -396,10 +403,12 @@ export async function handleRuns(req, res, match, ctx) {
     if (match.decl.id === "run-steer") {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
             return;
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -437,8 +446,14 @@ export async function handleRuns(req, res, match, ctx) {
         const steerInputId = steerScoped ? `idem-${createHash("sha256").update(steerScoped).digest("hex").slice(0, 32)}` : undefined;
         const messageId = steerInputId ?? uuidv7();
         const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const steerInput = () => ({
+            text,
+            trusted,
+            ...(steerInputId !== undefined ? { inputId: steerInputId } : {}),
+            ...(priority !== undefined ? { priority } : {}),
+        });
         try {
-            validatePendingSteer({ text, trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
+            validatePendingSteer(steerInput());
         }
         catch (e) {
             if (e instanceof CheckpointError && e.code === "steering.invalid_content") {
@@ -447,7 +462,7 @@ export async function handleRuns(req, res, match, ctx) {
             }
             throw e;
         }
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
@@ -458,11 +473,11 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         let parkQueueFull;
         let parkDuplicateKey;
-        const steerInput = () => ({ text, trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
         const tryPark = async () => {
-            const cs = deps.checkpointStore;
-            if (!cs)
+            const park = facts.checkpointPark(deps);
+            if (!park.available)
                 return "no-store";
+            const cs = park.checkpointStore;
             const parkBinding = { gateKinds: LIVE_RUN_GATE_KINDS };
             const scope = await cs.peekPendingScope(run.sessionId, parkBinding);
             if (scope === null || scope === undefined)
@@ -495,7 +510,7 @@ export async function handleRuns(req, res, match, ctx) {
             if (acceptance === "refused")
                 return;
             try {
-                await relayAcceptedInput(deps, acceptance, () => live.steer(text, { trusted, inputId: messageId }));
+                await relayAcceptedInput(deps, acceptance, () => live.steer(text, { trusted, inputId: messageId, ...(priority !== undefined ? { priority } : {}) }));
                 sendJson(res, 200, { taskId, status: "running", delivery: "applied", messageId, ...(priority ? { priority } : {}) });
                 return;
             }
@@ -516,7 +531,7 @@ export async function handleRuns(req, res, match, ctx) {
                 }
                 if (code !== "steering.not_running")
                     throw e;
-                const freshBeforePark = await deps.runStore.getRun(taskId).catch(() => undefined);
+                const freshBeforePark = await runStore.getRun(taskId).catch(() => undefined);
                 const raced = await tryPark();
                 if (raced === "parked") {
                     sendParked(freshBeforePark?.status ?? run.status);
@@ -535,11 +550,11 @@ export async function handleRuns(req, res, match, ctx) {
             }
         }
         if (isParkedRunStatus(run.status)) {
-            const outcome = await tryPark();
-            if (outcome === "no-store") {
+            if (!facts.checkpointPark(deps).available) {
                 sendError(res, 501, "capability.checkpoint_store_required", "steering a suspended run requires the checkpoint store");
                 return;
             }
+            const outcome = await tryPark();
             if (outcome === "parked") {
                 sendParked(run.status);
                 return;
@@ -566,7 +581,7 @@ export async function handleRuns(req, res, match, ctx) {
             return;
         }
         if (deps.checkpointStore && deps.sessionStorage?.getLeafId) {
-            const activeTaskId = await deps.runStore.getActiveTaskId?.(run.sessionId).catch(() => undefined);
+            const activeTaskId = await runStore.getActiveTaskId?.(run.sessionId).catch(() => undefined);
             if (activeTaskId !== undefined && activeTaskId !== null && activeTaskId !== taskId) {
                 sendNotRunning(`run is ${run.status} and its session has an ACTIVE run (${activeTaskId}) — steer that run instead`);
                 return;
@@ -688,10 +703,12 @@ export async function handleRuns(req, res, match, ctx) {
     if (match.decl.id === "run-interrupt") {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
             return;
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -746,7 +763,7 @@ export async function handleRuns(req, res, match, ctx) {
                 throw e;
             }
         }
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
@@ -790,7 +807,7 @@ export async function handleRuns(req, res, match, ctx) {
             catch (e) {
                 if (e.code !== "steering.not_running")
                     throw e;
-                const freshRun = await deps.runStore.getRun(taskId).catch(() => undefined);
+                const freshRun = await runStore.getRun(taskId).catch(() => undefined);
                 sendNoLiveTurn(freshRun?.status ?? run.status, true);
                 return;
             }
@@ -824,7 +841,7 @@ export async function handleRuns(req, res, match, ctx) {
             }
             if (code !== "steering.not_running")
                 throw e;
-            const freshRun = await deps.runStore.getRun(taskId).catch(() => undefined);
+            const freshRun = await runStore.getRun(taskId).catch(() => undefined);
             sendNoLiveTurn(freshRun?.status ?? run.status, true);
             return;
         }
@@ -834,17 +851,19 @@ export async function handleRuns(req, res, match, ctx) {
     if (match.decl.id === "run-compact") {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
             return;
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
         const taskId = match.params.taskId;
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
@@ -898,10 +917,12 @@ export async function handleRuns(req, res, match, ctx) {
     if (match.decl.id === "run-detach") {
         if (rateLimited(req, res))
             return;
-        if (!deps.runStore) {
+        const runs = facts.durableRuns(deps);
+        if (!runs.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = runs.runStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -924,7 +945,7 @@ export async function handleRuns(req, res, match, ctx) {
             sendError(res, 400, "request.body_shape", "body must be { toolCallId: string (non-empty, ≤256 chars) }");
             return;
         }
-        const run = await deps.runStore.getRun(taskId);
+        const run = await runStore.getRun(taskId);
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
@@ -949,10 +970,13 @@ export async function handleRunVerbs(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, rateLimited, quotaExceeded, ownerQuotaDenied, leaseDenied, ownerLeaseDenied, safeDecode, runOwnerOk, runSessionAcceptOk } = ctx.helpers;
     if (match.decl.id === "run-subagent-output") {
-        if (!deps.runStore || !deps.subagentTaskOutput) {
+        const outputFact = facts.subagentOutput(deps);
+        if (!outputFact.available) {
             sendError(res, 501, "capability.run_store_required", "subagent output reads require the run store");
             return;
         }
+        const runStore = outputFact.runStore;
+        const subagentTaskOutput = outputFact.output;
         const runId = safeDecode(match.params.runId);
         const target = safeDecode(match.params.sub);
         if (runId === null || target === null) {
@@ -963,7 +987,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         if (!gated)
             return;
         const { run } = gated;
-        const out = await deps.subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
+        const out = await subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const details = out.details;
         if (details?.error === "not_found" || details?.type !== "background_agent") {
             if (!sendHandleMiss(res, run, deps.instanceId))
@@ -974,10 +998,13 @@ export async function handleRunVerbs(req, res, match, ctx) {
         return;
     }
     if (match.decl.id === "run-subagent-stream") {
-        if (!deps.runStore || !deps.subagentTaskOutput) {
+        const outputFact = facts.subagentOutput(deps);
+        if (!outputFact.available) {
             sendError(res, 501, "capability.run_store_required", "subagent streams require the run store");
             return;
         }
+        const runStore = outputFact.runStore;
+        const subagentTaskOutput = outputFact.output;
         const runId = safeDecode(match.params.runId);
         const target = safeDecode(match.params.sub);
         if (runId === null || target === null) {
@@ -989,7 +1016,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         const { run } = gatedTail;
         const it = defaultSubagentTailBus.subscribe(target);
-        const probe = await deps.subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
+        const probe = await subagentTaskOutput(target, { owner: runId, scope: run.owner ?? "default", ...(run.sessionId ? { sessionId: run.sessionId } : {}) });
         const probeDetails = probe.details;
         if (probeDetails?.error === "not_found" || probeDetails?.type !== "background_agent") {
             void it.return?.();
@@ -1037,10 +1064,12 @@ export async function handleRunVerbs(req, res, match, ctx) {
     }
     if (match.decl.id === "run-task-output" || match.decl.id === "run-task-stop") {
         const stopVerb = match.decl.id === "run-task-stop";
-        if (!deps.runStore || !deps.taskHandleOutput || !deps.taskHandleStop) {
+        const handlesFact = facts.taskHandles(deps);
+        if (!handlesFact.available) {
             sendError(res, 501, "capability.run_store_required", "task-handle verbs require the run store and the task registry");
             return;
         }
+        const runStore = handlesFact.runStore;
         if (stopVerb && rateLimited(req, res))
             return;
         const runId = safeDecode(match.params.runId);
@@ -1060,8 +1089,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const out = stopVerb
-            ? await deps.taskHandleStop(target, access)
-            : await deps.taskHandleOutput(target, access);
+            ? await handlesFact.stop(target, access)
+            : await handlesFact.output(target, access);
         const details = out.details;
         if (details?.error === "not_found") {
             if (!sendHandleMiss(res, run, deps.instanceId))
@@ -1108,10 +1137,12 @@ export async function handleRunVerbs(req, res, match, ctx) {
         const verb = match.decl.id === "run-subagent-resume" ? "resume" : "steer";
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
             return;
-        if (!deps.runStore) {
+        const steerFact = facts.subagentSteer(deps);
+        if (!steerFact.available) {
             sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
             return;
         }
+        const runStore = steerFact.runStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -1144,7 +1175,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         }
         const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
-        const run = await deps.runStore.getRun(runId);
+        const run = await runStore.getRun(runId);
         if (!run) {
             sendError(res, 404, "not_found.run", RUN_NOT_FOUND_MESSAGE);
             return;
@@ -1155,7 +1186,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             return;
         const send409 = (errorCode, error) => sendError(res, 409, errorCode, error);
         const redacted = redactSteerIn(body.content, target);
-        const resolution = deps.subagentSteerRegistry?.resolve(runId, target);
+        const resolution = steerFact.registry.resolve(runId, target);
         if (resolution && resolution.count > 1) {
             send409("steering.ambiguous_target", `${resolution.count} sub-agents match '${target}' in this run — address by parentToolCallId`);
             return;
@@ -1215,7 +1246,8 @@ export async function handleRunVerbs(req, res, match, ctx) {
     if (match.decl.id === "elicitation-respond") {
         if (rateLimited(req, res))
             return;
-        if (!deps.elicitation) {
+        const elicitFact = facts.elicitation(deps);
+        if (!elicitFact.available) {
             sendError(res, 501, "feature.elicitation_disabled", "inbound MCP elicitation is not enabled on this worker (MCP_ELICITATION_ENABLED)");
             return;
         }
@@ -1233,14 +1265,15 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
-        const { status, body: respBody } = deps.elicitation.respond(id, principal, body);
+        const { status, body: respBody } = elicitFact.coordinator.respond(id, principal, body);
         sendJson(res, status, respBody);
         return;
     }
     if (match.decl.id === "question-respond") {
         if (rateLimited(req, res))
             return;
-        if (!deps.question) {
+        const questionFact = facts.askUserQuestion(deps);
+        if (!questionFact.available) {
             sendError(res, 501, "feature.ask_question_disabled", "AskUserQuestion live HITL is not enabled on this worker (ASK_QUESTION_ENABLED)");
             return;
         }
@@ -1258,14 +1291,15 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
-        const { status, body: respBody } = deps.question.respond(id, principal, body);
+        const { status, body: respBody } = questionFact.coordinator.respond(id, principal, body);
         sendJson(res, status, respBody);
         return;
     }
     if (match.decl.id === "tool-approval-respond") {
         if (rateLimited(req, res))
             return;
-        if (!deps.toolApproval) {
+        const approvalFact = facts.toolApproval(deps);
+        if (!approvalFact.available) {
             sendError(res, 501, "feature.tool_approval_disabled", "live tool-approval HITL is not enabled on this worker (TOOL_APPROVAL_ENABLED)");
             return;
         }
@@ -1283,7 +1317,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendError(res, 400, "request.invalid_json", "invalid JSON body");
             return;
         }
-        const { status, body: respBody } = await deps.toolApproval.respond(id, principal, body, req);
+        const { status, body: respBody } = await approvalFact.coordinator.respond(id, principal, body, req);
         const retryAfterSec = respBody.retryAfterSec;
         if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0) {
             res.setHeader("retry-after", String(Math.ceil(retryAfterSec)));
@@ -1294,17 +1328,12 @@ export async function handleRunVerbs(req, res, match, ctx) {
     if (match.decl.id === "task-ask-decision") {
         if (rateLimited(req, res))
             return;
-        const gate = resolveStreamApprovalGate({
-            toolApprovalEnabled: Boolean(deps.toolApproval),
-            streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
-            backend: deps.backend,
-            parkFacility: deps.checkpointStore !== undefined,
-        });
-        const askStore = gate.active ? gate.askStore : undefined;
-        if (!askStore) {
+        const streamFact = facts.streamApproval(deps);
+        if (!streamFact.available) {
             sendError(res, 501, "feature.approval_ask_disabled", "the durable stream-approval ask ledger is not enabled on this worker (needs STREAM_APPROVAL_ENABLED plus a DURABLE store backend — the local backend keeps asks in memory and would lose accepted decisions on restart)");
             return;
         }
+        const askStore = streamFact.askStore;
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendPrincipalRefusal(res, req, deps.config);
@@ -1434,7 +1463,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     return;
                 case "DENIED":
                 case "VOID":
-                    sendError(res, 410, "gone.ask", "this ask reached a terminal state without a human decision (routing failure or batch abort) and can no longer be decided", {
+                    sendError(res, 410, "gone.ask", "this ask reached a terminal state without a human decision (deniedReason says why: a routing failure, a cancellation or batch abort, or the process that held it ended) and can no longer be decided", {
                         state: row.state,
                         ...(row.deniedReason !== null ? { deniedReason: row.deniedReason } : {}),
                     });
@@ -1566,11 +1595,12 @@ export async function createDurableRun(req, res, ctx, prepared, idemKey) {
     const { idemCache, inflightRuns, preemptableRuns, steerableRuns } = ctx.registry;
     const { leaseDenied, usageWindowDenied } = ctx.helpers;
     const source = ctx.req.source;
-    if (!deps.runStore) {
+    const runs = facts.durableRuns(deps);
+    if (!runs.available) {
         sendError(res, 501, "capability.run_store_required", "async runs require a durable run store (DB_BACKEND=mysql|pg|local)");
         return null;
     }
-    const runStore = deps.runStore;
+    const runStore = runs.runStore;
     const rawClientTaskId = prepared.body.taskId;
     if (rawClientTaskId !== undefined && (typeof rawClientTaskId !== "string" || !isUuidV7(rawClientTaskId))) {
         sendError(res, 400, "request.id_invalid", "body.taskId must be a uuidv7 string (caller-minted idempotency key)");