@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/router/virtual-router/engine.js

@@ -1,1695 +1,328 @@
-import { ProviderHealthManager } from './health-manager.js';
+import { VirtualRouterError, VirtualRouterErrorCode } from './types.js';
+import { ROUTING_INSTRUCTION_MARKER_PATTERN } from './routing-instructions/types.js';
+import { parseRoutingInstructions } from './routing-instructions/parse.js';
+import { createVirtualRouterEngineProxy } from './engine-selection/native-virtual-router-engine-proxy.js';
+import { cleanRoutingInstructionMarkersWithNative, parseRoutingInstructionKindsWithNative } from './engine-selection/native-virtual-router-routing-instructions-semantics.js';
+import { getLatestUserTextFromResponsesContext, hasLatestUserRoutingInstructionMarker, hasRoutingInstructionMarkerInResponsesContext } from './engine-legacy/helpers.js';
 import { ProviderRegistry } from './provider-registry.js';
-import { RouteLoadBalancer } from './load-balancer.js';
-import { RoutingClassifier } from './classifier.js';
-import { buildRoutingFeatures } from './features.js';
-import { ContextAdvisor } from './context-advisor.js';
-import { DEFAULT_ROUTE, ROUTE_PRIORITY, VirtualRouterError, VirtualRouterErrorCode } from './types.js';
-import { getStatsCenter } from '../../telemetry/stats-center.js';
-import { parseRoutingInstructions, applyRoutingInstructions, cleanMessagesFromRoutingInstructions } from './routing-instructions.js';
-import { extractMessageText } from './message-utils.js';
-import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
-import { buildHitReason, createVirtualRouterHitRecord, formatVirtualRouterHit, toVirtualRouterHitEvent } from './engine-logging.js';
-import { selectDirectProviderModel, selectFromStickyPool, selectProviderImpl } from './engine/routing-pools/index.js';
-import { applyQuotaDepletedImpl, applyQuotaRecoveryImpl, applySeriesCooldownImpl, applyAntigravityRiskPolicyImpl, handleProviderFailureImpl, mapProviderErrorImpl } from './engine/health/index.js';
-import { hydrateAntigravityAliasLeaseStoreIfNeeded, recordAntigravitySessionLease, resolveAntigravityAliasReuseCooldownMs } from './engine/antigravity/alias-lease.js';
-import { buildMetadataInstructions, resolveRoutingMode } from './engine/routing-state/metadata.js';
-import { getRoutingInstructionState, persistRoutingInstructionState, resolveStopMessageScope } from './engine/routing-state/store.js';
-import { ensureStopMessageModeMaxRepeats } from './routing-stop-message-state-codec.js';
-import { extractKeyAlias, extractKeyIndex, extractProviderId, getProviderModelId } from './engine/provider-key/parse.js';
-import { resolveSessionScope as resolveSessionScopeImpl, resolveStickyKey as resolveStickyKeyImpl } from './engine/routing-state/keys.js';
-import { RouteAnalytics } from './engine/route-analytics.js';
-import { StickySessionManager } from './engine/sticky-session-manager.js';
-import { CooldownManager } from './engine/cooldown-manager.js';
-const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
-function isStopScopeTraceEnabled() {
-    const raw = String(process.env.ROUTECODEX_STOP_SCOPE_TRACE ?? process.env.RCC_STOP_SCOPE_TRACE ?? '')
-        .trim()
-        .toLowerCase();
-    return (raw === '1' ||
-        raw === 'true' ||
-        raw === 'on' ||
-        raw === 'yes' ||
-        raw === 'debug' ||
-        raw === 'trace' ||
-        raw === 'verbose');
-}
-function normalizeStopMessageStageMode(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
-        return normalized;
-    }
-    return undefined;
-}
-function normalizeStopMessageAiMode(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === 'on' || normalized === 'off') {
-        return normalized;
-    }
-    return undefined;
-}
-function stripStopMessageFields(state) {
-    return {
-        ...state,
-        stopMessageSource: undefined,
-        stopMessageText: undefined,
-        stopMessageMaxRepeats: undefined,
-        stopMessageUsed: undefined,
-        stopMessageUpdatedAt: undefined,
-        stopMessageLastUsedAt: undefined,
-        stopMessageStageMode: undefined,
-        stopMessageAiMode: undefined,
-        stopMessageAiSeedPrompt: undefined,
-        stopMessageAiHistory: undefined
-    };
-}
-function stripClientInjectScopedFields(state) {
-    return {
-        ...stripStopMessageFields(state),
-        preCommandSource: undefined,
-        preCommandScriptPath: undefined,
-        preCommandUpdatedAt: undefined
-    };
-}
-function hasClientInjectScopedFields(state) {
-    if (!state) {
-        return false;
-    }
-    return (typeof state.stopMessageText === 'string' ||
-        typeof state.stopMessageMaxRepeats === 'number' ||
-        typeof state.stopMessageUsed === 'number' ||
-        typeof state.stopMessageStageMode === 'string' ||
-        typeof state.stopMessageAiMode === 'string' ||
-        typeof state.stopMessageAiSeedPrompt === 'string' ||
-        Array.isArray(state.stopMessageAiHistory) ||
-        typeof state.preCommandScriptPath === 'string' ||
-        typeof state.preCommandUpdatedAt === 'number');
-}
-function hasRoutingInstructionMarker(messages) {
-    for (const message of messages) {
-        if (!message || message.role !== 'user') {
-            continue;
-        }
-        const content = extractMessageText(message);
-        if (!content) {
-            continue;
-        }
-        if (/<\*\*[\s\S]*?\*\*>/.test(content)) {
-            return true;
+import { resolveStopMessageScope } from './engine/routing-state/store.js';
+export class VirtualRouterEngine {
+    nativeProxy;
+    registry;
+    routingInstructionStateStore;
+    constructor(deps) {
+        this.nativeProxy = createVirtualRouterEngineProxy();
+        this.registry = new ProviderRegistry();
+        this.routingInstructionStateStore = new Map();
+        if (deps) {
+            this.nativeProxy.updateDeps(deps);
         }
     }
-    return false;
-}
-function hasLatestUserRoutingInstructionMarker(messages) {
-    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
-        const message = messages[idx];
-        if (!message) {
-            continue;
-        }
-        if (message.role !== 'user') {
-            return false;
-        }
-        const content = extractMessageText(message);
-        if (!content) {
-            return false;
-        }
-        return /<\*\*[\s\S]*?\*\*>/.test(content);
+    get antigravitySessionAliasStore() {
+        return this.nativeProxy.antigravitySessionAliasStore;
     }
-    return false;
-}
-function isServerToolFollowupRequest(metadata) {
-    if (!metadata || typeof metadata !== 'object') {
-        return false;
+    get routingInstructionState() {
+        return this.routingInstructionStateStore;
     }
-    const rt = metadata.__rt;
-    if (!rt || typeof rt !== 'object' || Array.isArray(rt)) {
-        return false;
+    get providerRegistry() {
+        return this.registry;
     }
-    const flag = rt.serverToolFollowup;
-    return (flag === true ||
-        (typeof flag === 'string' && flag.trim().toLowerCase() === 'true'));
-}
-export class VirtualRouterEngine {
-    routing = {};
-    providerRegistry = new ProviderRegistry();
-    healthManager = new ProviderHealthManager();
-    get providerCooldowns() { return this.cooldownManager.getCooldownMap(); }
-    loadBalancer = new RouteLoadBalancer();
-    classifier = new RoutingClassifier({});
-    contextAdvisor = new ContextAdvisor();
-    contextRouting;
-    routeAnalytics = new RouteAnalytics();
-    stickySessionManager = new StickySessionManager();
-    cooldownManager;
-    antigravityLeasePersistence = { loadedOnce: false, loadedMtimeMs: null, flushTimer: null };
-    debug = console; // thin hook; host may monkey-patch for colored logging
-    healthConfig = null;
-    statsCenter = getStatsCenter();
-    // Derived flags from VirtualRouterConfig/routing used by process / response layers.
-    webSearchForce = false;
-    healthStore;
-    routingStateStore = {
-        loadSync: loadRoutingInstructionStateSync,
-        saveAsync: saveRoutingInstructionStateAsync,
-        saveSync: saveRoutingInstructionStateSync
-    };
-    routingInstructionState = new Map();
-    quotaView;
-    /**
-     * Backward-compatible test/debug surface used by existing regression scripts.
-     * Keep this as a read-only view over StickySessionManager storage.
-     */
-    get antigravitySessionAliasStore() {
-        return this.stickySessionManager.getAllStores().sessionAliasStore;
-    }
-    constructor(deps) {
-        this.cooldownManager = new CooldownManager({
-            healthStore: deps?.healthStore,
-            healthConfig: this.healthConfig,
-            quotaView: deps?.quotaView
-        });
-        if (deps?.healthStore) {
-            this.healthStore = deps.healthStore;
-        }
-        if (deps?.routingStateStore) {
-            this.routingStateStore = deps.routingStateStore;
-        }
-        if (deps?.quotaView) {
-            this.quotaView = deps.quotaView;
-        }
+    initialize(config) {
+        this.nativeProxy.initialize(JSON.stringify(config));
+        this.registry.load(config.providers ?? {});
+        this.routingInstructionStateStore.clear();
     }
     updateDeps(deps) {
-        if (!deps || typeof deps !== 'object') {
-            return;
-        }
-        if ('healthStore' in deps) {
-            this.healthStore = deps.healthStore ?? undefined;
-            this.cooldownManager.updateDeps({ healthStore: this.healthStore });
-        }
-        if ('routingStateStore' in deps) {
-            this.routingStateStore =
-                deps.routingStateStore ??
-                    {
-                        loadSync: loadRoutingInstructionStateSync,
-                        saveAsync: saveRoutingInstructionStateAsync,
-                        saveSync: saveRoutingInstructionStateSync
-                    };
-            // Routing state store changes require clearing in-memory cache to avoid stale reads.
-            this.routingInstructionState.clear();
-        }
-        if ('quotaView' in deps) {
-            const prevQuotaEnabled = Boolean(this.quotaView);
-            this.quotaView = deps.quotaView ?? undefined;
-            this.cooldownManager.updateDeps({ quotaView: this.quotaView });
-            const nextQuotaEnabled = Boolean(this.quotaView);
-            // When quotaView is enabled, health/cooldown decisions must be driven by quotaView only.
-            // - Enabling quotaView: clear any legacy router-local cooldown TTLs immediately.
-            // - Disabling quotaView: reload legacy cooldown state from health snapshots.
-            if (!prevQuotaEnabled && nextQuotaEnabled) {
-                this.cooldownManager.clearAllCooldowns();
-            }
-            else if (prevQuotaEnabled && !nextQuotaEnabled) {
-                this.cooldownManager.clearAllCooldowns();
-                this.restoreHealthFromStore();
-            }
-        }
+        this.nativeProxy.updateDeps(deps);
     }
-    parseDirectProviderModel(model) {
-        const raw = typeof model === 'string' ? model.trim() : '';
-        if (!raw) {
-            return null;
-        }
-        const firstDot = raw.indexOf('.');
-        if (firstDot <= 0 || firstDot === raw.length - 1) {
-            return null;
-        }
-        const providerId = raw.slice(0, firstDot).trim();
-        const modelId = raw.slice(firstDot + 1).trim();
-        if (!providerId || !modelId) {
-            return null;
-        }
-        if (this.providerRegistry.listProviderKeys(providerId).length === 0) {
-            return null;
-        }
-        return { providerId, modelId };
+    updateVirtualRouterConfig(config) {
+        this.nativeProxy.updateVirtualRouterConfig(JSON.stringify(config));
+        this.registry.load(config.providers ?? {});
     }
-    shouldFallbackDirectModelForMedia(direct, features) {
-        if (!features.hasImageAttachment) {
-            return false;
-        }
-        const providerId = direct.providerId.trim().toLowerCase();
-        const modelId = direct.modelId.trim().toLowerCase();
-        if (providerId !== 'qwen') {
-            return false;
-        }
-        const isQwen35Plus = modelId === 'qwen3.5-plus' || modelId === 'qwen3-5-plus' || modelId === 'qwen3_5-plus';
-        if (!isQwen35Plus) {
-            return false;
-        }
-        if (!(features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true)) {
-            return false;
-        }
-        return this.routeHasTargets(this.routing.vision);
+    markProviderCooldown(providerKey, cooldownMs) {
+        this.nativeProxy.markProviderCooldown(providerKey, cooldownMs);
     }
-    initialize(config) {
-        this.validateConfig(config);
-        this.routing = config.routing;
-        this.providerRegistry.load(config.providers);
-        this.healthManager.configure(config.health);
-        this.healthConfig = config.health ?? null;
-        this.healthManager.registerProviders(Object.keys(config.providers));
-        this.cooldownManager.clearAllCooldowns();
-        this.restoreHealthFromStore();
-        this.loadBalancer = new RouteLoadBalancer(config.loadBalancing);
-        const aliasReuseCooldownMs = resolveAntigravityAliasReuseCooldownMs(config);
-        this.stickySessionManager = new StickySessionManager(aliasReuseCooldownMs);
-        hydrateAntigravityAliasLeaseStoreIfNeeded({
-            force: true,
-            leaseStore: this.stickySessionManager.getAllStores().aliasLeaseStore,
-            persistence: this.antigravityLeasePersistence,
-            aliasReuseCooldownMs: this.stickySessionManager.getAliasReuseCooldownMs()
-        });
-        this.classifier = new RoutingClassifier(config.classifier);
-        this.contextRouting = config.contextRouting ?? { warnRatio: 0.9, hardLimit: false };
-        this.contextAdvisor.configure(this.contextRouting);
-        this.webSearchForce = config.webSearch?.force === true;
-        this.routeAnalytics.getAllRouteStats().clear();
-        for (const routeName of Object.keys(this.routing)) {
-            this.routeAnalytics.getRouteStats(routeName) || this.routeAnalytics.incrementRouteStat(routeName, '', { timestampMs: Date.now(), stopMessage: { active: false } });
-        }
+    clearProviderCooldown(providerKey) {
+        this.nativeProxy.clearProviderCooldown(providerKey);
     }
     route(request, metadata) {
-        const stickyKey = this.resolveStickyKey(metadata);
-        const sessionScope = this.resolveSessionScope(metadata);
-        const stopMessageScope = resolveStopMessageScope(metadata);
-        // Route sticky state remains session/request scoped for routing behavior,
-        // but stopMessage state is tmux/clockd scoped and merged separately below.
-        const stateKey = sessionScope || stickyKey || 'default';
-        const baseState = getRoutingInstructionState(stateKey, this.routingInstructionState, this.routingStateStore);
-        let routingState = stripStopMessageFields(baseState);
-        const metadataInstructions = buildMetadataInstructions(metadata);
-        if (metadataInstructions.length > 0) {
-            routingState = applyRoutingInstructions(metadataInstructions, routingState);
-        }
-        const disableStickyRoutes = metadata &&
-            typeof metadata === 'object' &&
-            metadata.disableStickyRoutes === true;
-        if (disableStickyRoutes && (routingState.stickyTarget || routingState.preferTarget)) {
-            routingState = {
-                ...routingState,
-                stickyTarget: undefined,
-                preferTarget: undefined
-            };
-        }
-        if (stopMessageScope) {
-            const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-            if (ensureStopMessageModeMaxRepeats(sessionState)) {
-                this.routingInstructionState.set(stopMessageScope, sessionState);
-                persistRoutingInstructionState(stopMessageScope, sessionState, this.routingStateStore);
-            }
-            if (typeof sessionState.stopMessageText === 'string' ||
-                typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                typeof sessionState.stopMessageStageMode === 'string' ||
-                typeof sessionState.stopMessageAiMode === 'string' ||
-                typeof sessionState.stopMessageAiSeedPrompt === 'string' ||
-                Array.isArray(sessionState.stopMessageAiHistory)) {
-                routingState = {
-                    ...routingState,
-                    stopMessageText: sessionState.stopMessageText,
-                    stopMessageMaxRepeats: sessionState.stopMessageMaxRepeats,
-                    stopMessageUsed: sessionState.stopMessageUsed,
-                    stopMessageUpdatedAt: sessionState.stopMessageUpdatedAt,
-                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt,
-                    stopMessageStageMode: sessionState.stopMessageStageMode,
-                    stopMessageAiMode: sessionState.stopMessageAiMode,
-                    stopMessageAiSeedPrompt: sessionState.stopMessageAiSeedPrompt,
-                    stopMessageAiHistory: sessionState.stopMessageAiHistory
-                };
-            }
-            if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
-                routingState = {
-                    ...routingState,
-                    preCommandSource: sessionState.preCommandSource,
-                    preCommandScriptPath: sessionState.preCommandScriptPath,
-                    preCommandUpdatedAt: sessionState.preCommandUpdatedAt
-                };
-            }
-        }
-        const parsedInstructions = parseRoutingInstructions(request.messages);
-        const markerDetected = hasRoutingInstructionMarker(request.messages);
-        if (markerDetected && isStopScopeTraceEnabled()) {
-            const parsedTypes = parsedInstructions.map((entry) => entry.type);
-            this.debug?.log?.(`[virtual-router][instruction_parse] requestId=${metadata.requestId || 'n/a'} marker=detected parsed=${parsedTypes.join(',') || 'none'}`);
-        }
-        else if (isStopScopeTraceEnabled()) {
-            const latestUserText = [...request.messages]
-                .reverse()
-                .find((message) => message?.role === 'user');
-            const latestText = latestUserText ? extractMessageText(latestUserText).trim() : '';
-            if (latestText && /stopmessage/i.test(latestText)) {
-                const preview = latestText.replace(/\s+/g, ' ').slice(0, 120);
-                this.debug?.log?.(`[virtual-router][instruction_parse] requestId=${metadata.requestId || 'n/a'} marker=missing contains_stopmessage=yes preview=${preview}`);
-            }
-        }
-        const serverToolFollowup = isServerToolFollowupRequest(metadata);
-        const latestUserHasMarker = hasLatestUserRoutingInstructionMarker(request.messages);
-        let instructions = parsedInstructions;
-        if (serverToolFollowup && instructions.length > 0) {
-            instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet' &&
-                entry.type !== 'stopMessageMode' &&
-                entry.type !== 'stopMessageClear' &&
-                entry.type !== 'preCommandSet' &&
-                entry.type !== 'preCommandClear');
-        }
-        if (stopMessageScope && parsedInstructions.length > 0) {
-            const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-            const hasStaleStopMessageInstruction = !latestUserHasMarker &&
-                parsedInstructions.some((entry) => entry.type === 'stopMessageSet' ||
-                    entry.type === 'stopMessageMode');
-            if (hasStaleStopMessageInstruction) {
-                const hasActiveStopState = typeof sessionState.stopMessageText === 'string' ||
-                    typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                    typeof sessionState.stopMessageStageMode === 'string' ||
-                    typeof sessionState.stopMessageAiMode === 'string' ||
-                    typeof sessionState.stopMessageAiSeedPrompt === 'string' ||
-                    Array.isArray(sessionState.stopMessageAiHistory);
-                const hasStopLifecycleStamp = (typeof sessionState.stopMessageUpdatedAt === 'number' && Number.isFinite(sessionState.stopMessageUpdatedAt)) ||
-                    (typeof sessionState.stopMessageLastUsedAt === 'number' && Number.isFinite(sessionState.stopMessageLastUsedAt));
-                if (hasActiveStopState || hasStopLifecycleStamp) {
-                    instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet' &&
-                        entry.type !== 'stopMessageMode');
-                }
-            }
-        }
-        // stopMessage/precommand require explicit client inject scope (tmux).
-        // When scope is missing, drop only these instructions and keep request passthrough.
-        if (instructions.length > 0 && !stopMessageScope) {
-            const blockedInstructionTypes = instructions
-                .filter((entry) => entry.type === 'stopMessageSet' ||
-                entry.type === 'stopMessageMode' ||
-                entry.type === 'stopMessageClear' ||
-                entry.type === 'preCommandSet' ||
-                entry.type === 'preCommandClear')
-                .map((entry) => entry.type);
-            if (blockedInstructionTypes.length > 0 && isStopScopeTraceEnabled()) {
-                this.debug?.log?.(`[virtual-router][stop_scope] requestId=${metadata.requestId || 'n/a'} stage=drop reason=missing_tmux_scope instructions=${blockedInstructionTypes.join(',')}`);
-            }
-            instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet' &&
-                entry.type !== 'stopMessageMode' &&
-                entry.type !== 'stopMessageClear' &&
-                entry.type !== 'preCommandSet' &&
-                entry.type !== 'preCommandClear');
-        }
-        if (hasRoutingInstructionMarker(request.messages)) {
-            request.messages = cleanMessagesFromRoutingInstructions(request.messages);
-        }
-        let appliedRoutingState = routingState;
-        if (instructions.length > 0) {
-            appliedRoutingState = applyRoutingInstructions(instructions, routingState);
-            const persistedBaseState = stopMessageScope
-                ? stripClientInjectScopedFields(appliedRoutingState)
-                : appliedRoutingState;
-            routingState = persistedBaseState;
-            this.routingInstructionState.set(stateKey, persistedBaseState);
-            persistRoutingInstructionState(stateKey, persistedBaseState, this.routingStateStore);
-            // Persist stopMessage under tmux/clockd scope so client injection and trigger matching
-            // use the same scope and never fall back to generic session keys.
-            if (stopMessageScope) {
-                const hasStopMessageSet = instructions.some((entry) => entry.type === 'stopMessageSet');
-                const hasStopMessageMode = instructions.some((entry) => entry.type === 'stopMessageMode');
-                const hasGlobalClear = instructions.some((entry) => entry.type === 'clear');
-                const hasStopMessageClear = hasGlobalClear || instructions.some((entry) => entry.type === 'stopMessageClear');
-                if (hasStopMessageSet || hasStopMessageMode || hasStopMessageClear) {
-                    const activeInstructionTypes = instructions
-                        .filter((entry) => entry.type === 'stopMessageSet' ||
-                        entry.type === 'stopMessageMode' ||
-                        entry.type === 'stopMessageClear')
-                        .map((entry) => entry.type);
-                    if (isStopScopeTraceEnabled()) {
-                        this.debug?.log?.(`[virtual-router][stop_scope] requestId=${metadata.requestId || 'n/a'} stage=apply scope=${stopMessageScope} instructions=${activeInstructionTypes.join(',') || 'none'}`);
-                    }
-                    const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-                    let nextSessionState = {
-                        ...sessionState
-                    };
-                    let shouldPersistSessionState = false;
-                    const hasStopMessageStateChanged = () => {
-                        return (nextSessionState.stopMessageText !== sessionState.stopMessageText ||
-                            nextSessionState.stopMessageMaxRepeats !== sessionState.stopMessageMaxRepeats ||
-                            nextSessionState.stopMessageUsed !== sessionState.stopMessageUsed ||
-                            nextSessionState.stopMessageUpdatedAt !== sessionState.stopMessageUpdatedAt ||
-                            nextSessionState.stopMessageLastUsedAt !== sessionState.stopMessageLastUsedAt ||
-                            nextSessionState.stopMessageSource !== sessionState.stopMessageSource ||
-                            nextSessionState.stopMessageStageMode !== sessionState.stopMessageStageMode ||
-                            nextSessionState.stopMessageAiMode !== sessionState.stopMessageAiMode ||
-                            nextSessionState.stopMessageAiSeedPrompt !== sessionState.stopMessageAiSeedPrompt ||
-                            JSON.stringify(nextSessionState.stopMessageAiHistory || []) !==
-                                JSON.stringify(sessionState.stopMessageAiHistory || []));
-                    };
-                    if (hasStopMessageClear) {
-                        if (hasGlobalClear) {
-                            // <**clear**> is a hard reset: clear all session-scoped routing state
-                            // and let persistRoutingInstructionState delete persistence markers.
-                            nextSessionState = {
-                                forcedTarget: undefined,
-                                stickyTarget: undefined,
-                                preferTarget: undefined,
-                                allowedProviders: new Set(),
-                                disabledProviders: new Set(),
-                                disabledKeys: new Map(),
-                                disabledModels: new Map(),
-                                stopMessageSource: undefined,
-                                stopMessageText: undefined,
-                                stopMessageMaxRepeats: undefined,
-                                stopMessageUsed: undefined,
-                                stopMessageUpdatedAt: undefined,
-                                stopMessageLastUsedAt: undefined,
-                                stopMessageStageMode: undefined,
-                                stopMessageAiMode: undefined,
-                                stopMessageAiSeedPrompt: undefined,
-                                stopMessageAiHistory: undefined,
-                                preCommandSource: undefined,
-                                preCommandScriptPath: undefined,
-                                preCommandUpdatedAt: undefined
-                            };
-                            shouldPersistSessionState = true;
-                        }
-                        else {
-                            nextSessionState.stopMessageText = undefined;
-                            nextSessionState.stopMessageMaxRepeats = undefined;
-                            nextSessionState.stopMessageUsed = undefined;
-                            nextSessionState.stopMessageUpdatedAt = undefined;
-                            nextSessionState.stopMessageLastUsedAt = undefined;
-                            nextSessionState.stopMessageSource = undefined;
-                            nextSessionState.stopMessageStageMode = undefined;
-                            nextSessionState.stopMessageAiMode = undefined;
-                            nextSessionState.stopMessageAiSeedPrompt = undefined;
-                            nextSessionState.stopMessageAiHistory = undefined;
-                            shouldPersistSessionState = true;
-                        }
-                    }
-                    else if (hasStopMessageSet || hasStopMessageMode) {
-                        nextSessionState.stopMessageText =
-                            typeof appliedRoutingState.stopMessageText === 'string' && appliedRoutingState.stopMessageText.trim()
-                                ? appliedRoutingState.stopMessageText
-                                : undefined;
-                        nextSessionState.stopMessageMaxRepeats =
-                            typeof appliedRoutingState.stopMessageMaxRepeats === 'number' && Number.isFinite(appliedRoutingState.stopMessageMaxRepeats)
-                                ? Math.floor(appliedRoutingState.stopMessageMaxRepeats)
-                                : undefined;
-                        nextSessionState.stopMessageUsed =
-                            typeof appliedRoutingState.stopMessageUsed === 'number' && Number.isFinite(appliedRoutingState.stopMessageUsed)
-                                ? Math.max(0, Math.floor(appliedRoutingState.stopMessageUsed))
-                                : undefined;
-                        nextSessionState.stopMessageUpdatedAt =
-                            typeof appliedRoutingState.stopMessageUpdatedAt === 'number' && Number.isFinite(appliedRoutingState.stopMessageUpdatedAt)
-                                ? appliedRoutingState.stopMessageUpdatedAt
-                                : undefined;
-                        nextSessionState.stopMessageLastUsedAt =
-                            typeof appliedRoutingState.stopMessageLastUsedAt === 'number' && Number.isFinite(appliedRoutingState.stopMessageLastUsedAt)
-                                ? appliedRoutingState.stopMessageLastUsedAt
-                                : undefined;
-                        nextSessionState.stopMessageSource =
-                            typeof appliedRoutingState.stopMessageSource === 'string' && appliedRoutingState.stopMessageSource.trim()
-                                ? appliedRoutingState.stopMessageSource.trim()
-                                : undefined;
-                        nextSessionState.stopMessageStageMode = normalizeStopMessageStageMode(appliedRoutingState.stopMessageStageMode);
-                        nextSessionState.stopMessageAiMode = normalizeStopMessageAiMode(appliedRoutingState.stopMessageAiMode);
-                        nextSessionState.stopMessageAiSeedPrompt =
-                            typeof appliedRoutingState.stopMessageAiSeedPrompt === 'string' &&
-                                appliedRoutingState.stopMessageAiSeedPrompt.trim()
-                                ? appliedRoutingState.stopMessageAiSeedPrompt.trim()
-                                : undefined;
-                        nextSessionState.stopMessageAiHistory = Array.isArray(appliedRoutingState.stopMessageAiHistory)
-                            ? appliedRoutingState.stopMessageAiHistory
-                            : undefined;
-                        shouldPersistSessionState = hasStopMessageStateChanged();
-                    }
-                    if (shouldPersistSessionState) {
-                        this.routingInstructionState.set(stopMessageScope, nextSessionState);
-                        persistRoutingInstructionState(stopMessageScope, nextSessionState, this.routingStateStore);
-                    }
-                    else {
-                        nextSessionState = sessionState;
-                    }
-                    // 日志展示使用 session scope 的 stopMessage 状态，避免每次解析重复刷新时间/次数。
-                    if (typeof nextSessionState.stopMessageText === 'string' ||
-                        typeof nextSessionState.stopMessageMaxRepeats === 'number' ||
-                        typeof nextSessionState.stopMessageStageMode === 'string' ||
-                        typeof nextSessionState.stopMessageAiMode === 'string' ||
-                        typeof nextSessionState.stopMessageAiSeedPrompt === 'string' ||
-                        Array.isArray(nextSessionState.stopMessageAiHistory)) {
-                        routingState.stopMessageText = nextSessionState.stopMessageText;
-                        routingState.stopMessageMaxRepeats = nextSessionState.stopMessageMaxRepeats;
-                        routingState.stopMessageUsed = nextSessionState.stopMessageUsed;
-                        routingState.stopMessageUpdatedAt = nextSessionState.stopMessageUpdatedAt;
-                        routingState.stopMessageLastUsedAt = nextSessionState.stopMessageLastUsedAt;
-                        routingState.stopMessageStageMode = nextSessionState.stopMessageStageMode;
-                        routingState.stopMessageAiMode = nextSessionState.stopMessageAiMode;
-                        routingState.stopMessageAiSeedPrompt = nextSessionState.stopMessageAiSeedPrompt;
-                        routingState.stopMessageAiHistory = nextSessionState.stopMessageAiHistory;
-                    }
-                }
-            }
-        }
-        if (instructions.length > 0 && stopMessageScope) {
-            const hasPreCommandSet = instructions.some((entry) => entry.type === 'preCommandSet');
-            const hasPreCommandClear = instructions.some((entry) => entry.type === 'preCommandClear');
-            if (hasPreCommandSet || hasPreCommandClear) {
-                const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-                const nextSessionState = {
-                    ...sessionState
-                };
-                let changed = false;
-                if (hasPreCommandClear) {
-                    changed =
-                        typeof sessionState.preCommandScriptPath === 'string' ||
-                            typeof sessionState.preCommandSource === 'string' ||
-                            typeof sessionState.preCommandUpdatedAt === 'number';
-                    nextSessionState.preCommandScriptPath = undefined;
-                    nextSessionState.preCommandSource = undefined;
-                    nextSessionState.preCommandUpdatedAt = Date.now();
-                }
-                if (hasPreCommandSet) {
-                    const scriptPath = typeof appliedRoutingState.preCommandScriptPath === 'string' ? appliedRoutingState.preCommandScriptPath.trim() : '';
-                    if (scriptPath) {
-                        if (sessionState.preCommandScriptPath !== scriptPath) {
-                            changed = true;
-                        }
-                        nextSessionState.preCommandScriptPath = scriptPath;
-                        nextSessionState.preCommandSource = 'explicit';
-                        nextSessionState.preCommandUpdatedAt =
-                            typeof appliedRoutingState.preCommandUpdatedAt === 'number' && Number.isFinite(appliedRoutingState.preCommandUpdatedAt)
-                                ? appliedRoutingState.preCommandUpdatedAt
-                                : Date.now();
-                    }
-                }
-                if (changed) {
-                    this.routingInstructionState.set(stopMessageScope, nextSessionState);
-                    persistRoutingInstructionState(stopMessageScope, nextSessionState, this.routingStateStore);
-                    routingState.preCommandScriptPath = nextSessionState.preCommandScriptPath;
-                    routingState.preCommandSource = nextSessionState.preCommandSource;
-                    routingState.preCommandUpdatedAt = nextSessionState.preCommandUpdatedAt;
-                }
-            }
-        }
-        if (instructions.length === 0 && stopMessageScope) {
-            const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-            if (typeof sessionState.stopMessageText === 'string' ||
-                typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                typeof sessionState.stopMessageStageMode === 'string' ||
-                typeof sessionState.stopMessageAiMode === 'string' ||
-                typeof sessionState.stopMessageAiSeedPrompt === 'string' ||
-                Array.isArray(sessionState.stopMessageAiHistory)) {
-                routingState.stopMessageText = sessionState.stopMessageText;
-                routingState.stopMessageMaxRepeats = sessionState.stopMessageMaxRepeats;
-                routingState.stopMessageUsed = sessionState.stopMessageUsed;
-                routingState.stopMessageUpdatedAt = sessionState.stopMessageUpdatedAt;
-                routingState.stopMessageLastUsedAt = sessionState.stopMessageLastUsedAt;
-                routingState.stopMessageStageMode = sessionState.stopMessageStageMode;
-                routingState.stopMessageAiMode = sessionState.stopMessageAiMode;
-                routingState.stopMessageAiSeedPrompt = sessionState.stopMessageAiSeedPrompt;
-                routingState.stopMessageAiHistory = sessionState.stopMessageAiHistory;
-            }
-            if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
-                routingState.preCommandScriptPath = sessionState.preCommandScriptPath;
-                routingState.preCommandSource = sessionState.preCommandSource;
-                routingState.preCommandUpdatedAt = sessionState.preCommandUpdatedAt;
-            }
-        }
-        // Guardrail: if a session is restricted to providers that do not exist in any routing pools,
-        // we must not hard-fail the request loop. Auto-clear the allowlist and fall back to normal routing.
-        if (routingState.allowedProviders.size > 0) {
-            const providersInRouting = new Set();
-            for (const pools of Object.values(this.routing)) {
-                if (!Array.isArray(pools))
-                    continue;
-                for (const pool of pools) {
-                    if (!pool || !Array.isArray(pool.targets))
-                        continue;
-                    for (const key of pool.targets) {
-                        if (typeof key !== 'string' || !key)
-                            continue;
-                        const providerId = extractProviderId(key);
-                        if (providerId) {
-                            providersInRouting.add(providerId);
-                        }
-                    }
-                }
-            }
-            const allowed = Array.from(routingState.allowedProviders).filter((provider) => typeof provider === 'string');
-            const hasIntersection = allowed.some((provider) => providersInRouting.has(provider));
-            if (!hasIntersection) {
-                routingState = {
-                    ...routingState,
-                    allowedProviders: new Set()
-                };
-                this.routingInstructionState.set(stateKey, routingState);
-                persistRoutingInstructionState(stateKey, routingState, this.routingStateStore);
-            }
-        }
-        const features = buildRoutingFeatures(request, metadata);
-        const directProviderModel = this.parseDirectProviderModel(request?.model);
-        let classification;
-        let requestedRoute;
-        let selection;
-        const selectionDeps = {
-            routing: this.routing,
-            providerRegistry: this.providerRegistry,
-            healthManager: this.healthManager,
-            contextAdvisor: this.contextAdvisor,
-            loadBalancer: this.loadBalancer,
-            isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
-            resolveStickyKey: (m) => this.resolveStickyKey(m),
-            quotaView: this.quotaView
-        };
-        if (directProviderModel) {
-            const forceMediaFallback = this.shouldFallbackDirectModelForMedia(directProviderModel, features);
-            const providerKeys = this.providerRegistry.listProviderKeys(directProviderModel.providerId);
-            let hasModel = false;
-            for (const key of providerKeys) {
-                try {
-                    const profile = this.providerRegistry.get(key);
-                    if (profile?.modelId === directProviderModel.modelId) {
-                        hasModel = true;
-                        break;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (!hasModel) {
-                throw new VirtualRouterError(`Unknown model ${directProviderModel.modelId} for provider ${directProviderModel.providerId}`, VirtualRouterErrorCode.CONFIG_ERROR, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
-            }
-            if (!forceMediaFallback) {
-                const directSelection = selectDirectProviderModel(directProviderModel.providerId, directProviderModel.modelId, metadata, features, routingState, selectionDeps);
-                if (!directSelection) {
-                    throw new VirtualRouterError(`All providers unavailable for model ${directProviderModel.providerId}.${directProviderModel.modelId}`, VirtualRouterErrorCode.PROVIDER_NOT_AVAILABLE, { providerId: directProviderModel.providerId, modelId: directProviderModel.modelId });
-                }
-                classification = {
-                    routeName: 'direct',
-                    confidence: 1,
-                    reasoning: `direct_model:${directProviderModel.providerId}.${directProviderModel.modelId}`,
-                    fallback: false,
-                    candidates: ['direct']
-                };
-                requestedRoute = 'direct';
-                selection = directSelection;
-            }
-            else {
-                classification = this.classifier.classify(features);
-                requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-                selection = this.selectProvider(requestedRoute, metadata, classification, features, routingState);
-            }
-        }
-        else {
-            // Prefer target (from "<**!provider.model**>") is evaluated before routing classification.
-            const preferTarget = routingState.preferTarget;
-            if (preferTarget && typeof preferTarget.provider === 'string' && preferTarget.provider.trim()) {
-                const providerId = preferTarget.provider.trim();
-                const keyAlias = typeof preferTarget.keyAlias === 'string' ? preferTarget.keyAlias.trim() : '';
-                const modelId = typeof preferTarget.model === 'string' ? preferTarget.model.trim() : '';
-                const keyIndex = typeof preferTarget.keyIndex === 'number' && Number.isFinite(preferTarget.keyIndex)
-                    ? Math.floor(preferTarget.keyIndex)
-                    : undefined;
-                const candidateKeys = [];
-                if (keyIndex !== undefined && keyIndex > 0) {
-                    const runtimeKey = this.providerRegistry.resolveRuntimeKeyByIndex(providerId, keyIndex);
-                    if (runtimeKey) {
-                        candidateKeys.push(runtimeKey);
-                    }
-                }
-                else if (modelId) {
-                    const allKeys = this.providerRegistry.listProviderKeys(providerId);
-                    for (const key of allKeys) {
-                        if (keyAlias) {
-                            const prefix = `${providerId}.${keyAlias}.`;
-                            if (!key.startsWith(prefix)) {
-                                continue;
-                            }
-                        }
-                        try {
-                            const profile = this.providerRegistry.get(key);
-                            if (profile?.modelId === modelId) {
-                                candidateKeys.push(key);
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-                const allowAliasRotation = !keyAlias && keyIndex === undefined;
-                const eligibleKeys = (() => {
-                    if (candidateKeys.length === 0) {
-                        return [];
-                    }
-                    const quotaView = selectionDeps.quotaView;
-                    const now = quotaView ? Date.now() : 0;
-                    return candidateKeys.filter((key) => {
-                        if (!quotaView) {
-                            if (this.isProviderCoolingDown(key)) {
-                                return false;
-                            }
-                            if (!this.healthManager.isAvailable(key)) {
-                                return false;
-                            }
-                            return true;
-                        }
-                        const entry = quotaView(key);
-                        if (!entry) {
-                            return true;
-                        }
-                        if (!entry.inPool) {
-                            return false;
-                        }
-                        if (entry.cooldownUntil && entry.cooldownUntil > now) {
-                            return false;
-                        }
-                        if (entry.blacklistUntil && entry.blacklistUntil > now) {
-                            return false;
-                        }
-                        return true;
-                    });
-                })();
-                const preferSelection = eligibleKeys.length > 0
-                    ? selectFromStickyPool(new Set(eligibleKeys), metadata, features, routingState, selectionDeps, {
-                        allowAliasRotation
-                    })
-                    : null;
-                if (preferSelection) {
-                    classification = {
-                        routeName: 'prefer',
-                        confidence: 1,
-                        reasoning: keyIndex !== undefined ? `prefer_key:${providerId}.${keyIndex}` : `prefer_model:${providerId}.${modelId}`,
-                        fallback: false,
-                        candidates: ['prefer']
-                    };
-                    requestedRoute = 'prefer';
-                    selection = {
-                        ...preferSelection,
-                        routeUsed: 'prefer',
-                        poolId: 'prefer-primary'
-                    };
-                }
-                else if (routingState.preferTarget) {
-                    // Auto-clear only when the target becomes invalid or blocked by explicit routing instructions.
-                    // Do NOT clear for temporary unavailability (e.g. 429 cooldown, quota cooldown, transient health).
-                    const shouldAutoClear = (() => {
-                        if (candidateKeys.length === 0) {
-                            return true;
-                        }
-                        // Prefer selection failed despite eligible keys existing: treat as a hard block (e.g. routing rules).
-                        if (eligibleKeys.length > 0) {
-                            return true;
-                        }
-                        // If quota explicitly marks the preferred target as out-of-pool, clear the prefer instruction so
-                        // the router can fall back to other targets without repeatedly retrying an impossible preference.
-                        if (selectionDeps.quotaView) {
-                            for (const key of candidateKeys) {
-                                const entry = selectionDeps.quotaView(key);
-                                if (entry && entry.inPool === false) {
-                                    return true;
-                                }
-                            }
-                        }
-                        return false;
-                    })();
-                    if (shouldAutoClear) {
-                        routingState = {
-                            ...routingState,
-                            preferTarget: undefined
-                        };
-                        this.routingInstructionState.set(stateKey, routingState);
-                        persistRoutingInstructionState(stateKey, routingState, this.routingStateStore);
-                    }
-                }
-            }
-            if (!selection) {
-                classification = metadata.routeHint && metadata.routeHint.trim()
-                    ? {
-                        routeName: metadata.routeHint.trim(),
-                        confidence: 1,
-                        reasoning: `route_hint:${metadata.routeHint.trim()}`,
-                        fallback: false,
-                        candidates: [metadata.routeHint.trim()]
-                    }
-                    : this.classifier.classify(features);
-                requestedRoute = this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE);
-                selection = this.selectProvider(requestedRoute, metadata, classification, features, routingState);
-            }
-        }
-        const baseTarget = this.providerRegistry.buildTarget(selection.providerKey);
-        const forceVision = selection.routeUsed === 'vision' && this.routeHasForceFlag('vision');
-        const target = {
-            ...baseTarget,
-            ...(this.webSearchForce ? { forceWebSearch: true } : {}),
-            ...(forceVision ? { forceVision: true } : {})
-        };
-        const instructionProcessMode = this.resolveInstructionProcessModeForSelection(selection.providerKey, routingState);
-        if (instructionProcessMode) {
-            target.processMode = instructionProcessMode;
-        }
-        recordAntigravitySessionLease({
-            metadata: features.metadata,
-            providerKey: selection.providerKey,
-            sessionKey: this.resolveSessionScope(features.metadata),
-            providerRegistry: this.providerRegistry,
-            leaseStore: this.stickySessionManager.getAllStores().aliasLeaseStore,
-            sessionAliasStore: this.stickySessionManager.getAllStores().sessionAliasStore,
-            persistence: this.antigravityLeasePersistence,
-            aliasReuseCooldownMs: this.stickySessionManager.getAliasReuseCooldownMs(),
-            commitSessionBinding: false,
-            debug: this.debug
-        });
-        const routingMode = resolveRoutingMode([...metadataInstructions, ...instructions], routingState);
-        const hitReason = buildHitReason(selection.routeUsed, selection.providerKey, classification, features, routingMode, { providerRegistry: this.providerRegistry, contextRouting: this.contextRouting });
-        const stickyScope = routingMode !== 'none' ? this.resolveSessionScope(metadata) : undefined;
-        const routeForLog = routingMode === 'sticky' ? 'sticky' : selection.routeUsed;
-        const hitRecord = createVirtualRouterHitRecord({
-            routeName: routeForLog,
-            poolId: selection.poolId,
-            providerKey: selection.providerKey,
-            modelId: target.modelId || undefined,
-            hitReason,
-            stickyScope,
-            routingState,
-            requestTokens: features.estimatedTokens,
-            selectionPenalty: this.resolveSelectionPenalty(selection.providerKey)
-        });
-        this.routeAnalytics.incrementRouteStat(selection.routeUsed, selection.providerKey, hitRecord);
+        const parseLog = buildRoutingInstructionParseLog(request, metadata);
+        const nativeMetadata = injectRuntimeNowMs(metadata);
+        let raw;
         try {
-            this.statsCenter.recordVirtualRouterHit(toVirtualRouterHitEvent(hitRecord, {
-                requestId: metadata.requestId,
-                entryEndpoint: metadata.entryEndpoint || '/v1/chat/completions'
-            }));
-        }
-        catch {
-            // stats must never break routing
-        }
-        const formatted = formatVirtualRouterHit(hitRecord);
-        if (formatted) {
-            this.debug?.log?.(formatted);
-        }
-        else {
-            this.debug?.log?.(formatVirtualRouterHit(hitRecord));
-        }
-        const didFallback = selection.routeUsed !== requestedRoute;
-        return {
-            target,
-            decision: {
-                routeName: selection.routeUsed,
-                providerKey: selection.providerKey,
-                pool: selection.pool,
-                poolId: selection.poolId,
-                confidence: classification.confidence,
-                reasoning: classification.reasoning,
-                fallback: didFallback
-            },
-            diagnostics: {
-                routeName: selection.routeUsed,
-                providerKey: selection.providerKey,
-                pool: selection.pool,
-                poolId: selection.poolId,
-                reasoning: classification.reasoning,
-                fallback: didFallback,
-                confidence: classification.confidence
-            }
-        };
+            raw = this.nativeProxy.route(JSON.stringify(request), JSON.stringify(nativeMetadata));
+        }
+        catch (error) {
+            throw normalizeNativeVirtualRouterError(error);
+        }
+        if (typeof raw !== 'string') {
+            throw normalizeNativeVirtualRouterError(raw);
+        }
+        if (raw.startsWith('Error:') || raw.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
+            throw normalizeNativeVirtualRouterError(raw);
+        }
+        const parsed = JSON.parse(raw);
+        emitRoutingInstructionParseLog(parseLog);
+        // Keep legacy observable behavior for callers/tests that inspect the request object
+        // after route(): instruction markers are stripped from forwarded payload structures.
+        cleanRoutingInstructionMarkersInPlace(request);
+        const stopScope = parseLog?.stopScope || resolveStopMessageScope(metadata);
+        const stopState = stopScope ? this.getStopMessageState(metadata) : null;
+        const forceStopStatusLabel = Boolean(parseLog?.stopMessageTypes.length ||
+            parseLog?.scopedTypes.some((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear'));
+        emitVirtualRouterHitLog(parsed, {
+            requestId: metadata.requestId,
+            stopScope,
+            stopState,
+            forceStopStatusLabel
+        });
+        return parsed;
     }
     getStopMessageState(metadata) {
-        const hasArmedStopState = (candidate) => {
-            if (!candidate) {
-                return false;
-            }
-            const text = typeof candidate.stopMessageText === 'string' ? candidate.stopMessageText.trim() : '';
-            const maxRepeats = typeof candidate.stopMessageMaxRepeats === 'number' && Number.isFinite(candidate.stopMessageMaxRepeats)
-                ? Math.max(1, Math.floor(candidate.stopMessageMaxRepeats))
-                : 0;
-            const mode = typeof candidate.stopMessageStageMode === 'string'
-                ? candidate.stopMessageStageMode.trim().toLowerCase()
-                : '';
-            if (mode === 'off') {
-                return false;
-            }
-            return Boolean(text) && maxRepeats > 0;
-        };
-        const stopMessageScope = resolveStopMessageScope(metadata);
-        if (!stopMessageScope) {
-            const sessionScope = this.resolveSessionScope(metadata);
-            if (sessionScope) {
-                const legacyState = getRoutingInstructionState(sessionScope, this.routingInstructionState, this.routingStateStore);
-                if (hasClientInjectScopedFields(legacyState)) {
-                    const cleared = stripClientInjectScopedFields(legacyState);
-                    this.routingInstructionState.set(sessionScope, cleared);
-                    persistRoutingInstructionState(sessionScope, cleared, this.routingStateStore);
-                }
-            }
-            return null;
-        }
-        const effectiveState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-        if (!hasArmedStopState(effectiveState)) {
-            return null;
-        }
-        const text = typeof effectiveState.stopMessageText === 'string' ? effectiveState.stopMessageText.trim() : '';
-        const maxRepeats = typeof effectiveState.stopMessageMaxRepeats === 'number' &&
-            Number.isFinite(effectiveState.stopMessageMaxRepeats)
-            ? Math.max(1, Math.floor(effectiveState.stopMessageMaxRepeats))
-            : 0;
-        const stageModeRaw = typeof effectiveState.stopMessageStageMode === 'string'
-            ? effectiveState.stopMessageStageMode.trim().toLowerCase()
-            : '';
-        const stageModeNormalized = stageModeRaw === 'on' || stageModeRaw === 'off' || stageModeRaw === 'auto'
-            ? stageModeRaw
-            : undefined;
-        const aiModeRaw = typeof effectiveState.stopMessageAiMode === 'string'
-            ? effectiveState.stopMessageAiMode.trim().toLowerCase()
-            : '';
-        const aiModeNormalized = aiModeRaw === 'on' || aiModeRaw === 'off' ? aiModeRaw : undefined;
-        if (stageModeNormalized === 'off' || !text || maxRepeats <= 0) {
-            return null;
-        }
-        return {
-            ...(text ? { stopMessageText: text } : {}),
-            stopMessageMaxRepeats: maxRepeats,
-            ...(typeof effectiveState.stopMessageSource === 'string' && effectiveState.stopMessageSource.trim()
-                ? { stopMessageSource: effectiveState.stopMessageSource.trim() }
-                : {}),
-            ...(typeof effectiveState.stopMessageUsed === 'number' && Number.isFinite(effectiveState.stopMessageUsed)
-                ? { stopMessageUsed: Math.max(0, Math.floor(effectiveState.stopMessageUsed)) }
-                : {}),
-            ...(typeof effectiveState.stopMessageUpdatedAt === 'number' &&
-                Number.isFinite(effectiveState.stopMessageUpdatedAt)
-                ? { stopMessageUpdatedAt: effectiveState.stopMessageUpdatedAt }
-                : {}),
-            ...(typeof effectiveState.stopMessageLastUsedAt === 'number' &&
-                Number.isFinite(effectiveState.stopMessageLastUsedAt)
-                ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
-                : {}),
-            ...(stageModeNormalized ? { stopMessageStageMode: stageModeNormalized } : {}),
-            ...(aiModeNormalized ? { stopMessageAiMode: aiModeNormalized } : {}),
-            ...(typeof effectiveState.stopMessageAiSeedPrompt === 'string' &&
-                effectiveState.stopMessageAiSeedPrompt.trim()
-                ? { stopMessageAiSeedPrompt: effectiveState.stopMessageAiSeedPrompt.trim() }
-                : {}),
-            ...(Array.isArray(effectiveState.stopMessageAiHistory)
-                ? { stopMessageAiHistory: effectiveState.stopMessageAiHistory }
-                : {}),
-        };
+        const raw = this.nativeProxy.getStopMessageState(JSON.stringify(metadata));
+        return JSON.parse(raw);
     }
     getPreCommandState(metadata) {
-        const stopMessageScope = resolveStopMessageScope(metadata);
-        if (!stopMessageScope) {
-            return null;
-        }
-        const effectiveState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-        if (!effectiveState) {
-            return null;
-        }
-        const scriptPath = typeof effectiveState.preCommandScriptPath === 'string' ? effectiveState.preCommandScriptPath.trim() : '';
-        if (!scriptPath) {
-            return null;
-        }
-        return {
-            preCommandScriptPath: scriptPath,
-            ...(typeof effectiveState.preCommandSource === 'string' && effectiveState.preCommandSource.trim()
-                ? { preCommandSource: effectiveState.preCommandSource.trim() }
-                : {}),
-            ...(typeof effectiveState.preCommandUpdatedAt === 'number' && Number.isFinite(effectiveState.preCommandUpdatedAt)
-                ? { preCommandUpdatedAt: effectiveState.preCommandUpdatedAt }
-                : {})
-        };
+        const raw = this.nativeProxy.getPreCommandState(JSON.stringify(metadata));
+        return JSON.parse(raw);
     }
     handleProviderFailure(event) {
-        handleProviderFailureImpl(event, this.healthManager, this.providerHealthConfig(), (key, ttl) => this.markProviderCooldown(key, ttl));
+        this.nativeProxy.handleProviderFailure(JSON.stringify(event));
     }
     handleProviderError(event) {
-        if (this.healthStore && typeof this.healthStore.recordProviderError === 'function') {
-            try {
-                this.healthStore.recordProviderError(event);
-            }
-            catch {
-                // ignore persistence errors
-            }
-        }
-        // Quota routing mode: health/cooldown must be driven by quotaView only (host/core quota center).
-        // VirtualRouter must not produce or persist its own cooldown state in this mode.
-        // 当 Host 注入 quotaView 时，VirtualRouter 的入池/优先级决策应以 quota 为准；
-        // 此时不再在 engine-health 内部进行 429/backoff/series cooldown 等健康决策，
-        // 以避免与 daemon/quota-center 的长期熔断策略重复维护并导致日志噪声。
-        if (this.quotaView) {
-            return;
-        }
-        // Antigravity account safety policy uses router-local cooldown TTLs; only applies when quota routing is disabled.
-        applyAntigravityRiskPolicyImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
-        // 配额恢复事件优先处理：一旦识别到 virtualRouterQuotaRecovery，
-        // 直接清理健康状态/冷却 TTL，避免继续走常规错误映射逻辑。
-        const handledByQuota = applyQuotaRecoveryImpl(event, this.healthManager, (key) => this.clearProviderCooldown(key), this.debug);
-        if (handledByQuota) {
-            return;
-        }
-        const handledByQuotaDepleted = applyQuotaDepletedImpl(event, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
-        if (handledByQuotaDepleted) {
-            return;
-        }
-        applySeriesCooldownImpl(event, this.providerRegistry, this.healthManager, (key, ttl) => this.markProviderCooldown(key, ttl), this.debug);
-        const derived = mapProviderErrorImpl(event, this.providerHealthConfig());
-        if (!derived) {
-            return;
-        }
-        this.handleProviderFailure(derived);
+        this.nativeProxy.handleProviderError(JSON.stringify(event));
     }
     handleProviderSuccess(event) {
-        if (!event || typeof event !== 'object') {
-            return;
-        }
-        const providerKey = event.runtime && typeof event.runtime.providerKey === 'string' ? event.runtime.providerKey.trim() : '';
-        if (!providerKey) {
-            return;
-        }
-        const metadata = event.metadata && typeof event.metadata === 'object' && !Array.isArray(event.metadata)
-            ? event.metadata
-            : null;
-        if (!metadata) {
-            return;
-        }
-        if (providerKey.toLowerCase().startsWith('antigravity.')) {
-            recordAntigravitySessionLease({
-                metadata: metadata,
-                providerKey,
-                sessionKey: this.resolveSessionScope(metadata),
-                providerRegistry: this.providerRegistry,
-                leaseStore: this.stickySessionManager.getAllStores().aliasLeaseStore,
-                sessionAliasStore: this.stickySessionManager.getAllStores().sessionAliasStore,
-                persistence: this.antigravityLeasePersistence,
-                aliasReuseCooldownMs: this.stickySessionManager.getAliasReuseCooldownMs(),
-                commitSessionBinding: true,
-                debug: this.debug
-            });
-        }
+        this.nativeProxy.handleProviderSuccess(JSON.stringify(event));
     }
     getStatus() {
-        const routes = {};
-        for (const [route, pools] of Object.entries(this.routing)) {
-            const stats = this.routeAnalytics.getRouteStats(route);
-            routes[route] = {
-                providers: this.flattenPoolTargets(pools),
-                hits: stats?.hits ?? 0,
-                lastUsedProvider: stats?.lastProvider,
-                ...(stats?.lastHit ? { lastHit: { ...stats.lastHit } } : {})
-            };
-        }
-        return {
-            routes,
-            health: this.healthManager.getSnapshot()
-        };
+        return JSON.parse(this.nativeProxy.getStatus());
     }
-    /**
-     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
-     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
-     */
-    normalizeRouteAlias(routeName) {
-        const base = routeName && routeName.trim() ? routeName.trim() : DEFAULT_ROUTE;
-        return base;
-    }
-    validateConfig(config) {
-        if (!config.routing || typeof config.routing !== 'object') {
-            throw new VirtualRouterError('routing configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        if (!config.providers || Object.keys(config.providers).length === 0) {
-            throw new VirtualRouterError('providers configuration is required', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        const defaultPools = config.routing[DEFAULT_ROUTE];
-        if (!this.routeHasTargets(defaultPools)) {
-            throw new VirtualRouterError('default route must be configured with at least one provider', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        if (!this.hasPrimaryPool(defaultPools)) {
-            throw new VirtualRouterError('default route must define at least one non-backup pool', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        const providerKeys = new Set(Object.keys(config.providers));
-        for (const [routeName, pools] of Object.entries(config.routing)) {
-            if (!this.routeHasTargets(pools)) {
-                if (routeName === DEFAULT_ROUTE) {
-                    throw new VirtualRouterError('default route cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
-                }
-                continue;
-            }
-            for (const pool of pools) {
-                if (!Array.isArray(pool.targets) || !pool.targets.length) {
-                    continue;
-                }
-                for (const providerKey of pool.targets) {
-                    if (!providerKeys.has(providerKey)) {
-                        throw new VirtualRouterError(`Route ${routeName} references unknown provider ${providerKey}`, VirtualRouterErrorCode.CONFIG_ERROR);
-                    }
-                }
-            }
-        }
-    }
-    selectProvider(requestedRoute, metadata, classification, features, routingState) {
-        const activeState = routingState ||
-            getRoutingInstructionState(this.resolveStickyKey(metadata), this.routingInstructionState, this.routingStateStore);
-        return selectProviderImpl(requestedRoute, metadata, classification, features, activeState, {
-            routing: this.routing,
-            providerRegistry: this.providerRegistry,
-            healthManager: this.healthManager,
-            contextAdvisor: this.contextAdvisor,
-            loadBalancer: this.loadBalancer,
-            isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
-            getProviderCooldownRemainingMs: (key) => this.getProviderCooldownRemainingMs(key),
-            resolveStickyKey: (m) => this.resolveStickyKey(m),
-            quotaView: this.quotaView,
-            aliasQueueStore: this.stickySessionManager.getAllStores().aliasQueueStore,
-            antigravityAliasLeaseStore: this.stickySessionManager.getAllStores().aliasLeaseStore,
-            antigravitySessionAliasStore: this.stickySessionManager.getAllStores().sessionAliasStore,
-            antigravityAliasReuseCooldownMs: this.stickySessionManager.getAliasReuseCooldownMs()
-        }, { routingState });
-    }
-    resolveSelectionPenalty(providerKey) {
-        if (!this.quotaView) {
-            return undefined;
-        }
-        try {
-            const entry = this.quotaView(providerKey);
-            const raw = entry?.selectionPenalty;
-            if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0) {
-                return undefined;
-            }
-            return Math.floor(raw);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    providerHealthConfig() {
-        return this.healthManager.getConfig();
-    }
-    resolveStickyKey(metadata) {
-        return resolveStickyKeyImpl(metadata);
-    }
-    resolveSessionScope(metadata) {
-        return resolveSessionScopeImpl(metadata);
+}
+const VIRTUAL_ROUTER_ERROR_PREFIX = 'VIRTUAL_ROUTER_ERROR:';
+function normalizeNativeVirtualRouterError(error) {
+    if (error instanceof VirtualRouterError) {
+        return error;
     }
-    resolveInstructionProcessModeForSelection(providerKey, routingState) {
-        const candidates = [
-            routingState.forcedTarget,
-            routingState.stickyTarget,
-            routingState.preferTarget
-        ];
-        for (const candidate of candidates) {
-            const processMode = candidate?.processMode;
-            if (!processMode) {
-                continue;
-            }
-            const resolved = this.resolveInstructionTarget(candidate);
-            if (!resolved) {
-                continue;
-            }
-            if (resolved.keys.includes(providerKey)) {
-                return processMode;
-            }
-        }
-        return undefined;
+    const message = extractNativeErrorMessage(error);
+    const parsed = parseVirtualRouterErrorMessage(message);
+    if (parsed) {
+        return new VirtualRouterError(parsed.message, parsed.code);
     }
-    resolveInstructionTarget(target) {
-        if (!target || !target.provider) {
-            return null;
-        }
-        const providerId = target.provider;
-        const providerKeys = this.providerRegistry.listProviderKeys(providerId);
-        if (providerKeys.length === 0) {
-            return null;
-        }
-        const alias = typeof target.keyAlias === 'string' ? target.keyAlias.trim() : '';
-        const aliasExplicit = alias.length > 0 && target.pathLength === 3;
-        if (aliasExplicit) {
-            const runtimeKey = this.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
-            if (runtimeKey) {
-                return { mode: 'exact', keys: [runtimeKey] };
-            }
-        }
-        if (typeof target.keyIndex === 'number' && target.keyIndex > 0) {
-            const runtimeKey = this.providerRegistry.resolveRuntimeKeyByIndex(providerId, target.keyIndex);
-            if (runtimeKey) {
-                return { mode: 'exact', keys: [runtimeKey] };
-            }
-        }
-        if (target.model && target.model.trim()) {
-            const normalizedModel = target.model.trim();
-            const matchingKeys = providerKeys.filter((key) => {
-                const modelId = getProviderModelId(key, this.providerRegistry);
-                return modelId === normalizedModel;
-            });
-            if (matchingKeys.length > 0) {
-                return { mode: 'filter', keys: matchingKeys };
-            }
-        }
-        if (alias && !aliasExplicit) {
-            const legacyKey = this.providerRegistry.resolveRuntimeKeyByAlias(providerId, alias);
-            if (legacyKey) {
-                return { mode: 'exact', keys: [legacyKey] };
-            }
-        }
-        return { mode: 'filter', keys: providerKeys };
+    if (isVirtualRouterErrorLike(error)) {
+        return new VirtualRouterError(typeof error.message === 'string' && error.message.trim() ? error.message : 'Virtual router error', error.code);
     }
-    filterCandidatesByRoutingState(routes, state) {
-        // console.log('[filter] routes:', routes, 'state:', {
-        //   allowed: Array.from(state.allowedProviders),
-        //   disabled: Array.from(state.disabledProviders)
-        // });
-        if (state.allowedProviders.size === 0 &&
-            state.disabledProviders.size === 0 &&
-            state.disabledKeys.size === 0 &&
-            state.disabledModels.size === 0) {
-            return routes;
-        }
-        return routes.filter(routeName => {
-            const pools = this.routing[routeName];
-            if (!pools)
-                return false;
-            for (const pool of pools) {
-                if (!Array.isArray(pool.targets) || pool.targets.length === 0) {
-                    continue;
-                }
-                for (const providerKey of pool.targets) {
-                    const providerId = extractProviderId(providerKey);
-                    // console.log('[filter] checking', providerKey, 'id=', providerId);
-                    if (!providerId)
-                        continue;
-                    if (state.allowedProviders.size > 0 && !state.allowedProviders.has(providerId)) {
-                        // console.log('[filter] dropped by allowed list');
-                        continue;
-                    }
-                    if (state.disabledProviders.has(providerId)) {
-                        continue;
-                    }
-                    const disabledKeys = state.disabledKeys.get(providerId);
-                    if (disabledKeys && disabledKeys.size > 0) {
-                        const keyAlias = extractKeyAlias(providerKey);
-                        const keyIndex = extractKeyIndex(providerKey);
-                        if (keyAlias && disabledKeys.has(keyAlias)) {
-                            continue;
-                        }
-                        if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
-                            continue;
-                        }
-                    }
-                    const disabledModels = state.disabledModels.get(providerId);
-                    if (disabledModels && disabledModels.size > 0) {
-                        const modelId = getProviderModelId(providerKey, this.providerRegistry);
-                        if (modelId && disabledModels.has(modelId)) {
-                            continue;
-                        }
-                    }
-                    return true;
-                }
-            }
-            return false;
-        });
-    }
-    selectFromCandidates(routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation) {
-        // legacy helper kept for backward compatibility; selection logic moved to engine-selection.ts
-        return selectProviderImpl(this.normalizeRouteAlias(classification.routeName || DEFAULT_ROUTE), metadata, classification, features, state, {
-            routing: this.routing,
-            providerRegistry: this.providerRegistry,
-            healthManager: this.healthManager,
-            contextAdvisor: this.contextAdvisor,
-            loadBalancer: this.loadBalancer,
-            isProviderCoolingDown: (key) => this.isProviderCoolingDown(key),
-            getProviderCooldownRemainingMs: (key) => this.getProviderCooldownRemainingMs(key),
-            resolveStickyKey: (m) => this.resolveStickyKey(m),
-            quotaView: this.quotaView,
-            aliasQueueStore: this.stickySessionManager.getAllStores().aliasQueueStore
-        }, { routingState: state });
+    return error instanceof Error ? error : new Error(message || 'Virtual router error');
+}
+function extractNativeErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
     }
-    /**
-     * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
-     * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
-     * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
-     * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
-     */
-    buildStickyRouteCandidatesFromFiltered(filteredCandidates, stickyKeySet) {
-        const routesWithSticky = [];
-        const candidateSet = new Set(filteredCandidates.filter((name) => name && name !== 'tools'));
-        for (const routeName of candidateSet) {
-            const pools = this.routing[routeName];
-            if (!this.routeHasTargets(pools)) {
-                continue;
-            }
-            const targets = this.flattenPoolTargets(pools);
-            if (!targets.some((key) => stickyKeySet.has(key))) {
-                continue;
-            }
-            routesWithSticky.push(routeName);
-        }
-        // 若当前候选路由中没有任何挂载 sticky key 的路由，尝试直接在 default 路由上兜底；
-        // 若 default 也不包含 sticky key，则视为 sticky 配置失效，由调用方回落到非 sticky 逻辑。
-        if (routesWithSticky.length === 0) {
-            const defaultPools = this.routing[DEFAULT_ROUTE];
-            if (this.routeHasTargets(defaultPools)) {
-                const targets = this.flattenPoolTargets(defaultPools);
-                if (targets.some((key) => stickyKeySet.has(key))) {
-                    return [DEFAULT_ROUTE];
-                }
-            }
-            return [];
-        }
-        const ordered = this.sortByPriority(routesWithSticky);
-        const result = [];
-        let hasDefault = false;
-        for (const routeName of ordered) {
-            if (routeName === DEFAULT_ROUTE) {
-                hasDefault = true;
-                continue;
-            }
-            if (!result.includes(routeName)) {
-                result.push(routeName);
-            }
-        }
-        // default 路由若包含 sticky key，则始终放在候选列表最后，用于 sticky 模式兜底。
-        if (hasDefault && !result.includes(DEFAULT_ROUTE)) {
-            result.push(DEFAULT_ROUTE);
-        }
-        return result;
+    if (error instanceof Error) {
+        return error.message;
     }
-    /**
-     * 在 sticky 模式下，仅在 sticky 池内选择 Provider：
-     * - stickyKeySet 表示已经解析并通过健康检查的 providerKey 集合；
-     * - 不再依赖 routing[*].targets 中是否挂载这些 key，避免「未初始化路由池」导致 sticky 池为空；
-     * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
-     */
-    selectFromStickyPool(stickyKeySet, metadata, features, state, allowAliasRotation) {
-        if (!stickyKeySet || stickyKeySet.size === 0) {
-            return null;
-        }
-        const allowedProviders = new Set(state.allowedProviders);
-        const disabledProviders = new Set(state.disabledProviders);
-        const disabledKeysMap = new Map(Array.from(state.disabledKeys.entries()).map(([provider, keys]) => [
-            provider,
-            new Set(Array.from(keys).map((k) => (typeof k === 'string' ? k : k + 1)))
-        ]));
-        const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
-        // 初始候选集合：sticky 池中的所有 key
-        // In quota routing mode, cooldown is controlled by quotaView only.
-        let candidates = Array.from(stickyKeySet).filter((key) => (this.quotaView ? true : !this.isProviderCoolingDown(key)));
-        // 应用 provider 白名单 / 黑名单
-        if (allowedProviders.size > 0) {
-            candidates = candidates.filter((key) => {
-                const providerId = extractProviderId(key);
-                return providerId && allowedProviders.has(providerId);
-            });
-        }
-        if (disabledProviders.size > 0) {
-            candidates = candidates.filter((key) => {
-                const providerId = extractProviderId(key);
-                return providerId && !disabledProviders.has(providerId);
-            });
-        }
-        // 应用 key / model 级别黑名单
-        if (disabledKeysMap.size > 0 || disabledModels.size > 0) {
-            candidates = candidates.filter((key) => {
-                const providerId = extractProviderId(key);
-                if (!providerId) {
-                    return true;
-                }
-                const disabledKeys = disabledKeysMap.get(providerId);
-                if (disabledKeys && disabledKeys.size > 0) {
-                    const keyAlias = extractKeyAlias(key);
-                    const keyIndex = extractKeyIndex(key);
-                    if (keyAlias && disabledKeys.has(keyAlias)) {
-                        return false;
-                    }
-                    if (keyIndex !== undefined && disabledKeys.has(keyIndex + 1)) {
-                        return false;
-                    }
-                }
-                const disabledModelSet = disabledModels.get(providerId);
-                if (disabledModelSet && disabledModelSet.size > 0) {
-                    const modelId = getProviderModelId(key, this.providerRegistry);
-                    if (modelId && disabledModelSet.has(modelId)) {
-                        return false;
-                    }
-                }
-                return true;
-            });
-        }
-        if (!candidates.length) {
-            return null;
-        }
-        const stickyKey = allowAliasRotation ? undefined : this.resolveStickyKey(metadata);
-        const estimatedTokens = typeof features.estimatedTokens === 'number' && Number.isFinite(features.estimatedTokens)
-            ? Math.max(0, features.estimatedTokens)
-            : 0;
-        // delegate to selection module
+    return '';
+}
+function parseVirtualRouterErrorMessage(message) {
+    if (!message) {
         return null;
     }
-    // mapProviderError/applySeriesCooldown moved to engine-health.ts
-    extractExcludedProviderKeySet(metadata) {
-        return this.routeAnalytics.extractExcludedProviderKeySet(metadata);
-    }
-    buildRouteCandidates(requestedRoute, classificationCandidates, features) {
-        const forceVision = this.routeHasForceFlag('vision');
-        const hasMultimodalTargets = this.routeHasTargets(this.routing.multimodal);
-        const hasVisionTargets = this.routeHasTargets(this.routing.vision);
-        const hasLocalVideoAttachment = features.hasVideoAttachment === true && features.hasLocalVideoAttachment === true;
-        if (features.hasImageAttachment && hasLocalVideoAttachment && hasVisionTargets) {
-            return ['vision'];
-        }
-        const normalized = this.normalizeRouteAlias(requestedRoute || DEFAULT_ROUTE);
-        const baseList = [];
-        if (classificationCandidates && classificationCandidates.length) {
-            for (const candidate of classificationCandidates) {
-                baseList.push(this.normalizeRouteAlias(candidate));
-            }
-        }
-        else if (normalized) {
-            baseList.push(normalized);
-        }
-        if (features.hasImageAttachment) {
-            if (hasMultimodalTargets) {
-                if (!baseList.includes('multimodal')) {
-                    baseList.unshift('multimodal');
-                }
-            }
-            if (hasVisionTargets && (!hasMultimodalTargets || forceVision)) {
-                if (!baseList.includes('vision')) {
-                    baseList.push('vision');
-                }
-            }
-            if (!forceVision && hasMultimodalTargets) {
-                const visionAwareRoutes = [DEFAULT_ROUTE, 'thinking'];
-                for (const routeName of visionAwareRoutes) {
-                    if (this.routeHasTargets(this.routing[routeName]) && !baseList.includes(routeName)) {
-                        baseList.push(routeName);
-                    }
-                }
-            }
-        }
-        let ordered = this.sortByPriority(baseList);
-        if (features.hasImageAttachment && !forceVision && hasMultimodalTargets) {
-            ordered = this.reorderForInlineVision(ordered);
-        }
-        if (features.hasImageAttachment && hasMultimodalTargets) {
-            ordered = this.reorderForPreferredModel(ordered, 'kimi-k2.5');
-        }
-        const deduped = [];
-        for (const routeName of ordered) {
-            if (routeName && !deduped.includes(routeName)) {
-                deduped.push(routeName);
-            }
-        }
-        if (!deduped.includes(DEFAULT_ROUTE)) {
-            deduped.push(DEFAULT_ROUTE);
-        }
-        const filtered = deduped.filter((routeName) => this.routeHasTargets(this.routing[routeName]));
-        if (!filtered.includes(DEFAULT_ROUTE) && this.routeHasTargets(this.routing[DEFAULT_ROUTE])) {
-            filtered.push(DEFAULT_ROUTE);
-        }
-        return filtered.length ? filtered : [DEFAULT_ROUTE];
-    }
-    reorderForInlineVision(routeNames) {
-        const unique = Array.from(new Set(routeNames.filter(Boolean)));
-        if (!unique.length) {
-            return unique;
-        }
-        // 仅当 default/thinking 中存在 Responses/Gemini 提供方时，才将其提前作为「一次完成」优先级。
-        const inlinePreferred = [];
-        const inlineRoutes = [DEFAULT_ROUTE, 'thinking'];
-        for (const routeName of inlineRoutes) {
-            if (this.routeSupportsInlineVision(routeName) && !inlinePreferred.includes(routeName)) {
-                inlinePreferred.push(routeName);
-            }
-        }
-        if (!inlinePreferred.length) {
-            return unique;
-        }
-        const remaining = [];
-        for (const routeName of unique) {
-            if (!inlinePreferred.includes(routeName)) {
-                remaining.push(routeName);
-            }
-        }
-        return [...inlinePreferred, ...remaining];
+    const normalized = message.startsWith('Error:') ? message.replace(/^Error:\s*/, '') : message;
+    if (!normalized.startsWith(VIRTUAL_ROUTER_ERROR_PREFIX)) {
+        return null;
     }
-    reorderForPreferredModel(routeNames, modelId) {
-        const unique = Array.from(new Set(routeNames.filter(Boolean)));
-        if (!unique.length) {
-            return unique;
-        }
-        const preferred = unique.filter((routeName) => this.routeSupportsModel(routeName, modelId));
-        if (!preferred.length) {
-            return unique;
-        }
-        const remaining = unique.filter((routeName) => !preferred.includes(routeName));
-        return [...preferred, ...remaining];
+    const remainder = normalized.slice(VIRTUAL_ROUTER_ERROR_PREFIX.length);
+    const idx = remainder.indexOf(':');
+    if (idx <= 0) {
+        return null;
     }
-    routeSupportsModel(routeName, modelId) {
-        const normalizedModel = modelId.trim().toLowerCase();
-        if (!normalizedModel) {
-            return false;
-        }
-        const pools = this.routing[routeName];
-        if (!Array.isArray(pools)) {
-            return false;
-        }
-        for (const pool of pools) {
-            if (!Array.isArray(pool.targets)) {
-                continue;
-            }
-            for (const providerKey of pool.targets) {
-                try {
-                    const profile = this.providerRegistry.get(providerKey);
-                    const candidate = typeof profile.modelId === 'string' ? profile.modelId.trim().toLowerCase() : '';
-                    if (candidate === normalizedModel) {
-                        return true;
-                    }
-                }
-                catch {
-                    // ignore unknown provider keys during capability probing
-                }
-            }
-        }
-        return false;
+    const code = remainder.slice(0, idx);
+    const detail = remainder.slice(idx + 1).trim();
+    if (!isVirtualRouterErrorCode(code)) {
+        return null;
     }
-    routeSupportsInlineVision(routeName) {
-        const pools = this.routing[routeName];
-        if (!Array.isArray(pools)) {
-            return false;
-        }
-        for (const pool of pools) {
-            if (!Array.isArray(pool.targets)) {
-                continue;
-            }
-            for (const providerKey of pool.targets) {
-                try {
-                    const profile = this.providerRegistry.get(providerKey);
-                    if (profile.providerType === 'responses' || profile.providerType === 'gemini') {
-                        return true;
-                    }
-                }
-                catch {
-                    // ignore unknown provider keys during capability probing
-                }
-            }
-        }
+    return { code, message: detail || 'Virtual router error' };
+}
+function isVirtualRouterErrorCode(value) {
+    return Object.values(VirtualRouterErrorCode).includes(value);
+}
+function isVirtualRouterErrorLike(error) {
+    if (!error || typeof error !== 'object') {
         return false;
     }
-    sortByPriority(routeNames) {
-        return [...routeNames].sort((a, b) => this.routeWeight(a) - this.routeWeight(b));
-    }
-    routeWeight(routeName) {
-        const idx = ROUTE_PRIORITY.indexOf(routeName);
-        return idx >= 0 ? idx : ROUTE_PRIORITY.length;
+    const record = error;
+    return typeof record.code === 'string' && isVirtualRouterErrorCode(record.code);
+}
+function injectRuntimeNowMs(metadata) {
+    const nowMs = Date.now();
+    const rt = metadata.__rt;
+    if (rt && typeof rt === 'object' && !Array.isArray(rt)) {
+        return { ...metadata, __rt: { ...rt, nowMs } };
     }
-    routeHasForceFlag(routeName) {
-        const pools = this.routing[routeName];
-        if (!Array.isArray(pools)) {
-            return false;
-        }
-        return pools.some((pool) => pool.force);
+    return { ...metadata, __rt: { nowMs } };
+}
+function buildRoutingInstructionParseLog(request, metadata) {
+    const messages = Array.isArray(request.messages)
+        ? (request.messages ?? [])
+        : [];
+    if (!messages.length) {
+        return null;
     }
-    routeHasTargets(pools) {
-        if (!Array.isArray(pools)) {
+    const latest = messages[messages.length - 1];
+    const latestText = typeof latest?.content === 'string' ? latest.content.trim() : '';
+    const parsedKinds = parseRoutingInstructionKindsWithNative(request);
+    const stopMessageTypes = parsedKinds.filter((type) => type === 'stopMessageSet' || type === 'stopMessageMode' || type === 'stopMessageClear');
+    const scopedTypes = parsedKinds.filter((type) => type === 'stopMessageSet' ||
+        type === 'stopMessageMode' ||
+        type === 'stopMessageClear' ||
+        type === 'preCommandSet' ||
+        type === 'preCommandClear');
+    const markerDetected = messages.some((message) => {
+        if (!message || typeof message !== 'object') {
             return false;
         }
-        return pools.some((pool) => Array.isArray(pool.targets) && pool.targets.length > 0);
+        const record = message;
+        return record.role === 'user' && typeof record.content === 'string' && /<\*\*[\s\S]*?\*\*>/.test(record.content);
+    });
+    const hasStopKeyword = /stopmessage/i.test(latestText);
+    if (!hasStopKeyword && stopMessageTypes.length === 0 && scopedTypes.length === 0) {
+        return null;
     }
-    hasPrimaryPool(pools) {
-        if (!Array.isArray(pools)) {
-            return false;
+    return {
+        requestId: metadata.requestId || 'n/a',
+        markerDetected,
+        preview: latestText.replace(/\s+/g, ' ').slice(0, 120),
+        stopMessageTypes,
+        scopedTypes,
+        stopScope: resolveStopMessageScope(metadata)
+    };
+}
+function emitRoutingInstructionParseLog(log) {
+    if (!log) {
+        return;
+    }
+    const reset = '\x1b[0m';
+    const tagColor = '\x1b[38;5;39m';
+    const scopeColor = '\x1b[38;5;220m';
+    console.log(`${tagColor}[virtual-router][stop_message_parse]${reset} requestId=${log.requestId} marker=${log.markerDetected ? 'detected' : 'missing'} parsed=${log.stopMessageTypes.join(',') || 'none'} preview=${log.preview}`);
+    if (log.scopedTypes.length > 0) {
+        if (log.stopScope) {
+            console.log(`${scopeColor}[virtual-router][stop_scope]${reset} requestId=${log.requestId} stage=apply scope=${log.stopScope} instructions=${log.scopedTypes.join(',')}`);
         }
-        return pools.some((pool) => !pool.backup && Array.isArray(pool.targets) && pool.targets.length > 0);
-    }
-    sortRoutePools(pools) {
-        if (!Array.isArray(pools)) {
-            return [];
+        else {
+            console.log(`${scopeColor}[virtual-router][stop_scope]${reset} requestId=${log.requestId} stage=drop reason=missing_tmux_scope instructions=${log.scopedTypes.join(',')}`);
         }
-        return pools
-            .filter((pool) => Array.isArray(pool.targets) && pool.targets.length > 0)
-            .sort((a, b) => {
-            if (a.backup && !b.backup)
-                return 1;
-            if (!a.backup && b.backup)
-                return -1;
-            if (a.priority !== b.priority) {
-                return b.priority - a.priority;
-            }
-            return a.id.localeCompare(b.id);
-        });
     }
-    flattenPoolTargets(pools) {
-        const flattened = [];
-        if (!Array.isArray(pools)) {
-            return flattened;
-        }
-        for (const pool of pools) {
-            if (!Array.isArray(pool.targets)) {
-                continue;
-            }
-            for (const target of pool.targets) {
-                if (typeof target === 'string' && target && !flattened.includes(target)) {
-                    flattened.push(target);
-                }
+}
+function emitVirtualRouterHitLog(result, options) {
+    const reset = '\x1b[0m';
+    const prefixColor = '\x1b[38;5;208m';
+    const timeColor = '\x1b[90m';
+    const stopColor = '\x1b[38;5;214m';
+    const routeColorMap = {
+        multimodal: '\x1b[38;5;45m',
+        tools: '\x1b[38;5;214m',
+        thinking: '\x1b[34m',
+        coding: '\x1b[35m',
+        longcontext: '\x1b[38;5;141m',
+        web_search: '\x1b[32m',
+        search: '\x1b[38;5;34m',
+        vision: '\x1b[38;5;207m',
+        background: '\x1b[90m'
+    };
+    const now = new Date();
+    const timestamp = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
+    const routeLabel = result.decision.poolId
+        ? `${result.decision.routeName}/${result.decision.poolId}`
+        : result.decision.routeName;
+    const routeColor = routeColorMap[result.decision.routeName] ?? '\x1b[36m';
+    const providerKey = result.decision.providerKey || result.target.providerKey;
+    const modelSuffix = result.target.modelId ? `.${result.target.modelId}` : '';
+    const reason = result.decision.reasoning ? ` reason=${result.decision.reasoning}` : '';
+    const stopStatusLabel = formatStopMessageStatusLabel(options?.stopState ?? null, options?.stopScope, Boolean(options?.forceStopStatusLabel));
+    const requestId = typeof options?.requestId === 'string' ? options.requestId : '';
+    const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
+    console.log(`${prefixColor}[virtual-router-hit]${reset} ${timeColor}${timestamp}${reset}${requestLabel} ${routeColor}${routeLabel} -> ${providerKey}${modelSuffix}${reason}${reset}${stopStatusLabel ? ` ${stopColor}${stopStatusLabel}${reset}` : ''}`);
+}
+function formatStopMessageStatusLabel(snapshot, scope, forceShow) {
+    const scopeLabel = scope && scope.trim() ? scope.trim() : 'none';
+    if (!snapshot) {
+        if (!forceShow) {
+            return '';
+        }
+        return `[stopMessage:scope=${scopeLabel} active=no state=cleared]`;
+    }
+    const text = typeof snapshot.stopMessageText === 'string' ? snapshot.stopMessageText.trim() : '';
+    const safeText = text ? (text.length > 24 ? `${text.slice(0, 21)}...` : text) : '(mode-only)';
+    const mode = (snapshot.stopMessageStageMode || 'unset').toString().toLowerCase();
+    const maxRepeats = typeof snapshot.stopMessageMaxRepeats === 'number' && Number.isFinite(snapshot.stopMessageMaxRepeats)
+        ? Math.max(0, Math.floor(snapshot.stopMessageMaxRepeats))
+        : 0;
+    const used = typeof snapshot.stopMessageUsed === 'number' && Number.isFinite(snapshot.stopMessageUsed)
+        ? Math.max(0, Math.floor(snapshot.stopMessageUsed))
+        : 0;
+    const remaining = maxRepeats > 0 ? Math.max(0, maxRepeats - used) : -1;
+    const active = mode !== 'off' && Boolean(text) && maxRepeats > 0;
+    const rounds = maxRepeats > 0 ? `${used}/${maxRepeats}` : `${used}/-`;
+    const left = remaining >= 0 ? String(remaining) : 'n/a';
+    return `[stopMessage:scope=${scopeLabel} text="${safeText}" mode=${mode} round=${rounds} left=${left} active=${active ? 'yes' : 'no'}]`;
+}
+function cleanRoutingInstructionMarkersInPlace(request) {
+    const cleaned = cleanRoutingInstructionMarkersWithNative(request);
+    if (Array.isArray(cleaned.messages)) {
+        request.messages = cleaned.messages;
+    }
+    const cleanedSemantics = cleaned.semantics;
+    if (cleanedSemantics && typeof cleanedSemantics === 'object' && !Array.isArray(cleanedSemantics)) {
+        const cleanedResponses = cleanedSemantics.responses;
+        if (cleanedResponses && typeof cleanedResponses === 'object' && !Array.isArray(cleanedResponses)) {
+            const cleanedContext = cleanedResponses.context;
+            if (cleanedContext !== undefined) {
+                const semantics = request.semantics && typeof request.semantics === 'object' && !Array.isArray(request.semantics)
+                    ? request.semantics
+                    : {};
+                const responses = semantics.responses && typeof semantics.responses === 'object' && !Array.isArray(semantics.responses)
+                    ? semantics.responses
+                    : {};
+                responses.context = cleanedContext;
+                semantics.responses = responses;
+                request.semantics = semantics;
             }
         }
-        return flattened;
-    }
-    markProviderCooldown(providerKey, cooldownMs) {
-        this.cooldownManager.markProviderCooldown(providerKey, cooldownMs);
-    }
-    clearProviderCooldown(providerKey) {
-        this.cooldownManager.clearProviderCooldown(providerKey);
     }
-    isProviderCoolingDown(providerKey) {
-        return this.cooldownManager.isProviderCoolingDown(providerKey);
-    }
-    getProviderCooldownRemainingMs(providerKey) {
-        if (!providerKey) {
-            return 0;
-        }
-        const expiry = this.providerCooldowns.get(providerKey);
-        if (!expiry || !Number.isFinite(expiry)) {
-            return 0;
+}
+function collectClientScopedInstructions(request) {
+    const messages = Array.isArray(request.messages)
+        ? request.messages
+        : [];
+    const responsesContext = request.semantics && typeof request.semantics === 'object'
+        ? request.semantics.responses?.context
+        : undefined;
+    const responsesHasMarker = hasRoutingInstructionMarkerInResponsesContext(responsesContext);
+    const latestUserHasMarker = hasLatestUserRoutingInstructionMarker(messages) || responsesHasMarker;
+    if (!latestUserHasMarker && !messages.some((message) => {
+        if (!message || typeof message !== 'object') {
+            return false;
         }
-        const remaining = Math.floor(expiry - Date.now());
-        return remaining > 0 ? remaining : 0;
+        const record = message;
+        return record.role === 'user' && typeof record.content === 'string' && ROUTING_INSTRUCTION_MARKER_PATTERN.test(record.content);
+    })) {
+        return { instructions: [], latestUserHasMarker };
     }
-    restoreHealthFromStore() {
-        this.cooldownManager.restoreHealthFromStore();
-    }
-    buildHealthSnapshot() {
-        const providers = this.healthManager.getSnapshot();
-        const cooldownSnapshot = this.cooldownManager.buildHealthSnapshot();
-        return { providers, cooldowns: cooldownSnapshot.cooldowns };
-    }
-    persistHealthSnapshot() {
-        this.cooldownManager.persistHealthSnapshot();
+    let instructions = parseRoutingInstructions(messages);
+    if (instructions.length === 0 && responsesHasMarker) {
+        const responsesLatestUserText = getLatestUserTextFromResponsesContext(responsesContext);
+        if (responsesLatestUserText) {
+            instructions = parseRoutingInstructions([{ role: 'user', content: responsesLatestUserText }]);
+        }
     }
+    return { instructions, latestUserHasMarker };
+}
+function isClientScopedInstruction(instruction) {
+    return (instruction.type === 'stopMessageSet' ||
+        instruction.type === 'stopMessageMode' ||
+        instruction.type === 'stopMessageClear' ||
+        instruction.type === 'preCommandSet' ||
+        instruction.type === 'preCommandClear' ||
+        instruction.type === 'clear');
 }