open-multi-agent-kit 0.78.0 → 0.78.2

package/dist/runtime/provider-maturity-gate.js

@@ -0,0 +1,101 @@
+/**
+ * Provider Maturity Gate — Phase 3 of OMK Weakness Remediation.
+ *
+ * Evaluates a provider/runtime across 8 adapter test dimensions and
+ * produces a maturity score M_p, an authority class, and a pass/fail
+ * verdict.
+ */
+// ── Constants ───────────────────────────────────────────────────
+const WEIGHT_AUTH = 0.10;
+const WEIGHT_READ = 0.10;
+const WEIGHT_WRITE = 0.15;
+const WEIGHT_SHELL = 0.10;
+const WEIGHT_MCP = 0.15;
+const WEIGHT_MERGE = 0.15;
+const WEIGHT_EVIDENCE = 0.15;
+const WEIGHT_FALLBACK = 0.10;
+const MERGE_AUTHORITY_THRESHOLD = 0.90;
+const MERGE_SUBSCORE_THRESHOLD = 0.90;
+const EVIDENCE_SUBSCORE_THRESHOLD_FOR_MERGE = 0.85;
+const WRITE_AUTHORITY_THRESHOLD = 0.80;
+const WRITE_SUBSCORE_THRESHOLD = 0.85;
+const REVIEW_AUTHORITY_THRESHOLD = 0.70;
+const READ_SUBSCORE_THRESHOLD = 0.90;
+const READ_ONLY_ADVISORY_THRESHOLD = 0.55;
+// ── Helpers ─────────────────────────────────────────────────────
+function clamp01(n) {
+    return Math.max(0, Math.min(1, n));
+}
+function computeAuthorityClass(score, subScores) {
+    if (score >= MERGE_AUTHORITY_THRESHOLD &&
+        subScores.merge >= MERGE_SUBSCORE_THRESHOLD &&
+        subScores.evidence >= EVIDENCE_SUBSCORE_THRESHOLD_FOR_MERGE) {
+        return "merge-authority";
+    }
+    if (score >= WRITE_AUTHORITY_THRESHOLD &&
+        subScores.write >= WRITE_SUBSCORE_THRESHOLD) {
+        return "write-authority";
+    }
+    if (score >= REVIEW_AUTHORITY_THRESHOLD &&
+        subScores.read >= READ_SUBSCORE_THRESHOLD) {
+        return "review-authority";
+    }
+    if (score >= READ_ONLY_ADVISORY_THRESHOLD) {
+        return "read-only-advisory";
+    }
+    return "disabled";
+}
+function buildSubScoreMap(results) {
+    const map = {
+        auth: 0,
+        read: 0,
+        write: 0,
+        shell: 0,
+        mcp: 0,
+        merge: 0,
+        evidence: 0,
+        fallback: 0,
+    };
+    for (const r of results) {
+        map[r.kind] = clamp01(r.score);
+    }
+    return map;
+}
+export function createProviderMaturityTable() {
+    const table = new Map();
+    return {
+        lookup(providerId) {
+            return table.get(providerId);
+        },
+        register(providerId, result) {
+            table.set(providerId, result);
+        },
+    };
+}
+export function createProviderMaturityGate() {
+    return {
+        evaluate(results) {
+            const subScores = Object.freeze(buildSubScoreMap(results));
+            const score = WEIGHT_AUTH * subScores.auth +
+                WEIGHT_READ * subScores.read +
+                WEIGHT_WRITE * subScores.write +
+                WEIGHT_SHELL * subScores.shell +
+                WEIGHT_MCP * subScores.mcp +
+                WEIGHT_MERGE * subScores.merge +
+                WEIGHT_EVIDENCE * subScores.evidence +
+                WEIGHT_FALLBACK * subScores.fallback;
+            const finalScore = clamp01(score);
+            const authorityClass = computeAuthorityClass(finalScore, subScores);
+            return Object.freeze({
+                score: finalScore,
+                authorityClass,
+                passed: authorityClass !== "disabled",
+                subScores,
+            });
+        },
+        getSubScore(results, kind) {
+            const found = results.find((r) => r.kind === kind);
+            return found ? clamp01(found.score) : 0;
+        },
+    };
+}

package/dist/runtime/public-surface.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Public Surface Compression — Phase 1 of OMK Weakness Remediation.
+ *
+ * Takes a candidate set of runtime surfaces, scores each item,
+ * enforces mandatory anchors, applies budget K, and returns
+ * public surface S and hidden set H.
+ *
+ * Also enforces the 5-step flow invariant:
+ *   goal → dag → route → verify → replay
+ */
+/** A candidate surface item (e.g., a tool, MCP server, skill, or runtime). */
+export interface SurfaceItem {
+    readonly id: string;
+    readonly name: string;
+    readonly category: "tool" | "mcp" | "skill" | "runtime" | "hook";
+    /** How often this surface is invoked per 100 turns. */
+    readonly usage: number;
+    /** Contribution score from verified runs [0, 1]. */
+    readonly verifiedRunContribution: number;
+    /** Contribution score from evidence items [0, 1]. */
+    readonly evidenceContribution: number;
+    /** Onboarding difficulty/cost [0, 1]. */
+    readonly onboardingCost: number;
+    /** Explainability burden [0, 1]. */
+    readonly explainabilityCost: number;
+    /** Risk of lineage drift [0, 1]. */
+    readonly lineageRisk: number;
+}
+/** Scored surface item with computed score. */
+export interface ScoredSurfaceItem extends SurfaceItem {
+    readonly score: number;
+}
+/** Mandatory anchor identifiers. */
+export type MandatoryAnchor = "goal" | "dag" | "route" | "verify" | "replay";
+/** Compression result: public surface S and hidden set H. */
+export interface CompressionResult {
+    readonly publicSurface: readonly ScoredSurfaceItem[];
+    readonly hiddenSet: readonly ScoredSurfaceItem[];
+    readonly mandatoryAnchors: readonly MandatoryAnchor[];
+    readonly budget: number;
+    readonly invariantPassed: boolean;
+    readonly invariantViolations: readonly string[];
+}
+/**
+ * Compute surface score from item metrics.
+ *
+ * Formula:
+ *   0.30 * usage
+ * + 0.30 * verifiedRunContribution
+ * + 0.20 * evidenceContribution
+ * - 0.10 * onboardingCost
+ * - 0.05 * explainabilityCost
+ * - 0.05 * lineageRisk
+ */
+export declare function computeSurfaceScore(item: SurfaceItem): number;
+/**
+ * Validate the 5-step flow invariant against the public surface.
+ *
+ * Invariant: The public surface must contain all mandatory anchors
+ * in order: goal → dag → route → verify → replay.
+ *
+ * Returns violations as human-readable strings.
+ */
+export declare function enforceFlowInvariant(publicSurface: readonly ScoredSurfaceItem[]): {
+    readonly passed: boolean;
+    readonly violations: readonly string[];
+};
+export interface PublicSurfaceCompressorOptions {
+    /** Maximum number of items in the public surface (default 5). */
+    readonly budget?: number;
+    /** Optional custom scoring function. */
+    readonly scoreFn?: (item: SurfaceItem) => number;
+}
+/**
+ * Compresses a candidate surface set into public (S) and hidden (H) subsets.
+ *
+ * Rules:
+ * 1. Mandatory anchors A = {goal, dag, route, verify, replay} are always in S.
+ * 2. Remaining slots are filled by highest score until budget K is reached.
+ * 3. The 5-step flow invariant is enforced and reported.
+ */
+export declare class PublicSurfaceCompressor {
+    private readonly budget;
+    private readonly scoreFn;
+    constructor(options?: PublicSurfaceCompressorOptions);
+    /**
+     * Compress candidates into public surface S and hidden set H.
+     *
+     * @param candidates All candidate surface items.
+     * @returns CompressionResult with S, H, and invariant status.
+     */
+    compress(candidates: readonly SurfaceItem[]): CompressionResult;
+}

package/dist/runtime/public-surface.js

@@ -0,0 +1,146 @@
+/**
+ * Public Surface Compression — Phase 1 of OMK Weakness Remediation.
+ *
+ * Takes a candidate set of runtime surfaces, scores each item,
+ * enforces mandatory anchors, applies budget K, and returns
+ * public surface S and hidden set H.
+ *
+ * Also enforces the 5-step flow invariant:
+ *   goal → dag → route → verify → replay
+ */
+// ── Constants ───────────────────────────────────────────────────
+const MANDATORY_ANCHORS = [
+    "goal",
+    "dag",
+    "route",
+    "verify",
+    "replay",
+];
+const DEFAULT_BUDGET = 5;
+// ── Scoring ─────────────────────────────────────────────────────
+/**
+ * Compute surface score from item metrics.
+ *
+ * Formula:
+ *   0.30 * usage
+ * + 0.30 * verifiedRunContribution
+ * + 0.20 * evidenceContribution
+ * - 0.10 * onboardingCost
+ * - 0.05 * explainabilityCost
+ * - 0.05 * lineageRisk
+ */
+export function computeSurfaceScore(item) {
+    const raw = 0.30 * item.usage +
+        0.30 * item.verifiedRunContribution +
+        0.20 * item.evidenceContribution -
+        0.10 * item.onboardingCost -
+        0.05 * item.explainabilityCost -
+        0.05 * item.lineageRisk;
+    // Clamp to [0, 1]
+    return Math.max(0, Math.min(1, raw));
+}
+// ── Invariant Enforcement ───────────────────────────────────────
+/**
+ * Validate the 5-step flow invariant against the public surface.
+ *
+ * Invariant: The public surface must contain all mandatory anchors
+ * in order: goal → dag → route → verify → replay.
+ *
+ * Returns violations as human-readable strings.
+ */
+export function enforceFlowInvariant(publicSurface) {
+    const violations = [];
+    const ids = publicSurface.map((s) => s.id);
+    for (const anchor of MANDATORY_ANCHORS) {
+        if (!ids.includes(anchor)) {
+            violations.push(`Missing mandatory anchor: ${anchor}`);
+        }
+    }
+    if (violations.length === 0) {
+        const orderIndices = MANDATORY_ANCHORS.map((a) => ids.indexOf(a));
+        for (let i = 1; i < orderIndices.length; i++) {
+            if (orderIndices[i] < orderIndices[i - 1]) {
+                violations.push(`Flow order violation: ${MANDATORY_ANCHORS[i - 1]} must precede ${MANDATORY_ANCHORS[i]}`);
+            }
+        }
+    }
+    return {
+        passed: violations.length === 0,
+        violations: Object.freeze(violations),
+    };
+}
+/**
+ * Compresses a candidate surface set into public (S) and hidden (H) subsets.
+ *
+ * Rules:
+ * 1. Mandatory anchors A = {goal, dag, route, verify, replay} are always in S.
+ * 2. Remaining slots are filled by highest score until budget K is reached.
+ * 3. The 5-step flow invariant is enforced and reported.
+ */
+export class PublicSurfaceCompressor {
+    budget;
+    scoreFn;
+    constructor(options = {}) {
+        this.budget = Math.max(MANDATORY_ANCHORS.length, options.budget ?? DEFAULT_BUDGET);
+        this.scoreFn = options.scoreFn ?? computeSurfaceScore;
+    }
+    /**
+     * Compress candidates into public surface S and hidden set H.
+     *
+     * @param candidates All candidate surface items.
+     * @returns CompressionResult with S, H, and invariant status.
+     */
+    compress(candidates) {
+        const scored = candidates.map((item) => ({
+            ...item,
+            score: this.scoreFn(item),
+        }));
+        // Partition mandatory vs elective
+        const mandatoryItems = [];
+        const electiveItems = [];
+        for (const item of scored) {
+            if (MANDATORY_ANCHORS.includes(item.id)) {
+                mandatoryItems.push(item);
+            }
+            else {
+                electiveItems.push(item);
+            }
+        }
+        // Ensure all mandatory anchors are present; inject placeholders if missing
+        const presentIds = new Set(mandatoryItems.map((m) => m.id));
+        for (const anchor of MANDATORY_ANCHORS) {
+            if (!presentIds.has(anchor)) {
+                mandatoryItems.push({
+                    id: anchor,
+                    name: anchor,
+                    category: "runtime",
+                    usage: 0,
+                    verifiedRunContribution: 0,
+                    evidenceContribution: 0,
+                    onboardingCost: 0,
+                    explainabilityCost: 0,
+                    lineageRisk: 0,
+                    score: 0,
+                });
+            }
+        }
+        // Sort mandatory by canonical order, electives by score desc
+        const orderedMandatory = MANDATORY_ANCHORS.map((anchor) => mandatoryItems.find((m) => m.id === anchor));
+        electiveItems.sort((a, b) => b.score - a.score);
+        const remainingSlots = Math.max(0, this.budget - orderedMandatory.length);
+        const publicSurface = Object.freeze([
+            ...orderedMandatory,
+            ...electiveItems.slice(0, remainingSlots),
+        ]);
+        const hiddenSet = Object.freeze(electiveItems.slice(remainingSlots));
+        const invariant = enforceFlowInvariant(publicSurface);
+        return Object.freeze({
+            publicSurface,
+            hiddenSet,
+            mandatoryAnchors: MANDATORY_ANCHORS,
+            budget: this.budget,
+            invariantPassed: invariant.passed,
+            invariantViolations: invariant.violations,
+        });
+    }
+}

package/dist/runtime/router-v2-scoring.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Router V2 Scoring Engine — Bayesian-smoothed evidence calibration (Algorithm 6).
+ *
+ * Composite formula:
+ *   0.25*E + 0.15*conf + 0.20*cap + 0.15*mat + 0.10*lat + 0.10*cost
+ *   - 0.15*pen - 0.10*blast
+ */
+import type { AgentRuntime } from "./agent-runtime.js";
+import type { EvidenceHistoryEntry, NodeIntent, RuntimeScoreV2, RouterV2Options, RouterV2ScoringEngine, BlastRadiusParams } from "./contracts/router-v2.js";
+export declare function createRouterV2ScoringEngine(options?: RouterV2Options, blastRadiusFn?: (params: BlastRadiusParams) => number): RouterV2ScoringEngine;
+export declare function scoreRuntimes(candidates: AgentRuntime[], intent: NodeIntent, history: EvidenceHistoryEntry[], options?: RouterV2Options): RuntimeScoreV2[];

package/dist/runtime/router-v2-scoring.js

@@ -0,0 +1,151 @@
+/**
+ * Router V2 Scoring Engine — Bayesian-smoothed evidence calibration (Algorithm 6).
+ *
+ * Composite formula:
+ *   0.25*E + 0.15*conf + 0.20*cap + 0.15*mat + 0.10*lat + 0.10*cost
+ *   - 0.15*pen - 0.10*blast
+ */
+import { computeBlastRadiusPenalty } from "./blast-radius.js";
+const ALPHA_0 = 1;
+const BETA_0 = 1;
+const INTENT_CAPABILITY_WEIGHTS = {
+    research: [["read", 0.35], ["review", 0.2], ["toolCalling", 0.15], ["vision", 0.1]],
+    planning: [["read", 0.3], ["review", 0.2], ["toolCalling", 0.15]],
+    coding: [["write", 0.3], ["patch", 0.25], ["shell", 0.15], ["toolCalling", 0.1]],
+    debugging: [["read", 0.2], ["write", 0.2], ["patch", 0.2], ["shell", 0.15], ["toolCalling", 0.1]],
+    refactor: [["write", 0.25], ["patch", 0.25], ["review", 0.15], ["toolCalling", 0.1]],
+    review: [["review", 0.35], ["read", 0.25], ["toolCalling", 0.1]],
+    "test-generation": [["write", 0.25], ["patch", 0.2], ["review", 0.15], ["toolCalling", 0.1]],
+    documentation: [["read", 0.25], ["write", 0.15], ["review", 0.15], ["toolCalling", 0.1]],
+    "shell-operation": [["shell", 0.4], ["read", 0.15], ["write", 0.1]],
+};
+function runtimeCapabilityEnabled(capabilities, capability) {
+    if (capability === "toolCalling") {
+        return capabilities.toolCalling === true || capabilities.supportsToolCalling === true;
+    }
+    if (capability === "streaming") {
+        return capabilities.streaming === true || capabilities.supportsStreaming === true;
+    }
+    return capabilities[capability] === true;
+}
+function computeCapabilityFit(runtime, intent) {
+    const caps = runtime.capabilities;
+    if (!caps)
+        return 0;
+    let score = 0;
+    for (const [capability, weight] of INTENT_CAPABILITY_WEIGHTS[intent]) {
+        if (runtimeCapabilityEnabled(caps, capability))
+            score += weight;
+    }
+    if (caps.maxTokens != null && caps.maxTokens > 0) {
+        score += Math.min(0.1, caps.maxTokens / 1_000_000);
+    }
+    if (caps.maxContextTokens != null && caps.maxContextTokens > 0) {
+        score += Math.min(0.1, caps.maxContextTokens / 1_000_000);
+    }
+    return score;
+}
+function computeMaturityScore(runtime) {
+    const caps = runtime.capabilities;
+    if (!caps)
+        return 0.5;
+    const capabilityCount = [
+        caps.read,
+        caps.write,
+        caps.shell,
+        caps.patch,
+        caps.review,
+        caps.merge,
+        caps.vision,
+        caps.mcp,
+        caps.toolCalling,
+        caps.supportsToolCalling,
+    ].filter(Boolean).length;
+    const breadthScore = Math.min(1, capabilityCount / 8);
+    const priorityScore = Math.max(0, Math.min(1, runtime.priority / 100));
+    return 0.6 * breadthScore + 0.4 * priorityScore;
+}
+function computeLatencyScore(runtime) {
+    return runtime.capabilities?.supportsStreaming === true || runtime.capabilities?.streaming === true
+        ? 0.85
+        : 0.70;
+}
+function computeCostScore(runtime) {
+    return runtime.priority > 50 ? 0.75 : 0.90;
+}
+export function createRouterV2ScoringEngine(options = {}, blastRadiusFn = computeBlastRadiusPenalty) {
+    const { enableBlastRadius = false, blastRadiusParams = { downstreamNodeCount: 0, affectedFileCount: 0, hasGlobalSideEffects: false }, } = options;
+    function score(runtime, intent, history) {
+        const runtimeHistory = history.filter((e) => e.runtime === runtime.id);
+        const totalAttempts = runtimeHistory.length;
+        const passedAttempts = runtimeHistory.filter((e) => e.passed).length;
+        // Bayesian smoothing with α₀=1, β₀=1
+        const bayesianEvidenceScore = (ALPHA_0 + passedAttempts) / (ALPHA_0 + BETA_0 + totalAttempts);
+        // Confidence increases with sample size (asymptotic toward 1)
+        const confidence = Math.min(1, totalAttempts / 10 + 0.1);
+        const recentFailures = runtimeHistory
+            .filter((e) => !e.passed)
+            .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+            .slice(0, 5);
+        const recentFailurePenalty = Math.min(0.3, recentFailures.length * 0.06);
+        const capabilityFit = computeCapabilityFit(runtime, intent);
+        const maturityScore = computeMaturityScore(runtime);
+        const latencyScore = computeLatencyScore(runtime);
+        const costScore = computeCostScore(runtime);
+        const blastRadiusPenalty = enableBlastRadius ? blastRadiusFn(blastRadiusParams) : 0;
+        const composite = 0.25 * bayesianEvidenceScore +
+            0.15 * confidence +
+            0.20 * capabilityFit +
+            0.15 * maturityScore +
+            0.10 * latencyScore +
+            0.10 * costScore -
+            0.15 * recentFailurePenalty -
+            0.10 * blastRadiusPenalty;
+        return {
+            runtimeId: runtime.id,
+            bayesianEvidenceScore,
+            confidence,
+            capabilityFit,
+            maturityScore,
+            latencyScore,
+            costScore,
+            recentFailurePenalty,
+            blastRadiusPenalty,
+            composite,
+        };
+    }
+    function select(candidates, intent, history) {
+        const scored = candidates.map((runtime) => ({
+            runtime,
+            score: score(runtime, intent, history),
+        }));
+        scored.sort((a, b) => b.score.composite - a.score.composite);
+        const primary = scored[0].runtime;
+        const fallbacks = scored.slice(1).map((s) => s.runtime);
+        const bestScore = scored[0].score;
+        const reason = [
+            `intent=${intent}`,
+            `bayesianE=${bestScore.bayesianEvidenceScore.toFixed(2)}`,
+            `confidence=${bestScore.confidence.toFixed(2)}`,
+            `capability=${bestScore.capabilityFit.toFixed(2)}`,
+            `maturity=${bestScore.maturityScore.toFixed(2)}`,
+            `latency=${bestScore.latencyScore.toFixed(2)}`,
+            `cost=${bestScore.costScore.toFixed(2)}`,
+            `penalty=${bestScore.recentFailurePenalty.toFixed(2)}`,
+            `blast=${bestScore.blastRadiusPenalty.toFixed(2)}`,
+            `composite=${bestScore.composite.toFixed(3)}`,
+        ].join("; ");
+        return {
+            runtime: primary,
+            reason,
+            fallbacks,
+            intent,
+            scores: scored.map((s) => s.score),
+        };
+    }
+    return { score, select };
+}
+export function scoreRuntimes(candidates, intent, history, options = {}) {
+    const engine = createRouterV2ScoringEngine(options);
+    return candidates.map((runtime) => engine.score(runtime, intent, history));
+}

package/dist/runtime/runtime-backed-task-runner.js

@@ -14,6 +14,7 @@ import { applyTaskRunContextToAgentTask, envFromWorkerManifest } from "./worker-
 import { createRuntimeRegistry } from "./runtime-registry.js";
 import { createRuntimeRouter } from "./runtime-router.js";
 import { createContextBroker } from "./context-broker.js";
+import { maybeCompactWithHeadroom } from "./headroom-policy.js";
 import { DeepSeekRuntime } from "./deepseek-runtime.js";
 import { CodexRuntime } from "./codex-runtime.js";
 import { createOpencodeCliAdapter } from "../adapters/opencode/opencode-cli-adapter.js";
@@ -128,7 +129,14 @@ export async function createRuntimeBackedTaskRunner(options) {
                     startedAt: new Date().toISOString(),
                 }
                 : undefined;
-            const { capsule } = await contextBroker.buildCapsule(node, runState);
+            const { capsule, headroomDecision } = await contextBroker.buildCapsule(node, runState);
+            // CTX guard: compact via headroom before the context window crosses the threshold (~90%).
+            if (headroomDecision?.shouldCompact) {
+                await maybeCompactWithHeadroom({
+                    decision: headroomDecision,
+                    text: JSON.stringify(capsule),
+                }).catch(() => undefined);
+            }
             const routing = capsule.node.routing;
             const providerFallbackChain = options.fallbackChain
                 ?? (routing?.fallbackProvider ? [routing.fallbackProvider] : []);

package/dist/runtime/tool-dispatch-contracts.d.ts

@@ -1,8 +1,64 @@
 import type { OmkToolCall, OmkToolDefinition } from "./tool-registry-contract.js";
+import { type ToolAuthorityDecision, type ToolOp } from "../safety/tool-authority-gate.js";
+import type { ProviderAuthorityLevel } from "../contracts/provider-health.js";
 export interface ToolDispatchResult<R = unknown> {
     readonly call: OmkToolCall;
     readonly status: "fulfilled" | "rejected";
     readonly value?: R;
     readonly reason?: unknown;
 }
-export declare function dispatchToolCallsByContract<A, R>(calls: readonly OmkToolCall<A>[], registry: ReadonlyMap<string, OmkToolDefinition<A, R>>, dispatchOne: (call: OmkToolCall<A>) => Promise<R>): Promise<ToolDispatchResult<R>[]>;
+/** Shadow = record only; enforce = a block/ask(non-TTY) verdict rejects the call. */
+export type ToolAuthorityMode = "shadow" | "enforce";
+/**
+ * Per-call verdict recorded at the dispatch checkpoint. Carries only coarse,
+ * non-secret signals (op class, authority levels, policy) — never tool args.
+ */
+export interface ToolAuthorityDecisionRecord {
+    readonly toolName: string;
+    readonly op: ToolOp;
+    readonly decision: ToolAuthorityDecision;
+    readonly mode: ToolAuthorityMode;
+    /** True only when the verdict actually rejected the call (enforce + block). */
+    readonly enforced: boolean;
+    /** Redacted, human-readable reason. Never includes args or secret values. */
+    readonly reason: string;
+}
+/**
+ * Authority wiring for one dispatch turn. All inputs are non-secret enum/bool
+ * signals. When omitted from {@link dispatchToolCallsByContract}, dispatch is
+ * byte-identical to the ungated path.
+ */
+export interface ToolAuthorityWiring {
+    readonly writeAuthority: ProviderAuthorityLevel;
+    readonly shellAuthority: ProviderAuthorityLevel;
+    readonly approvalPolicy: "interactive" | "auto" | "yolo" | "block";
+    readonly sandboxMode: "read-only" | "workspace-write";
+    readonly tty: boolean;
+    /**
+     * Enforcement opt-in. Default `false` => shadow mode (zero behavior change):
+     * verdicts are computed and recorded but never block. When `true`, a `block`
+     * verdict (and `ask` in a non-TTY context, fail-closed) rejects the call.
+     */
+    readonly enforce?: boolean;
+    /** Optional sink for computed verdicts (invoked in both shadow and enforce). */
+    readonly onDecision?: (record: ToolAuthorityDecisionRecord) => void;
+}
+/**
+ * Resolve the global enforcement opt-in from the environment. Default OFF means
+ * the gate runs in shadow mode (record only). Set `OMK_TOOL_AUTHORITY_ENFORCE=1`
+ * to enable fail-closed enforcement at the dispatch checkpoint.
+ */
+export declare function resolveToolAuthorityEnforcement(env?: Record<string, string | undefined>): boolean;
+/** Error used to reject a tool call rejected by the authority gate (enforce mode). */
+export declare class ToolAuthorityBlockedError extends Error {
+    readonly toolName: string;
+    readonly op: ToolOp;
+    readonly decision: ToolAuthorityDecision;
+    constructor(record: ToolAuthorityDecisionRecord);
+}
+/** Compute the gate verdict for a single call. Pure (no IO, no env reads). */
+export declare function evaluateToolAuthority(toolName: string, wiring: ToolAuthorityWiring): {
+    readonly record: ToolAuthorityDecisionRecord;
+    readonly blocked: boolean;
+};
+export declare function dispatchToolCallsByContract<A, R>(calls: readonly OmkToolCall<A>[], registry: ReadonlyMap<string, OmkToolDefinition<A, R>>, dispatchOne: (call: OmkToolCall<A>) => Promise<R>, authority?: ToolAuthorityWiring): Promise<ToolDispatchResult<R>[]>;