open-multi-agent-kit 0.78.6 → 0.78.8

package/dist/runtime/sandbox-profile.js

@@ -1,3 +1,5 @@
+import * as nodePath from "node:path";
+import * as fs from "node:fs";
 export function createRuntimeSandboxProfile(options) {
     const mode = options.mode ?? "read-only";
     const enforcement = options.enforcement ?? "env-only";
@@ -33,3 +35,102 @@ function defaultSandboxNotes(enforcement) {
     }
     return ["OS-level sandbox enforcement is not configured."];
 }
+// ---------------------------------------------------------------------------
+// writableRoots enforcement (Lane C2)
+//
+// Pure helpers that decide whether a target path is permitted by an explicit
+// list of writable roots. SAFE DEFAULT: an empty/undefined root list means
+// "unrestricted" so existing behavior (no enforcement) is preserved. These are
+// IO-free; callers resolve the active sandbox profile and pass its roots.
+// ---------------------------------------------------------------------------
+/**
+ * Resolve `p` to a canonical real path, best-effort and fail-safe.
+ *
+ * The write target may not exist yet, so we cannot `realpathSync` it directly.
+ * Instead we walk UP to the deepest EXISTING ancestor, `realpathSync` that
+ * ancestor (collapsing any symlinks on the existing portion), then re-append the
+ * remaining non-existent segments. This catches a symlink whose real target
+ * escapes the writable roots even when the final file does not exist yet.
+ *
+ * Fail-safe: `realpathSync` can throw (ENOENT while walking, EACCES). This
+ * function NEVER throws — on total failure it falls back to {@link nodePath.resolve}
+ * (the prior behavior). Only {@link assertWritable} throws, and only on a genuine
+ * deny.
+ */
+function resolveRealPathBestEffort(p) {
+    const resolved = nodePath.resolve(p);
+    const trailing = [];
+    let current = resolved;
+    for (;;) {
+        try {
+            const real = fs.realpathSync(current);
+            return trailing.length === 0 ? real : nodePath.join(real, ...trailing);
+        }
+        catch {
+            const parent = nodePath.dirname(current);
+            if (parent === current) {
+                // Reached the filesystem root with no resolvable ancestor: fall back to
+                // the plain resolved path (never throw from the resolution step).
+                return resolved;
+            }
+            trailing.unshift(nodePath.basename(current));
+            current = parent;
+        }
+    }
+}
+/**
+ * Error thrown by {@link assertWritable} when a path is outside every writable
+ * root. Carries only the resolved target and roots (no secret values).
+ */
+export class SandboxWriteDeniedError extends Error {
+    target;
+    roots;
+    constructor(target, roots) {
+        super(`Write denied by sandbox writableRoots policy: "${target}" is not inside ` +
+            `any writable root [${roots.join(", ")}]`);
+        this.name = "SandboxWriteDeniedError";
+        this.target = target;
+        this.roots = roots;
+    }
+}
+/**
+ * Return true when `p` is writable under `roots`.
+ *
+ * Rules:
+ *  - Empty/undefined `roots` => unrestricted (returns true). This preserves the
+ *    current "metadata only" behavior; enforcement activates only when a
+ *    sandbox profile explicitly sets non-empty `writableRoots`.
+ *  - Both target and roots are resolved via {@link resolveRealPathBestEffort},
+ *    which (a) collapses `.`/`..` segments and (b) realpath-resolves the deepest
+ *    existing ancestor so a SYMLINK whose real target escapes every root is
+ *    DENIED — even when the final write target does not exist yet.
+ *  - Prefix matching is segment-boundary safe: target must equal a root or sit
+ *    under `root + path.sep`, so root `/a/b` does NOT match sibling `/a/bc`.
+ */
+export function isPathWritable(p, roots) {
+    if (!roots || roots.length === 0)
+        return true;
+    const target = resolveRealPathBestEffort(p);
+    for (const root of roots) {
+        if (!root)
+            continue;
+        const normalizedRoot = resolveRealPathBestEffort(root);
+        if (target === normalizedRoot)
+            return true;
+        const rootWithSep = normalizedRoot.endsWith(nodePath.sep)
+            ? normalizedRoot
+            : normalizedRoot + nodePath.sep;
+        if (target.startsWith(rootWithSep))
+            return true;
+    }
+    return false;
+}
+/**
+ * Throw {@link SandboxWriteDeniedError} when `p` is not writable under `roots`.
+ * No-op when `roots` is empty/undefined (safe default => unrestricted).
+ */
+export function assertWritable(p, roots) {
+    if (isPathWritable(p, roots))
+        return;
+    throw new SandboxWriteDeniedError(resolveRealPathBestEffort(p), roots ?? []);
+}

package/dist/runtime/slash-commands.js

@@ -1,6 +1,13 @@
-import { KNOWN_PROVIDER_IDS, normalizeProviderId, parseProviderModelArg, readProviderRegistry } from "../providers/model-registry.js";
+import { readFile } from "node:fs/promises";
+import { KNOWN_PROVIDER_IDS, normalizeProviderId, parseProviderModelArg, providerDoctorStatus, readProviderRegistry, } from "../providers/model-registry.js";
 import { groupProviderModelsByProvider, renderProviderModelTable } from "../providers/model-table.js";
-import { formatThinkingModelVariant, nextThinkingLevel, normalizeThinkingLevel, normalizeThinkingVariant, thinkingLevelsFor } from "../providers/thinking-levels.js";
+import { formatThinkingModelVariant, nextThinkingLevel, normalizeThinkingLevel, normalizeThinkingVariant, thinkingLevelsFor, } from "../providers/thinking-levels.js";
+import { buildMcpDoctorReport } from "../commands/mcp/doctor.js";
+import { evaluateHeadroom, isHeadroomEnabled } from "./headroom-policy.js";
+import { buildOmkToolPlaneManifest } from "./tool-plane.js";
+import { LocalGraphMemoryStore } from "../memory/local-graph-memory-store.js";
+import { createReasoningTraceStore, redactTrace, summarizeTrace } from "./reasoning-trace.js";
+import { getActiveRuntimePreset, getOmkResourceSettings } from "../util/resource-profile.js";
 function parseSlashInput(rawText) {
     const trimmed = rawText.trimStart();
     const match = trimmed.match(/^\/([a-zA-Z0-9_-]+)\s*(.*)/s);
@@ -33,6 +40,18 @@ function resultToCommandBusResult(result) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function numberValue(payload, key, fallback = 0) {
+    const value = payload[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function booleanValue(payload, key, fallback = false) {
+    const value = payload[key];
+    return typeof value === "boolean" ? value : fallback;
+}
+function recordArrayValue(payload, key) {
+    const value = payload[key];
+    return Array.isArray(value) ? value.filter((item) => isRecord(item)) : [];
+}
 function stringValue(payload, key, fallback = "unknown") {
     const value = payload[key];
     return typeof value === "string" && value.trim() ? value : fallback;
@@ -96,6 +115,88 @@ function renderSlashResultContent(result, fallback) {
             const commands = stringListValue(payload, "commands");
             return [`\n  OMK Slash Commands`, ...commands.map((command) => `  - ${command}`), ""].join("\n");
         }
+        case "mcp.show": {
+            const scope = stringValue(payload, "scope");
+            const configured = numberValue(payload, "configured");
+            const servers = recordArrayValue(payload, "servers");
+            const lines = [`\n  MCP servers (${configured} configured, scope: ${scope})`];
+            for (const srv of servers) {
+                const name = stringValue(srv, "name");
+                const status = stringValue(srv, "status");
+                const active = booleanValue(srv, "active");
+                lines.push(`  ${active ? "●" : "○"} ${name}  ${status}`);
+            }
+            return lines.join("\n");
+        }
+        case "provider.show": {
+            const provider = stringValue(payload, "provider");
+            const model = stringValue(payload, "model");
+            const lines = [`\n  Provider: ${provider}/${model}`];
+            const current = isRecord(payload.current) ? payload.current : undefined;
+            if (current) {
+                lines.push(`  Available: ${booleanValue(current, "available")}  Auth: ${booleanValue(current, "authPresent")}`);
+            }
+            const fallbacks = recordArrayValue(payload, "fallbacks");
+            if (fallbacks.length > 0) {
+                lines.push("  Fallbacks:");
+                for (const fb of fallbacks) {
+                    lines.push(`    ${stringValue(fb, "provider")}  available=${booleanValue(fb, "available")} auth=${booleanValue(fb, "authPresent")}`);
+                }
+            }
+            return lines.join("\n");
+        }
+        case "headroom.show": {
+            const enabled = booleanValue(payload, "enabled");
+            const utilization = numberValue(payload, "utilization");
+            const threshold = numberValue(payload, "threshold");
+            const shouldCompact = booleanValue(payload, "shouldCompact");
+            return `\n  Headroom: ${enabled ? "enabled" : "disabled"}  usage=${(utilization * 100).toFixed(1)}%  threshold=${(threshold * 100).toFixed(1)}%  compact=${shouldCompact}`;
+        }
+        case "tools.show": {
+            const groups = recordArrayValue(payload, "groups");
+            const total = groups.reduce((sum, group) => sum + numberValue(group, "count"), 0);
+            const lines = [`\n  Tools: ${total} total`];
+            for (const group of groups) {
+                const name = stringValue(group, "name");
+                const count = numberValue(group, "count");
+                const items = stringListValue(group, "items");
+                lines.push(`  ${name}: ${count}${items.length > 0 ? `  [${items.join(", ")}]` : ""}`);
+            }
+            return lines.join("\n");
+        }
+        case "memory.show": {
+            const available = booleanValue(payload, "available", true);
+            if (!available) {
+                return `\n  Memory: unavailable (${stringValue(payload, "reason")})`;
+            }
+            const backend = stringValue(payload, "backend");
+            const nodeCount = numberValue(payload, "nodeCount");
+            const edgeCount = numberValue(payload, "edgeCount");
+            const lastUpdated = stringValue(payload, "lastUpdated", "—");
+            const queryRaw = payload.query;
+            const query = typeof queryRaw === "string" && queryRaw.trim() ? queryRaw : undefined;
+            const results = recordArrayValue(payload, "results");
+            const lines = [`\n  Memory: ${backend}  nodes=${nodeCount}  edges=${edgeCount}  updated=${lastUpdated}`];
+            if (query) {
+                lines.push(`  Query: "${query}"`);
+                for (const result of results) {
+                    lines.push(`    - ${stringValue(result, "path")}  ${stringValue(result, "updatedAt")}`);
+                }
+            }
+            return lines.join("\n");
+        }
+        case "trace.show": {
+            const count = numberValue(payload, "count");
+            const traces = recordArrayValue(payload, "traces");
+            const lines = [`\n  Reasoning traces (latest ${count}):`];
+            for (const trace of traces) {
+                const outcome = stringValue(trace, "outcome");
+                const icon = outcome === "success" ? "✔" : outcome === "partial" ? "◐" : "✖";
+                const redacted = booleanValue(trace, "redacted") ? " (redacted)" : "";
+                lines.push(`  ${icon} ${stringValue(trace, "intent")} → ${outcome} [${stringValue(trace, "duration")}]${redacted}`);
+            }
+            return lines.join("\n");
+        }
         default:
             return fallback;
     }
@@ -262,6 +363,185 @@ class ThemeCommandHandler {
         };
     }
 }
+class McpCommandHandler {
+    async execute() {
+        const report = await buildMcpDoctorReport();
+        const servers = report.servers.map((srv) => ({
+            name: srv.name,
+            status: srv.status === "ok" ? "ok" : srv.status === "warn" ? "degraded" : "down",
+            active: srv.active,
+        }));
+        return {
+            kind: "status",
+            command: "mcp.show",
+            payload: {
+                configured: report.data.serverCount,
+                scope: report.activeScope,
+                servers,
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class ProviderCommandHandler {
+    async execute(input) {
+        const currentProvider = input.state.provider ?? "unknown";
+        const currentModel = input.state.model ?? "unknown";
+        const registry = await readProviderRegistry();
+        const statuses = await Promise.all(registry.map(async (entry) => {
+            const doctor = await providerDoctorStatus(entry.id).catch(() => undefined);
+            return doctor ? { ...doctor, configured: entry.configured } : undefined;
+        }));
+        const statusesDefined = statuses.filter((s) => s !== undefined);
+        const current = statusesDefined.find((s) => s.provider === currentProvider);
+        const fallbacks = statusesDefined
+            .filter((s) => s.provider !== currentProvider && s.configured)
+            .sort((a, b) => Number(b.available) - Number(a.available));
+        return {
+            kind: "status",
+            command: "provider.show",
+            payload: {
+                provider: currentProvider,
+                model: currentModel,
+                current: current
+                    ? {
+                        provider: current.provider,
+                        model: current.model,
+                        available: current.available,
+                        authPresent: current.apiKeySet === true,
+                        kind: current.kind,
+                    }
+                    : undefined,
+                fallbacks: fallbacks.map((s) => ({
+                    provider: s.provider,
+                    model: s.model,
+                    available: s.available,
+                    authPresent: s.apiKeySet === true,
+                })),
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class HeadroomCommandHandler {
+    async execute(input) {
+        const registry = await readProviderRegistry();
+        const entry = registry.find((e) => e.id === input.state.provider);
+        const contextWindow = typeof entry?.contextWindow === "number" && entry.contextWindow > 0 ? entry.contextWindow : 0;
+        const decision = evaluateHeadroom({ usedTokens: 0, contextWindow });
+        return {
+            kind: "status",
+            command: "headroom.show",
+            payload: {
+                enabled: isHeadroomEnabled(),
+                utilization: decision.utilization,
+                threshold: decision.threshold,
+                usedTokens: decision.usedTokens,
+                contextWindow: decision.contextWindow,
+                shouldCompact: decision.shouldCompact,
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class ToolsCommandHandler {
+    async execute() {
+        const [settings, preset] = await Promise.all([
+            getOmkResourceSettings(),
+            getActiveRuntimePreset().catch(() => undefined),
+        ]);
+        const manifest = await buildOmkToolPlaneManifest({
+            mcpScope: settings.mcpScope,
+            skills: preset?.skills ?? [],
+            hooks: preset?.hooks ?? [],
+            tools: [],
+        });
+        const groups = [
+            { name: "MCP servers", count: manifest.mcpServers.length, items: [...manifest.mcpServers] },
+            { name: "Skills", count: manifest.skills.length, items: [...manifest.skills] },
+            { name: "Hooks", count: manifest.hooks.length, items: [...manifest.hooks] },
+            { name: "Tools", count: manifest.tools.length, items: [...manifest.tools] },
+        ];
+        return {
+            kind: "status",
+            command: "tools.show",
+            payload: { groups },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class MemoryCommandHandler {
+    async execute(input) {
+        const store = await LocalGraphMemoryStore.create();
+        if (!store) {
+            return {
+                kind: "status",
+                command: "memory.show",
+                payload: { available: false, reason: "local graph memory not configured" },
+                renderMode: "theme",
+                sideEffects: [],
+            };
+        }
+        const status = store.status;
+        const raw = await readFile(status.localGraph.path, "utf-8").catch(() => "{}");
+        const parsed = JSON.parse(raw);
+        const nodeCount = Array.isArray(parsed.nodes) ? parsed.nodes.length : 0;
+        const edgeCount = Array.isArray(parsed.edges) ? parsed.edges.length : 0;
+        const lastUpdated = typeof parsed.updatedAt === "string" ? parsed.updatedAt : "—";
+        const query = input.args.join(" ").trim();
+        let results = [];
+        if (query) {
+            const hits = await store.search(query, 5);
+            results = hits.map((hit) => ({ path: hit.path, updatedAt: hit.updatedAt }));
+        }
+        return {
+            kind: "status",
+            command: "memory.show",
+            payload: {
+                available: true,
+                backend: status.backend,
+                nodeCount,
+                edgeCount,
+                lastUpdated,
+                query: query || undefined,
+                results,
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class TraceCommandHandler {
+    async execute(input) {
+        const store = createReasoningTraceStore();
+        const limit = Math.min(20, Math.max(1, Number(input.args[0]) || 5));
+        const traces = await store.list(limit);
+        const summaries = traces.map((trace) => {
+            const redacted = trace.privacy.level === "l0" || !trace.privacy.consentGiven;
+            const source = redacted ? redactTrace(trace) : trace;
+            const summary = summarizeTrace(source);
+            return {
+                id: trace.id,
+                intent: summary.intent,
+                outcome: summary.outcome,
+                duration: summary.duration,
+                confidence: summary.confidence,
+                redacted,
+            };
+        });
+        return {
+            kind: "status",
+            command: "trace.show",
+            payload: { count: summaries.length, traces: summaries },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
 class HelpCommandHandler {
     async execute() {
         return {
@@ -273,6 +553,12 @@ class HelpCommandHandler {
                     "/think [next|medium|high|xhigh|max|variant <name>] - Cycle or set thinking variant",
                     "/status - Show current runtime status",
                     "/theme [name] - Show or set theme",
+                    "/mcp - Show MCP server health",
+                    "/provider - Show current provider, model, and fallback status",
+                    "/headroom - Show context headroom status",
+                    "/tools - Show tool plane manifest",
+                    "/memory [query] - Show memory summary or search top-N",
+                    "/trace - Show latest reasoning trace summaries",
                     "/help - Show this help",
                 ],
             },
@@ -287,6 +573,12 @@ const defaultHandlers = {
     thinking: new ThinkCommandHandler(),
     status: new StatusCommandHandler(),
     theme: new ThemeCommandHandler(),
+    mcp: new McpCommandHandler(),
+    provider: new ProviderCommandHandler(),
+    headroom: new HeadroomCommandHandler(),
+    tools: new ToolsCommandHandler(),
+    memory: new MemoryCommandHandler(),
+    trace: new TraceCommandHandler(),
     help: new HelpCommandHandler(),
 };
 export function createSlashCommandHandler(state = {}) {
@@ -317,5 +609,11 @@ export function registerSlashCommands(bus, state = {}) {
     bus.registerHandler("thinking", handler);
     bus.registerHandler("status", handler);
     bus.registerHandler("theme", handler);
+    bus.registerHandler("mcp", handler);
+    bus.registerHandler("provider", handler);
+    bus.registerHandler("headroom", handler);
+    bus.registerHandler("tools", handler);
+    bus.registerHandler("memory", handler);
+    bus.registerHandler("trace", handler);
     bus.registerHandler("help", handler);
 }

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

@@ -51,6 +51,21 @@ export interface ToolAuthorityWiring {
      * Runtimes without a valid proof cannot enter authority lanes.
      */
     readonly enforcementProof?: EnforcementProof;
+    /**
+     * Optional writable-root allowlist for filesystem write enforcement (Lane C2).
+     * Only consulted when `enforce === true` AND {@link resolveWritePath} is
+     * provided AND it returns a non-empty path. ABSENT or empty => NO path check
+     * runs and dispatch is byte-identical to the ungated path.
+     */
+    readonly writableRoots?: readonly string[];
+    /**
+     * Optional resolver mapping a tool call to its filesystem write target. Only
+     * consulted when `enforce === true` AND `writableRoots` is non-empty. When this
+     * is ABSENT (or returns undefined/empty), NO write-path check runs and dispatch
+     * is byte-identical to now. When it returns a non-empty path, that path is
+     * checked against `writableRoots` via {@link assertWritable}; a deny throws.
+     */
+    readonly resolveWritePath?: (call: OmkToolCall) => string | undefined;
 }
 /**
  * Resolve the global enforcement opt-in from the environment. Default OFF means

package/dist/runtime/tool-dispatch-contracts.js

@@ -1,5 +1,6 @@
 import { createToolExecutionBatches } from "./tool-registry-contract.js";
 import { decideToolAuthority, decideToolAuthorityV2, mapToolNameToOp, } from "../safety/tool-authority-gate.js";
+import { assertWritable } from "./sandbox-profile.js";
 const ENFORCE_PATTERN = /^(1|true|yes|on)$/i;
 /**
  * Resolve the global enforcement opt-in from the environment. Default OFF means
@@ -109,6 +110,17 @@ function buildGatedDispatch(wiring, dispatchOne) {
         if (blocked) {
             throw new ToolAuthorityBlockedError(record);
         }
+        // Lane C2 filesystem write enforcement. NON-BREAKING: this block is entered
+        // only when ALL opt-ins are present (enforce === true AND a non-empty
+        // writableRoots AND a resolveWritePath that yields a non-empty path). When
+        // any is absent the dispatch path is byte-identical to the pre-C2 behavior.
+        // A symlink/escape deny throws SandboxWriteDeniedError from assertWritable.
+        if (wiring.enforce === true && wiring.writableRoots?.length && wiring.resolveWritePath) {
+            const writeTarget = wiring.resolveWritePath(call);
+            if (writeTarget) {
+                assertWritable(writeTarget, wiring.writableRoots);
+            }
+        }
         return dispatchOne(call);
     };
 }

package/dist/runtime/weights-config.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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 type { NodeIntent } from "./contracts/router-v2.js";
+declare const RELEASE_GATE_WEIGHT_KEYS: readonly ["ci", "build", "types", "tests", "install", "demo", "proof", "maturity", "docs"];
+export type ReleaseGateWeightKey = (typeof RELEASE_GATE_WEIGHT_KEYS)[number];
+declare const RELEASE_GATE_PENALTY_KEYS: readonly ["regression"];
+export type ReleaseGatePenaltyKey = (typeof RELEASE_GATE_PENALTY_KEYS)[number];
+declare const RELEASE_GATE_THRESHOLD_KEYS: readonly ["preRelease", "stable"];
+export type ReleaseGateThresholdKey = (typeof RELEASE_GATE_THRESHOLD_KEYS)[number];
+declare const ROUTER_V2_WEIGHT_KEYS: readonly ["bayesianEvidence", "confidence", "capabilityFit", "maturity", "latency", "cost"];
+export type RouterV2WeightKey = (typeof ROUTER_V2_WEIGHT_KEYS)[number];
+declare const ROUTER_V2_PENALTY_KEYS: readonly ["recentFailure", "blastRadius"];
+export type RouterV2PenaltyKey = (typeof ROUTER_V2_PENALTY_KEYS)[number];
+declare const CAPABILITY_WEIGHT_KEYS: readonly ["read", "write", "shell", "patch", "review", "vision", "toolCalling"];
+/** Capability keys allowed in intentCapability vectors. */
+export type CapabilityWeightKey = (typeof CAPABILITY_WEIGHT_KEYS)[number];
+/** A normalize:true vector: weights are normalized, penalties/thresholds scaled uniformly. */
+export interface NormalizedVectorSpec<W extends string, P extends string, T extends string = never> {
+    readonly normalize: true;
+    readonly weights: Readonly<Record<W, number>>;
+    readonly penalties: Readonly<Record<P, number>>;
+    readonly thresholds?: Readonly<Record<T, number>>;
+}
+/** A normalize:false vector family kept verbatim (no scaling). */
+export interface IntentCapabilitySpec {
+    readonly normalize: false;
+    readonly rationale: string;
+    readonly vectors: Readonly<Record<NodeIntent, Readonly<Partial<Record<CapabilityWeightKey, number>>>>>;
+}
+export type ReleaseGateSpec = NormalizedVectorSpec<ReleaseGateWeightKey, ReleaseGatePenaltyKey, ReleaseGateThresholdKey>;
+export type RouterV2CompositeSpec = NormalizedVectorSpec<RouterV2WeightKey, RouterV2PenaltyKey>;
+export interface WeightsConfigV1 {
+    readonly schemaVersion: "omk.weights.v1";
+    readonly vectors: {
+        readonly releaseGate: ReleaseGateSpec;
+        readonly routerV2Composite: RouterV2CompositeSpec;
+        readonly intentCapability: IntentCapabilitySpec;
+    };
+}
+/** Effective (uniformly scaled) weights/penalties/thresholds for a vector. */
+export interface EffectiveVector<W extends string, P extends string, T extends string = never> {
+    readonly weights: Readonly<Record<W, number>>;
+    readonly penalties: Readonly<Record<P, number>>;
+    readonly thresholds: Readonly<Record<T, number>>;
+    /** Uniform scale factor 1/Σw applied to weights, penalties, and thresholds. */
+    readonly scale: number;
+}
+export declare const DEFAULT_WEIGHTS: WeightsConfigV1;
+/**
+ * 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 declare function loadWeightsConfig(): WeightsConfigV1;
+/** Memoized accessor for the loaded weights config. */
+export declare function getWeightsConfig(): WeightsConfigV1;
+/**
+ * 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 declare function normalizeVector<W extends string, P extends string, T extends string>(name: string, spec: NormalizedVectorSpec<W, P, T>): EffectiveVector<W, P, T>;
+/** Effective (normalized) release-gate weights, penalties, and thresholds. */
+export declare function releaseGateEffective(config?: WeightsConfigV1): EffectiveVector<ReleaseGateWeightKey, ReleaseGatePenaltyKey, ReleaseGateThresholdKey>;
+/** Effective (normalized) Router V2 composite weights and penalties. */
+export declare function routerV2CompositeEffective(config?: WeightsConfigV1): EffectiveVector<RouterV2WeightKey, RouterV2PenaltyKey>;
+/**
+ * Intent → capability weight entries, verbatim (normalize:false), in the
+ * declared order of each vector.
+ */
+export declare function intentCapabilityWeights(config?: WeightsConfigV1): Readonly<Record<NodeIntent, ReadonlyArray<readonly [CapabilityWeightKey, number]>>>;
+export {};