@sema-agent/server 7.115.0 → 7.116.0

package/dist/capability-facts.d.ts

@@ -0,0 +1,296 @@
+/**
+ * 能力事实 —— 「这台部署上,这一面能不能用」的**唯一**判据家。
+ *
+ * 一条规则,三个读者:
+ *  · 每个事实 = 这里**一只**纯函数。入 = 服务 deps 的只读切片(签名里的 `Pick` 就是它读哪几格的完整清单);
+ *    出 = `{ available: true }` 或 `{ available: false; why }`。零 I/O、零 await、零副作用。
+ *  · `GET /v1/capabilities` 的位只**投影**事实(布尔位 = `.available`;对象位写明投影规则)。
+ *  · 回答「这台部署上不可用」的每一道门(HTTP 501;a2a 两条路由的 404)调**同一只**事实;拒句可以按端点各写,
+ *    谓词不再写第二遍。
+ * 于是「位说有而端点恒拒」在结构上不可能:两边读的是同一个值。
+ *
+ * `why` 是一张闭集表({@link CAPABILITY_FACT_WHY}):每只事实的 why 类型被约束在这张表的键里(用了表外词 = 编译红),
+ * 多 why 的事实在门里按 `switch (f.why)` 收口(给事实添一个 why 而门没跟 = 编译红)。
+ *
+ * **见证**:携设施的事实在 available 臂上另带被判在场的那只设施引用(结构上仍是 `{ available: true }` 的子型)。
+ * 门在拒臂之后从见证取店,不再读 `deps.X` 第二遍 —— 否则只剩两条路:非空断言,或者把谓词再写一遍。
+ * 能力位只读 `.available`,见证不上 wire。
+ *
+ * 复合事实(一个位管一族、族内要几只事实都在)也住这里:能力面只读一只事实的 `.available`,不写 `a && b`。
+ */
+import type { FlatServiceDeps } from "./http/server.js";
+import type { ServiceConfig } from "./config.js";
+import type { OwnerAwareSessionStore } from "./security.js";
+import type { ServiceFileHistoryStore } from "./plugins/store-backend.js";
+import { resolveStreamApprovalGate } from "./tool-approval.js";
+/** why 闭集:词 → 给运维看的一句义(诊断 / 测试读它;wire 上的拒句由各门自写)。 */
+export declare const CAPABILITY_FACT_WHY: {
+    readonly run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)";
+    readonly subagent_registry_absent: "the sub-agent steer registry is not wired";
+    readonly subagent_output_face_absent: "the background sub-agent output face is not wired";
+    readonly task_handle_faces_absent: "the background task-handle output/stop faces are not wired";
+    readonly session_owner_face_absent: "the session store has no ownership face (sessionStorage.ownerOf)";
+    readonly checkpoint_store_absent: "no durable checkpoint store is wired (DURABLE_APPROVAL)";
+    readonly session_audit_absent: "no session audit view is wired (needs a durable session store)";
+    readonly session_watch_absent: "the session watch registry is not wired";
+    readonly session_leaf_face_absent: "the session store has no leaf-read face (sessionStorage.getLeafId)";
+    readonly session_lister_absent: "no session enumerator is wired (session store or run store listSessions)";
+    readonly session_fork_face_absent: "the session store has no fork face";
+    readonly session_purge_absent: "no session purge coordinator is wired";
+    readonly session_policy_store_absent: "no session policy store is wired";
+    readonly store_backend_absent: "no store backend is wired (DB_BACKEND=memory, multi-tenant bare boot, or half-configured SQL)";
+    readonly file_history_store_absent: "no file-history store is wired";
+    readonly session_export_absent: "the session store has no entry export faces (exportEntries / exportEntriesStream)";
+    readonly session_import_staging_absent: "the session store has no staged-import face (beginImportStaging)";
+    readonly policy_purge_absent: "the session policy store has no deleteBySession purge verb";
+    readonly sync_blob_faces_absent: "the file-history store has no blob transfer faces (SQL backends only)";
+    readonly device_hub_absent: "the device lane hub is not wired";
+    readonly device_store_absent: "the device store is not wired";
+    readonly device_enrollment_absent: "device enrollment is not wired";
+    readonly fleet_bus_absent: "the fleet event bus is not wired";
+    readonly workspace_retired: "the workspace browse face was retired with the whole-tree snapshot epoch";
+    readonly leader_endpoint_absent: "the leader endpoint is not wired";
+    readonly image_index_absent: "no image index is wired (SQL backends only)";
+    readonly shared_memory_store_absent: "no shared memory store provider is wired";
+    readonly org_memory_directory_absent: "no org memory directory (membership fold) is wired";
+    readonly operator_principals_empty: "OPERATOR_PRINCIPALS is empty, so no caller can ever be an operator";
+    readonly adoption_store_absent: "no adoption log store is wired (SQL backends only)";
+    readonly memory_bundle_faces_absent: "the memory engine's governance bundle faces are not wired";
+    readonly memory_compliance_faces_absent: "the memory engine's provenance/erasure faces are not wired";
+    readonly memory_origin_faces_absent: "the memory engine's origin marking faces are not wired";
+    readonly consolidation_valve_closed: "the memory consolidation valve is closed (MEMORY_CONSOLIDATION_DRIVER)";
+    readonly memory_optout_grant_absent: "no memory-capture opt-out grant store is wired (SQL backends only)";
+    readonly outcome_ledger_unqueryable: "the outcome sink has no query face (File sink)";
+    readonly config_catalog_disabled: "the config catalog is switched off (CONFIG_CATALOG_ENABLED=false)";
+    readonly rule_store_absent: "no permission-rule store is wired";
+    readonly caller_principal_absent: "this request carries no verified principal";
+    readonly caller_mcp_injection_refused: "this deployment does not honor caller-supplied MCP servers";
+    readonly a2a_serve_off: "A2A_SERVE_ENABLED is off";
+    readonly elicitation_disabled: "inbound MCP elicitation is off (MCP_ELICITATION_ENABLED)";
+    readonly ask_question_disabled: "AskUserQuestion live HITL is off (ASK_QUESTION_ENABLED)";
+    readonly tool_approval_disabled: "live tool approval is off (TOOL_APPROVAL_ENABLED)";
+    readonly stream_approval_disabled: "the stream approval protocol is off (STREAM_APPROVAL_ENABLED)";
+    readonly background_agent_store_absent: "no background-agent store is wired";
+    readonly sendfile_ledger_absent: "no SendUserFile ledger is wired";
+    readonly workflow_engine_absent: "the workflow engine is not available on this worker";
+    readonly entitlement_resolver_absent: "self-orchestration is on for a multi-tenant worker with no per-principal entitlement source";
+    readonly workflow_run_store_absent: "no workflow run store is wired (SELF_ORCHESTRATION_ENABLED)";
+    readonly workflow_journal_store_absent: "no workflow journal store is wired (needs a store backend)";
+    readonly scheduler_disabled: "the self-wake scheduler is off (SCHEDULER_ENABLED)";
+    readonly multi_tenant_deployment: "this is a multi-tenant deployment (REQUIRE_PRINCIPAL=true)";
+    readonly not_host_lane: "the execution lane is not the single-user host lane (REMOTE_EXEC=host)";
+};
+export type CapabilityFactWhy = keyof typeof CAPABILITY_FACT_WHY;
+/** 不可用臂。 */
+export interface FactUnavailable<Why extends CapabilityFactWhy> {
+    readonly available: false;
+    readonly why: Why;
+}
+/** 一只事实的出形(`W` = available 臂上的见证;无见证的事实取默认空对象 = 只有 `available: true`)。 */
+export type Fact<Why extends CapabilityFactWhy, W extends object = {}> = ({
+    readonly available: true;
+} & Readonly<W>) | FactUnavailable<Why>;
+type Deps = FlatServiceDeps;
+type Store<K extends keyof Deps> = NonNullable<Deps[K]>;
+type WithMethods<T, K extends keyof T> = T & {
+    [P in K]-?: NonNullable<T[P]>;
+};
+/** 持久 run 账面在场 —— `/v1/runs/*` 族、trace / 用量统计、assistant 的 preempt / resume / plan-review、
+ *  会话 detach、设备换绑都站在这一只事实上。 */
+export declare function durableRuns(d: Pick<Deps, "runStore">): Fact<"run_store_absent", {
+    runStore: Store<"runStore">;
+}>;
+export declare function subagentSteer(d: Pick<Deps, "runStore" | "subagentSteerRegistry">): Fact<"run_store_absent" | "subagent_registry_absent", {
+    runStore: Store<"runStore">;
+    registry: Store<"subagentSteerRegistry">;
+}>;
+export declare function subagentOutput(d: Pick<Deps, "runStore" | "subagentTaskOutput">): Fact<"run_store_absent" | "subagent_output_face_absent", {
+    runStore: Store<"runStore">;
+    output: Store<"subagentTaskOutput">;
+}>;
+export declare function taskHandles(d: Pick<Deps, "runStore" | "taskHandleOutput" | "taskHandleStop">): Fact<"run_store_absent" | "task_handle_faces_absent", {
+    runStore: Store<"runStore">;
+    output: Store<"taskHandleOutput">;
+    stop: Store<"taskHandleStop">;
+}>;
+type OwnedSessionStore = WithMethods<OwnerAwareSessionStore, "ownerOf">;
+/** 会话属主面在场(入站 owner 门的地基;缺它,带会话的门一律 fail-closed)。 */
+export declare function sessionOwnership(d: Pick<Deps, "sessionStorage">): Fact<"session_owner_face_absent", {
+    sessionStorage: OwnedSessionStore;
+}>;
+export declare function mcpReconnect(d: Pick<Deps, "runStore" | "sessionStorage">): Fact<"run_store_absent" | "session_owner_face_absent", {
+    runStore: Store<"runStore">;
+    sessionStorage: OwnedSessionStore;
+}>;
+export declare function sessionAuditView(d: Pick<Deps, "sessionAudit">): Fact<"session_audit_absent", {
+    sessionAudit: Store<"sessionAudit">;
+}>;
+export declare function sessionEventStream(d: Pick<Deps, "sessionWatch" | "sessionStorage">): Fact<"session_watch_absent" | "session_leaf_face_absent" | "session_owner_face_absent", {
+    watch: Store<"sessionWatch">;
+    sessionStorage: WithMethods<OwnerAwareSessionStore, "ownerOf" | "getLeafId">;
+}>;
+type SessionLister = NonNullable<OwnerAwareSessionStore["listSessions"]>;
+/** 会话枚举面:session 店的 `listSessions`,否则老形 run 店聚合。见证 = 已绑好宿主的那一只。 */
+export declare function sessionList(d: Pick<Deps, "sessionStorage" | "runStore">): Fact<"session_lister_absent", {
+    lister: SessionLister;
+}>;
+export declare function sessionFork(d: Pick<Deps, "sessionStorage">): Fact<"session_fork_face_absent" | "session_owner_face_absent", {
+    sessionStorage: WithMethods<OwnerAwareSessionStore, "ownerOf" | "fork">;
+}>;
+export declare function sessionDelete(d: Pick<Deps, "purgeSession" | "sessionStorage">): Fact<"session_purge_absent" | "session_owner_face_absent", {
+    purge: Store<"purgeSession">;
+    sessionStorage: OwnedSessionStore;
+}>;
+export declare function sessionPolicy(d: Pick<Deps, "sessionPolicyStore" | "sessionStorage">): Fact<"session_policy_store_absent" | "session_owner_face_absent", {
+    policyStore: Store<"sessionPolicyStore">;
+    sessionStorage: OwnedSessionStore;
+}>;
+type SyncSessionStore = WithMethods<OwnerAwareSessionStore, "ownerOf" | "exportEntries" | "exportEntriesStream" | "beginImportStaging">;
+type SessionSyncWhy = "store_backend_absent" | "session_owner_face_absent" | "file_history_store_absent" | "session_export_absent" | "session_import_staging_absent" | "policy_purge_absent";
+/** 会话对等同步的**对话半族**(manifest / entries / plan / import 两相):后端 ∧ 属主面 ∧ 文件历史店 ∧ 导出两面 ∧
+ *  staged 导入面 ∧ policy 店能清(overwrite-dst 的 commit 要擦目的端旧 policy 行)。文件历史的 blob 搬运是另一只事实。 */
+export declare function sessionSync(d: Pick<Deps, "backend" | "sessionStorage" | "fileHistoryStore" | "sessionPolicyStore">): Fact<SessionSyncWhy, {
+    backend: Store<"backend">;
+    sessionStorage: SyncSessionStore;
+    historyStore: ServiceFileHistoryStore;
+}>;
+/** blob 两面齐备的文件历史店(marker 门,不做名字探测:local 的引擎文件店带一只同名私有助手)。 */
+export type SyncBlobHistoryStore = ServiceFileHistoryStore & {
+    readonly syncBlobFaces: true;
+} & {
+    [P in "putBlob" | "getBlob"]-?: NonNullable<ServiceFileHistoryStore[P]>;
+};
+/** 会话同步的**文件历史半族**:对话半族 ∧ 文件历史店有 blob 搬运面(只有 SQL 两只店有)。 */
+export declare function sessionSyncFileHistory(d: Pick<Deps, "backend" | "sessionStorage" | "fileHistoryStore" | "sessionPolicyStore">): Fact<SessionSyncWhy | "sync_blob_faces_absent", {
+    historyStore: SyncBlobHistoryStore;
+}>;
+/** 持久审批底座(checkpoint 店)在场 —— `/v1/approvals/*` 与 `/v1/assistant/*` 整条车道、会话 wake 都站在它上面。 */
+export declare function checkpointPark(d: Pick<Deps, "checkpointStore">): Fact<"checkpoint_store_absent", {
+    checkpointStore: Store<"checkpointStore">;
+}>;
+export declare function elicitation(d: Pick<Deps, "elicitation">): Fact<"elicitation_disabled", {
+    coordinator: Store<"elicitation">;
+}>;
+export declare function askUserQuestion(d: Pick<Deps, "question">): Fact<"ask_question_disabled", {
+    coordinator: Store<"question">;
+}>;
+export declare function toolApproval(d: Pick<Deps, "toolApproval">): Fact<"tool_approval_disabled", {
+    coordinator: Store<"toolApproval">;
+}>;
+type StreamApprovalWhy = "tool_approval_disabled" | "stream_approval_disabled" | "store_backend_absent" | "checkpoint_store_absent";
+type ActiveStreamApproval = Extract<ReturnType<typeof resolveStreamApprovalGate>, {
+    active: true;
+}>;
+/** 流内审批协议在场 —— 判据的属主仍是 `resolveStreamApprovalGate`(三条执行腿的装配也读它);本事实把它的拒因译进 why 闭集。 */
+export declare function streamApproval(d: Pick<Deps, "toolApproval" | "config" | "backend" | "checkpointStore">): Fact<StreamApprovalWhy, {
+    askStore: ActiveStreamApproval["askStore"];
+}>;
+export declare function deviceLane(d: Pick<Deps, "deviceHub">): Fact<"device_hub_absent", {
+    hub: Store<"deviceHub">;
+}>;
+/** 设备管理三动词(列 / 读 / 换绑):hub ∧ 设备店 ∧ 入网 ∧ 持久 run 账面(换绑的「无在飞 run」门要它)。 */
+export declare function deviceManagement(d: Pick<Deps, "deviceHub" | "deviceStore" | "deviceEnrollment" | "runStore">): Fact<"device_hub_absent" | "device_store_absent" | "device_enrollment_absent" | "run_store_absent", {
+    hub: Store<"deviceHub">;
+    store: Store<"deviceStore">;
+    enrollment: Store<"deviceEnrollment">;
+    runStore: Store<"runStore">;
+}>;
+export declare function fleetStream(d: Pick<Deps, "fleetBus">): Fact<"fleet_bus_absent", {
+    fleetBus: Store<"fleetBus">;
+}>;
+/** workspace 浏览面:随整树快照纪元退役,恒不可用(位恒 false、路由恒 501,两边读这同一句)。**结构上**没有可用臂(型 = `FactUnavailable`,
+ *  不是 `Fact`)—— 调用方不写「可用时」那一臂,端点只按 why 穷举作答。 */
+export declare function workspaceBrowse(): FactUnavailable<"workspace_retired">;
+export declare function leaderLane(d: Pick<Deps, "leaderEndpoint">): Fact<"leader_endpoint_absent", {
+    endpoint: Store<"leaderEndpoint">;
+}>;
+export declare function imagePool(d: Pick<Deps, "imageIndex">): Fact<"image_index_absent", {
+    imageIndex: Store<"imageIndex">;
+}>;
+export declare function agentRoster(d: Pick<Deps, "backgroundAgentStore">): Fact<"background_agent_store_absent", {
+    store: Store<"backgroundAgentStore">;
+}>;
+export declare function sendFileLedger(d: Pick<Deps, "sendFileLedger">): Fact<"sendfile_ledger_absent", {
+    ledger: Store<"sendFileLedger">;
+}>;
+/** org 共享记忆只读面:供给面 ∧ org 折叠面(没有成员性判据的共享读面比没有更糟)。 */
+export declare function sharedMemoryRead(d: Pick<Deps, "sharedMemoryStore" | "orgMemoryDirectory">): Fact<"shared_memory_store_absent" | "org_memory_directory_absent", {
+    provider: Store<"sharedMemoryStore">;
+    directory: Store<"orgMemoryDirectory">;
+}>;
+/** operator 名单非空。空名单下 `explicitOperatorOk` 对任何身份恒假 ⇒ 这一族的口对谁都打不通 = 部署不可用(不是鉴权拒)。
+ *
+ * operator 族的复合事实**先判名单、再判设施**:门序是「身份 → 名单空(501)→ 授权(403)→ 设施缺席(501)」——
+ * 名单空时没有人过得了授权,不先判它,这一形就永远答成 403;设施缺席则留在授权之后答(不对非 operator 透露部署形态)。 */
+export declare function operatorLane(d: {
+    readonly config: Pick<ServiceConfig, "operatorPrincipals">;
+}): Fact<"operator_principals_empty">;
+type AdoptionCapableBackend = Store<"backend"> & {
+    adoptionLog(): ReturnType<NonNullable<Store<"backend">["adoptionLog"]>>;
+};
+export declare function adoption(d: Pick<Deps, "config" | "backend">): Fact<"operator_principals_empty" | "adoption_store_absent", {
+    backend: AdoptionCapableBackend;
+}>;
+export declare function memoryBundle(d: Pick<Deps, "config" | "memoryBundleExport" | "memoryBundleImport">): Fact<"operator_principals_empty" | "memory_bundle_faces_absent", {
+    exportScopes: Store<"memoryBundleExport">;
+    importBundle: Store<"memoryBundleImport">;
+}>;
+export declare function memoryCompliance(d: Pick<Deps, "config" | "memoryCompliance">): Fact<"operator_principals_empty" | "memory_compliance_faces_absent", {
+    faces: Store<"memoryCompliance">;
+}>;
+export declare function memoryOrigin(d: Pick<Deps, "config" | "memoryOriginFace">): Fact<"operator_principals_empty" | "memory_origin_faces_absent", {
+    faces: Store<"memoryOriginFace">;
+}>;
+/** 记忆整理阀门的两口。阀门关是一句旋钮表态(不是授权问题),所以它**先于**名单判:关着就对谁都答「关着」。 */
+export declare function memoryConsolidation(d: Pick<Deps, "config" | "memoryConsolidation">): Fact<"consolidation_valve_closed" | "operator_principals_empty", {
+    valve: Store<"memoryConsolidation">;
+}>;
+export declare function memoryOptOutGrant(d: Pick<Deps, "config" | "memoryOptOutGrant">): Fact<"operator_principals_empty" | "memory_optout_grant_absent", {
+    store: Store<"memoryOptOutGrant">;
+}>;
+type QueryableOutcomeSink = WithMethods<Store<"outcomeSink">, "summary">;
+/** 可查询的 outcome 账面 ∧(单用户 ∨ operator 名单非空)—— 单用户形唯一的用户就是 operator,这一口不判名单。 */
+export declare function outcomeLedger(d: Pick<Deps, "config" | "outcomeSink">): Fact<"operator_principals_empty" | "outcome_ledger_unqueryable", {
+    sink: QueryableOutcomeSink;
+}>;
+/** 配置目录。旋钮关是一句表态(合规部署不想让部署事实上 wire),先于名单判。 */
+export declare function configCatalog(d: Pick<Deps, "config">): Fact<"config_catalog_disabled" | "operator_principals_empty">;
+export declare function ruleLane(d: Pick<Deps, "ruleConsent">): Fact<"rule_store_absent", {
+    lane: Store<"ruleConsent">;
+}>;
+/** 规则车道**对这个调用方**够不够得着:车道在场 ∧ 本请求有已验 principal(规则车道按 principal 寻址,
+ *  `routes/rules.ts` 的域头对无 principal 一律 401)。按调用方算 —— 同一台 worker 对不同请求答案不同。 */
+export declare function ruleLaneForCaller(d: Pick<Deps, "ruleConsent">, principal: string | undefined): Fact<"rule_store_absent" | "caller_principal_absent">;
+/** 调用方自带 MCP 规格兑不兑现 —— 判据属主仍是 `mcpInjectionHonored`(提交腿的字段门也读它)。 */
+export declare function mcpInjection(d: Pick<Deps, "config">): Fact<"caller_mcp_injection_refused">;
+/** server-as-peer:旋钮开 ∧ 持久 run 账面在场。两只 JSON-RPC 方法(`message/send` / `tasks/get`)都要 run 店 ——
+ *  没有它,这个 peer 什么都做不了,对外就不该存在(卡与 RPC 一起 404)。 */
+export declare function a2aServe(d: Pick<Deps, "config" | "runStore">): Fact<"a2a_serve_off" | "run_store_absent", {
+    serve: NonNullable<ServiceConfig["a2aServe"]>;
+    runStore: Store<"runStore">;
+}>;
+/** 引擎能不能自编排(core 单源 `workflowsCapability`,boot 算好经 `workflowsCapable` 递来;缺席回落行店代理)。 */
+export declare function selfOrchestrationEngine(d: Pick<Deps, "workflowsCapable" | "workflowRunStore">): Fact<"workflow_engine_absent">;
+/** 部署级准入:引擎在、而本部署对任何 principal 都授不出去(多租户 + 没接 entitlement 源)⇒ 不可用。
+ *  判据属主仍是 `selfOrchestrationDenial`(与提交面准入同一只)。 */
+export declare function selfOrchestrationAdmission(d: Pick<Deps, "config">): Fact<"entitlement_resolver_absent">;
+/** 「这台机器上真跑得起来」的自编排 = 引擎能 ∧ 准入不拒。 */
+export declare function selfOrchestration(d: Pick<Deps, "config" | "workflowsCapable" | "workflowRunStore">): Fact<"workflow_engine_absent" | "entitlement_resolver_absent">;
+/** workflow run 的持久列举三口(list / detail / stream)= 行店(能力位 `workflowsList` 投影这一只)。 */
+export declare function workflowRuns(d: Pick<Deps, "workflowRunStore">): Fact<"workflow_run_store_absent", {
+    store: Store<"workflowRunStore">;
+}>;
+export declare function workflowJournal(d: Pick<Deps, "workflowJournalStore">): Fact<"workflow_journal_store_absent", {
+    journal: Store<"workflowJournalStore">;
+}>;
+/** workflow run 的 **journal 口**(`GET /v1/workflows/:id/journal`;能力位 `workflowsJournal` 投影这一只)= 行店 ∧ journal 店 —— journal 口要先按行判属主。
+ *  与 `workflowRuns` 是**拆开**的两只(照 `sessionSync` / `sessionSyncFileHistory`):无后端 + 自编排的三形上行店在、journal 店不在,
+ *  三口真能用而 journal 口恒 501 —— 合成一位总有一半在说假话。 */
+export declare function workflowsJournal(d: Pick<Deps, "workflowRunStore" | "workflowJournalStore">): Fact<"workflow_run_store_absent" | "workflow_journal_store_absent", {
+    store: Store<"workflowRunStore">;
+    journal: Store<"workflowJournalStore">;
+}>;
+/** 自唤醒调度器挂在宿主 env 上:`SCHEDULER_ENABLED` ∧ 单用户 ∧ host 车道。装配(`boot/execution-env.ts`)与能力位同调。 */
+export declare function hostScheduler(c: Pick<ServiceConfig, "schedulerEnabled" | "requirePrincipal" | "remoteExec">): Fact<"scheduler_disabled" | "multi_tenant_deployment" | "not_host_lane">;
+export {};
+//# sourceMappingURL=capability-facts.d.ts.map

package/dist/capability-facts.js

@@ -0,0 +1,354 @@
+import { mcpInjectionHonored } from "./task-mcp.js";
+import { resolveStreamApprovalGate } from "./tool-approval.js";
+import { selfOrchestrationDenial } from "./task-workflow.js";
+import { centerEntitlementSourceWired } from "./runtime-caps-resolver.js";
+import { overwriteWipeIncapable } from "./session-sync.js";
+export const CAPABILITY_FACT_WHY = {
+    run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)",
+    subagent_registry_absent: "the sub-agent steer registry is not wired",
+    subagent_output_face_absent: "the background sub-agent output face is not wired",
+    task_handle_faces_absent: "the background task-handle output/stop faces are not wired",
+    session_owner_face_absent: "the session store has no ownership face (sessionStorage.ownerOf)",
+    checkpoint_store_absent: "no durable checkpoint store is wired (DURABLE_APPROVAL)",
+    session_audit_absent: "no session audit view is wired (needs a durable session store)",
+    session_watch_absent: "the session watch registry is not wired",
+    session_leaf_face_absent: "the session store has no leaf-read face (sessionStorage.getLeafId)",
+    session_lister_absent: "no session enumerator is wired (session store or run store listSessions)",
+    session_fork_face_absent: "the session store has no fork face",
+    session_purge_absent: "no session purge coordinator is wired",
+    session_policy_store_absent: "no session policy store is wired",
+    store_backend_absent: "no store backend is wired (DB_BACKEND=memory, multi-tenant bare boot, or half-configured SQL)",
+    file_history_store_absent: "no file-history store is wired",
+    session_export_absent: "the session store has no entry export faces (exportEntries / exportEntriesStream)",
+    session_import_staging_absent: "the session store has no staged-import face (beginImportStaging)",
+    policy_purge_absent: "the session policy store has no deleteBySession purge verb",
+    sync_blob_faces_absent: "the file-history store has no blob transfer faces (SQL backends only)",
+    device_hub_absent: "the device lane hub is not wired",
+    device_store_absent: "the device store is not wired",
+    device_enrollment_absent: "device enrollment is not wired",
+    fleet_bus_absent: "the fleet event bus is not wired",
+    workspace_retired: "the workspace browse face was retired with the whole-tree snapshot epoch",
+    leader_endpoint_absent: "the leader endpoint is not wired",
+    image_index_absent: "no image index is wired (SQL backends only)",
+    shared_memory_store_absent: "no shared memory store provider is wired",
+    org_memory_directory_absent: "no org memory directory (membership fold) is wired",
+    operator_principals_empty: "OPERATOR_PRINCIPALS is empty, so no caller can ever be an operator",
+    adoption_store_absent: "no adoption log store is wired (SQL backends only)",
+    memory_bundle_faces_absent: "the memory engine's governance bundle faces are not wired",
+    memory_compliance_faces_absent: "the memory engine's provenance/erasure faces are not wired",
+    memory_origin_faces_absent: "the memory engine's origin marking faces are not wired",
+    consolidation_valve_closed: "the memory consolidation valve is closed (MEMORY_CONSOLIDATION_DRIVER)",
+    memory_optout_grant_absent: "no memory-capture opt-out grant store is wired (SQL backends only)",
+    outcome_ledger_unqueryable: "the outcome sink has no query face (File sink)",
+    config_catalog_disabled: "the config catalog is switched off (CONFIG_CATALOG_ENABLED=false)",
+    rule_store_absent: "no permission-rule store is wired",
+    caller_principal_absent: "this request carries no verified principal",
+    caller_mcp_injection_refused: "this deployment does not honor caller-supplied MCP servers",
+    a2a_serve_off: "A2A_SERVE_ENABLED is off",
+    elicitation_disabled: "inbound MCP elicitation is off (MCP_ELICITATION_ENABLED)",
+    ask_question_disabled: "AskUserQuestion live HITL is off (ASK_QUESTION_ENABLED)",
+    tool_approval_disabled: "live tool approval is off (TOOL_APPROVAL_ENABLED)",
+    stream_approval_disabled: "the stream approval protocol is off (STREAM_APPROVAL_ENABLED)",
+    background_agent_store_absent: "no background-agent store is wired",
+    sendfile_ledger_absent: "no SendUserFile ledger is wired",
+    workflow_engine_absent: "the workflow engine is not available on this worker",
+    entitlement_resolver_absent: "self-orchestration is on for a multi-tenant worker with no per-principal entitlement source",
+    workflow_run_store_absent: "no workflow run store is wired (SELF_ORCHESTRATION_ENABLED)",
+    workflow_journal_store_absent: "no workflow journal store is wired (needs a store backend)",
+    scheduler_disabled: "the self-wake scheduler is off (SCHEDULER_ENABLED)",
+    multi_tenant_deployment: "this is a multi-tenant deployment (REQUIRE_PRINCIPAL=true)",
+    not_host_lane: "the execution lane is not the single-user host lane (REMOTE_EXEC=host)",
+};
+const no = (why) => ({ available: false, why });
+const yes = (w) => ({ available: true, ...w });
+const YES = yes({});
+export function durableRuns(d) {
+    return d.runStore !== undefined ? yes({ runStore: d.runStore }) : no("run_store_absent");
+}
+export function subagentSteer(d) {
+    const runs = durableRuns(d);
+    if (!runs.available)
+        return runs;
+    return d.subagentSteerRegistry !== undefined ? yes({ runStore: runs.runStore, registry: d.subagentSteerRegistry }) : no("subagent_registry_absent");
+}
+export function subagentOutput(d) {
+    const runs = durableRuns(d);
+    if (!runs.available)
+        return runs;
+    return d.subagentTaskOutput !== undefined ? yes({ runStore: runs.runStore, output: d.subagentTaskOutput }) : no("subagent_output_face_absent");
+}
+export function taskHandles(d) {
+    const runs = durableRuns(d);
+    if (!runs.available)
+        return runs;
+    return d.taskHandleOutput !== undefined && d.taskHandleStop !== undefined
+        ? yes({ runStore: runs.runStore, output: d.taskHandleOutput, stop: d.taskHandleStop })
+        : no("task_handle_faces_absent");
+}
+export function sessionOwnership(d) {
+    const s = d.sessionStorage;
+    return s?.ownerOf !== undefined ? yes({ sessionStorage: s }) : no("session_owner_face_absent");
+}
+export function mcpReconnect(d) {
+    const runs = durableRuns(d);
+    if (!runs.available)
+        return runs;
+    const owned = sessionOwnership(d);
+    if (!owned.available)
+        return owned;
+    return yes({ runStore: runs.runStore, sessionStorage: owned.sessionStorage });
+}
+export function sessionAuditView(d) {
+    return d.sessionAudit !== undefined ? yes({ sessionAudit: d.sessionAudit }) : no("session_audit_absent");
+}
+export function sessionEventStream(d) {
+    if (d.sessionWatch === undefined)
+        return no("session_watch_absent");
+    const s = d.sessionStorage;
+    if (s?.getLeafId === undefined)
+        return no("session_leaf_face_absent");
+    if (s.ownerOf === undefined)
+        return no("session_owner_face_absent");
+    return yes({ watch: d.sessionWatch, sessionStorage: s });
+}
+export function sessionList(d) {
+    const lister = d.sessionStorage?.listSessions?.bind(d.sessionStorage) ?? d.runStore?.listSessions?.bind(d.runStore);
+    return lister !== undefined ? yes({ lister }) : no("session_lister_absent");
+}
+export function sessionFork(d) {
+    const s = d.sessionStorage;
+    if (s?.fork === undefined)
+        return no("session_fork_face_absent");
+    if (s.ownerOf === undefined)
+        return no("session_owner_face_absent");
+    return yes({ sessionStorage: s });
+}
+export function sessionDelete(d) {
+    if (d.purgeSession === undefined)
+        return no("session_purge_absent");
+    const owned = sessionOwnership(d);
+    if (!owned.available)
+        return owned;
+    return yes({ purge: d.purgeSession, sessionStorage: owned.sessionStorage });
+}
+export function sessionPolicy(d) {
+    if (d.sessionPolicyStore === undefined)
+        return no("session_policy_store_absent");
+    const owned = sessionOwnership(d);
+    if (!owned.available)
+        return owned;
+    return yes({ policyStore: d.sessionPolicyStore, sessionStorage: owned.sessionStorage });
+}
+export function sessionSync(d) {
+    if (d.backend === undefined)
+        return no("store_backend_absent");
+    const s = d.sessionStorage;
+    if (s?.ownerOf === undefined)
+        return no("session_owner_face_absent");
+    if (d.fileHistoryStore === undefined)
+        return no("file_history_store_absent");
+    if (s.exportEntries === undefined || s.exportEntriesStream === undefined)
+        return no("session_export_absent");
+    if (s.beginImportStaging === undefined)
+        return no("session_import_staging_absent");
+    if (overwriteWipeIncapable(d.sessionPolicyStore))
+        return no("policy_purge_absent");
+    return yes({ backend: d.backend, sessionStorage: s, historyStore: d.fileHistoryStore });
+}
+export function sessionSyncFileHistory(d) {
+    const sync = sessionSync(d);
+    if (!sync.available)
+        return sync;
+    const fs = sync.historyStore;
+    return fs.syncBlobFaces === true && typeof fs.putBlob === "function" && typeof fs.getBlob === "function"
+        ? yes({ historyStore: fs })
+        : no("sync_blob_faces_absent");
+}
+export function checkpointPark(d) {
+    return d.checkpointStore !== undefined ? yes({ checkpointStore: d.checkpointStore }) : no("checkpoint_store_absent");
+}
+export function elicitation(d) {
+    return d.elicitation !== undefined ? yes({ coordinator: d.elicitation }) : no("elicitation_disabled");
+}
+export function askUserQuestion(d) {
+    return d.question !== undefined ? yes({ coordinator: d.question }) : no("ask_question_disabled");
+}
+export function toolApproval(d) {
+    return d.toolApproval !== undefined ? yes({ coordinator: d.toolApproval }) : no("tool_approval_disabled");
+}
+export function streamApproval(d) {
+    const gate = resolveStreamApprovalGate({
+        toolApprovalEnabled: d.toolApproval !== undefined,
+        streamApprovalEnabled: d.config.streamApproval?.enabled === true,
+        backend: d.backend,
+        parkFacility: d.checkpointStore !== undefined,
+    });
+    if (gate.active)
+        return yes({ askStore: gate.askStore });
+    switch (gate.reason) {
+        case "no_tool_approval":
+            return no("tool_approval_disabled");
+        case "protocol_disabled":
+            return no("stream_approval_disabled");
+        case "no_backend":
+            return no("store_backend_absent");
+        case "no_park_facility":
+            return no("checkpoint_store_absent");
+        default: {
+            const unhandled = gate.reason;
+            throw new Error(`unhandled stream-approval gate reason: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+export function deviceLane(d) {
+    return d.deviceHub !== undefined ? yes({ hub: d.deviceHub }) : no("device_hub_absent");
+}
+export function deviceManagement(d) {
+    const lane = deviceLane(d);
+    if (!lane.available)
+        return lane;
+    if (d.deviceStore === undefined)
+        return no("device_store_absent");
+    if (d.deviceEnrollment === undefined)
+        return no("device_enrollment_absent");
+    const runs = durableRuns(d);
+    if (!runs.available)
+        return runs;
+    return yes({ hub: lane.hub, store: d.deviceStore, enrollment: d.deviceEnrollment, runStore: runs.runStore });
+}
+export function fleetStream(d) {
+    return d.fleetBus !== undefined ? yes({ fleetBus: d.fleetBus }) : no("fleet_bus_absent");
+}
+export function workspaceBrowse() {
+    return no("workspace_retired");
+}
+export function leaderLane(d) {
+    return d.leaderEndpoint !== undefined ? yes({ endpoint: d.leaderEndpoint }) : no("leader_endpoint_absent");
+}
+export function imagePool(d) {
+    return d.imageIndex !== undefined ? yes({ imageIndex: d.imageIndex }) : no("image_index_absent");
+}
+export function agentRoster(d) {
+    return d.backgroundAgentStore !== undefined ? yes({ store: d.backgroundAgentStore }) : no("background_agent_store_absent");
+}
+export function sendFileLedger(d) {
+    return d.sendFileLedger !== undefined ? yes({ ledger: d.sendFileLedger }) : no("sendfile_ledger_absent");
+}
+export function sharedMemoryRead(d) {
+    if (d.sharedMemoryStore === undefined)
+        return no("shared_memory_store_absent");
+    if (d.orgMemoryDirectory === undefined)
+        return no("org_memory_directory_absent");
+    return yes({ provider: d.sharedMemoryStore, directory: d.orgMemoryDirectory });
+}
+export function operatorLane(d) {
+    return d.config.operatorPrincipals.length > 0 ? YES : no("operator_principals_empty");
+}
+export function adoption(d) {
+    const lane = operatorLane(d);
+    if (!lane.available)
+        return lane;
+    const b = d.backend;
+    return b !== undefined && typeof b.adoptionLog === "function" ? yes({ backend: b }) : no("adoption_store_absent");
+}
+export function memoryBundle(d) {
+    const lane = operatorLane(d);
+    if (!lane.available)
+        return lane;
+    return d.memoryBundleExport !== undefined && d.memoryBundleImport !== undefined
+        ? yes({ exportScopes: d.memoryBundleExport, importBundle: d.memoryBundleImport })
+        : no("memory_bundle_faces_absent");
+}
+export function memoryCompliance(d) {
+    const lane = operatorLane(d);
+    if (!lane.available)
+        return lane;
+    return d.memoryCompliance !== undefined ? yes({ faces: d.memoryCompliance }) : no("memory_compliance_faces_absent");
+}
+export function memoryOrigin(d) {
+    const lane = operatorLane(d);
+    if (!lane.available)
+        return lane;
+    return d.memoryOriginFace !== undefined ? yes({ faces: d.memoryOriginFace }) : no("memory_origin_faces_absent");
+}
+export function memoryConsolidation(d) {
+    if (d.memoryConsolidation === undefined)
+        return no("consolidation_valve_closed");
+    const lane = operatorLane(d);
+    return lane.available ? yes({ valve: d.memoryConsolidation }) : lane;
+}
+export function memoryOptOutGrant(d) {
+    const lane = operatorLane(d);
+    if (!lane.available)
+        return lane;
+    return d.memoryOptOutGrant !== undefined ? yes({ store: d.memoryOptOutGrant }) : no("memory_optout_grant_absent");
+}
+export function outcomeLedger(d) {
+    if (d.config.requirePrincipal === true) {
+        const lane = operatorLane(d);
+        if (!lane.available)
+            return lane;
+    }
+    const sink = d.outcomeSink;
+    return sink?.summary !== undefined ? yes({ sink: sink }) : no("outcome_ledger_unqueryable");
+}
+export function configCatalog(d) {
+    if (d.config.configCatalogEnabled !== true)
+        return no("config_catalog_disabled");
+    return operatorLane(d);
+}
+export function ruleLane(d) {
+    return d.ruleConsent !== undefined ? yes({ lane: d.ruleConsent }) : no("rule_store_absent");
+}
+export function ruleLaneForCaller(d, principal) {
+    const lane = ruleLane(d);
+    if (!lane.available)
+        return lane;
+    return principal !== undefined ? YES : no("caller_principal_absent");
+}
+export function mcpInjection(d) {
+    return mcpInjectionHonored(d.config) ? YES : no("caller_mcp_injection_refused");
+}
+export function a2aServe(d) {
+    const serve = d.config.a2aServe;
+    if (serve === undefined)
+        return no("a2a_serve_off");
+    const runs = durableRuns(d);
+    return runs.available ? yes({ serve, runStore: runs.runStore }) : runs;
+}
+export function selfOrchestrationEngine(d) {
+    return (d.workflowsCapable ?? d.workflowRunStore !== undefined) ? YES : no("workflow_engine_absent");
+}
+export function selfOrchestrationAdmission(d) {
+    const denial = selfOrchestrationDenial({ selfOrchestrationEnabled: d.config.selfOrchestrationEnabled, requirePrincipal: d.config.requirePrincipal }, centerEntitlementSourceWired(d.config));
+    return denial === null ? YES : no(denial);
+}
+export function selfOrchestration(d) {
+    const engine = selfOrchestrationEngine(d);
+    if (!engine.available)
+        return engine;
+    return selfOrchestrationAdmission(d);
+}
+export function workflowRuns(d) {
+    return d.workflowRunStore !== undefined ? yes({ store: d.workflowRunStore }) : no("workflow_run_store_absent");
+}
+export function workflowJournal(d) {
+    return d.workflowJournalStore !== undefined ? yes({ journal: d.workflowJournalStore }) : no("workflow_journal_store_absent");
+}
+export function workflowsJournal(d) {
+    const runs = workflowRuns(d);
+    if (!runs.available)
+        return runs;
+    const journal = workflowJournal(d);
+    return journal.available ? yes({ store: runs.store, journal: journal.journal }) : journal;
+}
+export function hostScheduler(c) {
+    if (c.schedulerEnabled !== true)
+        return no("scheduler_disabled");
+    if (c.requirePrincipal === true)
+        return no("multi_tenant_deployment");
+    if (c.remoteExec?.provider !== "host")
+        return no("not_host_lane");
+    return YES;
+}
+//# sourceMappingURL=capability-facts.js.map