open-multi-agent-kit 0.80.0 → 0.80.3

package/dist/runtime/weights-config.js

@@ -1,249 +0,0 @@
-/**
- * omk.weights.v1 — single weights contract for scoring vectors.
- *
- * Source of truth: schemas/omk.weights.v1.json (repo dev). The npm package
- * ships without schemas/, so DEFAULT_WEIGHTS embeds the same values and is
- * used as the fallback. The two MUST stay deep-equal (enforced by
- * test/weights-config.test.mjs).
- *
- * Normalization contract (behavior-preserving):
- *   ŵ = w / Σw, and penalties AND thresholds are scaled by the SAME factor
- *   1/Σw, so the transform is a pure uniform scaling. Rankings and threshold
- *   verdicts are mathematically identical to the historical raw-weight
- *   formulas.
- *
- * intentCapability is intentionally NOT normalized: the vectors are
- * feature-fit emphasis templates whose sub-unit sums are intentional;
- * normalizing them would change cross-term mixing (NOT behavior-preserving).
- */
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-// ── Key vocabularies ─────────────────────────────────────────────
-const RELEASE_GATE_WEIGHT_KEYS = [
-    "ci",
-    "build",
-    "types",
-    "tests",
-    "install",
-    "demo",
-    "proof",
-    "maturity",
-    "docs",
-];
-const RELEASE_GATE_PENALTY_KEYS = ["regression"];
-const RELEASE_GATE_THRESHOLD_KEYS = ["preRelease", "stable"];
-const ROUTER_V2_WEIGHT_KEYS = [
-    "bayesianEvidence",
-    "confidence",
-    "capabilityFit",
-    "maturity",
-    "latency",
-    "cost",
-];
-const ROUTER_V2_PENALTY_KEYS = ["recentFailure", "blastRadius"];
-const NODE_INTENT_KEYS = [
-    "research",
-    "planning",
-    "coding",
-    "debugging",
-    "refactor",
-    "review",
-    "test-generation",
-    "documentation",
-    "shell-operation",
-];
-const CAPABILITY_WEIGHT_KEYS = [
-    "read",
-    "write",
-    "shell",
-    "patch",
-    "review",
-    "vision",
-    "toolCalling",
-];
-// ── Embedded defaults (mirror of schemas/omk.weights.v1.json) ────
-export const DEFAULT_WEIGHTS = {
-    schemaVersion: "omk.weights.v1",
-    vectors: {
-        releaseGate: {
-            normalize: true,
-            weights: {
-                ci: 0.15,
-                build: 0.1,
-                types: 0.1,
-                tests: 0.1,
-                install: 0.1,
-                demo: 0.15,
-                proof: 0.15,
-                maturity: 0.1,
-                docs: 0.1,
-            },
-            penalties: { regression: 0.15 },
-            thresholds: { preRelease: 0.75, stable: 0.9 },
-        },
-        routerV2Composite: {
-            normalize: true,
-            weights: {
-                bayesianEvidence: 0.25,
-                confidence: 0.15,
-                capabilityFit: 0.2,
-                maturity: 0.15,
-                latency: 0.1,
-                cost: 0.1,
-            },
-            penalties: { recentFailure: 0.15, blastRadius: 0.1 },
-        },
-        intentCapability: {
-            normalize: false,
-            rationale: "feature-fit emphasis templates; sub-unit sums intentional; normalizing would change cross-term mixing (NOT behavior-preserving)",
-            vectors: {
-                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 },
-            },
-        },
-    },
-};
-// ── JSON loading ─────────────────────────────────────────────────
-const SCHEMA_FILENAME = "omk.weights.v1.json";
-function schemaFilePath() {
-    const here = dirname(fileURLToPath(import.meta.url));
-    // dist/runtime/weights-config.js → <repo>/schemas/omk.weights.v1.json
-    return join(here, "..", "..", "schemas", SCHEMA_FILENAME);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasNumberKeys(value, keys) {
-    if (!isRecord(value))
-        return false;
-    return keys.every((key) => typeof value[key] === "number" && Number.isFinite(value[key]));
-}
-function isCapabilityVector(value) {
-    if (!isRecord(value))
-        return false;
-    return Object.entries(value).every(([key, weight]) => CAPABILITY_WEIGHT_KEYS.includes(key) &&
-        typeof weight === "number" &&
-        Number.isFinite(weight));
-}
-function isWeightsConfigV1(value) {
-    if (!isRecord(value) || value.schemaVersion !== "omk.weights.v1")
-        return false;
-    const vectors = value.vectors;
-    if (!isRecord(vectors))
-        return false;
-    const releaseGate = vectors.releaseGate;
-    if (!isRecord(releaseGate) ||
-        releaseGate.normalize !== true ||
-        !hasNumberKeys(releaseGate.weights, RELEASE_GATE_WEIGHT_KEYS) ||
-        !hasNumberKeys(releaseGate.penalties, RELEASE_GATE_PENALTY_KEYS) ||
-        !hasNumberKeys(releaseGate.thresholds, RELEASE_GATE_THRESHOLD_KEYS)) {
-        return false;
-    }
-    const routerV2 = vectors.routerV2Composite;
-    if (!isRecord(routerV2) ||
-        routerV2.normalize !== true ||
-        !hasNumberKeys(routerV2.weights, ROUTER_V2_WEIGHT_KEYS) ||
-        !hasNumberKeys(routerV2.penalties, ROUTER_V2_PENALTY_KEYS)) {
-        return false;
-    }
-    const intentCapability = vectors.intentCapability;
-    if (!isRecord(intentCapability) ||
-        intentCapability.normalize !== false ||
-        typeof intentCapability.rationale !== "string" ||
-        !isRecord(intentCapability.vectors)) {
-        return false;
-    }
-    const intentVectors = intentCapability.vectors;
-    return NODE_INTENT_KEYS.every((intent) => isCapabilityVector(intentVectors[intent]));
-}
-/**
- * Load the omk.weights.v1 config: prefer schemas/omk.weights.v1.json when the
- * repo file exists (dev checkout), otherwise use the embedded defaults
- * (published package ships without schemas/).
- */
-export function loadWeightsConfig() {
-    const filePath = schemaFilePath();
-    if (existsSync(filePath)) {
-        try {
-            const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-            if (isWeightsConfigV1(parsed))
-                return parsed;
-        }
-        catch {
-            // Malformed repo file: fall back to embedded defaults.
-        }
-    }
-    return DEFAULT_WEIGHTS;
-}
-let cachedConfig;
-/** Memoized accessor for the loaded weights config. */
-export function getWeightsConfig() {
-    if (cachedConfig === undefined)
-        cachedConfig = loadWeightsConfig();
-    return cachedConfig;
-}
-// ── Normalization ────────────────────────────────────────────────
-function scaleRecord(record, scale) {
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        out[key] = value * scale;
-    }
-    return out;
-}
-/**
- * Normalize a normalize:true vector: ŵ = w/Σw. Penalties and thresholds are
- * scaled by the SAME factor 1/Σw so the transform is a pure uniform scaling
- * (ranking and threshold semantics preserved).
- *
- * @throws Error when the post-normalization invariant |Σŵ-1|>1e-6 fails.
- */
-export function normalizeVector(name, spec) {
-    const positiveSum = Object.values(spec.weights).reduce((acc, value) => acc + value, 0);
-    if (!(positiveSum > 0)) {
-        throw new Error(`omk.weights.v1 invariant violated: Σw≤0 for ${name}`);
-    }
-    const scale = 1 / positiveSum;
-    const weights = scaleRecord(spec.weights, scale);
-    const normalizedSum = Object.values(weights).reduce((acc, value) => acc + value, 0);
-    if (Math.abs(normalizedSum - 1) > 1e-6) {
-        throw new Error(`omk.weights.v1 invariant violated: |Σŵ-1|>1e-6 for ${name}`);
-    }
-    const penalties = scaleRecord(spec.penalties, scale);
-    const thresholds = scaleRecord((spec.thresholds ?? {}), scale);
-    return { weights, penalties, thresholds, scale };
-}
-// ── Effective vector accessors ───────────────────────────────────
-/** Effective (normalized) release-gate weights, penalties, and thresholds. */
-export function releaseGateEffective(config = getWeightsConfig()) {
-    return normalizeVector("releaseGate", config.vectors.releaseGate);
-}
-/** Effective (normalized) Router V2 composite weights and penalties. */
-export function routerV2CompositeEffective(config = getWeightsConfig()) {
-    return normalizeVector("routerV2Composite", config.vectors.routerV2Composite);
-}
-/**
- * Intent → capability weight entries, verbatim (normalize:false), in the
- * declared order of each vector.
- */
-export function intentCapabilityWeights(config = getWeightsConfig()) {
-    const out = {};
-    for (const intent of NODE_INTENT_KEYS) {
-        const vector = config.vectors.intentCapability.vectors[intent];
-        const entries = [];
-        for (const [key, weight] of Object.entries(vector)) {
-            if (typeof weight === "number") {
-                entries.push([key, weight]);
-            }
-        }
-        out[intent] = entries;
-    }
-    return out;
-}

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

@@ -1,34 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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 || routing?.freedomd?.degradedMode === "read-only-local-review";
-    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

@@ -1,4 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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/enforcement-engine.d.ts

@@ -1,89 +0,0 @@
-/**
- * Policy / Sandbox Enforcement Engine v2
- *
- * Capability lattice with conservative policy combination.
- * effectivePolicy = minByAuthority(userPolicy, repoPolicy, providerPolicy, adapterPolicy, riskPolicy)
- *
- * Conservative by default. Any ambiguity → block.
- */
-export type SandboxCapability = "read" | "write" | "shell" | "network" | "secret_read" | "secret_write" | "merge" | "publish";
-export declare const ALL_CAPABILITIES: readonly SandboxCapability[];
-export type CapabilityLevel = "none" | "advisory" | "direct" | "full";
-export interface CapabilityLattice {
-    read: CapabilityLevel;
-    write: CapabilityLevel;
-    shell: CapabilityLevel;
-    network: CapabilityLevel;
-    secret_read: CapabilityLevel;
-    secret_write: CapabilityLevel;
-    merge: CapabilityLevel;
-    publish: CapabilityLevel;
-}
-export type SandboxMode = "read-only" | "workspace-write" | "network-isolated" | "unrestricted";
-export type ApprovalPolicy = "interactive" | "auto" | "yolo" | "block";
-export interface PolicyLayer {
-    readonly source: "user" | "repo" | "provider" | "adapter" | "risk";
-    /** Partial lattice — omitted capabilities mean "no opinion" (inherit from other layers). */
-    readonly lattice: Partial<CapabilityLattice>;
-    readonly sandboxMode?: SandboxMode;
-    readonly approvalPolicy?: ApprovalPolicy;
-}
-export interface CombinedPolicy {
-    readonly lattice: Readonly<CapabilityLattice>;
-    readonly sandboxMode: SandboxMode;
-    readonly approvalPolicy: ApprovalPolicy;
-    /** Ordered list of sources that contributed to the combination. */
-    readonly sources: readonly PolicyLayer["source"][];
-}
-export interface EnforcementProof {
-    readonly sandboxMode: SandboxMode;
-    /** Which policy layers were active in the final combination. */
-    readonly enforcedBy: readonly string[];
-    /** Capabilities fully blocked (level === "none" or sandbox hard floor). */
-    readonly blockedCapabilities: readonly SandboxCapability[];
-    /** Capabilities that require explicit approval (level === "advisory" or interactive policy). */
-    readonly approvalRequired: readonly SandboxCapability[];
-    /** Deterministic hash of the combined policy for audit / replay. */
-    readonly policyHash: string;
-}
-export declare function rankOf(level: CapabilityLevel): number;
-export declare function defaultLattice(): CapabilityLattice;
-/**
- * Combine multiple policy layers by taking the **most restrictive**
- * (minimum) authority level for each capability.
- *
- * If no layer expresses an opinion on a capability, it defaults to "full".
- * If any layer expresses a sandbox mode, the most restrictive mode wins.
- * If any layer expresses an approval policy, the most restrictive wins.
- */
-export declare function combinePoliciesByMinAuthority(layers: readonly PolicyLayer[]): CombinedPolicy;
-/**
- * Compute the enforcement proof from a combined policy.
- *
- * Rules:
- * 1. read-only sandbox blocks write, shell, network, merge, publish.
- * 2. network-isolated sandbox blocks network.
- * 3. Any capability with level "none" is blocked.
- * 4. Any capability with level "advisory" requires approval.
- * 5. interactive policy requires approval for non-read capabilities.
- * 6. block policy blocks everything except read.
- */
-export declare function computeEnforcementProof(combined: CombinedPolicy): EnforcementProof;
-/**
- * Returns true when the runtime/adapter has provided a valid enforcement proof.
- * Runtimes without enforcement proof cannot enter authority lanes.
- */
-export declare function hasValidEnforcementProof(proof: unknown): proof is EnforcementProof;
-export declare function policyLayerFromLegacyAuthorities(source: PolicyLayer["source"], options: {
-    writeAuthority?: "none" | "advisory" | "direct" | "full";
-    shellAuthority?: "none" | "advisory" | "direct" | "full";
-    sandboxMode?: SandboxMode;
-    approvalPolicy?: ApprovalPolicy;
-}): PolicyLayer;
-export type ToolOpV2 = "read" | "write" | "shell" | "merge" | "network" | "secret";
-/**
- * Map a capability-lattice capability to the coarse ToolOp used by the gate.
- * This preserves backward compatibility with the existing 4-class gate while
- * allowing the new lattice to express finer-grained restrictions.
- */
-export declare function capabilityToToolOp(cap: SandboxCapability): ToolOpV2;