@jsonstudio/llms 0.6.1892 → 0.6.2172

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

@@ -1,4 +1,4 @@
-import { detectExtendedThinkingKeyword, detectImageAttachment, detectKeyword, extractMessageText, getLatestMessageRole, getLatestUserMessage } from './message-utils.js';
+import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
 import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
@@ -18,10 +18,14 @@ export function buildRoutingFeatures(request, metadata) {
             return undefined;
         }
     })();
-    const latestUserMessage = getLatestUserMessage(request.messages);
     const latestMessageRole = getLatestMessageRole(request.messages);
+    const latestMessage = Array.isArray(request.messages) && request.messages.length
+        ? request.messages[request.messages.length - 1]
+        : undefined;
     const assistantMessages = request.messages.filter((msg) => msg.role === 'assistant');
-    const latestUserText = latestUserMessage ? extractMessageText(latestUserMessage) : '';
+    const latestUserText = latestMessageRole === 'user' && latestMessage
+        ? extractMessageText(latestMessage)
+        : '';
     const normalizedUserText = latestUserText.toLowerCase();
     const meaningfulDeclaredTools = extractMeaningfulDeclaredToolNames(request.tools);
     const hasTools = meaningfulDeclaredTools.length > 0;
@@ -31,7 +35,8 @@ export function buildRoutingFeatures(request, metadata) {
     const hasVisionTool = detectVisionTool(request);
     // Vision routing must only trigger for the current user turn (latest message),
     // not for historical user messages carrying images during tool/assistant followups.
-    const hasImageAttachment = latestMessageRole === 'user' && detectImageAttachment(latestUserMessage);
+    const mediaSignals = latestMessageRole === 'user' ? analyzeMediaAttachments(latestMessage) : analyzeMediaAttachments(undefined);
+    const hasImageAttachment = mediaSignals.hasAnyMedia;
     const hasCodingTool = detectCodingTool(request);
     const hasWebTool = detectWebTool(request);
     const hasThinkingKeyword = hasThinking || detectExtendedThinkingKeyword(normalizedUserText);
@@ -58,6 +63,9 @@ export function buildRoutingFeatures(request, metadata) {
         hasToolCallResponses,
         hasVisionTool,
         hasImageAttachment,
+        hasVideoAttachment: mediaSignals.hasVideo,
+        hasRemoteVideoAttachment: mediaSignals.hasRemoteVideo,
+        hasLocalVideoAttachment: mediaSignals.hasLocalVideo,
         hasWebTool,
         hasWebSearchToolDeclared: detectWebSearchToolDeclared(request),
         hasCodingTool,

package/dist/router/virtual-router/message-utils.d.ts

@@ -4,4 +4,12 @@ export declare function getLatestMessageRole(messages: StandardizedMessage[]): s
 export declare function extractMessageText(message: StandardizedMessage): string;
 export declare function detectKeyword(text: string, keywords: string[]): boolean;
 export declare function detectExtendedThinkingKeyword(text: string): boolean;
+export interface MediaAttachmentSignals {
+    hasAnyMedia: boolean;
+    hasImage: boolean;
+    hasVideo: boolean;
+    hasRemoteVideo: boolean;
+    hasLocalVideo: boolean;
+}
+export declare function analyzeMediaAttachments(message: StandardizedMessage | undefined): MediaAttachmentSignals;
 export declare function detectImageAttachment(message: StandardizedMessage | undefined): boolean;

package/dist/router/virtual-router/message-utils.js

@@ -1,3 +1,4 @@
+import { isIP } from 'node:net';
 export function getLatestUserMessage(messages) {
     for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
         if (messages[idx]?.role === 'user') {
@@ -56,55 +57,179 @@ export function detectExtendedThinkingKeyword(text) {
     const keywords = ['仔细分析', '思考', '超级思考', '深度思考', 'careful analysis', 'deep thinking', 'deliberate'];
     return keywords.some((keyword) => text.includes(keyword));
 }
-export function detectImageAttachment(message) {
-    if (!message)
+const LOCAL_URL_SCHEMES = ['data:', 'file:', 'blob:'];
+function extractMediaUrlCandidate(record) {
+    if (typeof record.image_url === 'string') {
+        return record.image_url ?? '';
+    }
+    if (typeof record.video_url === 'string') {
+        return record.video_url ?? '';
+    }
+    if (record.image_url &&
+        typeof record.image_url?.url === 'string') {
+        return record.image_url?.url ?? '';
+    }
+    if (record.video_url &&
+        typeof record.video_url?.url === 'string') {
+        return record.video_url?.url ?? '';
+    }
+    if (typeof record.url === 'string') {
+        return record.url ?? '';
+    }
+    if (typeof record.uri === 'string') {
+        return record.uri ?? '';
+    }
+    if (typeof record.data === 'string') {
+        return record.data ?? '';
+    }
+    return '';
+}
+function resolveMediaKind(typeValue, record) {
+    if (typeValue.includes('video')) {
+        return 'video';
+    }
+    if (typeValue.includes('image')) {
+        return 'image';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'video_url')) {
+        return 'video';
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'image_url')) {
+        return 'image';
+    }
+    return null;
+}
+function isPrivateHost(host) {
+    const normalized = host.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (normalized === 'localhost' || normalized.endsWith('.local')) {
+        return true;
+    }
+    const ipType = isIP(normalized);
+    if (ipType === 4) {
+        const octets = normalized.split('.').map((part) => Number.parseInt(part, 10));
+        if (octets.length !== 4 || octets.some((value) => !Number.isFinite(value))) {
+            return true;
+        }
+        if (octets[0] === 10)
+            return true;
+        if (octets[0] === 127)
+            return true;
+        if (octets[0] === 0)
+            return true;
+        if (octets[0] === 169 && octets[1] === 254)
+            return true;
+        if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31)
+            return true;
+        if (octets[0] === 192 && octets[1] === 168)
+            return true;
         return false;
-    // 仅基于标准 Chat 语义判断是否携带视觉媒体（图片/视频）：
-    // - content 为数组时查找 { type: 'image' | 'image_url' | 'input_image' | 'video' | 'video_url' | 'input_video', ... } 块；
-    // - 不再依赖 metadata.attachments，也不再用纯文本关键字或剪贴板标记作为信号。
-    if (Array.isArray(message.content)) {
-        for (const part of message.content) {
-            if (!part || typeof part !== 'object') {
-                continue;
-            }
-            const record = part;
-            const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
-            // For chat/standardized content, media may appear as:
-            // - { type: "image_url", image_url: { url } }
-            // - { type: "image", uri: "...", data: "...", url: "..." }
-            // - { type: "input_image", image_url: "data:..." }
-            // - { type: "video_url", video_url: { url } }
-            // - { type: "video", uri: "...", data: "...", url: "..." }
-            // - { type: "input_video", video_url: "data:..." }
-            // Treat any non-empty URL/URI/data on a media-* block as a signal.
-            let imageCandidate = '';
-            if (typeof record.image_url === 'string') {
-                imageCandidate = record.image_url ?? '';
-            }
-            else if (typeof record.video_url === 'string') {
-                imageCandidate = record.video_url ?? '';
-            }
-            else if (record.image_url &&
-                typeof record.image_url?.url === 'string') {
-                imageCandidate = record.image_url?.url ?? '';
-            }
-            else if (record.video_url &&
-                typeof record.video_url?.url === 'string') {
-                imageCandidate = record.video_url?.url ?? '';
-            }
-            else if (typeof record.url === 'string') {
-                imageCandidate = record.url ?? '';
-            }
-            else if (typeof record.uri === 'string') {
-                imageCandidate = record.uri ?? '';
+    }
+    if (ipType === 6) {
+        if (normalized === '::1')
+            return true;
+        if (normalized.startsWith('fc') || normalized.startsWith('fd'))
+            return true;
+        if (normalized.startsWith('fe80:'))
+            return true;
+        return false;
+    }
+    return false;
+}
+function isRemotePublicHttpUrl(raw) {
+    const value = raw.trim();
+    if (!value) {
+        return false;
+    }
+    const lowered = value.toLowerCase();
+    if (LOCAL_URL_SCHEMES.some((prefix) => lowered.startsWith(prefix))) {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return false;
+    }
+    return !isPrivateHost(parsed.hostname);
+}
+export function analyzeMediaAttachments(message) {
+    const result = {
+        hasAnyMedia: false,
+        hasImage: false,
+        hasVideo: false,
+        hasRemoteVideo: false,
+        hasLocalVideo: false
+    };
+    if (!message) {
+        return result;
+    }
+    if (typeof message.content === 'string' && message.content.trim()) {
+        const raw = message.content;
+        const hasImageBlock = /"type"\s*:\s*"(?:input_)?image(?:_url)?"/iu.test(raw);
+        const hasVideoBlock = /"type"\s*:\s*"(?:input_)?video(?:_url)?"/iu.test(raw);
+        const hasDataVideo = /data:video\//iu.test(raw);
+        const hasRemoteVideo = /https?:\/\/[^\s"'\\]+/iu.test(raw);
+        if (hasImageBlock || hasVideoBlock) {
+            result.hasAnyMedia = true;
+        }
+        if (hasImageBlock) {
+            result.hasImage = true;
+        }
+        if (hasVideoBlock) {
+            result.hasVideo = true;
+            if (hasDataVideo) {
+                result.hasLocalVideo = true;
             }
-            else if (typeof record.data === 'string') {
-                imageCandidate = record.data ?? '';
+            if (hasRemoteVideo) {
+                result.hasRemoteVideo = true;
             }
-            if ((typeValue.includes('image') || typeValue.includes('video')) && imageCandidate.trim().length > 0) {
-                return true;
+            if (!hasDataVideo && !hasRemoteVideo) {
+                result.hasLocalVideo = true;
             }
         }
+        if (result.hasAnyMedia) {
+            return result;
+        }
     }
-    return false;
+    if (!Array.isArray(message.content)) {
+        return result;
+    }
+    for (const part of message.content) {
+        if (!part || typeof part !== 'object') {
+            continue;
+        }
+        const record = part;
+        const typeValue = typeof record.type === 'string' ? record.type.toLowerCase() : '';
+        const mediaKind = resolveMediaKind(typeValue, record);
+        if (!mediaKind) {
+            continue;
+        }
+        const mediaUrl = extractMediaUrlCandidate(record).trim();
+        if (!mediaUrl) {
+            continue;
+        }
+        result.hasAnyMedia = true;
+        if (mediaKind === 'image') {
+            result.hasImage = true;
+            continue;
+        }
+        result.hasVideo = true;
+        if (isRemotePublicHttpUrl(mediaUrl)) {
+            result.hasRemoteVideo = true;
+        }
+        else {
+            result.hasLocalVideo = true;
+        }
+    }
+    return result;
+}
+export function detectImageAttachment(message) {
+    return analyzeMediaAttachments(message).hasAnyMedia;
 }

package/dist/router/virtual-router/pre-command-file-resolver.js

@@ -1,6 +1,14 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import os from 'node:os';
+const DEFAULT_PRECOMMAND_SCRIPT = 'default.sh';
+const DEFAULT_PRECOMMAND_SCRIPT_CONTENT = [
+    '#!/usr/bin/env bash',
+    '# RouteCodex default precommand hook (no-op).',
+    '# You can edit this file to customize precommand behavior.',
+    'exit 0',
+    ''
+].join('\n');
 function resolveRoutecodexUserDir() {
     const override = process.env.ROUTECODEX_USER_DIR;
     if (override && override.trim()) {
@@ -62,14 +70,44 @@ export function resolvePreCommandScriptPath(raw) {
         stat = fs.statSync(abs);
     }
     catch (err) {
-        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
-        throw new Error(`precommand: cannot stat ${abs}: ${message}`);
+        if (shouldAutoCreateDefaultScript(relToPreCommand, err)) {
+            tryCreateDefaultPreCommandScript(base, abs);
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch (retryErr) {
+                const retryMessage = retryErr && typeof retryErr.message === 'string' ? retryErr.message : String(retryErr || 'unknown error');
+                throw new Error(`precommand: cannot stat ${abs}: ${retryMessage}`);
+            }
+        }
+        else {
+            const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+            throw new Error(`precommand: cannot stat ${abs}: ${message}`);
+        }
     }
     if (!stat.isFile()) {
         throw new Error(`precommand: not a file: ${abs}`);
     }
     return abs;
 }
+function shouldAutoCreateDefaultScript(relToPreCommand, err) {
+    const code = err?.code;
+    if (code !== 'ENOENT') {
+        return false;
+    }
+    return relToPreCommand === DEFAULT_PRECOMMAND_SCRIPT;
+}
+function tryCreateDefaultPreCommandScript(baseDir, scriptPath) {
+    try {
+        fs.mkdirSync(baseDir, { recursive: true });
+        if (!fs.existsSync(scriptPath)) {
+            fs.writeFileSync(scriptPath, DEFAULT_PRECOMMAND_SCRIPT_CONTENT, { encoding: 'utf8', mode: 0o755 });
+        }
+    }
+    catch {
+        // Keep original resolver contract: caller gets a stat error on failure.
+    }
+}
 export function isPreCommandScriptPathAllowed(rawPath) {
     const scriptPath = typeof rawPath === 'string' ? rawPath.trim() : '';
     if (!scriptPath) {

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -10,6 +10,11 @@ export interface RoutingInstruction {
     stopMessageText?: string;
     stopMessageMaxRepeats?: number;
     stopMessageStageMode?: 'on' | 'off' | 'auto';
+    /**
+     * True when the instruction is parsed from an older user message
+     * (not the latest user turn in current request).
+     */
+    fromHistoricalUserMessage?: boolean;
     preCommandScriptPath?: string;
 }
 export interface RoutingInstructionState {
@@ -57,6 +62,9 @@ export interface RoutingInstructionState {
     stopMessageObservationHash?: string;
     stopMessageObservationStableCount?: number;
     stopMessageBdWorkState?: string;
+    stopMessageAssignedIssueId?: string;
+    stopMessageAssignedIssueSource?: 'in_progress' | 'ready' | 'open';
+    stopMessageNoTaskSummaryUsed?: boolean;
     preCommandSource?: string;
     preCommandScriptPath?: string;
     preCommandUpdatedAt?: number;

package/dist/router/virtual-router/routing-instructions.js

@@ -50,14 +50,23 @@ export function parseRoutingInstructions(messages) {
         for (const segment of segments) {
             const parsed = parseSingleInstruction(segment);
             if (parsed) {
+                const fromHistoricalUserMessage = lastUserIndex >= 0 &&
+                    sanitizedIndex >= 0 &&
+                    sanitizedIndex !== lastUserIndex;
+                const normalizedParsed = fromHistoricalUserMessage &&
+                    (parsed.type === 'stopMessageSet' ||
+                        parsed.type === 'stopMessageMode' ||
+                        parsed.type === 'stopMessageClear')
+                    ? { ...parsed, fromHistoricalUserMessage: true }
+                    : parsed;
                 // preCommand 是强副作用命令（执行本地脚本），仅允许从 latest user message 生效。
-                if ((parsed.type === 'preCommandSet' || parsed.type === 'preCommandClear') &&
+                if ((normalizedParsed.type === 'preCommandSet' || normalizedParsed.type === 'preCommandClear') &&
                     lastUserIndex >= 0 &&
                     sanitizedIndex >= 0 &&
                     sanitizedIndex !== lastUserIndex) {
                     continue;
                 }
-                instructions.push(parsed);
+                instructions.push(normalizedParsed);
             }
         }
     }
@@ -371,6 +380,9 @@ export function applyRoutingInstructions(instructions, currentState) {
         stopMessageObservationHash: currentState.stopMessageObservationHash,
         stopMessageObservationStableCount: currentState.stopMessageObservationStableCount,
         stopMessageBdWorkState: currentState.stopMessageBdWorkState,
+        stopMessageAssignedIssueId: currentState.stopMessageAssignedIssueId,
+        stopMessageAssignedIssueSource: currentState.stopMessageAssignedIssueSource,
+        stopMessageNoTaskSummaryUsed: currentState.stopMessageNoTaskSummaryUsed,
         preCommandSource: currentState.preCommandSource,
         preCommandScriptPath: currentState.preCommandScriptPath,
         preCommandUpdatedAt: currentState.preCommandUpdatedAt
@@ -500,6 +512,7 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.disabledProviders.clear();
                 newState.disabledKeys.clear();
                 newState.disabledModels.clear();
+                applyStopMessageInstructionToState({ type: 'stopMessageClear' }, newState);
                 clearPreCommandState(newState);
                 break;
             case 'stopMessageSet':
@@ -573,6 +586,9 @@ export function deserializeRoutingInstructionState(data) {
         stopMessageStageMode: undefined,
         stopMessageObservationHash: undefined,
         stopMessageBdWorkState: undefined,
+        stopMessageAssignedIssueId: undefined,
+        stopMessageAssignedIssueSource: undefined,
+        stopMessageNoTaskSummaryUsed: undefined,
         preCommandSource: undefined,
         preCommandScriptPath: undefined,
         preCommandUpdatedAt: undefined

package/dist/router/virtual-router/routing-stop-message-actions.js

@@ -1,4 +1,4 @@
-import { normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+import { DEFAULT_STOP_MESSAGE_MAX_REPEATS, ensureStopMessageModeMaxRepeats, normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
 export function applyStopMessageInstructionToState(instruction, state) {
     switch (instruction.type) {
         case 'stopMessageSet': {
@@ -24,13 +24,16 @@ export function applyStopMessageInstructionToState(instruction, state) {
                 : 0;
             const hasLastUsedAt = typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt);
             const shouldRearm = !isSameInstruction || used > 0 || hasLastUsedAt;
+            const shouldRearmForSource = instruction.fromHistoricalUserMessage
+                ? !isSameInstruction
+                : shouldRearm;
             state.stopMessageText = text;
             state.stopMessageMaxRepeats = maxRepeats;
             state.stopMessageSource = 'explicit';
             if (targetMode) {
                 state.stopMessageStageMode = targetMode;
             }
-            if (shouldRearm) {
+            if (shouldRearmForSource) {
                 resetStopMessageRuntimeState(state, Date.now());
             }
             return true;
@@ -40,9 +43,9 @@ export function applyStopMessageInstructionToState(instruction, state) {
             if (!mode) {
                 return true;
             }
-            const maxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
+            const explicitMaxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
                 ? Math.floor(instruction.stopMessageMaxRepeats)
-                : 0;
+                : undefined;
             if (mode === 'off') {
                 clearStopMessageState(state, { keepMode: 'off' });
                 return true;
@@ -50,17 +53,32 @@ export function applyStopMessageInstructionToState(instruction, state) {
             const previousMode = normalizeStopMessageStageMode(state.stopMessageStageMode);
             const previousMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
                 ? Math.floor(state.stopMessageMaxRepeats)
-                : 0;
+                : undefined;
+            const preservedMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+                ? Math.floor(state.stopMessageMaxRepeats)
+                : undefined;
+            const resolvedMax = typeof explicitMaxRepeats === 'number' && explicitMaxRepeats > 0
+                ? explicitMaxRepeats
+                : typeof preservedMax === 'number' && preservedMax > 0
+                    ? preservedMax
+                    : mode === 'on' || mode === 'auto'
+                        ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
+                        : undefined;
             state.stopMessageStageMode = mode;
             state.stopMessageSource = 'explicit';
-            if (maxRepeats > 0) {
-                state.stopMessageMaxRepeats = maxRepeats;
-            }
+            state.stopMessageMaxRepeats = resolvedMax;
+            ensureStopMessageModeMaxRepeats(state);
+            const nextMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
+                ? Math.floor(state.stopMessageMaxRepeats)
+                : undefined;
             const shouldRearm = previousMode !== mode ||
-                (maxRepeats > 0 && previousMax !== maxRepeats) ||
+                previousMax !== nextMax ||
                 typeof state.stopMessageUsed !== 'number' ||
                 !Number.isFinite(state.stopMessageUsed);
-            if (shouldRearm) {
+            const shouldRearmForSource = instruction.fromHistoricalUserMessage
+                ? (previousMode !== mode || previousMax !== nextMax || typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed))
+                : shouldRearm;
+            if (shouldRearmForSource) {
                 resetStopMessageRuntimeState(state, Date.now());
             }
             return true;
@@ -80,6 +98,9 @@ function resetStopMessageRuntimeState(state, atMs) {
     state.stopMessageObservationHash = undefined;
     state.stopMessageObservationStableCount = 0;
     state.stopMessageBdWorkState = undefined;
+    state.stopMessageAssignedIssueId = undefined;
+    state.stopMessageAssignedIssueSource = undefined;
+    state.stopMessageNoTaskSummaryUsed = undefined;
 }
 function clearStopMessageState(state, options) {
     state.stopMessageText = undefined;
@@ -93,4 +114,7 @@ function clearStopMessageState(state, options) {
     state.stopMessageObservationHash = undefined;
     state.stopMessageObservationStableCount = undefined;
     state.stopMessageBdWorkState = undefined;
+    state.stopMessageAssignedIssueId = undefined;
+    state.stopMessageAssignedIssueSource = undefined;
+    state.stopMessageNoTaskSummaryUsed = undefined;
 }

package/dist/router/virtual-router/routing-stop-message-state-codec.d.ts

@@ -1,4 +1,6 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
+export declare const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export declare function serializeStopMessageState(state: RoutingInstructionState): Record<string, unknown>;
 export declare function deserializeStopMessageState(data: Record<string, unknown>, state: RoutingInstructionState): void;
 export declare function normalizeStopMessageStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;
+export declare function ensureStopMessageModeMaxRepeats(state: RoutingInstructionState): boolean;

package/dist/router/virtual-router/routing-stop-message-state-codec.js

@@ -1,3 +1,4 @@
+export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export function serializeStopMessageState(state) {
     return {
         ...(typeof state.stopMessageSource === 'string' && state.stopMessageSource.trim()
@@ -32,6 +33,18 @@ export function serializeStopMessageState(state) {
             : {}),
         ...(typeof state.stopMessageBdWorkState === 'string' && state.stopMessageBdWorkState.trim()
             ? { stopMessageBdWorkState: state.stopMessageBdWorkState.trim() }
+            : {}),
+        ...(typeof state.stopMessageAssignedIssueId === 'string' && state.stopMessageAssignedIssueId.trim()
+            ? { stopMessageAssignedIssueId: state.stopMessageAssignedIssueId.trim() }
+            : {}),
+        ...(typeof state.stopMessageAssignedIssueSource === 'string' &&
+            (state.stopMessageAssignedIssueSource === 'in_progress' ||
+                state.stopMessageAssignedIssueSource === 'ready' ||
+                state.stopMessageAssignedIssueSource === 'open')
+            ? { stopMessageAssignedIssueSource: state.stopMessageAssignedIssueSource }
+            : {}),
+        ...(typeof state.stopMessageNoTaskSummaryUsed === 'boolean'
+            ? { stopMessageNoTaskSummaryUsed: state.stopMessageNoTaskSummaryUsed }
             : {})
     };
 }
@@ -42,7 +55,8 @@ export function deserializeStopMessageState(data, state) {
     if (typeof data.stopMessageText === 'string' && data.stopMessageText.trim()) {
         state.stopMessageText = data.stopMessageText;
     }
-    if (typeof data.stopMessageMaxRepeats === 'number' && Number.isFinite(data.stopMessageMaxRepeats)) {
+    const hasPersistedMaxRepeats = typeof data.stopMessageMaxRepeats === 'number' && Number.isFinite(data.stopMessageMaxRepeats);
+    if (hasPersistedMaxRepeats) {
         state.stopMessageMaxRepeats = Math.floor(data.stopMessageMaxRepeats);
     }
     if (typeof data.stopMessageUsed === 'number' && Number.isFinite(data.stopMessageUsed)) {
@@ -63,6 +77,10 @@ export function deserializeStopMessageState(data, state) {
             state.stopMessageStageMode = normalized;
         }
     }
+    // Keep stopMessage mode state armed consistently across old/new snapshots.
+    if (!hasPersistedMaxRepeats) {
+        ensureStopMessageModeMaxRepeats(state);
+    }
     if (typeof data.stopMessageObservationHash === 'string' && data.stopMessageObservationHash.trim()) {
         state.stopMessageObservationHash = data.stopMessageObservationHash.trim();
     }
@@ -72,6 +90,18 @@ export function deserializeStopMessageState(data, state) {
     if (typeof data.stopMessageBdWorkState === 'string' && data.stopMessageBdWorkState.trim()) {
         state.stopMessageBdWorkState = data.stopMessageBdWorkState.trim();
     }
+    if (typeof data.stopMessageAssignedIssueId === 'string' && data.stopMessageAssignedIssueId.trim()) {
+        state.stopMessageAssignedIssueId = data.stopMessageAssignedIssueId.trim();
+    }
+    if (typeof data.stopMessageAssignedIssueSource === 'string') {
+        const source = data.stopMessageAssignedIssueSource.trim().toLowerCase();
+        if (source === 'in_progress' || source === 'ready' || source === 'open') {
+            state.stopMessageAssignedIssueSource = source;
+        }
+    }
+    if (typeof data.stopMessageNoTaskSummaryUsed === 'boolean') {
+        state.stopMessageNoTaskSummaryUsed = data.stopMessageNoTaskSummaryUsed;
+    }
 }
 export function normalizeStopMessageStageMode(value) {
     if (typeof value !== 'string') {
@@ -83,3 +113,22 @@ export function normalizeStopMessageStageMode(value) {
     }
     return undefined;
 }
+export function ensureStopMessageModeMaxRepeats(state) {
+    const mode = normalizeStopMessageStageMode(state.stopMessageStageMode);
+    if (mode !== 'on' && mode !== 'auto') {
+        return false;
+    }
+    const hasValidRepeats = typeof state.stopMessageMaxRepeats === 'number' &&
+        Number.isFinite(state.stopMessageMaxRepeats) &&
+        Math.floor(state.stopMessageMaxRepeats) > 0;
+    if (hasValidRepeats) {
+        const normalized = Math.floor(state.stopMessageMaxRepeats);
+        if (state.stopMessageMaxRepeats !== normalized) {
+            state.stopMessageMaxRepeats = normalized;
+            return true;
+        }
+        return false;
+    }
+    state.stopMessageMaxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
+    return true;
+}

package/dist/router/virtual-router/stop-message-state-sync.d.ts

@@ -1,5 +1,5 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
-type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStage' | 'stopMessageStageMode' | 'stopMessageObservationHash' | 'stopMessageObservationStableCount' | 'stopMessageBdWorkState' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStage' | 'stopMessageStageMode' | 'stopMessageObservationHash' | 'stopMessageObservationStableCount' | 'stopMessageBdWorkState' | 'stopMessageAssignedIssueId' | 'stopMessageAssignedIssueSource' | 'stopMessageNoTaskSummaryUsed' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
 /**
  * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
  *

package/dist/router/virtual-router/stop-message-state-sync.js

@@ -46,6 +46,9 @@ export function mergeStopMessageFromPersisted(existing, persisted) {
             stopMessageObservationHash: persisted.stopMessageObservationHash,
             stopMessageObservationStableCount: persisted.stopMessageObservationStableCount,
             stopMessageBdWorkState: persisted.stopMessageBdWorkState,
+            stopMessageAssignedIssueId: persisted.stopMessageAssignedIssueId,
+            stopMessageAssignedIssueSource: persisted.stopMessageAssignedIssueSource,
+            stopMessageNoTaskSummaryUsed: persisted.stopMessageNoTaskSummaryUsed,
             stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
             stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
         };