@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -16,13 +16,24 @@ import { hydrateAntigravityAliasLeaseStoreIfNeeded, recordAntigravitySessionLeas
 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 { validateStopMessageStageTemplatesCompleteness } from './stop-message-stage-template-files.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;
@@ -33,31 +44,52 @@ function normalizeStopMessageStageMode(value) {
     }
     return undefined;
 }
-function resolveStopMessageStageModeAfterInstructions(instructions, currentMode) {
-    let mode = normalizeStopMessageStageMode(currentMode);
-    for (const instruction of instructions) {
-        if (instruction.type === 'stopMessageClear') {
-            mode = undefined;
-            continue;
-        }
-        if (instruction.type === 'stopMessageMode') {
-            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            if (incomingMode) {
-                mode = incomingMode;
-            }
-            continue;
-        }
-        if (instruction.type === 'stopMessageSet') {
-            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            if (incomingMode) {
-                mode = incomingMode;
-            }
-            else if (mode === 'off') {
-                mode = 'on';
-            }
-        }
+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 mode;
+    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) {
@@ -68,7 +100,7 @@ function hasRoutingInstructionMarker(messages) {
         if (!content) {
             continue;
         }
-        if (/<\*\*[^*]+\*\*>/.test(content)) {
+        if (/<\*\*[\s\S]*?\*\*>/.test(content)) {
             return true;
         }
     }
@@ -87,7 +119,7 @@ function hasLatestUserRoutingInstructionMarker(messages) {
         if (!content) {
             return false;
         }
-        return /<\*\*[^*]+\*\*>/.test(content);
+        return /<\*\*[\s\S]*?\*\*>/.test(content);
     }
     return false;
 }
@@ -256,11 +288,11 @@ export class VirtualRouterEngine {
         const stickyKey = this.resolveStickyKey(metadata);
         const sessionScope = this.resolveSessionScope(metadata);
         const stopMessageScope = resolveStopMessageScope(metadata);
-        // Routing instructions should be session/conversation-scoped when available (including /v1/responses),
-        // while auto-sticky for Responses remains request-chain scoped via resolveStickyKey().
+        // 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 = baseState;
+        let routingState = stripStopMessageFields(baseState);
         const metadataInstructions = buildMetadataInstructions(metadata);
         if (metadataInstructions.length > 0) {
             routingState = applyRoutingInstructions(metadataInstructions, routingState);
@@ -283,7 +315,10 @@ export class VirtualRouterEngine {
             }
             if (typeof sessionState.stopMessageText === 'string' ||
                 typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                typeof sessionState.stopMessageStageMode === 'string') {
+                typeof sessionState.stopMessageStageMode === 'string' ||
+                typeof sessionState.stopMessageAiMode === 'string' ||
+                typeof sessionState.stopMessageAiSeedPrompt === 'string' ||
+                Array.isArray(sessionState.stopMessageAiHistory)) {
                 routingState = {
                     ...routingState,
                     stopMessageText: sessionState.stopMessageText,
@@ -291,11 +326,10 @@ export class VirtualRouterEngine {
                     stopMessageUsed: sessionState.stopMessageUsed,
                     stopMessageUpdatedAt: sessionState.stopMessageUpdatedAt,
                     stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt,
-                    stopMessageStage: sessionState.stopMessageStage,
                     stopMessageStageMode: sessionState.stopMessageStageMode,
-                    stopMessageObservationHash: sessionState.stopMessageObservationHash,
-                    stopMessageObservationStableCount: sessionState.stopMessageObservationStableCount,
-                    stopMessageBdWorkState: sessionState.stopMessageBdWorkState
+                    stopMessageAiMode: sessionState.stopMessageAiMode,
+                    stopMessageAiSeedPrompt: sessionState.stopMessageAiSeedPrompt,
+                    stopMessageAiHistory: sessionState.stopMessageAiHistory
                 };
             }
             if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
@@ -308,6 +342,21 @@ export class VirtualRouterEngine {
             }
         }
         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;
@@ -322,205 +371,166 @@ export class VirtualRouterEngine {
             const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
             const hasStaleStopMessageInstruction = !latestUserHasMarker &&
                 parsedInstructions.some((entry) => entry.type === 'stopMessageSet' ||
-                    entry.type === 'stopMessageMode' ||
-                    entry.type === 'stopMessageClear');
+                    entry.type === 'stopMessageMode');
             if (hasStaleStopMessageInstruction) {
                 const hasActiveStopState = typeof sessionState.stopMessageText === 'string' ||
                     typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                    typeof sessionState.stopMessageStageMode === 'string';
+                    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' &&
-                        entry.type !== 'stopMessageClear');
-                }
-            }
-            const hasGlobalClear = instructions.some((entry) => entry.type === 'clear');
-            const hasStopMessageClear = hasGlobalClear || instructions.some((entry) => entry.type === 'stopMessageClear');
-            const stopMessageSets = instructions.filter((entry) => entry.type === 'stopMessageSet');
-            if (!hasStopMessageClear && stopMessageSets.length > 0) {
-                const sessionText = typeof sessionState.stopMessageText === 'string' ? sessionState.stopMessageText.trim() : '';
-                const sessionMax = typeof sessionState.stopMessageMaxRepeats === 'number' && Number.isFinite(sessionState.stopMessageMaxRepeats)
-                    ? Math.floor(sessionState.stopMessageMaxRepeats)
-                    : undefined;
-                const sessionMode = normalizeStopMessageStageMode(sessionState.stopMessageStageMode);
-                const allSame = stopMessageSets.every((entry) => {
-                    const entryText = typeof entry.stopMessageText === 'string' ? entry.stopMessageText.trim() : '';
-                    const entryMax = typeof entry.stopMessageMaxRepeats === 'number' && Number.isFinite(entry.stopMessageMaxRepeats)
-                        ? Math.floor(entry.stopMessageMaxRepeats)
-                        : undefined;
-                    const incomingMode = normalizeStopMessageStageMode(entry.stopMessageStageMode);
-                    const entryMode = incomingMode ?? (sessionMode === 'off' ? 'on' : sessionMode);
-                    return Boolean(entryText) && entryText === sessionText && entryMax === sessionMax && entryMode === sessionMode;
-                });
-                const used = typeof sessionState.stopMessageUsed === 'number' && Number.isFinite(sessionState.stopMessageUsed)
-                    ? Math.max(0, Math.floor(sessionState.stopMessageUsed))
-                    : 0;
-                const hasLastUsedAt = typeof sessionState.stopMessageLastUsedAt === 'number' &&
-                    Number.isFinite(sessionState.stopMessageLastUsedAt);
-                const alreadyArmed = used === 0 && !hasLastUsedAt;
-                if (allSame && alreadyArmed) {
-                    instructions = instructions.filter((entry) => entry.type !== 'stopMessageSet');
+                        entry.type !== 'stopMessageMode');
                 }
             }
         }
-        // stopMessage must be session-scoped: require explicit sessionId in metadata.
-        // This prevents global/default persistence and ensures the trigger matches the setting sessionId.
-        if (instructions.length > 0) {
-            const hasSessionScopedInstruction = instructions.some((entry) => entry.type === 'stopMessageSet' ||
+        // 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');
-            if (hasSessionScopedInstruction && !stopMessageScope) {
-                throw new VirtualRouterError('[stopMessage/precommand] requires sessionId (e.g. set x-session-id header or metadata.sessionId).', VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
-            }
-        }
-        if (stopMessageScope && instructions.length > 0) {
-            const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
-            const nextStopMessageMode = resolveStopMessageStageModeAfterInstructions(instructions, sessionState.stopMessageStageMode);
-            if (nextStopMessageMode === 'on') {
-                const templateCheck = validateStopMessageStageTemplatesCompleteness();
-                if (!templateCheck.ok) {
-                    const detail = templateCheck.missing
-                        .map((entry) => `${entry.stage}:${entry.ref || '(no-ref)'}:${entry.error || 'invalid'}`)
-                        .join('; ');
-                    throw new VirtualRouterError(`[stopMessage] mode=on requires complete stage message files (${detail}).`, VirtualRouterErrorCode.CONFIG_ERROR, { requestId: metadata.requestId, entryEndpoint: metadata.entryEndpoint });
-                }
+                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) {
-            routingState = applyRoutingInstructions(instructions, routingState);
-            this.routingInstructionState.set(stateKey, routingState);
-            persistRoutingInstructionState(stateKey, routingState, this.routingStateStore);
-            // 对 stopMessage 指令补充一份基于 session/conversation 的持久化状态，
-            // 便于 server-side 工具通过 session:*/conversation:* scope 读取到相同配置。
-            // stopMessage is strictly session-scoped (sessionId only). Persist it under the session scope
-            // so servertool triggers always match the setting sessionId.
+            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) {
-                        const clearedAt = Date.now();
-                        nextSessionState.stopMessageText = undefined;
-                        nextSessionState.stopMessageMaxRepeats = undefined;
-                        nextSessionState.stopMessageUsed = undefined;
-                        nextSessionState.stopMessageUpdatedAt = clearedAt;
-                        nextSessionState.stopMessageLastUsedAt = clearedAt;
-                        nextSessionState.stopMessageSource = undefined;
-                        nextSessionState.stopMessageStage = undefined;
-                        nextSessionState.stopMessageStageMode = undefined;
-                        nextSessionState.stopMessageObservationHash = undefined;
-                        nextSessionState.stopMessageObservationStableCount = undefined;
-                        nextSessionState.stopMessageBdWorkState = undefined;
-                        shouldPersistSessionState = true;
-                    }
-                    else if (hasStopMessageSet) {
-                        const text = typeof routingState.stopMessageText === 'string' ? routingState.stopMessageText : '';
-                        const maxRepeats = routingState.stopMessageMaxRepeats;
-                        const sameText = typeof sessionState.stopMessageText === 'string' &&
-                            sessionState.stopMessageText.trim() === text.trim();
-                        const sameMax = typeof sessionState.stopMessageMaxRepeats === 'number' &&
-                            typeof maxRepeats === 'number' &&
-                            Math.floor(sessionState.stopMessageMaxRepeats) === Math.floor(maxRepeats);
-                        const currentMode = normalizeStopMessageStageMode(sessionState.stopMessageStageMode);
-                        const nextMode = normalizeStopMessageStageMode(routingState.stopMessageStageMode) ?? currentMode;
-                        const isSameMode = currentMode === nextMode;
-                        const isSameInstruction = Boolean(text) && sameText && sameMax && isSameMode;
-                        const used = typeof sessionState.stopMessageUsed === 'number' && Number.isFinite(sessionState.stopMessageUsed)
-                            ? Math.max(0, Math.floor(sessionState.stopMessageUsed))
-                            : 0;
-                        const hasLastUsedAt = typeof sessionState.stopMessageLastUsedAt === 'number' &&
-                            Number.isFinite(sessionState.stopMessageLastUsedAt);
-                        const shouldRearm = !isSameInstruction || used > 0 || hasLastUsedAt;
-                        nextSessionState.stopMessageText = text || undefined;
-                        nextSessionState.stopMessageMaxRepeats = maxRepeats;
-                        nextSessionState.stopMessageSource = 'explicit';
-                        nextSessionState.stopMessageStageMode = nextMode;
-                        if (shouldRearm) {
-                            nextSessionState.stopMessageUsed = 0;
-                            nextSessionState.stopMessageUpdatedAt =
-                                typeof routingState.stopMessageUpdatedAt === 'number'
-                                    ? routingState.stopMessageUpdatedAt
-                                    : Date.now();
-                            nextSessionState.stopMessageStage = undefined;
-                            nextSessionState.stopMessageObservationHash = undefined;
-                            nextSessionState.stopMessageObservationStableCount = 0;
-                            nextSessionState.stopMessageBdWorkState = undefined;
-                            nextSessionState.stopMessageLastUsedAt = undefined;
+                        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 if (hasStopMessageMode) {
-                        const mode = normalizeStopMessageStageMode(routingState.stopMessageStageMode);
-                        const modeMaxRepeats = typeof routingState.stopMessageMaxRepeats === 'number' && Number.isFinite(routingState.stopMessageMaxRepeats)
-                            ? Math.floor(routingState.stopMessageMaxRepeats)
-                            : 0;
-                        if (mode === 'off') {
-                            const changed = typeof nextSessionState.stopMessageText === 'string' ||
-                                typeof nextSessionState.stopMessageMaxRepeats === 'number' ||
-                                typeof nextSessionState.stopMessageUsed === 'number' ||
-                                typeof nextSessionState.stopMessageSource === 'string' ||
-                                typeof nextSessionState.stopMessageStage === 'string' ||
-                                typeof nextSessionState.stopMessageObservationHash === 'string' ||
-                                typeof nextSessionState.stopMessageObservationStableCount === 'number' ||
-                                typeof nextSessionState.stopMessageBdWorkState === 'string' ||
-                                normalizeStopMessageStageMode(nextSessionState.stopMessageStageMode) !== 'off';
+                        else {
                             nextSessionState.stopMessageText = undefined;
                             nextSessionState.stopMessageMaxRepeats = undefined;
                             nextSessionState.stopMessageUsed = undefined;
-                            nextSessionState.stopMessageSource = undefined;
-                            nextSessionState.stopMessageStage = undefined;
-                            nextSessionState.stopMessageStageMode = 'off';
-                            nextSessionState.stopMessageObservationHash = undefined;
-                            nextSessionState.stopMessageObservationStableCount = undefined;
-                            nextSessionState.stopMessageBdWorkState = undefined;
-                            nextSessionState.stopMessageUpdatedAt = Date.now();
+                            nextSessionState.stopMessageUpdatedAt = undefined;
                             nextSessionState.stopMessageLastUsedAt = undefined;
-                            shouldPersistSessionState = changed;
-                        }
-                        else if (mode) {
-                            if (normalizeStopMessageStageMode(nextSessionState.stopMessageStageMode) !== mode) {
-                                nextSessionState.stopMessageStageMode = mode;
-                                shouldPersistSessionState = true;
-                            }
-                            const fallbackMaxRepeats = mode === 'on' || mode === 'auto'
-                                ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
-                                : 0;
-                            const normalizedMaxRepeats = modeMaxRepeats > 0 ? modeMaxRepeats : fallbackMaxRepeats;
-                            if (normalizedMaxRepeats > 0 &&
-                                (typeof nextSessionState.stopMessageMaxRepeats !== 'number' ||
-                                    Math.floor(nextSessionState.stopMessageMaxRepeats) !== normalizedMaxRepeats)) {
-                                nextSessionState.stopMessageMaxRepeats = normalizedMaxRepeats;
-                                shouldPersistSessionState = true;
-                            }
-                            // Explicit mode marker from latest user turn should re-arm lifecycle counters,
-                            // even when mode/max are unchanged (e.g. <**stopMessage:on,10**>).
-                            if (mode === 'on' || mode === 'auto') {
-                                nextSessionState.stopMessageUsed = 0;
-                                nextSessionState.stopMessageUpdatedAt = Date.now();
-                                nextSessionState.stopMessageLastUsedAt = undefined;
-                                nextSessionState.stopMessageStage = undefined;
-                                nextSessionState.stopMessageSource = 'explicit';
-                                nextSessionState.stopMessageObservationHash = undefined;
-                                nextSessionState.stopMessageObservationStableCount = 0;
-                                nextSessionState.stopMessageBdWorkState = undefined;
-                                shouldPersistSessionState = true;
-                            }
+                            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);
@@ -531,17 +541,19 @@ export class VirtualRouterEngine {
                     // 日志展示使用 session scope 的 stopMessage 状态，避免每次解析重复刷新时间/次数。
                     if (typeof nextSessionState.stopMessageText === 'string' ||
                         typeof nextSessionState.stopMessageMaxRepeats === 'number' ||
-                        typeof nextSessionState.stopMessageStageMode === 'string') {
+                        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.stopMessageStage = nextSessionState.stopMessageStage;
                         routingState.stopMessageStageMode = nextSessionState.stopMessageStageMode;
-                        routingState.stopMessageObservationHash = nextSessionState.stopMessageObservationHash;
-                        routingState.stopMessageObservationStableCount = nextSessionState.stopMessageObservationStableCount;
-                        routingState.stopMessageBdWorkState = nextSessionState.stopMessageBdWorkState;
+                        routingState.stopMessageAiMode = nextSessionState.stopMessageAiMode;
+                        routingState.stopMessageAiSeedPrompt = nextSessionState.stopMessageAiSeedPrompt;
+                        routingState.stopMessageAiHistory = nextSessionState.stopMessageAiHistory;
                     }
                 }
             }
@@ -565,7 +577,7 @@ export class VirtualRouterEngine {
                     nextSessionState.preCommandUpdatedAt = Date.now();
                 }
                 if (hasPreCommandSet) {
-                    const scriptPath = typeof routingState.preCommandScriptPath === 'string' ? routingState.preCommandScriptPath.trim() : '';
+                    const scriptPath = typeof appliedRoutingState.preCommandScriptPath === 'string' ? appliedRoutingState.preCommandScriptPath.trim() : '';
                     if (scriptPath) {
                         if (sessionState.preCommandScriptPath !== scriptPath) {
                             changed = true;
@@ -573,8 +585,8 @@ export class VirtualRouterEngine {
                         nextSessionState.preCommandScriptPath = scriptPath;
                         nextSessionState.preCommandSource = 'explicit';
                         nextSessionState.preCommandUpdatedAt =
-                            typeof routingState.preCommandUpdatedAt === 'number' && Number.isFinite(routingState.preCommandUpdatedAt)
-                                ? routingState.preCommandUpdatedAt
+                            typeof appliedRoutingState.preCommandUpdatedAt === 'number' && Number.isFinite(appliedRoutingState.preCommandUpdatedAt)
+                                ? appliedRoutingState.preCommandUpdatedAt
                                 : Date.now();
                     }
                 }
@@ -591,17 +603,19 @@ export class VirtualRouterEngine {
             const sessionState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
             if (typeof sessionState.stopMessageText === 'string' ||
                 typeof sessionState.stopMessageMaxRepeats === 'number' ||
-                typeof sessionState.stopMessageStageMode === 'string') {
+                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.stopMessageStage = sessionState.stopMessageStage;
                 routingState.stopMessageStageMode = sessionState.stopMessageStageMode;
-                routingState.stopMessageObservationHash = sessionState.stopMessageObservationHash;
-                routingState.stopMessageObservationStableCount = sessionState.stopMessageObservationStableCount;
-                routingState.stopMessageBdWorkState = sessionState.stopMessageBdWorkState;
+                routingState.stopMessageAiMode = sessionState.stopMessageAiMode;
+                routingState.stopMessageAiSeedPrompt = sessionState.stopMessageAiSeedPrompt;
+                routingState.stopMessageAiHistory = sessionState.stopMessageAiHistory;
             }
             if (typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()) {
                 routingState.preCommandScriptPath = sessionState.preCommandScriptPath;
@@ -922,23 +936,26 @@ export class VirtualRouterEngine {
             const mode = typeof candidate.stopMessageStageMode === 'string'
                 ? candidate.stopMessageStageMode.trim().toLowerCase()
                 : '';
-            const allowModeOnly = !text && maxRepeats > 0 && (mode === 'on' || mode === 'auto');
-            return (Boolean(text) || allowModeOnly) && maxRepeats > 0;
+            if (mode === 'off') {
+                return false;
+            }
+            return Boolean(text) && maxRepeats > 0;
         };
-        const sessionScope = this.resolveSessionScope(metadata);
-        const sessionState = sessionScope
-            ? getRoutingInstructionState(sessionScope, this.routingInstructionState, this.routingStateStore)
-            : null;
-        const stickyKey = this.resolveStickyKey(metadata);
-        const stickyState = stickyKey
-            ? getRoutingInstructionState(stickyKey, this.routingInstructionState, this.routingStateStore)
-            : null;
-        const effectiveState = hasArmedStopState(sessionState)
-            ? sessionState
-            : hasArmedStopState(stickyState)
-                ? stickyState
-                : null;
-        if (!effectiveState) {
+        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() : '';
@@ -952,8 +969,11 @@ export class VirtualRouterEngine {
         const stageModeNormalized = stageModeRaw === 'on' || stageModeRaw === 'off' || stageModeRaw === 'auto'
             ? stageModeRaw
             : undefined;
-        const allowModeOnly = !text && maxRepeats > 0 && (stageModeNormalized === 'on' || stageModeNormalized === 'auto');
-        if ((!text && !allowModeOnly) || maxRepeats <= 0) {
+        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 {
@@ -973,34 +993,23 @@ export class VirtualRouterEngine {
                 Number.isFinite(effectiveState.stopMessageLastUsedAt)
                 ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
                 : {}),
-            ...(typeof effectiveState.stopMessageStage === 'string' && effectiveState.stopMessageStage.trim()
-                ? { stopMessageStage: effectiveState.stopMessageStage.trim() }
-                : {}),
             ...(stageModeNormalized ? { stopMessageStageMode: stageModeNormalized } : {}),
-            ...(typeof effectiveState.stopMessageObservationHash === 'string' && effectiveState.stopMessageObservationHash.trim()
-                ? { stopMessageObservationHash: effectiveState.stopMessageObservationHash.trim() }
+            ...(aiModeNormalized ? { stopMessageAiMode: aiModeNormalized } : {}),
+            ...(typeof effectiveState.stopMessageAiSeedPrompt === 'string' &&
+                effectiveState.stopMessageAiSeedPrompt.trim()
+                ? { stopMessageAiSeedPrompt: effectiveState.stopMessageAiSeedPrompt.trim() }
                 : {}),
-            ...(typeof effectiveState.stopMessageObservationStableCount === 'number' &&
-                Number.isFinite(effectiveState.stopMessageObservationStableCount)
-                ? { stopMessageObservationStableCount: Math.max(0, Math.floor(effectiveState.stopMessageObservationStableCount)) }
+            ...(Array.isArray(effectiveState.stopMessageAiHistory)
+                ? { stopMessageAiHistory: effectiveState.stopMessageAiHistory }
                 : {}),
-            ...(typeof effectiveState.stopMessageBdWorkState === 'string' && effectiveState.stopMessageBdWorkState.trim()
-                ? { stopMessageBdWorkState: effectiveState.stopMessageBdWorkState.trim() }
-                : {})
         };
     }
     getPreCommandState(metadata) {
-        const sessionScope = this.resolveSessionScope(metadata);
-        const sessionState = sessionScope
-            ? getRoutingInstructionState(sessionScope, this.routingInstructionState, this.routingStateStore)
-            : null;
-        const stickyKey = this.resolveStickyKey(metadata);
-        const stickyState = stickyKey
-            ? getRoutingInstructionState(stickyKey, this.routingInstructionState, this.routingStateStore)
-            : null;
-        const effectiveState = sessionState && typeof sessionState.preCommandScriptPath === 'string' && sessionState.preCommandScriptPath.trim()
-            ? sessionState
-            : stickyState;
+        const stopMessageScope = resolveStopMessageScope(metadata);
+        if (!stopMessageScope) {
+            return null;
+        }
+        const effectiveState = getRoutingInstructionState(stopMessageScope, this.routingInstructionState, this.routingStateStore);
         if (!effectiveState) {
             return null;
         }
@@ -1469,7 +1478,7 @@ export class VirtualRouterEngine {
                     baseList.unshift('multimodal');
                 }
             }
-            if (hasVisionTargets) {
+            if (hasVisionTargets && (!hasMultimodalTargets || forceVision)) {
                 if (!baseList.includes('vision')) {
                     baseList.push('vision');
                 }