open-multi-agent-kit 0.78.8 → 0.79.3

package/dist/metrics/provenance-ratio.js

@@ -0,0 +1,33 @@
+export function computeProvenanceRatio(layers) {
+    if (layers.length === 0)
+        throw new Error("provenance ratio requires at least one layer");
+    const importanceSum = layers.reduce((sum, layer) => sum + layer.importance, 0);
+    if (importanceSum <= 0)
+        throw new Error("provenance layer importance must sum to a positive value");
+    const normalizedLayers = layers.map((layer) => {
+        const importance = layer.importance / importanceSum;
+        const originality = clamp01(layer.loc <= 0 ? 0 : layer.addedModifiedLines / layer.loc);
+        return {
+            ...layer,
+            importance,
+            originality: round6(originality),
+            weightedOriginality: round6(originality * importance),
+        };
+    });
+    const rawHeadline = layers.reduce((sum, layer) => {
+        const importance = layer.importance / importanceSum;
+        const originality = clamp01(layer.loc <= 0 ? 0 : layer.addedModifiedLines / layer.loc);
+        return sum + (originality * importance);
+    }, 0);
+    return {
+        headlineOriginality: round6(rawHeadline),
+        layers: normalizedLayers,
+        importanceSum: round6(normalizedLayers.reduce((sum, layer) => sum + layer.importance, 0)),
+    };
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function round6(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}

package/dist/orchestration/dag.d.ts

@@ -56,6 +56,23 @@ export interface DagNodeRouting {
     readOnly?: boolean;
     evidenceRequired?: boolean;
     rationale?: string;
+    routeTrace?: Array<{
+        id: string;
+        kind: "skill" | "mcp" | "tool" | "hook";
+        source: "project" | "global" | "builtin";
+        baseScore: number;
+        sourcePrior: number;
+        score: number;
+        features: {
+            roleMatch: number;
+            keywordScore: number;
+            evidenceFit: number;
+            contextFit: number;
+            safetyFit: number;
+            keywordMatches: number;
+        };
+        reason: string;
+    }>;
     replanHint?: {
         criterionId?: string;
         artifactRef?: string;

package/dist/orchestration/ensemble-decision.d.ts

@@ -1,5 +1,6 @@
 import type { RunState, NextAction } from "../contracts/orchestration.js";
 import type { GoalSpec, GoalEvidence, IntentFrame } from "../contracts/goal.js";
+import { type PersonaWeightState } from "./hedge-persona-weights.js";
 export interface DecisionCandidate {
     id: string;
     perspective: string;
@@ -12,6 +13,7 @@ export interface EnsembleDecisionPolicy {
     candidates?: DecisionCandidate[];
     extraVotes?: EnsembleDecisionCandidateVote[];
     intentFrame?: IntentFrame;
+    personaWeights?: PersonaWeightState;
 }
 export interface EnsembleDecisionResult {
     action: NextAction;

package/dist/orchestration/ensemble-decision.js

@@ -1,6 +1,7 @@
 import { evaluateMissingCriteria, suggestNextAction } from "../goal/eval-criteria.js";
 import { scoreGoal } from "../goal/scoring.js";
 import { renderPromptDigest } from "../goal/prompt-digest.js";
+import { applyPersonaWeights } from "./hedge-persona-weights.js";
 const DEFAULT_CANDIDATES = [
     { id: "progress-analyst", perspective: "Evaluate success-criteria completion rate and blocker severity", weight: 1.0 },
     { id: "risk-evaluator", perspective: "Assess failure modes, retry exhaustion, and rollback risk", weight: 0.9 },
@@ -248,6 +249,9 @@ export function evaluateEnsembleDecision(goal, runState, evidence, policy = {})
         ...(policy.extraVotes ?? []).map(normalizeExtraVote).filter((vote) => Boolean(vote)),
     ];
     votes = calibrateVoteWeights(votes, runState, evidence);
+    if (policy.personaWeights) {
+        votes = applyPersonaWeights(votes, policy.personaWeights);
+    }
     const actionScores = new Map();
     for (const vote of votes) {
         actionScores.set(vote.action, (actionScores.get(vote.action) ?? 0) + vote.weight);

package/dist/orchestration/hedge-persona-weights.d.ts

@@ -0,0 +1,25 @@
+import type { NextAction } from "../contracts/orchestration.js";
+export interface PersonaWeightState {
+    readonly weights: Record<string, number>;
+    readonly eta: number;
+    readonly floor: number;
+    readonly horizon: number;
+}
+export interface PersonaVoteOutcome {
+    readonly id: string;
+    readonly action: NextAction;
+}
+export interface PersonaWeightUpdateResult {
+    readonly state: PersonaWeightState;
+    readonly collapseAlert: boolean;
+    readonly dominantShare: number;
+}
+export declare function createHedgePersonaWeights(personaIds: readonly string[], options?: {
+    horizon?: number;
+    floor?: number;
+}): PersonaWeightState;
+export declare function updateHedgePersonaWeights(state: PersonaWeightState, votes: readonly PersonaVoteOutcome[], correctAction: NextAction): PersonaWeightUpdateResult;
+export declare function applyPersonaWeights<T extends {
+    id: string;
+    weight: number;
+}>(votes: readonly T[], state: PersonaWeightState): T[];

package/dist/orchestration/hedge-persona-weights.js

@@ -0,0 +1,43 @@
+export function createHedgePersonaWeights(personaIds, options = {}) {
+    const uniqueIds = [...new Set(personaIds)].filter(Boolean);
+    if (uniqueIds.length === 0)
+        throw new Error("Hedge persona weights require at least one persona");
+    const horizon = Math.max(1, options.horizon ?? 100);
+    const floor = Math.max(0, options.floor ?? 0.3);
+    const eta = Math.sqrt((8 * Math.log(uniqueIds.length)) / horizon);
+    return {
+        weights: Object.fromEntries(uniqueIds.map((id) => [id, 1])),
+        eta,
+        floor,
+        horizon,
+    };
+}
+export function updateHedgePersonaWeights(state, votes, correctAction) {
+    const ids = Object.keys(state.weights);
+    const voteById = new Map(votes.map((vote) => [vote.id, vote.action]));
+    const decayed = {};
+    for (const id of ids) {
+        const loss = voteById.get(id) === correctAction ? 0 : 1;
+        decayed[id] = state.weights[id] * Math.exp(-state.eta * loss);
+    }
+    const sum = Object.values(decayed).reduce((acc, value) => acc + value, 0);
+    const scaled = {};
+    for (const id of ids) {
+        scaled[id] = Math.max(state.floor, (ids.length * decayed[id]) / Math.max(Number.EPSILON, sum));
+    }
+    const scaledSum = Object.values(scaled).reduce((acc, value) => acc + value, 0);
+    const normalized = Object.fromEntries(ids.map((id) => [id, round6((ids.length * scaled[id]) / scaledSum)]));
+    const total = Object.values(normalized).reduce((acc, value) => acc + value, 0);
+    const dominantShare = Math.max(...Object.values(normalized)) / Math.max(Number.EPSILON, total);
+    return {
+        state: { ...state, weights: normalized },
+        collapseAlert: dominantShare > 0.5,
+        dominantShare: round6(dominantShare),
+    };
+}
+export function applyPersonaWeights(votes, state) {
+    return votes.map((vote) => ({ ...vote, weight: state.weights[vote.id] ?? vote.weight }));
+}
+function round6(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}

package/dist/orchestration/parallel-ui.d.ts

@@ -47,5 +47,6 @@ export declare class ParallelLiveRenderer {
     start(stateProvider: () => RunState | undefined): void;
     stop(): void;
     renderOnce(state: RunState): string;
+    private firstCockpitFrame;
     private renderNow;
 }

package/dist/orchestration/parallel-ui.js

@@ -406,6 +406,7 @@ export class ParallelLiveRenderer {
     }
     start(stateProvider) {
         this.stopped = false;
+        this.firstCockpitFrame = true;
         if (this.useAlternateScreen) {
             process.stdout.write("\x1b[?1049h");
         }
@@ -431,6 +432,7 @@ export class ParallelLiveRenderer {
         this.lastFrame = frame;
         return frame;
     }
+    firstCockpitFrame = true;
     renderNow(stateProvider) {
         const state = stateProvider();
         if (!state)
@@ -462,9 +464,16 @@ export class ParallelLiveRenderer {
                 void lockedStdoutWrite(frame);
             return;
         }
-        // Cockpit mode
-        const clearPrefix = this.useAlternateScreen ? "\x1b[2J\x1b[H" : "\x1b[H\x1b[J";
-        const output = clearPrefix + frame + "\n";
+        // Cockpit mode: use alternate-screen clear+home only when explicitly opted in.
+        // On the main screen, append frames so drag/scroll do not snap to the top.
+        let output;
+        if (this.useAlternateScreen) {
+            output = `${this.firstCockpitFrame ? "" : "\x1b[2J\x1b[H"}${frame}\n`;
+        }
+        else {
+            output = `${this.firstCockpitFrame ? "" : "\n\n"}${frame}\n`;
+        }
+        this.firstCockpitFrame = false;
         void lockedStdoutWrite(output);
     }
 }

package/dist/orchestration/route-calibration.d.ts

@@ -0,0 +1,27 @@
+export type RouteWeightKey = "role" | "keyword" | "evidence" | "context" | "safety";
+export type RouteWeights = Record<RouteWeightKey, number>;
+export interface RouteWeightEvaluation {
+    readonly weights: RouteWeights;
+    readonly keywordTau: number;
+    readonly outcomes: readonly boolean[];
+}
+export interface RouteCalibrationResult {
+    readonly adopted: boolean;
+    readonly current: RouteWeightEvaluation;
+    readonly candidate: RouteWeightEvaluation;
+    readonly meanDelta: number;
+    readonly mcnemarP: number;
+    readonly oddsRatio: number;
+    readonly reason: string;
+}
+export declare const DEFAULT_ROUTE_WEIGHTS: RouteWeights;
+export declare function projectRouteWeights(weights: RouteWeights): RouteWeights;
+export declare function smoothKeywordScore(matchCount: number, tau: number): number;
+export declare function generateRouteWeightCandidates(current?: RouteWeights, options?: {
+    step?: number;
+    keywordTaus?: readonly number[];
+}): RouteWeights[];
+export declare function selectBestRouteWeightEvaluation(evaluations: readonly RouteWeightEvaluation[]): RouteWeightEvaluation;
+export declare function decideRouteWeightAdoption(current: RouteWeightEvaluation, candidate: RouteWeightEvaluation, options?: {
+    alpha?: number;
+}): RouteCalibrationResult;

package/dist/orchestration/route-calibration.js

@@ -0,0 +1,123 @@
+const DEFAULT_KEYS = ["role", "keyword", "evidence", "context", "safety"];
+export const DEFAULT_ROUTE_WEIGHTS = Object.freeze({
+    role: 0.30,
+    keyword: 0.25,
+    evidence: 0.20,
+    context: 0.15,
+    safety: 0.10,
+});
+export function projectRouteWeights(weights) {
+    const clipped = Object.fromEntries(DEFAULT_KEYS.map((key) => [key, Math.max(0, Number(weights[key]) || 0)]));
+    const sum = DEFAULT_KEYS.reduce((acc, key) => acc + clipped[key], 0);
+    if (sum <= 0)
+        return { ...DEFAULT_ROUTE_WEIGHTS };
+    const projected = Object.fromEntries(DEFAULT_KEYS.map((key) => [key, clipped[key] / sum]));
+    return roundRouteWeights(projected);
+}
+export function smoothKeywordScore(matchCount, tau) {
+    const safeTau = Math.max(0.001, tau);
+    return round6(1 - Math.exp(-Math.max(0, matchCount) / safeTau));
+}
+export function generateRouteWeightCandidates(current = DEFAULT_ROUTE_WEIGHTS, options = {}) {
+    const step = options.step ?? 0.05;
+    const seeds = [projectRouteWeights(current), uniformRouteWeights()];
+    for (const key of DEFAULT_KEYS) {
+        seeds.push(projectRouteWeights({ ...current, [key]: current[key] + step }));
+        seeds.push(projectRouteWeights({ ...current, [key]: Math.max(0, current[key] - step) }));
+    }
+    const seen = new Set();
+    const result = [];
+    for (const seed of seeds) {
+        const id = DEFAULT_KEYS.map((key) => seed[key].toFixed(6)).join(",");
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        result.push(seed);
+    }
+    return result;
+}
+export function selectBestRouteWeightEvaluation(evaluations) {
+    if (evaluations.length === 0)
+        throw new Error("route calibration requires at least one evaluation");
+    return [...evaluations].sort((a, b) => meanSuccess(b.outcomes) - meanSuccess(a.outcomes))[0];
+}
+export function decideRouteWeightAdoption(current, candidate, options = {}) {
+    if (current.outcomes.length !== candidate.outcomes.length) {
+        throw new Error("paired route calibration requires equal-length outcome vectors");
+    }
+    if (current.outcomes.length === 0) {
+        throw new Error("route calibration requires at least one paired outcome");
+    }
+    const currentMean = meanSuccess(current.outcomes);
+    const candidateMean = meanSuccess(candidate.outcomes);
+    const meanDelta = round6(candidateMean - currentMean);
+    const { b, c } = discordantCounts(current.outcomes, candidate.outcomes);
+    const mcnemarP = exactMcNemarP(b, c);
+    const oddsRatio = c === 0 ? (b > 0 ? Number.POSITIVE_INFINITY : 1) : b / c;
+    const alpha = options.alpha ?? 0.05;
+    const adopted = mcnemarP < alpha && oddsRatio > 1;
+    return {
+        adopted,
+        current,
+        candidate,
+        meanDelta,
+        mcnemarP,
+        oddsRatio,
+        reason: adopted
+            ? `candidate wins paired McNemar p=${mcnemarP.toFixed(4)}, oddsRatio=${formatRatio(oddsRatio)}`
+            : "hand-set weights not yet beaten by paired evidence",
+    };
+}
+function uniformRouteWeights() {
+    return { role: 0.2, keyword: 0.2, evidence: 0.2, context: 0.2, safety: 0.2 };
+}
+function meanSuccess(outcomes) {
+    return outcomes.filter(Boolean).length / Math.max(1, outcomes.length);
+}
+function discordantCounts(current, candidate) {
+    let b = 0;
+    let c = 0;
+    for (let i = 0; i < current.length; i += 1) {
+        if (candidate[i] && !current[i])
+            b += 1;
+        if (!candidate[i] && current[i])
+            c += 1;
+    }
+    return { b, c };
+}
+function exactMcNemarP(b, c) {
+    const n = b + c;
+    if (n === 0)
+        return 1;
+    const observed = Math.min(b, c);
+    let tail = 0;
+    for (let k = 0; k <= observed; k += 1) {
+        tail += binomialProbability(n, k, 0.5);
+    }
+    return Math.min(1, 2 * tail);
+}
+function binomialProbability(n, k, p) {
+    return combination(n, k) * (p ** k) * ((1 - p) ** (n - k));
+}
+function combination(n, k) {
+    const kk = Math.min(k, n - k);
+    let result = 1;
+    for (let i = 1; i <= kk; i += 1) {
+        result = (result * (n - kk + i)) / i;
+    }
+    return result;
+}
+function roundRouteWeights(weights) {
+    const rounded = Object.fromEntries(DEFAULT_KEYS.map((key) => [key, round6(weights[key])]));
+    const sum = DEFAULT_KEYS.reduce((total, key) => total + rounded[key], 0);
+    const residual = round6(1 - sum);
+    const recipient = DEFAULT_KEYS.reduce((best, key) => (rounded[key] > rounded[best] ? key : best));
+    rounded[recipient] = round6(Math.max(0, rounded[recipient] + residual));
+    return rounded;
+}
+function round6(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+function formatRatio(value) {
+    return Number.isFinite(value) ? value.toFixed(3) : "Infinity";
+}

package/dist/orchestration/routing/mcp-config.js

@@ -101,7 +101,11 @@ export function loadMergedMcpConfigSync(projectRoot, scope) {
     if (scope === "none") {
         return { servers, sources, diagnostics };
     }
-    const globalFiles = scope === "all" ? [join(getRoutingUserHome(), ".kimi", "mcp.json"), join(getRoutingUserHome(), ".omk", "mcp.json")] : [];
+    const globalFiles = scope === "all" ? [
+        join(getRoutingUserHome(), ".omk", "agent", "mcp.json"),
+        join(getRoutingUserHome(), ".omk", "mcp.json"),
+        join(getRoutingUserHome(), ".kimi", "mcp.json"),
+    ] : [];
     for (const path of globalFiles) {
         if (!existsSync(path))
             continue;

package/dist/orchestration/routing/types.d.ts

@@ -15,9 +15,30 @@ export interface RouteCandidate {
     contextCost: 1 | 2 | 3;
     capabilities: string[];
 }
+export interface RouteScoreFeatures {
+    roleMatch: number;
+    keywordScore: number;
+    evidenceFit: number;
+    contextFit: number;
+    safetyFit: number;
+    keywordMatches: number;
+}
+export interface RouteScoreTrace {
+    id: string;
+    kind: RouteKind;
+    source: RouteSource;
+    baseScore: number;
+    sourcePrior: number;
+    score: number;
+    features: RouteScoreFeatures;
+    reason: string;
+}
 export interface ScoredRoute {
     candidate: RouteCandidate;
     score: number;
+    baseScore: number;
+    sourcePrior: number;
+    features: RouteScoreFeatures;
     reason: string;
 }
 export interface RoutingDiagnostic {

package/dist/orchestration/routing.d.ts

@@ -1,6 +1,13 @@
 import type { DagNode, DagNodeDefinition, DagNodeRouting } from "./dag.js";
 type RouteSource = "project" | "global" | "builtin";
 export type RoutingInput = Pick<DagNodeDefinition, "id" | "name" | "role" | "inputs" | "outputs" | "cost" | "routing">;
+declare const ROUTE_SCORE_WEIGHTS: {
+    readonly role: 0.3;
+    readonly keyword: 0.25;
+    readonly evidence: 0.2;
+    readonly context: 0.15;
+    readonly safety: 0.1;
+};
 export interface RoutingInventory {
     skills: Map<string, RouteSource>;
     mcpServers: Map<string, RouteSource>;
@@ -21,6 +28,9 @@ export declare function selectTaskRouting(input: RoutingInput): DagNodeRouting;
 export declare function resetRoutingInventoryCache(): void;
 export declare function mergeDagNodeRouting(auto: DagNodeRouting, override: DagNodeRouting | undefined): DagNodeRouting;
 export declare function dagNodeRoutingEnv(node: DagNode, dag?: import("./dag.js").Dag): Record<string, string>;
+export declare function computeRouteBaseScoreMinGap(weights: typeof ROUTE_SCORE_WEIGHTS): number;
+export declare function routeSourcePrior(source: RouteSource): number;
+export declare function assertRoutePriorTiebreakInvariant(priors: Record<RouteSource, number>, minBaseGap?: number): void;
 export declare function discoverRoutingInventory(projectRoot?: string): RoutingInventory;
 /** Exported for focused cache-equivalence tests. Returns the cached matcher for an
  * already-normalized alphanumeric keyword (or null when no regex path applies). */

package/dist/orchestration/routing.js

@@ -4,6 +4,21 @@ import { isAbsolute, join, relative, resolve, sep } from "path";
 import { normalizeUserHomePath } from "../util/fs.js";
 import { assignSkills } from "./skill-assigner.js";
 import { OMK_RELEASE_GUARD_PRESET, OMK_TS_PRODUCT_PRESET, OMK_WORKTREE_TEAM_PRESET, } from "../runtime/core-verified-preset.js";
+const ROUTE_SCORE_WEIGHTS = {
+    role: 0.30,
+    keyword: 0.25,
+    evidence: 0.20,
+    context: 0.15,
+    safety: 0.10,
+};
+const ROUTE_SOURCE_PRIOR = {
+    project: 0.02,
+    builtin: 0.01,
+    global: 0,
+};
+const ROUTE_SCORE_SCALE = 1_000_000;
+const ROUTE_BASE_SCORE_MIN_GAP = computeRouteBaseScoreMinGap(ROUTE_SCORE_WEIGHTS);
+assertRoutePriorTiebreakInvariant(ROUTE_SOURCE_PRIOR, ROUTE_BASE_SCORE_MIN_GAP);
 const MAX_SKILLS = 3;
 const MAX_MCP_SERVERS = 2;
 const MAX_TOOLS = 4;
@@ -363,6 +378,7 @@ export function selectTaskRouting(input) {
     const mergedRationale = autoAssignment.skills.length > 0
         ? `${renderRationale(scored.slice(0, 3), contextBudget)} | Auto: ${autoAssignment.rationale}`
         : renderRationale(scored.slice(0, 3), contextBudget);
+    const routeTrace = scored.slice(0, 8).map(toRouteScoreTrace);
     return {
         provider: "auto",
         providerReason: "Provider-neutral runtime router decides at node execution time",
@@ -374,6 +390,7 @@ export function selectTaskRouting(input) {
         readOnly,
         evidenceRequired,
         rationale: mergedRationale,
+        routeTrace,
         rejected: rejected.slice(0, 6),
         requiresMcp: input.routing?.requiresMcp ?? false,
         requiresToolCalling: input.routing?.requiresToolCalling ?? false,
@@ -467,6 +484,55 @@ export function dagNodeRoutingEnv(node, dag) {
         OMK_ROUTE_REQUIRES_TOOL_CALLING: String(routing.requiresToolCalling ?? false),
     };
 }
+export function computeRouteBaseScoreMinGap(weights) {
+    const increments = [
+        weights.role,
+        weights.keyword / 2,
+        weights.keyword,
+        weights.evidence,
+        weights.context / 2,
+        weights.context,
+        weights.safety / 2,
+        weights.safety,
+    ].map((value) => Math.round(value * ROUTE_SCORE_SCALE)).filter((value) => value > 0);
+    const gap = increments.reduce((acc, value) => gcd(acc, value));
+    return gap / ROUTE_SCORE_SCALE;
+}
+export function routeSourcePrior(source) {
+    return ROUTE_SOURCE_PRIOR[source] ?? 0;
+}
+export function assertRoutePriorTiebreakInvariant(priors, minBaseGap = ROUTE_BASE_SCORE_MIN_GAP) {
+    const values = Object.values(priors);
+    const spread = Math.max(...values) - Math.min(...values);
+    if (!(spread < minBaseGap)) {
+        throw new Error(`Route source prior spread ${spread.toFixed(6)} must be < base-score min gap ${minBaseGap.toFixed(6)}`);
+    }
+}
+function gcd(a, b) {
+    let x = Math.abs(a);
+    let y = Math.abs(b);
+    while (y !== 0) {
+        const next = x % y;
+        x = y;
+        y = next;
+    }
+    return x;
+}
+function roundScore(value) {
+    return Math.round(value * ROUTE_SCORE_SCALE) / ROUTE_SCORE_SCALE;
+}
+function toRouteScoreTrace(route) {
+    return {
+        id: route.candidate.id,
+        kind: route.candidate.kind,
+        source: route.candidate.source,
+        baseScore: route.baseScore,
+        sourcePrior: route.sourcePrior,
+        score: route.score,
+        features: route.features,
+        reason: route.reason,
+    };
+}
 function scoreRoute(candidate, role, text, evidenceRequired, contextBudget) {
     const roleMatch = candidate.roles.includes(role) ? 1 : 0;
     const keywordMatches = candidate.keywords.filter((keyword) => textMatchesKeyword(text, keyword)).length;
@@ -476,11 +542,27 @@ function scoreRoute(candidate, role, text, evidenceRequired, contextBudget) {
         ? candidate.contextCost === 1 ? 1 : 0
         : candidate.contextCost <= 2 ? 1 : 0.5;
     const safetyFit = candidate.writeRisk === "none" ? 1 : candidate.writeRisk === "low" ? 0.5 : 0;
-    const localFit = candidate.source === "project" ? 0.08 : candidate.source === "builtin" ? 0.04 : 0;
-    const score = (0.3 * roleMatch) + (0.25 * keywordScore) + (0.2 * evidenceFit) + (0.15 * smallContextFit) + (0.1 * safetyFit) + localFit;
+    const sourcePrior = routeSourcePrior(candidate.source);
+    const features = {
+        roleMatch,
+        keywordScore,
+        evidenceFit,
+        contextFit: smallContextFit,
+        safetyFit,
+        keywordMatches,
+    };
+    const baseScore = roundScore((ROUTE_SCORE_WEIGHTS.role * roleMatch)
+        + (ROUTE_SCORE_WEIGHTS.keyword * keywordScore)
+        + (ROUTE_SCORE_WEIGHTS.evidence * evidenceFit)
+        + (ROUTE_SCORE_WEIGHTS.context * smallContextFit)
+        + (ROUTE_SCORE_WEIGHTS.safety * safetyFit));
+    const score = roundScore(baseScore + sourcePrior);
     return {
         candidate,
         score,
+        baseScore,
+        sourcePrior,
+        features,
         reason: [
             roleMatch ? "role" : "",
             keywordMatches > 0 ? `${keywordMatches} keyword` : "",
@@ -806,7 +888,11 @@ function loadMergedMcpConfigSync(projectRoot, scope) {
     if (scope === "none") {
         return { servers, sources, diagnostics };
     }
-    const globalFiles = scope === "all" ? [join(getRoutingUserHome(), ".kimi", "mcp.json"), join(getRoutingUserHome(), ".omk", "mcp.json")] : [];
+    const globalFiles = scope === "all" ? [
+        join(getRoutingUserHome(), ".omk", "agent", "mcp.json"),
+        join(getRoutingUserHome(), ".omk", "mcp.json"),
+        join(getRoutingUserHome(), ".kimi", "mcp.json"),
+    ] : [];
     for (const path of globalFiles) {
         if (!existsSync(path))
             continue;

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", "anthropic"];
+export declare const KNOWN_PROVIDER_IDS: readonly ["mimo", "kimi", "deepseek", "qwen", "codex", "openrouter", "anthropic", "glm"];
 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 {
@@ -80,6 +80,7 @@ export interface UserModelAliasResolution {
     input: string;
     provider?: ProviderId;
     model: string;
+    thinkingLevel?: string;
     source: "user-alias" | "provider-alias" | "literal";
 }
 export declare function listUserModelAliases(options?: DeepSeekConfigPathOptions): Promise<Record<string, string>>;