open-multi-agent-kit 0.78.0

package/dist/runtime/worker-manifest.d.ts

@@ -0,0 +1,34 @@
+import type { DagNode } from "../contracts/dag.js";
+import type { OmkRuntimeScope, TaskRunContext, WorkerCapabilityManifest, WorkerManifest, WorkerManifestArtifacts } from "../contracts/worker-context.js";
+import type { AgentTask, ProviderPolicy } from "./agent-runtime.js";
+export interface WorkerToolPlaneInput {
+    readonly mcpServers?: readonly string[];
+    readonly mcpConfigFile?: string;
+    readonly skills?: readonly string[];
+    readonly hooks?: readonly string[];
+    readonly tools?: readonly string[];
+    readonly requiresRuntimeMcp?: boolean;
+}
+export interface BuildTaskRunContextInput {
+    readonly runId: string;
+    readonly node: DagNode;
+    readonly root?: string;
+    readonly goalId?: string;
+    readonly objective?: string;
+    readonly scopes?: {
+        readonly mcp?: OmkRuntimeScope;
+        readonly skills?: OmkRuntimeScope;
+        readonly hooks?: OmkRuntimeScope;
+    };
+    readonly toolPlane?: WorkerToolPlaneInput;
+    readonly providerPolicy?: ProviderPolicy;
+    readonly capabilities?: Partial<WorkerCapabilityManifest>;
+    readonly selectedRuntimeId?: string;
+    readonly model?: string;
+    readonly artifacts?: WorkerManifestArtifacts;
+    readonly createdAt?: string;
+}
+export declare function buildTaskRunContext(input: BuildTaskRunContextInput): TaskRunContext;
+export declare function buildWorkerManifestFromNode(input: BuildTaskRunContextInput): WorkerManifest;
+export declare function applyTaskRunContextToAgentTask(task: AgentTask, context?: TaskRunContext): AgentTask;
+export declare function envFromWorkerManifest(manifest: WorkerManifest): Record<string, string>;

package/dist/runtime/worker-manifest.js

@@ -0,0 +1,204 @@
+export function buildTaskRunContext(input) {
+    const root = input.root ?? process.cwd();
+    return {
+        goal: {
+            runId: input.runId,
+            goalId: input.goalId,
+            objective: input.objective ?? input.node.name,
+            root,
+            mcpScope: input.scopes?.mcp ?? "project",
+            skillsScope: input.scopes?.skills ?? "project",
+            hooksScope: input.scopes?.hooks ?? "project",
+        },
+        worker: buildWorkerManifestFromNode({ ...input, root }),
+    };
+}
+export function buildWorkerManifestFromNode(input) {
+    const toolPlane = buildWorkerToolPlane(input);
+    const provider = buildWorkerProviderManifest(input);
+    const derivedCapabilities = deriveWorkerCapabilities(input.node, toolPlane);
+    const capabilities = normalizeWorkerCapabilities({
+        ...derivedCapabilities,
+        ...(input.capabilities ?? {}),
+    });
+    return {
+        schemaVersion: 1,
+        owner: "omk",
+        runId: input.runId,
+        nodeId: input.node.id,
+        role: input.node.role,
+        provider,
+        toolPlane,
+        capabilities,
+        artifacts: input.artifacts ?? {},
+        createdAt: input.createdAt ?? new Date().toISOString(),
+    };
+}
+export function applyTaskRunContextToAgentTask(task, context) {
+    if (!context)
+        return task;
+    const manifest = context.worker;
+    return {
+        ...task,
+        context: {
+            ...task.context,
+            goal: task.context.goal ?? context.goal.objective,
+            goalContext: context.goal,
+            workerManifest: manifest,
+        },
+        tools: applyWorkerToolPlane(task.tools, manifest.toolPlane),
+        providerPolicy: {
+            ...task.providerPolicy,
+            preferredProviders: uniqueStrings([
+                ...manifest.provider.preferred,
+                ...task.providerPolicy.preferredProviders,
+            ]),
+            fallbackChain: uniqueStrings([
+                ...manifest.provider.fallbackChain,
+                ...task.providerPolicy.fallbackChain,
+            ]),
+        },
+        capabilities: {
+            ...task.capabilities,
+            ...manifest.capabilities,
+        },
+    };
+}
+export function envFromWorkerManifest(manifest) {
+    const env = {
+        OMK_OWNER: manifest.owner,
+        OMK_WORKER_MANIFEST_OWNER: manifest.owner,
+        OMK_WORKER_MANIFEST_SCHEMA: String(manifest.schemaVersion),
+        OMK_WORKER_MANIFEST_RUN_ID: manifest.runId,
+        OMK_WORKER_MANIFEST_NODE_ID: manifest.nodeId,
+        OMK_WORKER_MANIFEST_ROLE: manifest.role ?? "",
+        OMK_NODE_MCP_SERVERS: manifest.toolPlane.mcpServers.join(","),
+        OMK_NODE_SKILLS: manifest.toolPlane.skills.join(","),
+        OMK_NODE_HOOKS: manifest.toolPlane.hooks.join(","),
+        OMK_NODE_TOOLS: manifest.toolPlane.tools.join(","),
+        OMK_ROUTE_REQUIRES_MCP: String(manifest.toolPlane.requiresRuntimeMcp),
+        OMK_ROUTE_REQUIRES_TOOL_CALLING: String(manifest.capabilities.toolCalling === true),
+        OMK_PROVIDER_PREFERRED: manifest.provider.preferred.join(","),
+        OMK_PROVIDER_FALLBACK_CHAIN: manifest.provider.fallbackChain.join(","),
+    };
+    if (manifest.provider.selectedRuntimeId)
+        env.OMK_SELECTED_RUNTIME_ID = manifest.provider.selectedRuntimeId;
+    if (manifest.provider.model)
+        env.OMK_PROVIDER_MODEL = manifest.provider.model;
+    if (manifest.toolPlane.mcpConfigFile)
+        env.OMK_MCP_CONFIG_FILE = manifest.toolPlane.mcpConfigFile;
+    return env;
+}
+function buildWorkerToolPlane(input) {
+    const routing = input.node.routing;
+    return {
+        mcpServers: uniqueStrings([
+            ...(input.toolPlane?.mcpServers ?? []),
+            ...(routing?.mcpServers ?? []),
+            ...(routing?.assignedCapabilities?.mcpServers ?? []),
+        ]),
+        mcpConfigFile: input.toolPlane?.mcpConfigFile,
+        skills: uniqueStrings([
+            ...(input.toolPlane?.skills ?? []),
+            ...(routing?.skills ?? []),
+            ...(routing?.assignedCapabilities?.skills ?? []),
+        ]),
+        hooks: uniqueStrings([
+            ...(input.toolPlane?.hooks ?? []),
+            ...(routing?.hooks ?? []),
+            ...(routing?.assignedCapabilities?.hooks ?? []),
+        ]),
+        tools: uniqueStrings([
+            ...(input.toolPlane?.tools ?? []),
+            ...(routing?.tools ?? []),
+            ...(routing?.assignedCapabilities?.tools ?? []),
+        ]),
+        requiresRuntimeMcp: input.toolPlane?.requiresRuntimeMcp ?? routing?.requiresMcp === true,
+    };
+}
+function buildWorkerProviderManifest(input) {
+    const routing = input.node.routing;
+    const provider = routing?.provider && routing.provider !== "auto" ? [routing.provider] : [];
+    return {
+        preferred: uniqueStrings([
+            ...provider,
+            ...(input.providerPolicy?.preferredProviders ?? []),
+            ...(routing?.candidateProviders ?? []),
+        ]),
+        fallbackChain: uniqueStrings([
+            ...(input.providerPolicy?.fallbackChain ?? []),
+            ...(routing?.fallbackProvider ? [routing.fallbackProvider] : []),
+        ]),
+        selectedRuntimeId: input.selectedRuntimeId,
+        model: input.model ?? routing?.providerModel,
+    };
+}
+function deriveWorkerCapabilities(node, toolPlane) {
+    const routing = node.routing;
+    const role = node.role?.toLowerCase() ?? "";
+    const gates = node.outputs?.map((output) => output.gate).filter(Boolean) ?? [];
+    const assigned = new Set(routing?.assignedProviderCapabilities ?? []);
+    const readOnly = routing?.readOnly === true;
+    const merge = !readOnly && (assigned.has("merge") || role === "merger" || role === "integrator" || role === "orchestrator");
+    const write = !readOnly && (assigned.has("write") || merge || role === "coder" || role === "executor" || role === "refactorer");
+    const shell = !readOnly && (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");
+    return {
+        read: true,
+        write,
+        shell,
+        mcp,
+        patch: !readOnly && (write || assigned.has("patch")),
+        review,
+        merge,
+        vision,
+        toolCalling: routing?.requiresToolCalling === true || assigned.has("toolCalling") || toolPlane.tools.length > 0,
+    };
+}
+function normalizeWorkerCapabilities(input) {
+    return {
+        read: input.read ?? true,
+        write: input.write ?? false,
+        shell: input.shell ?? false,
+        mcp: input.mcp ?? false,
+        patch: input.patch ?? false,
+        review: input.review ?? false,
+        merge: input.merge ?? false,
+        vision: input.vision ?? false,
+        ...(input.toolCalling !== undefined && { toolCalling: input.toolCalling }),
+        ...(input.maxTokens !== undefined && { maxTokens: input.maxTokens }),
+    };
+}
+function applyWorkerToolPlane(tools, toolPlane) {
+    return {
+        available: mergeToolEntries(tools.available, toolPlane.tools),
+        mcpServers: uniqueStrings([...(toolPlane.mcpServers ?? []), ...(tools.mcpServers ?? [])]),
+        skills: uniqueStrings([...(toolPlane.skills ?? []), ...(tools.skills ?? [])]),
+        hooks: uniqueStrings([...(toolPlane.hooks ?? []), ...(tools.hooks ?? [])]),
+    };
+}
+function mergeToolEntries(existing, toolNames) {
+    const seen = new Set(existing.map((tool) => tool.name));
+    const merged = [...existing];
+    for (const name of toolNames) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        merged.push({ name, description: "", inputSchema: {} });
+    }
+    return merged;
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}

package/dist/safety/approval-policy.d.ts

@@ -0,0 +1,4 @@
+import type { ApprovalContext, ApprovalDecision, PolicyEngine } from "../contracts/safety.js";
+export type ApprovalPolicy = "interactive" | "auto" | "yolo" | "block";
+export declare function decideApproval(policy: ApprovalPolicy, ctx: ApprovalContext): ApprovalDecision;
+export declare function createPolicyEngine(policy: ApprovalPolicy): PolicyEngine;

package/dist/safety/approval-policy.js

@@ -0,0 +1,33 @@
+const SAFE_TOOLS = [
+    "ReadFile", "Glob", "Grep", "SearchWeb", "FetchURL",
+    "ctx_read", "ctx_tree", "ctx_search", "ctx_multi_read", "ctx_overview",
+    "browser_snapshot", "list_console_messages", "browser_network_requests",
+    "browser_console_messages", "browser_tabs", "browser_wait_for",
+];
+const DESTRUCTIVE_TOOLS = ["Shell", "WriteFile", "StrReplaceFile", "applyDiff", "browser_run_code_unsafe"];
+export function decideApproval(policy, ctx) {
+    if (policy === "yolo")
+        return "allow";
+    if (policy === "block")
+        return "block";
+    if (policy === "auto") {
+        if (SAFE_TOOLS.includes(ctx.tool))
+            return "allow";
+        if (DESTRUCTIVE_TOOLS.includes(ctx.tool))
+            return "ask";
+        return "ask";
+    }
+    // interactive
+    if (DESTRUCTIVE_TOOLS.includes(ctx.tool))
+        return "ask";
+    if (SAFE_TOOLS.includes(ctx.tool))
+        return "allow";
+    return "ask";
+}
+export function createPolicyEngine(policy) {
+    return {
+        async decide(ctx) {
+            return decideApproval(policy, ctx);
+        },
+    };
+}

package/dist/safety/guard-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { ApprovalDecision } from "../contracts/safety.js";
+export declare function preShellGuard(command: string): ApprovalDecision;
+export declare function protectSecrets(filePath: string, content: string): ApprovalDecision;

package/dist/safety/guard-hooks.js

@@ -0,0 +1,64 @@
+const DESTRUCTIVE_PATTERNS = [
+    /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\/($|\s)/,
+    /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+(~|\$\w+)/,
+    /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\.{0,2}\//,
+    /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s*\.{1,2}\s*$/,
+    /^\s*sudo\s+/,
+    /^\s*git\s+push\s+--force/,
+    /^\s*git\s+push\s+-f\s/,
+    /^\s*>:\s*\/dev\/\w+/,
+    /^\s*dd\s+if=.*\s+of=\/dev\/\w+/,
+    /^\s*mkfs\.\w+\s/,
+    /^\s*chmod\s+-R\s+777\s/,
+    /^\s*chown\s+-R\s+root\s/,
+    /^\s*curl\s+.*\|\s*(sh|bash|zsh)/,
+    /^\s*wget\s+.*\|\s*(sh|bash|zsh)/,
+    /^\s*eval\s+\$\(/,
+    /^\s*eval\s+`/,
+    /^\s*docker\s+system\s+prune/,
+    /^\s*kubectl\s+delete\s+/,
+    /^\s*aws\s+s3\s+rm\s+--recursive/,
+];
+const SENSITIVE_FILE_PATTERNS = [
+    /\.env$/,
+    /\.env\.\w+$/,
+    /\.pem$/,
+    /\.key$/,
+    /id_rsa$/,
+    /id_ed25519$/,
+    /id_ecdsa$/,
+    /credentials\.json$/,
+    /service-account.*\.json$/,
+    /\.aws\//,
+    /\.ssh\//,
+    /secrets?\//,
+];
+const SECRET_PATTERNS = [
+    /AKIA[0-9A-Z]{16}/, // AWS access key
+    /ghp_[a-zA-Z0-9]{36}/, // GitHub personal access token
+    /glpat-[a-zA-Z0-9-]{20,}/, // GitLab PAT
+    /sk-[a-zA-Z0-9]{20,}/, // OpenAI API key
+    /sk_live_[a-zA-Z0-9]{24,}/, // Stripe live key
+    /sk_test_[a-zA-Z0-9]{24,}/, // Stripe test key
+];
+export function preShellGuard(command) {
+    for (const pattern of DESTRUCTIVE_PATTERNS) {
+        if (pattern.test(command)) {
+            return "block";
+        }
+    }
+    return "allow";
+}
+export function protectSecrets(filePath, content) {
+    for (const pattern of SENSITIVE_FILE_PATTERNS) {
+        if (pattern.test(filePath)) {
+            return "block";
+        }
+    }
+    for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(content)) {
+            return "block";
+        }
+    }
+    return "allow";
+}

package/dist/schema/decision.schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export declare const DecisionTraceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"omk.decision.v1">;
+    runId: z.ZodString;
+    decisionId: z.ZodString;
+    timestamp: z.ZodString;
+    kind: z.ZodEnum<["provider-selection", "fallback-routing", "retry-policy", "skip-policy", "dependent-block", "context-brokering", "skill-assignment", "evidence-verdict", "security-policy"]>;
+    actor: z.ZodEnum<["runtime-router", "scheduler", "evidence-gate", "provider-router", "operator"]>;
+    inputRefs: z.ZodArray<z.ZodString, "many">;
+    outputRefs: z.ZodArray<z.ZodString, "many">;
+    selected: z.ZodOptional<z.ZodString>;
+    candidates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reason: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    kind: "provider-selection" | "fallback-routing" | "retry-policy" | "skip-policy" | "dependent-block" | "context-brokering" | "skill-assignment" | "evidence-verdict" | "security-policy";
+    runId: string;
+    schemaVersion: "omk.decision.v1";
+    timestamp: string;
+    decisionId: string;
+    actor: "runtime-router" | "evidence-gate" | "scheduler" | "provider-router" | "operator";
+    inputRefs: string[];
+    outputRefs: string[];
+    confidence?: number | undefined;
+    selected?: string | undefined;
+    candidates?: string[] | undefined;
+}, {
+    reason: string;
+    kind: "provider-selection" | "fallback-routing" | "retry-policy" | "skip-policy" | "dependent-block" | "context-brokering" | "skill-assignment" | "evidence-verdict" | "security-policy";
+    runId: string;
+    schemaVersion: "omk.decision.v1";
+    timestamp: string;
+    decisionId: string;
+    actor: "runtime-router" | "evidence-gate" | "scheduler" | "provider-router" | "operator";
+    inputRefs: string[];
+    outputRefs: string[];
+    confidence?: number | undefined;
+    selected?: string | undefined;
+    candidates?: string[] | undefined;
+}>;
+export declare const DecisionRefSchema: z.ZodObject<{
+    schemaVersion: z.ZodOptional<z.ZodLiteral<"omk.decision.v1">>;
+    decisionId: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    decisionId: string;
+    path?: string | undefined;
+    runId?: string | undefined;
+    schemaVersion?: "omk.decision.v1" | undefined;
+}, {
+    decisionId: string;
+    path?: string | undefined;
+    runId?: string | undefined;
+    schemaVersion?: "omk.decision.v1" | undefined;
+}>;

package/dist/schema/decision.schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { OMK_DECISION_SCHEMA_VERSION } from "../version.js";
+export const DecisionTraceSchema = z.object({
+    schemaVersion: z.literal(OMK_DECISION_SCHEMA_VERSION),
+    runId: z.string().min(1),
+    decisionId: z.string().min(1),
+    timestamp: z.string().min(1),
+    kind: z.enum([
+        "provider-selection",
+        "fallback-routing",
+        "retry-policy",
+        "skip-policy",
+        "dependent-block",
+        "context-brokering",
+        "skill-assignment",
+        "evidence-verdict",
+        "security-policy",
+    ]),
+    actor: z.enum(["runtime-router", "scheduler", "evidence-gate", "provider-router", "operator"]),
+    inputRefs: z.array(z.string()),
+    outputRefs: z.array(z.string()),
+    selected: z.string().optional(),
+    candidates: z.array(z.string()).optional(),
+    reason: z.string().min(1),
+    confidence: z.number().min(0).max(1).optional(),
+});
+export const DecisionRefSchema = z.object({
+    schemaVersion: z.literal(OMK_DECISION_SCHEMA_VERSION).optional(),
+    decisionId: z.string().min(1),
+    runId: z.string().min(1).optional(),
+    path: z.string().optional(),
+});

package/dist/schema/envelope.schema.d.ts

@@ -0,0 +1,216 @@
+import { z } from "zod";
+export declare const OmkEnvelopeStatusSchema: z.ZodEnum<["passed", "failed", "blocked", "skipped", "partial", "dry-run", "not-applicable"]>;
+export declare const OmkEnvelopeSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    schemaVersion: z.ZodLiteral<"omk.contract.v1">;
+    command: z.ZodString;
+    omkVersion: z.ZodString;
+    runtimeVersion: z.ZodLiteral<"v1.2">;
+    commit: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodString;
+    status: z.ZodEnum<["passed", "failed", "blocked", "skipped", "partial", "dry-run", "not-applicable"]>;
+    data: z.ZodUnknown;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<["CONFIG_INVALID", "PROVIDER_UNAVAILABLE", "PROVIDER_AUTH_REQUIRED", "PROVIDER_CAPABILITY_MISMATCH", "ROUTE_FALLBACK_TRIGGERED", "EVIDENCE_MISSING", "EVIDENCE_FAILED", "DAG_NODE_BLOCKED", "RUN_ARTIFACT_MISSING", "REPLAY_INCOMPLETE", "SECURITY_POLICY_BLOCKED", "MCP_UNHEALTHY", "INTERNAL_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+        severity: z.ZodEnum<["info", "warning", "error", "fatal"]>;
+        hint: z.ZodOptional<z.ZodString>;
+        cause: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }, {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }>, "many">;
+    errors: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<["CONFIG_INVALID", "PROVIDER_UNAVAILABLE", "PROVIDER_AUTH_REQUIRED", "PROVIDER_CAPABILITY_MISMATCH", "ROUTE_FALLBACK_TRIGGERED", "EVIDENCE_MISSING", "EVIDENCE_FAILED", "DAG_NODE_BLOCKED", "RUN_ARTIFACT_MISSING", "REPLAY_INCOMPLETE", "SECURITY_POLICY_BLOCKED", "MCP_UNHEALTHY", "INTERNAL_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+        severity: z.ZodEnum<["info", "warning", "error", "fatal"]>;
+        hint: z.ZodOptional<z.ZodString>;
+        cause: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }, {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }>, "many">;
+    evidenceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodOptional<z.ZodLiteral<"omk.evidence.v1">>;
+        evidenceId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        evidenceId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.evidence.v1" | undefined;
+    }, {
+        evidenceId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.evidence.v1" | undefined;
+    }>, "many">>;
+    decisionRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodOptional<z.ZodLiteral<"omk.decision.v1">>;
+        decisionId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        decisionId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.decision.v1" | undefined;
+    }, {
+        decisionId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.decision.v1" | undefined;
+    }>, "many">>;
+    metadata: z.ZodObject<{
+        cwd: z.ZodString;
+        platform: z.ZodString;
+        nodeVersion: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cwd: string;
+        durationMs: number;
+        timestamp: string;
+        platform: string;
+        nodeVersion: string;
+        provider?: string | undefined;
+    }, {
+        cwd: string;
+        durationMs: number;
+        timestamp: string;
+        platform: string;
+        nodeVersion: string;
+        provider?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "skipped" | "blocked" | "dry-run" | "partial" | "passed" | "not-applicable";
+    command: string;
+    errors: {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }[];
+    ok: boolean;
+    metadata: {
+        cwd: string;
+        durationMs: number;
+        timestamp: string;
+        platform: string;
+        nodeVersion: string;
+        provider?: string | undefined;
+    };
+    warnings: {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }[];
+    schemaVersion: "omk.contract.v1";
+    omkVersion: string;
+    runtimeVersion: "v1.2";
+    traceId: string;
+    data?: unknown;
+    runId?: string | undefined;
+    commit?: string | undefined;
+    evidenceRefs?: {
+        evidenceId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.evidence.v1" | undefined;
+    }[] | undefined;
+    decisionRefs?: {
+        decisionId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.decision.v1" | undefined;
+    }[] | undefined;
+}, {
+    status: "failed" | "skipped" | "blocked" | "dry-run" | "partial" | "passed" | "not-applicable";
+    command: string;
+    errors: {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }[];
+    ok: boolean;
+    metadata: {
+        cwd: string;
+        durationMs: number;
+        timestamp: string;
+        platform: string;
+        nodeVersion: string;
+        provider?: string | undefined;
+    };
+    warnings: {
+        message: string;
+        code: "CONFIG_INVALID" | "PROVIDER_UNAVAILABLE" | "PROVIDER_AUTH_REQUIRED" | "PROVIDER_CAPABILITY_MISMATCH" | "ROUTE_FALLBACK_TRIGGERED" | "EVIDENCE_MISSING" | "EVIDENCE_FAILED" | "DAG_NODE_BLOCKED" | "RUN_ARTIFACT_MISSING" | "REPLAY_INCOMPLETE" | "SECURITY_POLICY_BLOCKED" | "MCP_UNHEALTHY" | "INTERNAL_ERROR";
+        recoverable: boolean;
+        severity: "warning" | "error" | "info" | "fatal";
+        cause?: string | undefined;
+        path?: string | undefined;
+        hint?: string | undefined;
+    }[];
+    schemaVersion: "omk.contract.v1";
+    omkVersion: string;
+    runtimeVersion: "v1.2";
+    traceId: string;
+    data?: unknown;
+    runId?: string | undefined;
+    commit?: string | undefined;
+    evidenceRefs?: {
+        evidenceId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.evidence.v1" | undefined;
+    }[] | undefined;
+    decisionRefs?: {
+        decisionId: string;
+        path?: string | undefined;
+        runId?: string | undefined;
+        schemaVersion?: "omk.decision.v1" | undefined;
+    }[] | undefined;
+}>;