open-multi-agent-kit 0.78.6 → 0.78.7

package/dist/providers/anthropic-messages-runner.js

@@ -0,0 +1,197 @@
+import { renderPromptDigest } from "../goal/prompt-digest.js";
+import { inferNodeRisk } from "./router.js";
+import { contextPreflightErrorMessage, preflightProviderMessages, } from "./context-preflight.js";
+export function createAnthropicMessagesReadOnlyTaskRunner(options) {
+    let currentOnThinking;
+    const runner = {
+        get onThinking() {
+            return currentOnThinking;
+        },
+        set onThinking(fn) {
+            currentOnThinking = fn;
+        },
+        fork(onThinking) {
+            const forked = createAnthropicMessagesReadOnlyTaskRunner(options);
+            forked.onThinking = onThinking;
+            return forked;
+        },
+        async run(node, env, signal) {
+            const risk = inferNodeRisk(node);
+            const advisoryMode = env.OMK_PROVIDER_AUTHORITY === "advisory" && risk === "write";
+            if (risk !== "read" && !advisoryMode) {
+                return deny(node, `${options.provider} runner is read-only/advisory; write/shell/merge authority stays on the authority provider`);
+            }
+            if (node.routing?.requiresToolCalling === true || node.routing?.requiresMcp === true) {
+                return deny(node, `${options.provider} runner does not receive tool or MCP authority`);
+            }
+            if (!options.apiKey) {
+                return deny(node, `${options.provider} API key is missing (${options.apiKeyEnv ?? "provider env"}); provider-neutral authority fallback is required`);
+            }
+            const model = env.OMK_PROVIDER_MODEL || options.model;
+            currentOnThinking?.(`${options.provider} ${env.OMK_PROVIDER_AUTHORITY ?? "direct"} worker: ${node.name}`);
+            try {
+                const messages = [
+                    {
+                        role: "system",
+                        content: [
+                            `You are a ${options.provider} read-only/advisory worker inside OMK.`,
+                            "OMK and the configured authority provider are the root orchestrator and final authority.",
+                            "Do not claim file writes, shell execution, secret access, MCP access, or merge authority.",
+                            advisoryMode ? "For this file-affecting node, provide advisory strategy only." : "",
+                            "Return concise findings, evidence, risks, and recommended authority-provider follow-up.",
+                        ].filter(Boolean).join(" "),
+                    },
+                    { role: "user", content: buildNodePrompt(node, env, options) },
+                ];
+                const preflight = await preflightProviderMessages(messages, {
+                    provider: options.provider,
+                    model,
+                    contextWindow: options.contextWindow,
+                    reservedOutputTokens: options.reservedOutputTokens ?? options.maxTokens ?? 4096,
+                    safetyMarginTokens: options.safetyMarginTokens,
+                    runId: env.OMK_RUN_ID,
+                    nodeId: node.id,
+                    projectRoot: env.OMK_PROJECT_ROOT,
+                });
+                if (!preflight.ok) {
+                    return {
+                        success: false,
+                        exitCode: 1,
+                        stdout: "",
+                        stderr: contextPreflightErrorMessage(preflight.report),
+                        metadata: { contextPreflight: preflight.report },
+                    };
+                }
+                const content = await completeMessages({
+                    ...options,
+                    model,
+                    messages: preflight.messages,
+                    signal,
+                });
+                return {
+                    success: true,
+                    exitCode: 0,
+                    stdout: `[${node.id}:${node.role}:${options.provider}] ${content}\n`,
+                    stderr: "",
+                    metadata: preflight.report.compacted ? { contextPreflight: preflight.report } : undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: err instanceof Error ? err.message : String(err),
+                };
+            }
+        },
+    };
+    return runner;
+}
+async function completeMessages(options) {
+    const credential = options.apiKey?.trim();
+    if (!credential)
+        throw new Error(`${options.provider} API key is missing`);
+    const baseUrl = options.baseUrl.replace(/\/+$/, "");
+    const fetchImpl = options.fetchImpl ?? fetch;
+    // Anthropic Messages API separates system messages from the messages array
+    const systemMessages = [];
+    const chatMessages = options.messages
+        .filter((m) => {
+        if (m.role === "system") {
+            systemMessages.push(m.content);
+            return false;
+        }
+        return true;
+    })
+        .map((m) => ({ role: m.role, content: m.content }));
+    const body = {
+        model: options.model,
+        max_tokens: options.maxTokens ?? 4096,
+        messages: chatMessages,
+    };
+    if (systemMessages.length > 0) {
+        body.system = systemMessages.join("\n");
+    }
+    const response = await fetchImpl(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": credential,
+            "anthropic-version": "2023-06-01",
+            ...safeExtraHeaders(options.headers),
+        },
+        body: JSON.stringify(body),
+        signal: options.signal,
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(`${options.provider} HTTP ${response.status}: ${sanitizeProviderErrorText(text, credential)}`);
+    }
+    const parsed = JSON.parse(text);
+    const contentBlock = parsed.content?.find((c) => c.type === "text" || typeof c.text === "string");
+    const content = contentBlock?.text;
+    if (typeof content !== "string")
+        throw new Error(`${options.provider} response missing assistant content`);
+    return content;
+}
+function buildNodePrompt(node, env, options) {
+    return [
+        options.promptPrefix?.trim(),
+        `DAG node: ${node.id}`,
+        `Name: ${node.name}`,
+        `Role: ${node.role}`,
+        `Task type: ${env.OMK_TASK_TYPE ?? "general"}`,
+        `Complexity: ${env.OMK_COMPLEXITY ?? "moderate"}`,
+        `Provider: ${options.provider}`,
+        `Model: ${env.OMK_PROVIDER_MODEL ?? options.model}`,
+        `Authority: ${env.OMK_PROVIDER_AUTHORITY ?? "direct"}`,
+        `Provider route reason: ${env.OMK_PROVIDER_ROUTE_REASON ?? ""}`,
+        `Routing rationale: ${node.routing?.rationale ?? ""}`,
+        renderPromptDigest("Goal context digest from authority provider", env.OMK_GOAL_CONTEXT ?? env.OMK_GOAL, {
+            maxKeywords: 18,
+            maxPhrases: 3,
+        }),
+        renderList("Skills visible to authority provider", node.routing?.skills ?? []),
+        renderList("MCP hints visible to authority provider only", node.routing?.mcpServers ?? [], { showWhenEmpty: true }),
+        renderList("Tool hints visible to authority provider only", node.routing?.tools ?? [], { showWhenEmpty: true }),
+        "Required output:",
+        "- Summary",
+        "- Evidence or file/symbol references if known",
+        "- Risks/unknowns",
+        "- Recommended authority-provider follow-up",
+    ].filter((section) => Boolean(section)).join("\n").trim() || `Analyze DAG node ${node.id}.`;
+}
+function renderList(title, items, options = {}) {
+    if (items.length === 0)
+        return options.showWhenEmpty === true ? `${title}:\n- none` : "";
+    return `${title}:\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+function safeExtraHeaders(headers) {
+    const safe = {};
+    for (const [name, value] of Object.entries(headers ?? {})) {
+        const normalized = name.trim();
+        const lower = normalized.toLowerCase();
+        const trimmedValue = value?.trim();
+        if (!normalized || !trimmedValue)
+            continue;
+        if (lower === "x-api-key" || lower === "content-type" || lower === "anthropic-version")
+            continue;
+        safe[normalized] = trimmedValue;
+    }
+    return safe;
+}
+function sanitizeProviderErrorText(text, credential) {
+    return text
+        .replaceAll(credential, "[redacted]")
+        .replace(/x-api-key\s+\S+/g, "x-api-key [redacted]")
+        .slice(0, 500);
+}
+function deny(node, reason) {
+    return {
+        success: false,
+        exitCode: 1,
+        stdout: "",
+        stderr: `[${node.id}:${node.role}] ${reason}`,
+    };
+}

package/dist/providers/model-registry.d.ts

@@ -1,6 +1,6 @@
 import { type DeepSeekConfigPathOptions } from "./deepseek/deepseek-config.js";
 import type { ProviderAuthMethod, ProviderId, ProviderKind, ProviderModelRef, ProviderPlanKind, ProviderPolicy, ProviderProfileType, ProviderWireApi } from "./types.js";
-export declare const KNOWN_PROVIDER_IDS: readonly ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter"];
+export declare const KNOWN_PROVIDER_IDS: readonly ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter", "anthropic"];
 export declare const QWEN_DASHSCOPE_COMPAT_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
 export declare const OPENROUTER_COMPAT_BASE_URL = "https://openrouter.ai/api/v1";
 export interface ProviderRegistryEntry {

package/dist/providers/model-registry.js

@@ -1,10 +1,34 @@
 import { runShell } from "../util/shell.js";
 import { readOmkProvidersConfig, writeOmkProvidersConfig, } from "./deepseek/deepseek-config.js";
 import { DEFAULT_AUTHORITY_PROVIDER } from "./types.js";
-export const KNOWN_PROVIDER_IDS = ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter"];
+export const KNOWN_PROVIDER_IDS = ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter", "anthropic"];
 export const QWEN_DASHSCOPE_COMPAT_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
 export const OPENROUTER_COMPAT_BASE_URL = "https://openrouter.ai/api/v1";
 const DEFAULT_PROVIDER_CONFIGS = {
+    anthropic: {
+        enabled: false,
+        kind: "openai-compatible",
+        baseUrl: "https://api.anthropic.com",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "claude-fable-5",
+        aliases: {
+            default: "claude-fable-5",
+            fable: "claude-fable-5",
+            "fable-5": "claude-fable-5",
+            "claude-fable-5": "claude-fable-5",
+            "opus-4-8": "claude-opus-4-8",
+            "claude-opus-4-8": "claude-opus-4-8",
+        },
+        capabilities: ["read", "review", "qa", "research", "advisory"],
+        contextWindow: 200_000,
+        reservedOutputTokens: 8192,
+        wireApi: "anthropic-messages",
+        auth: { method: "oauth" },
+        profileType: "runtime",
+        planKind: "openai-api",
+        routing: "advisory",
+        headers: { "anthropic-version": "2023-06-01" },
+    },
     mimo: {
         enabled: true,
         kind: "openai-compatible",
@@ -108,6 +132,10 @@ const DEFAULT_PROVIDER_CONFIGS = {
             auto: "openrouter/auto",
             "openrouter-default": "openrouter/auto",
             "openrouter/auto": "openrouter/auto",
+            fable: "anthropic/claude-fable-5",
+            "fable-5": "anthropic/claude-fable-5",
+            "claude-fable-5": "anthropic/claude-fable-5",
+            "anthropic/claude-fable-5": "anthropic/claude-fable-5",
         },
         capabilities: ["read", "research", "review", "qa", "advisory"],
         contextWindow: 128_000,
@@ -146,6 +174,8 @@ export function normalizeProviderId(value) {
         return "qwen";
     if (lower === "openrouter" || lower === "openrouter-ai" || lower === "claude" || lower === "anthropic")
         return "openrouter";
+    if (lower === "anthropic-api" || lower === "anthropic-direct" || lower === "claude-api")
+        return "anthropic";
     return lower;
 }
 export function parseProviderModelArg(value) {
@@ -182,7 +212,7 @@ export function parseProviderModelArg(value) {
         return withThinking({ provider: "codex", model });
     if (model.startsWith("deepseek-v4-"))
         return withThinking({ provider: "deepseek", model });
-    if (model.startsWith("claude-") || model.startsWith("gpt-"))
+    if (model.startsWith("claude-") || model.startsWith("gpt-") || model.startsWith("anthropic/"))
         return withThinking({ provider: "openrouter", model });
     return withThinking({ model });
 }
@@ -202,8 +232,12 @@ export function normalizeModelAlias(value) {
         return "claude-sonnet";
     if (lower === "opus")
         return "claude-opus";
+    if (lower === "opus-4-8" || lower === "claude-opus-4-8")
+        return "claude-opus-4-8";
     if (lower === "haiku")
         return "claude-haiku";
+    if (lower === "fable" || lower === "fable-5" || lower === "claude-fable-5")
+        return "anthropic/claude-fable-5";
     if (lower === "flash" || lower === "thinking" || lower === "non-thinking" || lower === "reasoner")
         return "deepseek-v4-flash";
     if (lower === "pro")
@@ -403,7 +437,7 @@ function isKnownProviderId(value) {
     return KNOWN_PROVIDER_IDS.includes(value);
 }
 function normalizeWireApi(value) {
-    if (value === "kimi-native" || value === "openai-chat-completions" || value === "openai-responses" || value === "external-cli")
+    if (value === "kimi-native" || value === "openai-chat-completions" || value === "openai-responses" || value === "anthropic-messages" || value === "external-cli")
         return value;
     return undefined;
 }

package/dist/providers/provider-runtime.js

@@ -9,6 +9,7 @@ import { DEFAULT_AUTHORITY_PROVIDER } from "./types.js";
 import { createDeepSeekProvider } from "./deepseek-provider.js";
 import { createProviderRouter } from "./provider-router.js";
 import { createOpenAICompatibleReadOnlyTaskRunner } from "./openai-compatible-runner.js";
+import { createAnthropicMessagesReadOnlyTaskRunner } from "./anthropic-messages-runner.js";
 import { createCodexCliAdvisoryTaskRunner } from "./codex-cli-runner.js";
 import { providerDoctorStatus, readProviderRegistry } from "./model-registry.js";
 import { createContextBroker } from "../runtime/context-broker.js";
@@ -70,17 +71,32 @@ export async function createProviderBackedTaskRunner(options) {
             continue;
         const apiKey = entry.apiKeyEnv ? process.env[entry.apiKeyEnv] : undefined;
         if (apiKey && entry.baseUrl) {
-            providerRunners[entry.id] = createOpenAICompatibleReadOnlyTaskRunner({
-                provider: entry.id,
-                baseUrl: entry.baseUrl,
-                apiKey,
-                apiKeyEnv: entry.apiKeyEnv,
-                model: entry.defaultModel,
-                promptPrefix: options.deepseekPromptPrefix,
-                headers: openAICompatibleHeaders(entry, process.env),
-                contextWindow: entry.contextWindow,
-                reservedOutputTokens: entry.reservedOutputTokens,
-            });
+            if (entry.wireApi === "anthropic-messages") {
+                providerRunners[entry.id] = createAnthropicMessagesReadOnlyTaskRunner({
+                    provider: entry.id,
+                    baseUrl: entry.baseUrl,
+                    apiKey,
+                    apiKeyEnv: entry.apiKeyEnv,
+                    model: entry.defaultModel,
+                    promptPrefix: options.deepseekPromptPrefix,
+                    headers: openAICompatibleHeaders(entry, process.env),
+                    contextWindow: entry.contextWindow,
+                    reservedOutputTokens: entry.reservedOutputTokens,
+                });
+            }
+            else {
+                providerRunners[entry.id] = createOpenAICompatibleReadOnlyTaskRunner({
+                    provider: entry.id,
+                    baseUrl: entry.baseUrl,
+                    apiKey,
+                    apiKeyEnv: entry.apiKeyEnv,
+                    model: entry.defaultModel,
+                    promptPrefix: options.deepseekPromptPrefix,
+                    headers: openAICompatibleHeaders(entry, process.env),
+                    contextWindow: entry.contextWindow,
+                    reservedOutputTokens: entry.reservedOutputTokens,
+                });
+            }
             providerModels[entry.id] = providerModelDefault(entry);
         }
         else if (providerPolicy === entry.id) {

package/dist/providers/thinking-levels.js

@@ -4,14 +4,17 @@ const PROVIDER_LEVELS = {
     mimo: ["medium", "high", "xhigh", "max"],
     deepseek: ["off", "high", "xhigh", "max"],
     qwen: ["off", "medium", "high", "max"],
+    anthropic: ["minimal", "low", "medium", "high", "xhigh", "max"],
     openrouter: ["minimal", "low", "medium", "high", "xhigh", "max"],
+    duckcoding: ["minimal", "low", "medium", "high", "xhigh", "max"],
     codex: ["minimal", "low", "medium", "high", "xhigh"],
 };
 const MODEL_LEVELS = [
     { pattern: /kimi|mimo/i, levels: PROVIDER_LEVELS.kimi },
     { pattern: /deepseek/i, levels: PROVIDER_LEVELS.deepseek },
     { pattern: /qwen/i, levels: PROVIDER_LEVELS.qwen },
-    { pattern: /claude|sonnet|opus|haiku|gpt|openrouter/i, levels: PROVIDER_LEVELS.openrouter },
+    { pattern: /duck[-_ ]?coding/i, levels: PROVIDER_LEVELS.duckcoding },
+    { pattern: /fable|claude|sonnet|opus|haiku|anthropic|gpt|openrouter/i, levels: PROVIDER_LEVELS.anthropic },
     { pattern: /codex/i, levels: PROVIDER_LEVELS.codex },
 ];
 export function thinkingLevelsFor(provider, model) {

package/dist/providers/types.d.ts

@@ -1,5 +1,5 @@
 import type { TaskResult, TaskRunner } from "../contracts/orchestration.js";
-export type KnownProviderId = "mimo" | "kimi" | "deepseek" | "codex" | "qwen" | "openrouter";
+export type KnownProviderId = "mimo" | "kimi" | "deepseek" | "codex" | "qwen" | "openrouter" | "anthropic";
 export type ProviderId = KnownProviderId | (string & {});
 export type ProviderPolicy = "auto" | ProviderId;
 export declare const DEFAULT_AUTHORITY_PROVIDER: ProviderId;
@@ -12,7 +12,7 @@ export declare function resolveRuntimeFallbackChain(availableRuntimes?: readonly
 export type ProviderRisk = "read" | "write" | "shell" | "merge";
 export type ProviderComplexity = "simple" | "moderate" | "complex";
 export type ProviderKind = "kimi-native" | "openai-compatible" | "external-cli" | "codex-cli" | "local";
-export type ProviderWireApi = "kimi-native" | "openai-chat-completions" | "openai-responses" | "external-cli";
+export type ProviderWireApi = "kimi-native" | "openai-chat-completions" | "openai-responses" | "anthropic-messages" | "external-cli";
 export type ProviderAuthMethod = "api-key-env" | "oauth" | "external-cli" | "none";
 export type ProviderProfileType = "runtime" | "compatibility";
 export type ProviderPlanKind = "runtime" | "openai-api" | "chatgpt-plan" | "claude-code-plan" | "gemini-cli-plan" | "qwen-coding-plan" | "openrouter-credits" | "openrouter-byok";
@@ -85,7 +85,7 @@ export interface ProviderRouteDecision {
     /** Decision trace entries for forensic replay */
     trace?: import("../contracts/replay.js").DecisionTraceEntry[];
 }
-export type ProviderFailureKind = "availability" | "transient" | "policy" | "quota" | "unknown";
+export type ProviderFailureKind = "availability" | "transient" | "policy" | "quota" | "refusal" | "unknown";
 export interface ProviderAvailability {
     provider: ProviderId;
     available: boolean;

package/dist/runtime/contracts/weakness-remediation.d.ts

@@ -19,7 +19,15 @@ export declare const BETA_PRIOR_ALPHA0 = 1;
 export declare const BETA_PRIOR_BETA0 = 1;
 /** Default public surface budget K (max items). */
 export declare const SURFACE_BUDGET_K = 8;
-/** Algorithm 8 release gate weights. */
+/**
+ * Algorithm 8 release gate weights — raw (unnormalized) historical values.
+ *
+ * @deprecated Source of truth is the omk.weights.v1 contract
+ * (schemas/omk.weights.v1.json, mirrored by DEFAULT_WEIGHTS in
+ * src/runtime/weights-config.ts). The release promotion gate now consumes
+ * normalized effective weights via releaseGateEffective(); these raw values
+ * (positive Σ = 1.05) are kept only for backward compatibility.
+ */
 export declare const RELEASE_GATE_WEIGHTS: {
     readonly ci: 0.15;
     readonly build: 0.1;

package/dist/runtime/contracts/weakness-remediation.js

@@ -21,7 +21,15 @@ export const BETA_PRIOR_BETA0 = 1;
 /** Default public surface budget K (max items). */
 export const SURFACE_BUDGET_K = 8;
 // ── Phase 5 Release Promotion Gate ──────────────────────────────
-/** Algorithm 8 release gate weights. */
+/**
+ * Algorithm 8 release gate weights — raw (unnormalized) historical values.
+ *
+ * @deprecated Source of truth is the omk.weights.v1 contract
+ * (schemas/omk.weights.v1.json, mirrored by DEFAULT_WEIGHTS in
+ * src/runtime/weights-config.ts). The release promotion gate now consumes
+ * normalized effective weights via releaseGateEffective(); these raw values
+ * (positive Σ = 1.05) are kept only for backward compatibility.
+ */
 export const RELEASE_GATE_WEIGHTS = {
     ci: 0.15,
     build: 0.10,

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

@@ -1,9 +1,14 @@
 /**
  * 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
+ * Composite formula (omk.weights.v1 routerV2Composite vector, normalize:true):
+ *   ŵ_E*E + ŵ_conf*conf + ŵ_cap*cap + ŵ_mat*mat + ŵ_lat*lat + ŵ_cost*cost
+ *   - p̂_fail*pen - p̂_blast*blast
+ *
+ * Historical raw weights (0.25/0.15/0.20/0.15/0.10/0.10 − 0.15/0.10) had a
+ * positive Σ = 0.95; normalization divides weights AND penalties by the same
+ * factor (1/0.95), a pure uniform scaling. The composite is ranking-only
+ * (no absolute threshold compares it), so rankings are identical.
  */
 import type { AgentRuntime } from "./agent-runtime.js";
 import type { EvidenceHistoryEntry, NodeIntent, RuntimeScoreV2, RouterV2Options, RouterV2ScoringEngine, BlastRadiusParams } from "./contracts/router-v2.js";

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

@@ -1,24 +1,27 @@
 /**
  * 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
+ * Composite formula (omk.weights.v1 routerV2Composite vector, normalize:true):
+ *   ŵ_E*E + ŵ_conf*conf + ŵ_cap*cap + ŵ_mat*mat + ŵ_lat*lat + ŵ_cost*cost
+ *   - p̂_fail*pen - p̂_blast*blast
+ *
+ * Historical raw weights (0.25/0.15/0.20/0.15/0.10/0.10 − 0.15/0.10) had a
+ * positive Σ = 0.95; normalization divides weights AND penalties by the same
+ * factor (1/0.95), a pure uniform scaling. The composite is ranking-only
+ * (no absolute threshold compares it), so rankings are identical.
  */
 import { computeBlastRadiusPenalty } from "./blast-radius.js";
+import { intentCapabilityWeights, routerV2CompositeEffective } from "./weights-config.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]],
-};
+/**
+ * Intent → capability emphasis vectors, sourced verbatim from the
+ * omk.weights.v1 intentCapability vector family (normalize:false — sub-unit
+ * sums are intentional feature-fit emphasis templates).
+ */
+const INTENT_CAPABILITY_WEIGHTS = intentCapabilityWeights();
+/** Effective (normalized) composite weights/penalties — raw values ÷ 0.95. */
+const COMPOSITE_EFFECTIVE = routerV2CompositeEffective();
 function runtimeCapabilityEnabled(capabilities, capability) {
     if (capability === "toolCalling") {
         return capabilities.toolCalling === true || capabilities.supportsToolCalling === true;
@@ -93,14 +96,16 @@ export function createRouterV2ScoringEngine(options = {}, blastRadiusFn = comput
         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;
+        const cw = COMPOSITE_EFFECTIVE.weights;
+        const cp = COMPOSITE_EFFECTIVE.penalties;
+        const composite = cw.bayesianEvidence * bayesianEvidenceScore +
+            cw.confidence * confidence +
+            cw.capabilityFit * capabilityFit +
+            cw.maturity * maturityScore +
+            cw.latency * latencyScore +
+            cw.cost * costScore -
+            cp.recentFailure * recentFailurePenalty -
+            cp.blastRadius * blastRadiusPenalty;
         return {
             runtimeId: runtime.id,
             bayesianEvidenceScore,

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

@@ -48,4 +48,9 @@ export declare function createRuntimeRouter(options?: RuntimeRouterOptions): {
     setRuntimes(nextRuntimes: AgentRuntime[]): void;
     invalidateCache: () => void;
 };
+/** Test-only: deterministic capability-ordered sort using the precomputed score cache.
+ * Mirrors the production comparator so tests can assert identical ordering to the
+ * pre-change recompute-in-comparator reference. */
+export declare function sortRuntimesByCapabilityScore(runtimes: readonly AgentRuntime[], intent: NodeIntent): AgentRuntime[];
+export declare function computeRuntimeCapabilityScore(runtime: AgentRuntime, intent: NodeIntent): number;
 export {};

package/dist/runtime/runtime-router.js

@@ -137,7 +137,8 @@ export function createRuntimeRouter(options = {}) {
             score: scores[i],
             composite: computeComposite(scores[i], r, intent),
         }));
-        scored.sort((a, b) => compareScoredRuntimes(a, b, intent));
+        const capabilityScoreCache = buildCapabilityScoreCache(supporting, intent);
+        scored.sort((a, b) => compareScoredRuntimes(a, b, intent, capabilityScoreCache));
         const primary = scored[0].runtime;
         const fallbacks = scored.slice(1).map((s) => s.runtime);
         const bestScore = scored[0].score;
@@ -161,7 +162,10 @@ export function createRuntimeRouter(options = {}) {
             runtime: r,
             composite: computeRuntimeCapabilityScore(r, intent),
         }));
-        scored.sort((a, b) => compareRuntimeCandidates(a.runtime, b.runtime, intent));
+        // Reuse the capability scores already computed above instead of recomputing
+        // them inside the comparator on every comparison.
+        const capabilityScoreCache = new Map(scored.map((s) => [s.runtime, s.composite]));
+        scored.sort((a, b) => compareRuntimeCandidates(a.runtime, b.runtime, intent, capabilityScoreCache));
         const primary = scored[0].runtime;
         const fallbacks = scored.slice(1).map((s) => s.runtime);
         return {
@@ -337,6 +341,7 @@ export function createRuntimeRouter(options = {}) {
             throw new UnsupportedRuntimeError(capsule, detectedRuntimeLabels(runtimes));
         }
         const preferredRuntimeIds = task.providerPolicy?.fallbackChain ?? options.fallbackChain ?? [];
+        const capabilityScoreCache = buildCapabilityScoreCache(candidates, intent);
         candidates.sort((a, b) => {
             const runtimeDelta = runtimePreferenceIndex(a.id, preferredRuntimeIds)
                 - runtimePreferenceIndex(b.id, preferredRuntimeIds);
@@ -348,7 +353,7 @@ export function createRuntimeRouter(options = {}) {
                 if (providerDelta !== 0)
                     return providerDelta;
             }
-            return compareRuntimeCandidates(a, b, intent);
+            return compareRuntimeCandidates(a, b, intent, capabilityScoreCache);
         });
         let lastError;
         for (const runtime of candidates) {
@@ -574,14 +579,14 @@ function computeComposite(score, runtime, intent) {
         0.15 * computeRuntimeCapabilityScore(runtime, intent) +
         0.05 * runtimePriorityScore(runtime));
 }
-function compareScoredRuntimes(a, b, intent) {
+function compareScoredRuntimes(a, b, intent, scoreCache) {
     const compositeDelta = b.composite - a.composite;
     if (compositeDelta !== 0)
         return compositeDelta;
-    return compareRuntimeCandidates(a.runtime, b.runtime, intent);
+    return compareRuntimeCandidates(a.runtime, b.runtime, intent, scoreCache);
 }
-function compareRuntimeCandidates(a, b, intent) {
-    const capabilityDelta = computeRuntimeCapabilityScore(b, intent) - computeRuntimeCapabilityScore(a, intent);
+function compareRuntimeCandidates(a, b, intent, scoreCache) {
+    const capabilityDelta = capabilityScoreFromCache(scoreCache, b, intent) - capabilityScoreFromCache(scoreCache, a, intent);
     if (capabilityDelta !== 0)
         return capabilityDelta;
     const priorityDelta = b.priority - a.priority;
@@ -589,7 +594,34 @@ function compareRuntimeCandidates(a, b, intent) {
         return priorityDelta;
     return a.id.localeCompare(b.id);
 }
-function computeRuntimeCapabilityScore(runtime, intent) {
+// Precompute each candidate's capability score ONCE before sorting. Without this the
+// comparator recomputed `computeRuntimeCapabilityScore` for both operands on every
+// comparison, making the sort O(r log r * c) instead of O(r log r). Keyed by runtime
+// object reference so identical ids with distinct objects can never alias.
+function buildCapabilityScoreCache(runtimes, intent) {
+    const cache = new Map();
+    for (const runtime of runtimes) {
+        if (!cache.has(runtime))
+            cache.set(runtime, computeRuntimeCapabilityScore(runtime, intent));
+    }
+    return cache;
+}
+function capabilityScoreFromCache(cache, runtime, intent) {
+    const cached = cache.get(runtime);
+    if (cached !== undefined)
+        return cached;
+    const computed = computeRuntimeCapabilityScore(runtime, intent);
+    cache.set(runtime, computed);
+    return computed;
+}
+/** Test-only: deterministic capability-ordered sort using the precomputed score cache.
+ * Mirrors the production comparator so tests can assert identical ordering to the
+ * pre-change recompute-in-comparator reference. */
+export function sortRuntimesByCapabilityScore(runtimes, intent) {
+    const cache = buildCapabilityScoreCache(runtimes, intent);
+    return [...runtimes].sort((a, b) => compareRuntimeCandidates(a, b, intent, cache));
+}
+export function computeRuntimeCapabilityScore(runtime, intent) {
     const capabilities = runtime.capabilities;
     if (capabilities == null)
         return 0;

package/dist/runtime/sandbox-profile.d.ts

@@ -23,3 +23,32 @@ export interface CreateRuntimeSandboxProfileOptions {
     readonly notes?: readonly string[];
 }
 export declare function createRuntimeSandboxProfile(options: CreateRuntimeSandboxProfileOptions): RuntimeSandboxProfile;
+/**
+ * Error thrown by {@link assertWritable} when a path is outside every writable
+ * root. Carries only the resolved target and roots (no secret values).
+ */
+export declare class SandboxWriteDeniedError extends Error {
+    readonly target: string;
+    readonly roots: readonly string[];
+    constructor(target: string, roots: readonly string[]);
+}
+/**
+ * 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 declare function isPathWritable(p: string, roots: readonly string[] | undefined): boolean;
+/**
+ * Throw {@link SandboxWriteDeniedError} when `p` is not writable under `roots`.
+ * No-op when `roots` is empty/undefined (safe default => unrestricted).
+ */
+export declare function assertWritable(p: string, roots: readonly string[] | undefined): void;