open-multi-agent-kit 0.79.3 → 0.80.2

package/dist/runtime/authority-matrix.js

@@ -0,0 +1,171 @@
+export const RUNTIME_AUTHORITY_MATRIX = [
+    {
+        providerId: "kimi",
+        runtimeMode: "api",
+        authorities: ["read", "review", "vision", "toolCalling"],
+        advisory: true,
+        notes: "Moonshot/Kimi API is advisory; no direct workspace write/shell/merge authority.",
+    },
+    {
+        providerId: "kimi",
+        runtimeMode: "wire",
+        authorities: ["read", "review", "write", "patch", "vision", "toolCalling"],
+        advisory: false,
+        notes: "Kimi wire/CLI compatibility path can edit through the OMK-controlled adapter, but shell/merge still require explicit authority.",
+    },
+    {
+        providerId: "kimi",
+        runtimeMode: "cli",
+        authorities: ["read", "review", "write", "patch", "vision", "toolCalling"],
+        advisory: false,
+        notes: "Legacy Kimi CLI compatibility path is available only when explicitly requested; shell/merge remain separately gated.",
+    },
+    {
+        providerId: "mimo",
+        runtimeMode: "api",
+        authorities: ["read", "review"],
+        advisory: true,
+        notes: "MiMo API is read/review/thinking only until a write-capable runtime-mode contract exists.",
+    },
+    {
+        providerId: "deepseek",
+        runtimeMode: "api",
+        authorities: ["read", "review"],
+        advisory: true,
+    },
+    {
+        providerId: "glm",
+        runtimeMode: "api",
+        authorities: ["read", "review"],
+        advisory: true,
+    },
+    {
+        providerId: "codex",
+        runtimeMode: "cli",
+        authorities: ["read", "review", "write", "patch", "shell"],
+        advisory: false,
+        notes: "Codex CLI authority is bounded by OMK approval/sandbox policy; merge remains withheld.",
+    },
+    {
+        providerId: "opencode",
+        runtimeMode: "cli",
+        authorities: ["read", "review", "write", "patch", "shell"],
+        advisory: false,
+    },
+    {
+        providerId: "commandcode",
+        runtimeMode: "cli",
+        authorities: ["read", "review", "write", "patch", "shell"],
+        advisory: false,
+    },
+    {
+        providerId: "local-llm",
+        runtimeMode: "api",
+        authorities: ["read", "review"],
+        advisory: true,
+    },
+    {
+        providerId: "openrouter",
+        runtimeMode: "api",
+        authorities: ["read", "review", "vision", "toolCalling"],
+        advisory: true,
+        notes: "OpenRouter API is advisory unless paired with an OMK-owned write/shell adapter.",
+    },
+    {
+        providerId: "qwen",
+        runtimeMode: "api",
+        authorities: ["read", "review", "vision", "toolCalling"],
+        advisory: true,
+        notes: "Qwen API is advisory unless paired with an OMK-owned write/shell adapter.",
+    },
+];
+export function runtimeProviderId(runtime) {
+    return runtime.providerId ?? runtime.id.split("-")[0] ?? runtime.id;
+}
+export function runtimeModeOf(runtime) {
+    if (runtime.runtimeMode)
+        return runtime.runtimeMode;
+    if (runtime.kind)
+        return runtime.kind;
+    const suffix = runtime.id.split("-").slice(1).join("-");
+    if (suffix === "api" || suffix === "cli" || suffix === "wire")
+        return suffix;
+    return "api";
+}
+export function getRuntimeAuthorityEntry(runtime) {
+    const providerId = runtimeProviderId(runtime);
+    const runtimeMode = runtimeModeOf(runtime);
+    return RUNTIME_AUTHORITY_MATRIX.find((entry) => entry.providerId === providerId && entry.runtimeMode === runtimeMode);
+}
+export function authoritiesForRuntime(runtime) {
+    const entry = getRuntimeAuthorityEntry(runtime);
+    const caps = runtime.capabilities;
+    if (entry) {
+        const granted = new Set(entry.authorities);
+        // Provider/mode entries remain the source of truth for write/shell/merge.
+        // Add only explicitly declared auxiliary capabilities so test/fake runtimes
+        // and future adapters can expose MCP/tool contracts without broadening
+        // destructive authority by provider name alone.
+        if (caps?.mcp === true)
+            granted.add("mcp");
+        if (caps?.vision === true)
+            granted.add("vision");
+        if (caps?.toolCalling === true || caps?.supportsToolCalling === true)
+            granted.add("toolCalling");
+        return [...granted];
+    }
+    if (!caps)
+        return ["read"];
+    const derived = [];
+    for (const op of ["read", "review", "write", "patch", "shell", "mcp", "merge", "vision"]) {
+        if (caps[op] === true)
+            derived.push(op);
+    }
+    if (caps.toolCalling === true || caps.supportsToolCalling === true)
+        derived.push("toolCalling");
+    return derived.length > 0 ? derived : ["read"];
+}
+export function runtimeIsAdvisory(runtime) {
+    const entry = getRuntimeAuthorityEntry(runtime);
+    if (entry)
+        return entry.advisory;
+    return runtime.capabilities?.advisory === true;
+}
+export function requiredAuthorityForTask(task) {
+    const required = ["read"];
+    const caps = task.capabilities;
+    if (caps.review)
+        required.push("review");
+    if (caps.write)
+        required.push("write");
+    if (caps.patch)
+        required.push("patch");
+    if (caps.shell)
+        required.push("shell");
+    if (caps.mcp)
+        required.push("mcp");
+    if (caps.merge)
+        required.push("merge");
+    if (caps.vision)
+        required.push("vision");
+    if (caps.toolCalling)
+        required.push("toolCalling");
+    return [...new Set(required)];
+}
+export function runtimeSatisfiesAuthority(runtime, task) {
+    const granted = new Set(authoritiesForRuntime(runtime));
+    const required = requiredAuthorityForTask(task);
+    const missing = required.filter((op) => !granted.has(op));
+    if (missing.length === 0)
+        return { ok: true, missing: [] };
+    return {
+        ok: false,
+        missing,
+        reason: `runtime ${runtime.id} (${runtimeProviderId(runtime)}:${runtimeModeOf(runtime)}) lacks required authority: ${missing.join(", ")}`,
+    };
+}
+export function authorityCapableProviderIds(required) {
+    return [...new Set(RUNTIME_AUTHORITY_MATRIX
+            .filter((entry) => required.every((op) => entry.authorities.includes(op)))
+            .map((entry) => entry.providerId))];
+}

package/dist/runtime/chat-advisory-runtime.js

@@ -2,6 +2,9 @@ import { execSync } from "child_process";
 export function createChatAdvisoryRuntime() {
     return {
         id: "omk-advisory",
+        providerId: "omk",
+        runtimeMode: "local",
+        kind: "local",
         priority: 0,
         supports: () => true,
         async runNode(_capsule, _signal) {

package/dist/runtime/codex-cli-runtime.js

@@ -6,6 +6,8 @@ export function createCodexCliRuntime(options) {
     const runner = createCodexCliAdvisoryTaskRunner(options);
     return {
         id: "codex-cli",
+        providerId: "codex",
+        runtimeMode: "cli",
         displayName: "Codex CLI",
         kind: "cli",
         priority: 60,

package/dist/runtime/codex-runtime.d.ts

@@ -4,6 +4,7 @@
  * Spawns the `codex` CLI subprocess and bridges AgentTask / AgentResult.
  */
 import type { AgentRuntime, AgentRunResult, AgentResult, AgentTask, RuntimeCapabilities, RuntimeHealth } from "./agent-runtime.js";
+import type { RuntimeHealthProbeRequest } from "./contracts/shared.js";
 import type { ContextCapsule } from "./context-capsule.js";
 export interface CodexRuntimeOptions {
     bin?: string;
@@ -16,6 +17,8 @@ export interface CodexRuntimeOptions {
 }
 export declare class CodexRuntime implements AgentRuntime {
     readonly id = "codex-cli";
+    readonly providerId = "codex";
+    readonly runtimeMode = "cli";
     readonly kind = "cli";
     readonly priority = 60;
     readonly capabilities: RuntimeCapabilities;
@@ -28,7 +31,7 @@ export declare class CodexRuntime implements AgentRuntime {
     private readonly safetyMarginTokens;
     constructor(options?: CodexRuntimeOptions);
     supports(capsule: ContextCapsule): boolean;
-    health(): Promise<RuntimeHealth>;
+    health(input?: RuntimeHealthProbeRequest): Promise<RuntimeHealth>;
     runNode(capsule: ContextCapsule, signal: AbortSignal): Promise<AgentRunResult>;
     execute(task: AgentTask): Promise<AgentResult>;
     private buildPrompt;

package/dist/runtime/codex-runtime.js

@@ -9,8 +9,11 @@ import { sanitizeUserVisibleOutput } from "../util/user-visible-output.js";
 import { buildChildEnv } from "./child-env.js";
 import { contextPreflightErrorMessage, preflightProviderInput, } from "../providers/context-preflight.js";
 import { createRuntimeSandboxProfile } from "./sandbox-profile.js";
+import { staticRuntimeHealth } from "./runtime-health-probes.js";
 export class CodexRuntime {
     id = "codex-cli";
+    providerId = "codex";
+    runtimeMode = "cli";
     kind = "cli";
     priority = 60;
     capabilities = {
@@ -68,14 +71,25 @@ export class CodexRuntime {
         }
         return true;
     }
-    async health() {
-        const available = await checkCommand(this.bin).catch(() => false);
-        return {
+    async health(input = { probeKind: "static", highRisk: false }) {
+        const started = Date.now();
+        const runtimeOk = input.probeKind === "static"
+            ? await checkCommand(this.bin).catch(() => false)
+            : (await runShell(this.bin, ["--version"], { cwd: this.cwd, timeout: 5000 }).catch(() => ({ exitCode: 1 }))).exitCode === 0;
+        const available = runtimeOk;
+        return staticRuntimeHealth({
             runtimeId: this.id,
             available,
-            reason: available ? undefined : "codex CLI is not available on PATH",
-            checkedAt: new Date().toISOString(),
-        };
+            reason: available ? undefined : "codex CLI is not available or failed --version probe",
+            runtimeOk,
+            authOk: runtimeOk,
+            modelOk: true,
+            quotaOk: true,
+            rateLimitOk: true,
+            latencyMs: input.probeKind === "static" ? undefined : Date.now() - started,
+            probeKind: input.probeKind,
+            ttlMs: input.probeKind === "static" ? 60_000 : 30_000,
+        });
     }
     async runNode(capsule, signal) {
         try {
@@ -146,12 +160,7 @@ export class CodexRuntime {
                 ...(model ? { OMK_PROVIDER_MODEL: model } : {}),
             },
         });
-        const sandboxMode = task.context.sandboxMode === "read-only" || task.context.sandboxMode === "workspace-write"
-            ? task.context.sandboxMode
-            :
-                task.capabilities.write || task.capabilities.patch || task.capabilities.shell
-                    ? "workspace-write"
-                    : "read-only";
+        const sandboxMode = resolveCodexSandboxMode(task);
         const approvalPolicy = codexApprovalPolicy(task.context.approvalPolicy ?? task.context.env?.OMK_APPROVAL_POLICY, sandboxMode);
         const sandboxProfile = createRuntimeSandboxProfile({
             cwd: this.cwd,
@@ -254,10 +263,23 @@ export class CodexRuntime {
         return parts.join("\n");
     }
 }
+function resolveCodexSandboxMode(task) {
+    if (task.context.sandboxMode === "read-only" || task.context.sandboxMode === "workspace-write") {
+        return task.context.sandboxMode;
+    }
+    // Advisory API runtimes must stay read-only even if capabilities request write.
+    if (task.context.env?.OMK_PROVIDER_AUTHORITY === "advisory")
+        return "read-only";
+    if (task.capabilities.write || task.capabilities.patch || task.capabilities.shell) {
+        return "workspace-write";
+    }
+    return "read-only";
+}
 function codexApprovalPolicy(value, sandboxMode) {
     if (sandboxMode !== "read-only")
         return "on-request";
     const normalized = value?.trim().toLowerCase();
+    // OMK "ask" must never map to provider "never"; only explicit "never"/"yolo" does.
     if (normalized === "never" || normalized === "yolo")
         return "never";
     return "on-request";

package/dist/runtime/context-broker-converter.js

@@ -57,18 +57,46 @@ export async function capsuleToTask(capsule, options = {}) {
         maxLatencyMs: undefined,
     };
     const capabilities = capabilitiesFromNode(capsule);
+    const safety = safetyFromCapsule(capsule, capabilities);
+    const sovereignty = routing?.freedomd
+        ? {
+            mode: (routing.freedomd.degradedMode ?? routing.freedomd.dataBoundary) ? "freedomd" : "standard",
+            dataBoundary: routing.freedomd.dataBoundary ?? "internal",
+            retentionDecision: "allow",
+            jurisdictionDecision: "allow",
+            providerCutoffRisk: 0,
+            localFallbackAvailable: false,
+            reason: routing.freedomd.sovereigntyReason ?? "from dag routing",
+        }
+        : undefined;
     const task = {
         prompt: capsule.task,
         context,
         tools,
         providerPolicy,
         capabilities,
+        safety,
+        sovereignty,
     };
     return task;
 }
 function isAbortSignal(value) {
     return "aborted" in value && typeof value.addEventListener === "function";
 }
+function safetyFromCapsule(capsule, capabilities) {
+    const routing = capsule.node.routing;
+    const risk = routing?.risk ?? (capabilities.shell || capabilities.merge ? "shell" : capabilities.write || capabilities.patch ? "write" : "read");
+    const authorityMode = routing?.assignedProviderAuthority
+        ?? (routing?.readOnly === true ? "advisory" : "authority");
+    return {
+        risk,
+        riskTrace: routing?.riskTrace,
+        approvalPolicy: routing?.approvalPolicy ?? routing?.executionPrompt ?? "interactive",
+        sandboxMode: routing?.sandboxMode ?? (routing?.readOnly === true ? "read-only" : "workspace-write"),
+        evidenceRequired: routing?.evidenceRequired === true || capabilities.write || capabilities.patch || capabilities.shell || capabilities.merge,
+        authorityMode,
+    };
+}
 function capabilitiesFromNode(capsule) {
     const node = capsule.node;
     const routing = node.routing;
@@ -77,7 +105,9 @@ function capabilitiesFromNode(capsule) {
     const assigned = new Set(routing?.assignedProviderCapabilities ?? []);
     const merge = assigned.has("merge") || role === "merger" || role === "integrator" || role === "orchestrator";
     const write = assigned.has("write") || merge || role === "coder" || role === "executor" || role === "refactorer";
-    const shell = assigned.has("shell") || routing?.requiresToolCalling === true || gates.includes("command-pass") || gates.includes("test-pass");
+    const shell = routing?.readOnly === true
+        ? false
+        : assigned.has("shell") || routing?.requiresToolCalling === true || gates.includes("command-pass") || gates.includes("test-pass");
     const review = assigned.has("review") || role === "reviewer" || role === "qa" || role === "tester" || gates.includes("review-pass");
     const mcp = assigned.has("mcp") || routing?.requiresMcp === true;
     const vision = assigned.has("vision");
@@ -88,7 +118,7 @@ function capabilitiesFromNode(capsule) {
         mcp,
         patch: routing?.readOnly === true ? false : write,
         review,
-        merge,
+        merge: routing?.readOnly === true ? false : merge,
         vision,
         toolCalling: routing?.requiresToolCalling === true || assigned.has("toolCalling"),
         maxTokens: capsule.budget.maxInputTokens,

package/dist/runtime/context-broker.js

@@ -5,11 +5,27 @@ import { mkdir, readFile, stat, writeFile } from "fs/promises";
 import { createContextBudgetOptimizer } from "./context-budget-optimizer.js";
 import { createDecisionTraceStore } from "../evidence/decision-trace.js";
 import { evaluateHeadroom } from "./headroom-policy.js";
+import { getRunArtifactPath } from "../util/run-store.js";
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 function resolveBudget(node) {
     const preset = node.routing?.contextBudget ?? "small";
     return CONTEXT_BUDGET_PRESETS[preset] ?? DEFAULT_CONTEXT_BUDGET;
 }
+async function loadPrivatePromptPayload(node, runId, projectRoot) {
+    const ref = node.routing?.promptPayloadRef;
+    if (!ref || !runId)
+        return undefined;
+    try {
+        const raw = await readFile(getRunArtifactPath(runId, ref, projectRoot), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.compiledPrompt !== "string" || parsed.compiledPrompt.trim().length === 0)
+            return undefined;
+        return parsed.compiledPrompt;
+    }
+    catch {
+        return undefined;
+    }
+}
 function collectDependencySummaries(node, state) {
     if (!state || !node.dependsOn.length)
         return [];
@@ -238,9 +254,11 @@ export function createContextBroker(options = {}) {
             nodeId: node.id,
             graphMemory,
         }).catch(() => { });
+        const privatePrompt = await loadPrivatePromptPayload(node, state?.runId, projectRoot);
         const task = [
             `Execute DAG node: ${node.id}`,
             `Name: ${node.name}`,
+            privatePrompt ? `PrivatePrompt: ${privatePrompt}` : undefined,
             `Role: ${node.role}`,
             node.routing?.actionAtom ? `ActionAtom: ${node.routing.actionAtom.id} | ${node.routing.actionAtom.label} | ${node.routing.actionAtom.verb} ${node.routing.actionAtom.object ?? "assigned scope"} | evidence=${node.routing.actionAtom.evidenceTarget} | done=${node.routing.actionAtom.doneCondition}` : undefined,
             node.routing?.skills?.length ? `Skills: ${node.routing.skills.join(", ")}` : undefined,

package/dist/runtime/contracts/evidence.d.ts

@@ -68,6 +68,58 @@ export interface AdapterTestResult {
     readonly score: number;
     readonly details?: string;
 }
+/** Kinds of output gates that can satisfy evidence-required turns. */
+export type EvidenceGateKind = "file-exists" | "test-pass" | "review-pass" | "command-pass" | "summary" | "artifact" | "diff";
+/** A declared gate requirement. Declarations are not evidence. */
+export interface EvidenceRequirement {
+    readonly gate: EvidenceGateKind;
+    readonly ref?: string;
+    readonly required: boolean;
+}
+/** A produced, replayable evidence observation. */
+export interface EvidenceObservation {
+    readonly kind: EvidenceGateKind;
+    readonly source: "stdout" | "metadata" | "artifact" | "file";
+    readonly ref?: string;
+    readonly artifactPath?: string;
+    readonly timestamp: string;
+    readonly replayable: boolean;
+    readonly redacted: boolean;
+    /** Confidence that this observation is replayable, command-backed evidence. */
+    readonly confidence: number;
+}
+/** Result of checking whether a node/task produced required evidence. */
+export interface EvidenceGateCheck {
+    readonly required: boolean;
+    readonly satisfied: boolean;
+    readonly gates: readonly EvidenceGateKind[];
+    readonly missing: readonly EvidenceGateKind[];
+    readonly reason: string;
+    readonly requirements?: readonly EvidenceRequirement[];
+    readonly observations?: readonly EvidenceObservation[];
+}
+export declare function isEvidenceGateKind(value: string | undefined): value is EvidenceGateKind;
+export declare function evidenceRequirementsFromOutputs(outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined): EvidenceRequirement[];
+export declare function hasDeclaredEvidenceRequirement(outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined): boolean;
+export declare function evidenceObservationsFromResult(input: {
+    readonly metadata?: Record<string, unknown> | null;
+    readonly stdout?: string;
+    readonly artifactPaths?: readonly string[];
+    readonly timestamp?: string;
+}): EvidenceObservation[];
+export declare function checkEvidenceGate(required: boolean | undefined, outputs: readonly {
+    gate?: string;
+    ref?: string;
+    required?: boolean;
+}[] | undefined, metadata?: Record<string, unknown> | null, stdout?: string, artifactPaths?: readonly string[]): EvidenceGateCheck;
 /** Per-gate check result. */
 export interface GateCheck {
     readonly gate: string;

package/dist/runtime/contracts/evidence.js

@@ -4,4 +4,141 @@
  * Core interfaces that bridge reasoning traces, runtime decisions,
  * provider maturity, and release gates into a verifiable evidence model.
  */
-export {};
+const EVIDENCE_GATE_KINDS = [
+    "file-exists",
+    "test-pass",
+    "review-pass",
+    "command-pass",
+    "summary",
+    "artifact",
+    "diff",
+];
+export function isEvidenceGateKind(value) {
+    return Boolean(value && EVIDENCE_GATE_KINDS.includes(value.toLowerCase()));
+}
+export function evidenceRequirementsFromOutputs(outputs) {
+    const requirements = [];
+    for (const output of outputs ?? []) {
+        const kind = output.gate?.toLowerCase();
+        if (!isEvidenceGateKind(kind))
+            continue;
+        if (output.required === false)
+            continue;
+        requirements.push({ gate: kind, ref: output.ref, required: true });
+    }
+    return requirements;
+}
+export function hasDeclaredEvidenceRequirement(outputs) {
+    return evidenceRequirementsFromOutputs(outputs).length > 0;
+}
+export function evidenceObservationsFromResult(input) {
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const observations = [];
+    const metadata = input.metadata ?? undefined;
+    const metaGates = metadata?.evidenceGates;
+    if (Array.isArray(metaGates)) {
+        for (const raw of metaGates) {
+            const gate = typeof raw === "string" ? raw.toLowerCase() : undefined;
+            if (isEvidenceGateKind(gate)) {
+                observations.push({ kind: gate, source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+            }
+        }
+    }
+    if (metadata?.commandPass === true || metadata?.testPass === true || metadata?.buildPass === true) {
+        observations.push({ kind: "command-pass", source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+    }
+    if (metadata?.diff || metadata?.patch || metadata?.changedFiles) {
+        observations.push({ kind: "diff", source: "metadata", timestamp, replayable: true, redacted: true, confidence: 0.9 });
+    }
+    const artifactRef = metadata?.artifact ?? metadata?.artifactPath ?? metadata?.evidenceRef;
+    if (typeof artifactRef === "string" && artifactRef.trim().length > 0) {
+        observations.push({ kind: "artifact", source: "metadata", ref: artifactRef, artifactPath: artifactRef, timestamp, replayable: true, redacted: true, confidence: 0.95 });
+    }
+    for (const artifactPath of input.artifactPaths ?? []) {
+        observations.push({ kind: "artifact", source: "artifact", artifactPath, ref: artifactPath, timestamp, replayable: true, redacted: true, confidence: 0.95 });
+    }
+    const stdout = input.stdout ?? "";
+    if (stdout.trim().length > 0) {
+        const hasStructuredSummaryMarker = /^##\s+(Summary|Evidence|Verification)\b/im.test(stdout);
+        observations.push({
+            kind: "summary",
+            source: "stdout",
+            timestamp,
+            replayable: true,
+            redacted: true,
+            confidence: hasStructuredSummaryMarker ? 0.9 : 0.4,
+        });
+    }
+    if (/\b(pass(ed)?|success|ok)\b/i.test(stdout) && /\b(test|check|build|lint|command)\b/i.test(stdout)) {
+        observations.push({ kind: "command-pass", source: "stdout", timestamp, replayable: true, redacted: true, confidence: 0.4 });
+    }
+    return observations;
+}
+function minimumConfidenceFor(requirement) {
+    if (["command-pass", "test-pass", "summary", "review-pass"].includes(requirement.gate))
+        return 0.8;
+    return 0;
+}
+function observationSatisfies(requirement, observation) {
+    if (!observation.replayable || !observation.redacted)
+        return false;
+    if (observation.confidence < minimumConfidenceFor(requirement))
+        return false;
+    if (observation.kind === requirement.gate)
+        return true;
+    if (requirement.gate === "test-pass" && observation.kind === "command-pass")
+        return true;
+    if (requirement.gate === "review-pass" && observation.kind === "summary")
+        return true;
+    if (requirement.gate === "file-exists" && observation.kind === "artifact")
+        return true;
+    return false;
+}
+export function checkEvidenceGate(required, outputs, metadata, stdout, artifactPaths) {
+    const requirements = evidenceRequirementsFromOutputs(outputs);
+    const observations = evidenceObservationsFromResult({ metadata, stdout, artifactPaths });
+    const observedKinds = new Set(observations.map((o) => o.kind));
+    if (!required) {
+        return { required: false, satisfied: true, gates: [...observedKinds], missing: [], reason: "evidence not required", requirements, observations };
+    }
+    if (requirements.length === 0 && observations.length > 0) {
+        const strongObservations = observations.filter((observation) => observation.confidence >= 0.8 && observation.replayable && observation.redacted);
+        if (strongObservations.length > 0) {
+            return {
+                required: true,
+                satisfied: true,
+                gates: [...new Set(strongObservations.map((observation) => observation.kind))],
+                missing: [],
+                reason: `evidence satisfied by high-confidence observations without explicit gate: ${[...new Set(strongObservations.map((observation) => observation.kind))].join(", ")}`,
+                requirements,
+                observations,
+            };
+        }
+    }
+    const effectiveRequirements = requirements.length > 0
+        ? requirements
+        : EVIDENCE_GATE_KINDS.map((gate) => ({ gate, required: true }));
+    const missing = effectiveRequirements
+        .filter((requirement) => !observations.some((observation) => observationSatisfies(requirement, observation)))
+        .map((requirement) => requirement.gate);
+    if (missing.length === 0) {
+        return {
+            required: true,
+            satisfied: true,
+            gates: [...observedKinds],
+            missing: [],
+            reason: `evidence satisfied by observations: ${[...observedKinds].join(", ") || "none"}`,
+            requirements: effectiveRequirements,
+            observations,
+        };
+    }
+    return {
+        required: true,
+        satisfied: false,
+        gates: [...observedKinds],
+        missing,
+        reason: `required evidence observations missing: ${[...new Set(missing)].join(", ")}`,
+        requirements: effectiveRequirements,
+        observations,
+    };
+}

package/dist/runtime/contracts/shared.d.ts

@@ -26,9 +26,36 @@ export interface RuntimeCapabilities {
     supportsStructuredOutput?: boolean;
     supportsToolCalling?: boolean;
 }
+export type HealthState = "pass" | "fail" | "unknown";
+export type RuntimeHealthProbeKind = "none" | "static" | "cheap-call" | "live-call";
+export interface RuntimeHealthVector {
+    /** Legacy boolean dimensions retained for backward compatibility. */
+    runtimeOk?: boolean;
+    authOk?: boolean;
+    modelOk?: boolean;
+    quotaOk?: boolean;
+    rateLimitOk?: boolean;
+    /** Tri-state dimensions used by health-aware routing v2. */
+    runtime?: HealthState;
+    auth?: HealthState;
+    model?: HealthState;
+    quota?: HealthState;
+    rateLimit?: HealthState;
+    latencyMs?: number;
+    lastProbeKind?: RuntimeHealthProbeKind;
+    checkedAt?: string;
+    expiresAt?: string;
+}
+export interface RuntimeHealthProbeRequest {
+    readonly probeKind: RuntimeHealthProbeKind;
+    readonly taskRisk?: string;
+    readonly highRisk: boolean;
+}
 export interface RuntimeHealth {
     runtimeId: RuntimeId;
     available: boolean;
     reason?: string;
     checkedAt: string;
+    /** Structured health signals beyond a binary available flag. */
+    vector?: RuntimeHealthVector;
 }