@sema-agent/server 7.114.0 → 7.116.0

package/dist/http/routes/admin-drain.js

@@ -1,9 +1,10 @@
 import { sendJson, sendError } from "../send.js";
-import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
+import * as facts from "../../capability-facts.js";
 import { assertNever } from "../route-ctx.js";
 export const ADMIN_DRAIN_PATH = "/v1/admin/drain";
 export const MAX_DRAIN_REASON_CHARS = 256;
-const OPERATOR_ONLY_MESSAGE = "drain declaration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS (an empty list means NO one is an operator — configure it to enable this endpoint)";
+const OPERATOR_ONLY_MESSAGE = "drain declaration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS";
 export async function handleAdminDrain(req, res, match, ctx) {
     const { deps } = ctx;
     switch (match.decl.id) {
@@ -13,6 +14,10 @@ export async function handleAdminDrain(req, res, match, ctx) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
+            if (!facts.operatorLane(deps).available) {
+                sendOperatorPrincipalsRequired(res);
+                return;
+            }
             if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
                 sendError(res, 403, "auth.operator_only", OPERATOR_ONLY_MESSAGE);
                 return;

package/dist/http/routes/admin-memory-optout.d.ts

@@ -42,8 +42,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare const ADMIN_MEMORY_OPTOUT_PATH = "/v1/admin/memory-optout";
-/** 带参口(`:principal`)⇒ 路由声明表(`http/route-table.ts`)里走 `pattern` 行,不是 `path` 行。 */
-export declare const ADMIN_MEMORY_OPTOUT_OVERRIDE_RE: RegExp;
 export declare function handleMemoryOptOut(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryOptOutRouteId>, ctx: RouteCtx): Promise<void>;
 export declare const MEMORY_OPTOUT_ROUTES: readonly [{
     readonly id: "memory-optout-grants-list";

package/dist/http/routes/admin-memory-optout.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { sendJson, sendError } from "../send.js";
-import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 import { memoryOptOutPrincipalShapeProblem } from "../../plugins/memory-optout-grant-store-sql.js";
 export const ADMIN_MEMORY_OPTOUT_PATH = "/v1/admin/memory-optout";
-export const ADMIN_MEMORY_OPTOUT_OVERRIDE_RE = /^\/v1\/admin\/memory-optout\/([^/]+)$/;
 const PutBodySchema = z.object({ allow: z.boolean(), note: z.string().min(1).max(500).optional() }).strict();
 export async function handleMemoryOptOut(req, res, match, ctx) {
     const { deps } = ctx;
@@ -16,16 +16,29 @@ export async function handleMemoryOptOut(req, res, match, ctx) {
         sendPrincipalRefusal(res, req, deps.config);
         return;
     }
+    const fact = facts.memoryOptOutGrant(deps);
+    if (!fact.available && fact.why === "operator_principals_empty") {
+        sendOperatorPrincipalsRequired(res);
+        return;
+    }
     if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
-        sendError(res, 403, "auth.operator_only", "memory opt-out grant administration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS (an empty list means NO one is an operator — configure it to enable these endpoints)");
+        sendError(res, 403, "auth.operator_only", "memory opt-out grant administration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS");
         return;
     }
     const operator = principal;
-    const store = deps.memoryOptOutGrant;
-    if (store === undefined) {
-        sendError(res, 501, "capability.memory_optout_grant_required", "this deployment has no memory opt-out grant table: the per-principal memory-capture opt-out authorization store lives on a SQL store backend (DB_BACKEND=mysql|pg) and the local backend deliberately keeps no companion store for forgetting — wire a SQL backend to administer opt-out grants");
-        return;
+    if (!fact.available) {
+        switch (fact.why) {
+            case "memory_optout_grant_absent":
+                sendError(res, 501, "capability.memory_optout_grant_required", "this deployment has no memory opt-out grant table: the per-principal memory-capture opt-out authorization store lives on a SQL store backend (DB_BACKEND=mysql|pg) and the local backend deliberately keeps no companion store for forgetting — wire a SQL backend to administer opt-out grants");
+                return;
+            case "operator_principals_empty":
+                sendOperatorPrincipalsRequired(res);
+                return;
+            default:
+                return assertNever(fact.why);
+        }
     }
+    const store = fact.store;
     if (target !== undefined && (target === null || memoryOptOutPrincipalShapeProblem(target) !== undefined)) {
         sendError(res, 400, "request.path_malformed", "invalid memory opt-out grant principal — the path segment must percent-decode to a non-empty principal of at most 190 chars with no leading/trailing whitespace or control characters (the deployment default row is addressed by PUT on the collection root, not by a path segment)");
         return;

package/dist/http/routes/adoption.js

@@ -2,8 +2,9 @@ import { createAdoptionRunner } from "../../adoption/runner.js";
 import { AdoptionRequestSchema } from "../../adoption/wire.js";
 import { checkAdoptionPrincipalShape, checkAdoptionWidths } from "../../adoption/plan.js";
 import { sendJson, sendError } from "../send.js";
-import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 function sendOutcome(res, out) {
     switch (out.kind) {
         case "receipt":
@@ -46,15 +47,28 @@ export async function handleAdoption(req, res, match, ctx) {
         sendPrincipalRefusal(res, req, deps.config);
         return;
     }
+    const fact = facts.adoption(deps);
+    if (!fact.available && fact.why === "operator_principals_empty") {
+        sendOperatorPrincipalsRequired(res);
+        return;
+    }
     if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
         sendError(res, 403, "auth.operator_only", "adoption is an operator-only deployment action");
         return;
     }
-    const store = deps.backend?.adoptionLog?.();
-    if (!store) {
-        sendError(res, 501, "capability.adoption_store_required", "adoption requires a SQL store backend (DB_BACKEND=mysql|pg)");
-        return;
+    if (!fact.available) {
+        switch (fact.why) {
+            case "adoption_store_absent":
+                sendError(res, 501, "capability.adoption_store_required", "adoption requires a SQL store backend (DB_BACKEND=mysql|pg)");
+                return;
+            case "operator_principals_empty":
+                sendOperatorPrincipalsRequired(res);
+                return;
+            default:
+                return assertNever(fact.why);
+        }
     }
+    const store = fact.backend.adoptionLog();
     const runner = createAdoptionRunner({ store, dialect: deps.backend?.kind === "pg" ? "pg" : "tidb", now: Date.now, logger: deps.logger });
     switch (match.decl.id) {
         case "adoption-detail": {

package/dist/http/routes/agents-roster.js

@@ -1,6 +1,7 @@
 import { sendJson, sendError } from "../send.js";
 import { sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 export const ROSTER_SCAN_LIMIT = 500;
 const ROSTER_STATUSES = ["running", "parked", "completed", "failed", "killed"];
 const ROSTER_KEY_DISPOSITION = {
@@ -63,11 +64,12 @@ export async function handleAgentRoster(req, res, match, ctx) {
                 sendUnauthorized(res, "identity");
                 return;
             }
-            const store = deps.backgroundAgentStore;
-            if (!store) {
+            const roster = facts.agentRoster(deps);
+            if (!roster.available) {
                 sendError(res, 501, "capability.background_agent_store_required", "the agent roster requires a durable background-agent store (DB_BACKEND=mysql|pg, or the local file backend)");
                 return;
             }
+            const store = roster.store;
             const q = new URLSearchParams(match.search);
             const limitRaw = q.get("limit");
             if (limitRaw !== null && !(/^[0-9]+$/.test(limitRaw) && Number(limitRaw) >= 1 && Number(limitRaw) <= 100)) {

package/dist/http/routes/approvals-assistant.js

@@ -2,7 +2,7 @@ import { screenedGate } from "../../trace/project.js";
 import { hostDecisionFacts } from "../../host-decision.js";
 import { sameExecutionRecord } from "@sema-agent/core";
 import { DECIDED_REPLAY_SCAN_CAP, approvalPayloadFingerprint } from "../../plugins/checkpoint-store-sql.js";
-import { APPROVAL_GATE_KINDS, SETTLED_BY_DENY_ONLY, SETTLED_BY_MUST_BE_STRING, SETTLED_BY_TOO_WIDE, judgeSettledByBody } from "../../tool-approval.js";
+import { APPROVAL_GATE_KINDS, SETTLED_BY_DENY_ONLY, SETTLED_BY_MUST_BE_STRING, SETTLED_BY_TOO_WIDE, judgeSettledByBody, standingAnswerMayRetire } from "../../tool-approval.js";
 import { isParkedRunStatus } from "../../plugins/store-contracts.js";
 import { principalFrom, decodeCheckpointScope, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../../security.js";
 import { editedPlanBinding, isWellFormedUnicode, verifyDirectDoorProof } from "../../principal-jwt.js";
@@ -17,8 +17,10 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, isOperator, sendPrincipalRefusal } from "../principal-gate.js";
 import { governanceOriginOf } from "../../runtime-governance.js";
+import { answerGrantsBeyondCall } from "../../standing-answer-grant.js";
 import { sendResumeOutcome } from "../route-ctx.js";
 import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 import { readResumeCtx, resumeCtxCorruptAnswer } from "../resume-ctx-read.js";
 import { recordFailOpen } from "../../observability/fail-open.js";
 import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "../../request-key-closure.js";
@@ -258,7 +260,12 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
     const { readJson, rateLimited, quotaExceeded, safeDecode } = ctx.helpers;
     const { resumeCheckpoint, resumePreempted, preparePlanReview, drivePlanReview } = ctx.legs;
     {
-        const cs = deps.checkpointStore;
+        const park = facts.checkpointPark(deps);
+        if (!park.available) {
+            sendError(res, 501, "capability.checkpoint_store_required", "the approvals and assistant faces need a durable approval store (DURABLE_APPROVAL=true); this deployment has none wired");
+            return;
+        }
+        const cs = park.checkpointStore;
         const principal = gatedPrincipal(req, deps.config);
         const operator = isOperator(principal, deps.config.operatorPrincipals);
         if (match.decl.id === "approvals-stream") {
@@ -295,11 +302,12 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 const operators = deps.config.operatorPrincipals;
                 const isExplicitOperator = explicitOperatorOk(principal, operators);
                 if (!isExplicitOperator) {
-                    const ownerOf = deps.sessionStorage?.ownerOf?.bind(deps.sessionStorage);
-                    if (!ownerOf) {
+                    const owned = facts.sessionOwnership(deps);
+                    if (!owned.available) {
                         sendError(res, 501, "capability.session_store_required", "approval exemptions require a session-store backend");
                         return;
                     }
+                    const ownerOf = owned.sessionStorage.ownerOf.bind(owned.sessionStorage);
                     const owner = await ownerOf(exSessionId);
                     if (owner === undefined || (owner !== null && owner !== principal)) {
                         sendError(res, 404, "not_found.session", "not found");
@@ -311,7 +319,8 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                         sendError(res, 404, "request.route_unsupported", "not found");
                         return;
                     }
-                    sendJson(res, 200, { exemptions: await deps.approvalExemptionStore.list(exSessionId) });
+                    const rows = await deps.approvalExemptionStore.list(exSessionId);
+                    sendJson(res, 200, { exemptions: rows.filter((r) => !answerGrantsBeyondCall({ toolName: r.toolName })) });
                     return;
                 }
                 if (exToolName === undefined) {
@@ -357,13 +366,15 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
         if (match.decl.id === "assistant-tasks") {
             const ownerParam = new URLSearchParams(match.search).get("owner") || undefined;
             const scope = operator && ownerParam ? ownerParam : (principal ?? "__none__");
-            if (!deps.runStore) {
+            const ledger = facts.durableRuns(deps);
+            if (!ledger.available) {
                 sendJson(res, 200, { tasks: [] });
                 return;
             }
+            const runStore = ledger.runStore;
             const summaries = await cs.listByScope(scope);
             const byGate = new Map(summaries.map((s) => [s.sessionId, s]));
-            const runs = await deps.runStore.listRuns({ owner: scope, limit: 100 });
+            const runs = await runStore.listRuns({ owner: scope, limit: 100 });
             const tasks = runs
                 .filter((r) => r.status === "running" || isParkedRunStatus(r.status))
                 .map((r) => {
@@ -385,20 +396,22 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
         if (match.decl.id === "assistant-task-preempt") {
             if (rateLimited(req, res) || quotaExceeded(req, res))
                 return;
-            if (!deps.runStore) {
+            const runs = facts.durableRuns(deps);
+            if (!runs.available) {
                 sendError(res, 501, "capability.run_store_required", "preemption requires a durable run store (DB_BACKEND=mysql|pg|local)");
                 return;
             }
+            const runStore = runs.runStore;
             if (deps.config.requirePrincipal && principal === undefined) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            if (!deps.config.resourceSuspend || !deps.checkpointStore) {
+            if (!deps.config.resourceSuspend) {
                 sendError(res, 501, "feature.preemption_disabled", "preemption not enabled on this worker (needs RESOURCE_SUSPEND=true + a durable checkpoint store)");
                 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", "task not found");
                 return;
@@ -415,16 +428,16 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                     sendJson(res, 202, { taskId, status: run.status, note: "task is not preempt-eligible (verify/cascade leg) — preempt is a no-op" });
                     return;
                 }
-                let flagged = await deps.runStore.requestPreempt(taskId, run.owner);
+                let flagged = await runStore.requestPreempt(taskId, run.owner);
                 const PREEMPT_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)) {
                         sendError(res, 409, "conflict.already_suspended", "task is already suspended", { taskId, status: now.status });
                         return;
                     }
                     if (now?.status === "running" && attempt < PREEMPT_RECLASSIFY_ATTEMPTS) {
-                        flagged = await deps.runStore.requestPreempt(taskId, run.owner);
+                        flagged = await runStore.requestPreempt(taskId, run.owner);
                         continue;
                     }
                     if (now?.status === "running") {
@@ -448,16 +461,18 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
         if (match.decl.id === "assistant-task-resume") {
             if (rateLimited(req, res) || quotaExceeded(req, res))
                 return;
-            if (!deps.runStore) {
+            const runs = facts.durableRuns(deps);
+            if (!runs.available) {
                 sendError(res, 501, "capability.run_store_required", "resume requires a durable run store (DB_BACKEND=mysql|pg|local)");
                 return;
             }
+            const runStore = runs.runStore;
             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", "task not found");
                 return;
@@ -475,10 +490,12 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
         if (match.decl.id === "assistant-task-plan-review") {
             if (rateLimited(req, res) || quotaExceeded(req, res))
                 return;
-            if (!deps.runStore) {
+            const runs = facts.durableRuns(deps);
+            if (!runs.available) {
                 sendError(res, 501, "capability.run_store_required", "plan_review requires a durable run store (DB_BACKEND=mysql|pg|local)");
                 return;
             }
+            const runStore = runs.runStore;
             if (deps.config.requirePrincipal && principal === undefined) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
@@ -540,7 +557,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 }
             }
             const planNonce = typeof body.boundCallId === "string" ? body.boundCallId : undefined;
-            const run = await deps.runStore.getRun(taskId);
+            const run = await runStore.getRun(taskId);
             if (!run) {
                 if (deps.config.directDoorActive) {
                     sendError(res, 401, "principal_unverified", "principal proof required");
@@ -809,7 +826,13 @@ function redactPendingDisclosures(row) {
 function projectPendingForWire(row, governance) {
     const redacted = redactPendingDisclosures(row);
     const governanceForced = governanceOriginOf({ riskDescriptor: row.riskDescriptor ?? undefined }, governance);
-    return governanceForced ? { ...redacted, governanceForced } : redacted;
+    const rememberRefused = !standingAnswerMayRetire({
+        governanceForced: governanceForced === true,
+        requiresRealApproval: row.requiresRealApproval === true,
+        mandated: row.mandated === true || row.ruleOffersAbsence === "mandated",
+        grantsBeyondCall: answerGrantsBeyondCall(row),
+    });
+    return { ...redacted, ...(governanceForced ? { governanceForced } : {}), ...(rememberRefused ? { rememberRefused: true } : {}) };
 }
 function createSseDeltaLane(res, spec) {
     let prev = new Map();

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

@@ -59,8 +59,6 @@ export interface SessionBackgroundReceipt {
     id: string;
     outcome: BackgroundShellHardKillReceipt["outcome"];
 }
-/** 能力位与两口 501 的**同一个**谓词:会话属主面在场(入站 owner 门 fail-closed,缺它两口都 501)。 */
-export declare function sessionBackgroundFacesAvailable(deps: Pick<RouteCtx["deps"], "sessionStorage">): boolean;
 export declare function handleBackground(req: IncomingMessage, res: ServerResponse, match: RouteMatch<BackgroundRouteId>, ctx: RouteCtx): Promise<void>;
 export declare const BACKGROUND_ROUTES: readonly [{
     readonly id: "session-background-list";

package/dist/http/routes/background.js

@@ -6,6 +6,7 @@ import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import {} from "../route-ctx.js";
 import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 const LIST_LIMIT = 500;
 export const DESCRIPTION_MAX = 500;
 const ROW_KEY_DISPOSITION = {
@@ -32,9 +33,6 @@ function projectRow(r) {
     };
 }
 const StopBodySchema = z.object({ includeRetained: z.boolean() }).strict();
-export function sessionBackgroundFacesAvailable(deps) {
-    return Boolean(deps.sessionStorage?.ownerOf);
-}
 export async function handleBackground(req, res, match, ctx) {
     const { deps } = ctx;
     const id = match.decl.id;
@@ -59,11 +57,12 @@ export async function handleBackground(req, res, match, ctx) {
         sendError(res, 400, "request.path_malformed", "session id segment is not valid percent-encoding");
         return;
     }
-    if (!sessionBackgroundFacesAvailable(deps)) {
+    const owned = facts.sessionOwnership(deps);
+    if (!owned.available) {
         sendError(res, 501, "capability.session_ownership_required", "the session background faces require the session-ownership face (sessionStorage.ownerOf)");
         return;
     }
-    const owner = await deps.sessionStorage.ownerOf(sessionId);
+    const owner = await owned.sessionStorage.ownerOf(sessionId);
     if (owner === undefined) {
         sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
         return;

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

@@ -3,7 +3,8 @@
  *
  * 路由:`GET /v1/capabilities/scenarios/:name`、`GET /v1/capabilities`、`GET /v1/models`。
  * 三条都在全局 service-credential 门**之后**(config 面非密只读),装配表里的位置必须保住这一点。
- * 本域零可变状态;deps 面宽(能力布尔逐条对应各路由的 501 门,单源不许漂移)但全是存在性只读。
+ * 本域零可变状态。凡是某个端点也在判的位,值一律是 `src/capability-facts.ts` 里对应事实的投影 ——
+ * 端点的不可用门调的是**同一只**函数,所以「位说有而端点恒拒」在结构上不可能(不是靠两边各写一份再对拍)。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type McpProbeLocal } from "../../capabilities/mcp-probe.js";

package/dist/http/routes/capabilities.js

@@ -7,13 +7,11 @@ import { taskWriteFaceRefusal } from "../../hosted-posture.js";
 import { autonomyOverrides } from "../../runtime-governance.js";
 import { DEVICE_PROTOCOL_VERSION, DEVICE_WS_PATH } from "../../device-ws-protocol.js";
 import { a2aInjectionHonored } from "../../task-a2a.js";
-import { mcpInjectionHonored } from "../../task-mcp.js";
 import { buildEmptyMcpProbeFace, buildMcpInjectionRefusal, buildMcpProbeCacheKey, buildMcpProbeInflightRefusal, buildMcpProbeRateKey, buildMcpProbeRateRefusal, createMcpProbeLocal, buildMcpProbeDeclarationRefusal, buildMcpProbeIncompleteRefusal, McpProbeIncomplete, MCP_PROBE_HTTP_STATUS, MCP_PROBE_MAX_INFLIGHT, MCP_PROBE_VERDICT_TIMEOUT_MS, createMcpProbeWalk, readMcpProbeBody, } from "../../capabilities/mcp-probe.js";
 import { mcpForScenario } from "../../config-center/facade.js";
 import { sendJson, sendError } from "../send.js";
 import { assertNever } from "../route-ctx.js";
 import { fileHistoryCaptureOf } from "../../file-history-capture.js";
-import { resolveStreamApprovalGate } from "../../tool-approval.js";
 import { projectMemoryEngineCapability } from "../../memory-posture.js";
 import { projectWriteProtectionCapability } from "../../write-protection.js";
 import { projectStoreCapability } from "../../store-posture.js";
@@ -21,12 +19,12 @@ import { projectWebSearchCapability } from "../../plugins/web-search.js";
 import { projectExecutionLaneCapability } from "../../capabilities/execution-lane.js";
 import { gateCompositeMembers } from "../../capabilities/composite-members.js";
 import { projectApprovalsStreamLiveCapability } from "../../capabilities/approvals-push.js";
-import { workflowModelAllowlistFor, selfOrchestrationDenial } from "../../task-workflow.js";
+import { workflowModelAllowlistFor } from "../../task-workflow.js";
 import { centerEntitlementSourceWired } from "../../runtime-caps-resolver.js";
+import * as facts from "../../capability-facts.js";
 import { judgeAutoModeArming } from "../../auto-mode-face.js";
 import { coercePermissionModeStrict, SETTINGS_PERMISSION_MODE_WORDS, taskHooksHonored } from "../../task-settings.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
-import { sessionBackgroundFacesAvailable } from "./background.js";
 function routePairingOf(deps, name, m) {
     if (modelKeyPoisonOf(name, deps.config.modelApiKeyEnv ?? {}, process.env, deps.config.modelApiKeys ?? {}) !== undefined)
         return "unknown";
@@ -57,8 +55,8 @@ export async function handleCapabilities(req, res, match, ctx) {
             return;
         }
         case "capabilities": {
-            const workflowsEngineCan = deps.workflowsCapable ?? Boolean(deps.workflowRunStore);
-            const workflowsDenial = selfOrchestrationDenial({ selfOrchestrationEnabled: deps.config.selfOrchestrationEnabled, requirePrincipal: deps.config.requirePrincipal }, centerEntitlementSourceWired(deps.config));
+            const workflowsEngine = facts.selfOrchestrationEngine(deps);
+            const workflowsAdmission = facts.selfOrchestrationAdmission(deps);
             const requestedModeRaw = new URLSearchParams(match.search).get("permissionMode");
             const requestedMode = requestedModeRaw === null ? undefined : coercePermissionModeStrict(requestedModeRaw);
             if (requestedModeRaw !== null && requestedMode === undefined) {
@@ -69,44 +67,44 @@ export async function handleCapabilities(req, res, match, ctx) {
             const { fault: autoModeFault, ...autoMode } = await judgeAutoModeArming(deps.autoModeFace, { requestedMode, principal: gatedPrincipal(req, deps.config), localDeny: deps.config.permissionsDisableAutoMode });
             if (autoModeFault !== undefined)
                 deps.logger?.warn("auto_mode_face_resolver_fault", { fault: autoModeFault });
-            const rulesLaneReachable = Boolean(deps.ruleConsent) && gatedPrincipal(req, deps.config) !== undefined;
+            const rulesLaneForCaller = facts.ruleLaneForCaller(deps, gatedPrincipal(req, deps.config)).available;
             sendJson(res, 200, gateCompositeMembers({
                 ...deps.capabilities,
-                asyncRuns: Boolean(deps.runStore),
-                artifacts: Boolean(deps.runStore),
-                approvals: Boolean(deps.checkpointStore),
-                sessions: Boolean(deps.sessionAudit),
-                deviceExecutor: deps.deviceHub
-                    ? { enabled: true, protocolVersion: DEVICE_PROTOCOL_VERSION, maxInflightPerDevice: deps.config.remoteExec?.provider === "device" ? (deps.config.remoteExec.maxInflightPerDevice ?? 4) : 4, wsPath: DEVICE_WS_PATH, management: Boolean(deps.deviceStore && deps.deviceEnrollment) }
+                asyncRuns: facts.durableRuns(deps).available,
+                artifacts: facts.durableRuns(deps).available,
+                approvals: facts.checkpointPark(deps).available,
+                sessions: facts.sessionAuditView(deps).available,
+                deviceExecutor: facts.deviceLane(deps).available
+                    ? { enabled: true, protocolVersion: DEVICE_PROTOCOL_VERSION, maxInflightPerDevice: deps.config.remoteExec?.provider === "device" ? (deps.config.remoteExec.maxInflightPerDevice ?? 4) : 4, wsPath: DEVICE_WS_PATH, management: facts.deviceManagement(deps).available }
                     : false,
-                sessionEvents: Boolean(deps.sessionWatch && deps.sessionStorage?.getLeafId && deps.sessionStorage?.ownerOf),
-                fleet: deps.fleetBus
-                    ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory", hookFailureNotice: true }
+                sessionEvents: facts.sessionEventStream(deps).available,
+                fleet: facts.fleetStream(deps).available
+                    ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "engine", hookFailureNotice: true }
                     : false,
-                workspace: false,
-                leader: Boolean(deps.leaderEndpoint),
-                images: Boolean(deps.imageIndex),
+                workspace: facts.workspaceBrowse().available,
+                leader: facts.leaderLane(deps).available,
+                images: facts.imagePool(deps).available,
                 memory: false,
                 memoryWrite: false,
                 memoryEngine: projectMemoryEngineCapability(deps.memoryPosture),
                 store: projectStoreCapability(deps.storePosture ?? { declared: deps.config.dbBackend, backend: "memory" }, deps.sqlEngineFacts?.()),
                 centerWiring: deps.centerWiring?.(gatedPrincipal(req, deps.config)),
                 webSearch: projectWebSearchCapability(deps.webSearchProvider),
-                sessionBackgroundable: Boolean(deps.runStore),
-                runMemoryCaptureOptOut: Boolean(deps.runStore),
-                mcpReconnect: Boolean(deps.runStore) && Boolean(deps.sessionStorage?.ownerOf),
-                background: { listFace: sessionBackgroundFacesAvailable(deps), exitFaces: sessionBackgroundFacesAvailable(deps) },
-                sharedMemory: Boolean(deps.sharedMemoryStore && deps.orgMemoryDirectory),
-                adoption: Boolean(deps.backend?.adoptionLog) && deps.config.operatorPrincipals.length > 0,
-                memoryBundle: Boolean(deps.memoryBundleExport && deps.memoryBundleImport) && deps.config.operatorPrincipals.length > 0,
-                memoryCompliance: Boolean(deps.memoryCompliance) && deps.config.operatorPrincipals.length > 0,
-                memoryOrigin: Boolean(deps.memoryOriginFace) && deps.config.operatorPrincipals.length > 0,
-                memoryConsolidationDriver: Boolean(deps.memoryConsolidation) && deps.config.operatorPrincipals.length > 0,
-                memoryOptOutGrant: Boolean(deps.memoryOptOutGrant) && deps.config.operatorPrincipals.length > 0,
-                outcomeLedger: Boolean(deps.outcomeSink?.summary) && (deps.config.requirePrincipal !== true || deps.config.operatorPrincipals.length > 0),
-                permissionRules: rulesLaneReachable,
-                permissionRulesWrite: rulesLaneReachable,
-                permissionRulesRevoke: Boolean(deps.ruleConsent),
+                sessionBackgroundable: facts.durableRuns(deps).available,
+                runMemoryCaptureOptOut: facts.durableRuns(deps).available,
+                mcpReconnect: facts.mcpReconnect(deps).available,
+                background: { listFace: facts.sessionOwnership(deps).available, exitFaces: facts.sessionOwnership(deps).available },
+                sharedMemory: facts.sharedMemoryRead(deps).available,
+                adoption: facts.adoption(deps).available,
+                memoryBundle: facts.memoryBundle(deps).available,
+                memoryCompliance: facts.memoryCompliance(deps).available,
+                memoryOrigin: facts.memoryOrigin(deps).available,
+                memoryConsolidationDriver: facts.memoryConsolidation(deps).available,
+                memoryOptOutGrant: facts.memoryOptOutGrant(deps).available,
+                outcomeLedger: facts.outcomeLedger(deps).available,
+                permissionRules: rulesLaneForCaller,
+                permissionRulesWrite: rulesLaneForCaller,
+                permissionRulesRevoke: facts.ruleLane(deps).available,
                 respondFreeFormRules: true,
                 respondBatchRuleOffers: true,
                 oneShot: true,
@@ -119,9 +117,10 @@ export async function handleCapabilities(req, res, match, ctx) {
                 messageIdentity: true,
                 forwardSubagentEvents: true,
                 scratchpadDir: true,
-                subagentSteer: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
-                subagentResume: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
+                subagentSteer: facts.subagentSteer(deps).available,
+                subagentResume: facts.subagentSteer(deps).available,
                 taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: cwdHonored(deps.config) || deviceCwdHonored(deps.config), hooks: taskHooksHonored(deps.config) },
+                settings: { permissions: { allowGrant: true } },
                 permissionModeAuto: {
                     accepted: true,
                     classifierSeat: deps.autoModeFace?.seatMounted === true,
@@ -132,59 +131,58 @@ export async function handleCapabilities(req, res, match, ctx) {
                 writeProtection: projectWriteProtectionCapability(deps.writeProtection),
                 appendSystemPrompt: true,
                 compactionModel: true,
-                subagentOutput: Boolean(deps.subagentTaskOutput) && Boolean(deps.runStore),
-                subagentStream: Boolean(deps.subagentTaskOutput) && Boolean(deps.runStore),
-                taskHandles: Boolean(deps.taskHandleOutput) && Boolean(deps.taskHandleStop) && Boolean(deps.runStore),
+                subagentOutput: facts.subagentOutput(deps).available,
+                subagentStream: facts.subagentOutput(deps).available,
+                taskHandles: facts.taskHandles(deps).available,
                 taskAgents: deps.config.requirePrincipal !== true,
                 retainBackgroundProcesses: deps.config.requirePrincipal !== true,
                 interactiveTools: true,
                 disableSkills: true,
+                userInvokedSkills: true,
+                skillToolLists: true,
                 projectContext: cwdHonored(deps.config),
                 callerCwd: cwdHonored(deps.config) || deviceCwdHonored(deps.config),
                 taskWriteFaceOpen: taskWriteFaceRefusal(deps.config) === undefined && autonomyOverrides(deps.config.autonomy).writeFace !== "roots",
                 executionLane: projectExecutionLaneCapability(deps.config),
-                mcpInjection: mcpInjectionHonored(deps.config),
+                mcpInjection: facts.mcpInjection(deps).available,
                 a2a: true,
                 a2aInjection: a2aInjectionHonored(deps.config),
-                a2aServe: deps.config.a2aServe !== undefined,
+                a2aServe: facts.a2aServe(deps).available,
                 modelUsage: Boolean(deps.runStore && deps.modelUsage),
                 sessionInit: true,
                 mcp: true,
                 mcpProbe: true,
-                mcpElicitation: Boolean(deps.elicitation),
-                askUserQuestion: Boolean(deps.question),
-                toolApproval: Boolean(deps.toolApproval),
+                mcpElicitation: facts.elicitation(deps).available,
+                askUserQuestion: facts.askUserQuestion(deps).available,
+                toolApproval: facts.toolApproval(deps).available,
                 approvalsStreamLive: projectApprovalsStreamLiveCapability(deps),
-                streamApproval: resolveStreamApprovalGate({
-                    toolApprovalEnabled: Boolean(deps.toolApproval),
-                    streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
-                    backend: deps.backend,
-                    parkFacility: deps.checkpointStore !== undefined,
-                }).active,
+                streamApproval: facts.streamApproval(deps).available,
                 approvalDecisionNote: true,
                 sideQuery: true,
-                agentRoster: Boolean(deps.backgroundAgentStore),
+                agentRoster: facts.agentRoster(deps).available,
                 retention: retentionAdvertisement(deps.config),
                 peerLane: Boolean(deps.peerDirectory),
-                sessionList: Boolean(deps.sessionStorage?.listSessions ?? deps.runStore?.listSessions),
-                sessionSearch: Boolean(deps.sessionStorage?.listSessions ?? deps.runStore?.listSessions),
-                sessionFork: Boolean(deps.sessionStorage?.fork),
-                sessionDelete: Boolean(deps.purgeSession),
+                sessionList: facts.sessionList(deps).available,
+                sessionSearch: facts.sessionList(deps).available,
+                sessionFork: facts.sessionFork(deps).available,
+                sessionDelete: facts.sessionDelete(deps).available,
                 resumeAt: Boolean(deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
                 promptSuggestions: true,
-                sessionPolicy: Boolean(deps.sessionPolicyStore),
+                sessionPolicy: facts.sessionPolicy(deps).available,
                 rewindFiles: Boolean(deps.fileHistoryStore),
                 restoreFiles: Boolean(deps.fileHistoryStore),
                 rewindFilesTo: Boolean(deps.fileHistoryStore && deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
                 fileHistoryCapture: fileHistoryCaptureOf(deps.fileHistoryStore, deps.config.fileHistoryCapture),
-                scheduler: Boolean(deps.config.schedulerEnabled && deps.config.requirePrincipal !== true && deps.config.remoteExec?.provider === "host"),
-                sessionSync: Boolean(deps.backend && deps.sessionStorage?.exportEntries && deps.sessionStorage?.beginImportStaging && deps.fileHistoryStore),
+                scheduler: facts.hostScheduler(deps.config).available,
+                sessionSync: facts.sessionSync(deps).available,
+                sessionSyncFileHistory: facts.sessionSyncFileHistory(deps).available,
                 sendUserFile: Boolean(deps.sendUserFile && deps.config.sendUserFile?.publicEndpoint),
                 s3PublicEndpoint: deps.config.sendUserFile?.publicEndpoint ?? null,
-                sendUserFileLedger: Boolean(deps.sendFileLedger),
-                workflows: workflowsEngineCan && workflowsDenial === null,
-                workflowsList: Boolean(deps.workflowRunStore),
-                workflowsGate: { engineCan: workflowsEngineCan, denial: workflowsDenial },
+                sendUserFileLedger: facts.sendFileLedger(deps).available,
+                workflows: facts.selfOrchestration(deps).available,
+                workflowsList: facts.workflowRuns(deps).available,
+                workflowsJournal: facts.workflowsJournal(deps).available,
+                workflowsGate: { engineCan: workflowsEngine.available, denial: workflowsAdmission.available ? null : workflowsAdmission.why },
                 workflowModels: (() => {
                     const allow = deps.workflowModelAllowlist
                         ?? workflowModelAllowlistFor({
@@ -197,8 +195,8 @@ export async function handleCapabilities(req, res, match, ctx) {
                     const live = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
                     return allow.filter((n) => Object.hasOwn(live, n));
                 })(),
-                manualCompact: Boolean(deps.runStore),
-                configCatalog: deps.config.configCatalogEnabled === true && deps.config.operatorPrincipals.length > 0,
+                manualCompact: facts.durableRuns(deps).available,
+                configCatalog: facts.configCatalog(deps).available,
                 sealedKey: projectSealedKeyCapability(deps.sealedKeyPublic),
             }));
             return;
@@ -218,7 +216,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            if (!mcpInjectionHonored(deps.config)) {
+            if (!facts.mcpInjection(deps).available) {
                 sendMcpProbeRefusal(res, ctx, buildMcpInjectionRefusal(), "gate_closed");
                 return;
             }