@jsonstudio/llms 0.6.1739 → 0.6.1749

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

@@ -172,7 +172,11 @@ export class VirtualRouterEngine {
                     stopMessageMaxRepeats: sessionState.stopMessageMaxRepeats,
                     stopMessageUsed: sessionState.stopMessageUsed,
                     stopMessageUpdatedAt: sessionState.stopMessageUpdatedAt,
-                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt
+                    stopMessageLastUsedAt: sessionState.stopMessageLastUsedAt,
+                    stopMessageStage: sessionState.stopMessageStage,
+                    stopMessageObservationHash: sessionState.stopMessageObservationHash,
+                    stopMessageObservationStableCount: sessionState.stopMessageObservationStableCount,
+                    stopMessageBdWorkState: sessionState.stopMessageBdWorkState
                 };
             }
         }
@@ -241,6 +245,10 @@ export class VirtualRouterEngine {
                         nextSessionState.stopMessageUpdatedAt = clearedAt;
                         nextSessionState.stopMessageLastUsedAt = clearedAt;
                         nextSessionState.stopMessageSource = undefined;
+                        nextSessionState.stopMessageStage = undefined;
+                        nextSessionState.stopMessageObservationHash = undefined;
+                        nextSessionState.stopMessageObservationStableCount = undefined;
+                        nextSessionState.stopMessageBdWorkState = undefined;
                         shouldPersistSessionState = true;
                     }
                     else if (hasStopMessageSet) {
@@ -267,6 +275,10 @@ export class VirtualRouterEngine {
                                 typeof routingState.stopMessageUpdatedAt === 'number'
                                     ? routingState.stopMessageUpdatedAt
                                     : Date.now();
+                            nextSessionState.stopMessageStage = undefined;
+                            nextSessionState.stopMessageObservationHash = undefined;
+                            nextSessionState.stopMessageObservationStableCount = 0;
+                            nextSessionState.stopMessageBdWorkState = undefined;
                             nextSessionState.stopMessageLastUsedAt = undefined;
                             shouldPersistSessionState = true;
                         }
@@ -286,6 +298,10 @@ export class VirtualRouterEngine {
                         routingState.stopMessageUsed = nextSessionState.stopMessageUsed;
                         routingState.stopMessageUpdatedAt = nextSessionState.stopMessageUpdatedAt;
                         routingState.stopMessageLastUsedAt = nextSessionState.stopMessageLastUsedAt;
+                        routingState.stopMessageStage = nextSessionState.stopMessageStage;
+                        routingState.stopMessageObservationHash = nextSessionState.stopMessageObservationHash;
+                        routingState.stopMessageObservationStableCount = nextSessionState.stopMessageObservationStableCount;
+                        routingState.stopMessageBdWorkState = nextSessionState.stopMessageBdWorkState;
                     }
                 }
             }
@@ -299,6 +315,10 @@ export class VirtualRouterEngine {
                 routingState.stopMessageUsed = sessionState.stopMessageUsed;
                 routingState.stopMessageUpdatedAt = sessionState.stopMessageUpdatedAt;
                 routingState.stopMessageLastUsedAt = sessionState.stopMessageLastUsedAt;
+                routingState.stopMessageStage = sessionState.stopMessageStage;
+                routingState.stopMessageObservationHash = sessionState.stopMessageObservationHash;
+                routingState.stopMessageObservationStableCount = sessionState.stopMessageObservationStableCount;
+                routingState.stopMessageBdWorkState = sessionState.stopMessageBdWorkState;
             }
         }
         // Guardrail: if a session is restricted to providers that do not exist in any routing pools,
@@ -623,6 +643,19 @@ export class VirtualRouterEngine {
             ...(typeof effectiveState.stopMessageLastUsedAt === 'number' &&
                 Number.isFinite(effectiveState.stopMessageLastUsedAt)
                 ? { stopMessageLastUsedAt: effectiveState.stopMessageLastUsedAt }
+                : {}),
+            ...(typeof effectiveState.stopMessageStage === 'string' && effectiveState.stopMessageStage.trim()
+                ? { stopMessageStage: effectiveState.stopMessageStage.trim() }
+                : {}),
+            ...(typeof effectiveState.stopMessageObservationHash === 'string' && effectiveState.stopMessageObservationHash.trim()
+                ? { stopMessageObservationHash: effectiveState.stopMessageObservationHash.trim() }
+                : {}),
+            ...(typeof effectiveState.stopMessageObservationStableCount === 'number' &&
+                Number.isFinite(effectiveState.stopMessageObservationStableCount)
+                ? { stopMessageObservationStableCount: Math.max(0, Math.floor(effectiveState.stopMessageObservationStableCount)) }
+                : {}),
+            ...(typeof effectiveState.stopMessageBdWorkState === 'string' && effectiveState.stopMessageBdWorkState.trim()
+                ? { stopMessageBdWorkState: effectiveState.stopMessageBdWorkState.trim() }
                 : {})
         };
     }

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

@@ -46,6 +46,10 @@ export interface RoutingInstructionState {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
+    stopMessageStage?: string;
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
 }
 export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
 /**

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

@@ -362,11 +362,16 @@ export function applyRoutingInstructions(instructions, currentState) {
         disabledProviders: new Set(currentState.disabledProviders),
         disabledKeys: new Map(Array.from(currentState.disabledKeys.entries()).map(([k, v]) => [k, new Set(v)])),
         disabledModels: new Map(Array.from(currentState.disabledModels.entries()).map(([k, v]) => [k, new Set(v)])),
+        stopMessageSource: currentState.stopMessageSource,
         stopMessageText: currentState.stopMessageText,
         stopMessageMaxRepeats: currentState.stopMessageMaxRepeats,
         stopMessageUsed: currentState.stopMessageUsed,
         stopMessageUpdatedAt: currentState.stopMessageUpdatedAt,
-        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt
+        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt,
+        stopMessageStage: currentState.stopMessageStage,
+        stopMessageObservationHash: currentState.stopMessageObservationHash,
+        stopMessageObservationStableCount: currentState.stopMessageObservationStableCount,
+        stopMessageBdWorkState: currentState.stopMessageBdWorkState
     };
     let allowReset = false;
     let disableReset = false;
@@ -516,6 +521,10 @@ export function applyRoutingInstructions(instructions, currentState) {
                         newState.stopMessageUsed = 0;
                         newState.stopMessageUpdatedAt = Date.now();
                         newState.stopMessageLastUsedAt = undefined;
+                        newState.stopMessageStage = undefined;
+                        newState.stopMessageObservationHash = undefined;
+                        newState.stopMessageObservationStableCount = 0;
+                        newState.stopMessageBdWorkState = undefined;
                     }
                 }
                 break;
@@ -527,6 +536,10 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.stopMessageSource = undefined;
                 newState.stopMessageUpdatedAt = undefined;
                 newState.stopMessageLastUsedAt = undefined;
+                newState.stopMessageStage = undefined;
+                newState.stopMessageObservationHash = undefined;
+                newState.stopMessageObservationStableCount = undefined;
+                newState.stopMessageBdWorkState = undefined;
                 break;
         }
     }
@@ -586,6 +599,18 @@ export function serializeRoutingInstructionState(state) {
             : {}),
         ...(typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
             ? { stopMessageLastUsedAt: state.stopMessageLastUsedAt }
+            : {}),
+        ...(typeof state.stopMessageStage === 'string' && state.stopMessageStage.trim()
+            ? { stopMessageStage: state.stopMessageStage.trim() }
+            : {}),
+        ...(typeof state.stopMessageObservationHash === 'string' && state.stopMessageObservationHash.trim()
+            ? { stopMessageObservationHash: state.stopMessageObservationHash.trim() }
+            : {}),
+        ...(typeof state.stopMessageObservationStableCount === 'number' && Number.isFinite(state.stopMessageObservationStableCount)
+            ? { stopMessageObservationStableCount: Math.max(0, Math.floor(state.stopMessageObservationStableCount)) }
+            : {}),
+        ...(typeof state.stopMessageBdWorkState === 'string' && state.stopMessageBdWorkState.trim()
+            ? { stopMessageBdWorkState: state.stopMessageBdWorkState.trim() }
             : {})
     };
 }
@@ -599,8 +624,12 @@ export function deserializeRoutingInstructionState(data) {
         disabledKeys: new Map(),
         disabledModels: new Map(),
         stopMessageText: undefined,
+        stopMessageSource: undefined,
         stopMessageMaxRepeats: undefined,
-        stopMessageUsed: undefined
+        stopMessageUsed: undefined,
+        stopMessageStage: undefined,
+        stopMessageObservationHash: undefined,
+        stopMessageBdWorkState: undefined
     };
     if (data.forcedTarget && typeof data.forcedTarget === 'object') {
         state.forcedTarget = data.forcedTarget;
@@ -649,5 +678,17 @@ export function deserializeRoutingInstructionState(data) {
     if (typeof data.stopMessageLastUsedAt === 'number' && Number.isFinite(data.stopMessageLastUsedAt)) {
         state.stopMessageLastUsedAt = data.stopMessageLastUsedAt;
     }
+    if (typeof data.stopMessageStage === 'string' && data.stopMessageStage.trim()) {
+        state.stopMessageStage = data.stopMessageStage.trim();
+    }
+    if (typeof data.stopMessageObservationHash === 'string' && data.stopMessageObservationHash.trim()) {
+        state.stopMessageObservationHash = data.stopMessageObservationHash.trim();
+    }
+    if (typeof data.stopMessageObservationStableCount === 'number' && Number.isFinite(data.stopMessageObservationStableCount)) {
+        state.stopMessageObservationStableCount = Math.max(0, Math.floor(data.stopMessageObservationStableCount));
+    }
+    if (typeof data.stopMessageBdWorkState === 'string' && data.stopMessageBdWorkState.trim()) {
+        state.stopMessageBdWorkState = data.stopMessageBdWorkState.trim();
+    }
     return state;
 }

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' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStage' | 'stopMessageObservationHash' | 'stopMessageObservationStableCount' | 'stopMessageBdWorkState' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
 /**
  * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
  *

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

@@ -41,6 +41,10 @@ export function mergeStopMessageFromPersisted(existing, persisted) {
             stopMessageText: persisted.stopMessageText,
             stopMessageMaxRepeats: persisted.stopMessageMaxRepeats,
             stopMessageUsed: persisted.stopMessageUsed,
+            stopMessageStage: persisted.stopMessageStage,
+            stopMessageObservationHash: persisted.stopMessageObservationHash,
+            stopMessageObservationStableCount: persisted.stopMessageObservationStableCount,
+            stopMessageBdWorkState: persisted.stopMessageBdWorkState,
             stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
             stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
         };

package/dist/router/virtual-router/types.d.ts

@@ -460,6 +460,10 @@ export interface StopMessageStateSnapshot {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
+    stopMessageStage?: string;
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
 }
 export interface RoutingStatusSnapshot {
     routes: Record<string, {

package/dist/servertool/handlers/stop-message-auto.js

@@ -2,6 +2,7 @@ import { registerServerToolHandler } from '../registry.js';
 import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync } from '../../router/virtual-router/sticky-session-store.js';
 import { isCompactionRequest } from './compaction-detect.js';
 import { extractCapturedChatSeed } from './followup-request-builder.js';
+import { resolveStopMessageStageDecision } from './stop-message-stage-policy.js';
 import { readRuntimeMetadata } from '../../conversion/shared/runtime-metadata.js';
 const STOPMESSAGE_DEBUG = (process.env.ROUTECODEX_STOPMESSAGE_DEBUG || '').trim() === '1';
 const STOPMESSAGE_IMPLICIT_GEMINI = (process.env.ROUTECODEX_STOPMESSAGE_IMPLICIT_GEMINI || '').trim() === '1';
@@ -30,16 +31,8 @@ const handler = async (ctx) => {
     const followupFlagRaw = rt?.serverToolFollowup;
     if (followupFlagRaw === true ||
         (typeof followupFlagRaw === 'string' && followupFlagRaw.trim().toLowerCase() === 'true')) {
-        // Allow chained followups only within the stop_message_flow loop itself.
-        // Other servertool followups must not re-trigger stopMessage (prevents cross-flow loops).
-        const loopState = rt?.serverToolLoopState;
-        const flowId = loopState && typeof loopState === 'object' && !Array.isArray(loopState)
-            ? String(loopState.flowId || '').trim()
-            : '';
-        if (flowId !== FLOW_ID) {
-            debugLog('skip_followup_loop');
-            return null;
-        }
+        debugLog('skip_followup_loop');
+        return null;
     }
     if (hasCompactionFlag(rt)) {
         debugLog('skip_compaction_flag');
@@ -68,11 +61,7 @@ const handler = async (ctx) => {
         typeof state.stopMessageSource === 'string' &&
         state.stopMessageSource.trim().toLowerCase() === 'auto' &&
         !STOPMESSAGE_IMPLICIT_GEMINI) {
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageUpdatedAt = undefined;
-        state.stopMessageLastUsedAt = undefined;
+        clearStopMessageState(state, Date.now());
         saveRoutingInstructionStateAsync(stickyKey, state);
         debugLog('skip_auto_state_disabled', { stickyKey });
         return null;
@@ -114,14 +103,7 @@ const handler = async (ctx) => {
             maxRepeats
         });
         // Auto-clear after reaching max repeats to avoid leaving an "exhausted" stopMessage stuck in sticky state.
-        const now = Date.now();
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageSource = undefined;
-        // Keep monotonic timestamps as a tombstone to prevent accidental re-application from replayed history.
-        state.stopMessageUpdatedAt = now;
-        state.stopMessageLastUsedAt = now;
+        clearStopMessageState(state, Date.now());
         saveRoutingInstructionStateAsync(stickyKey, state);
         return null;
     }
@@ -148,6 +130,31 @@ const handler = async (ctx) => {
         debugLog('skip_failed_build_followup', { stickyKey });
         return null;
     }
+    const stageDecision = resolveStopMessageStageDecision({
+        baseText: text,
+        state,
+        capturedMessages: Array.isArray(seed.messages)
+            ? (seed.messages || [])
+            : []
+    });
+    state.stopMessageObservationHash = stageDecision.observationHash;
+    state.stopMessageObservationStableCount = stageDecision.observationStableCount;
+    state.stopMessageBdWorkState = stageDecision.bdWorkState;
+    state.stopMessageStage = stageDecision.stage;
+    if (stageDecision.action === 'stop') {
+        clearStopMessageState(state, Date.now());
+        saveRoutingInstructionStateAsync(stickyKey, state);
+        debugLog('stop_by_stage_policy', {
+            stickyKey,
+            reason: stageDecision.stopReason,
+            observationStableCount: stageDecision.observationStableCount,
+            bdWorkState: stageDecision.bdWorkState
+        });
+        return null;
+    }
+    const followupText = typeof stageDecision.followupText === 'string' && stageDecision.followupText.trim()
+        ? stageDecision.followupText.trim()
+        : text;
     // Extract assistant message for potential followup injection (no-op today; keeps compat).
     void extractAssistantMessageForFollowup(ctx.base);
     // Increment stopMessage usage counter when we decide to trigger followup.
@@ -158,12 +165,7 @@ const handler = async (ctx) => {
     // We still return the followup plan for this trigger, but clear the config
     // so the next response won't trigger again.
     if (nextUsed >= maxRepeats) {
-        const now = Date.now();
-        state.stopMessageText = undefined;
-        state.stopMessageMaxRepeats = undefined;
-        state.stopMessageUsed = undefined;
-        state.stopMessageSource = undefined;
-        state.stopMessageUpdatedAt = now;
+        clearStopMessageState(state, Date.now());
     }
     saveRoutingInstructionStateAsync(stickyKey, state);
     const followupProviderKey = resolveStopMessageFollowupProviderKey({ record, runtimeMetadata: rt });
@@ -179,7 +181,7 @@ const handler = async (ctx) => {
     }
     followupOps.push({ op: 'append_assistant_message', required: false });
     followupOps.push({ op: 'ensure_standard_tools' });
-    followupOps.push({ op: 'append_user_text', text });
+    followupOps.push({ op: 'append_user_text', text: followupText });
     return {
         flowId: FLOW_ID,
         finalize: async () => ({
@@ -437,13 +439,29 @@ function resolveStopMessageSnapshot(raw) {
     const source = typeof record.stopMessageSource === 'string' && record.stopMessageSource.trim()
         ? record.stopMessageSource.trim()
         : undefined;
+    const stage = typeof record.stopMessageStage === 'string' && record.stopMessageStage.trim()
+        ? record.stopMessageStage.trim()
+        : undefined;
+    const observationHash = typeof record.stopMessageObservationHash === 'string' && record.stopMessageObservationHash.trim()
+        ? record.stopMessageObservationHash.trim()
+        : undefined;
+    const observationStableCount = typeof record.stopMessageObservationStableCount === 'number' && Number.isFinite(record.stopMessageObservationStableCount)
+        ? Math.max(0, Math.floor(record.stopMessageObservationStableCount))
+        : undefined;
+    const bdWorkState = typeof record.stopMessageBdWorkState === 'string' && record.stopMessageBdWorkState.trim()
+        ? record.stopMessageBdWorkState.trim()
+        : undefined;
     return {
         text,
         maxRepeats,
         used,
         ...(source ? { source } : {}),
         ...(updatedAt ? { updatedAt } : {}),
-        ...(lastUsedAt ? { lastUsedAt } : {})
+        ...(lastUsedAt ? { lastUsedAt } : {}),
+        ...(stage ? { stage } : {}),
+        ...(observationHash ? { observationHash } : {}),
+        ...(typeof observationStableCount === 'number' ? { observationStableCount } : {}),
+        ...(bdWorkState ? { bdWorkState } : {})
     };
 }
 function hasCompactionFlag(rt) {
@@ -564,9 +582,25 @@ function createStopMessageState(snapshot) {
         stopMessageMaxRepeats: snapshot.maxRepeats,
         stopMessageUsed: snapshot.used,
         stopMessageUpdatedAt: snapshot.updatedAt,
-        stopMessageLastUsedAt: snapshot.lastUsedAt
+        stopMessageLastUsedAt: snapshot.lastUsedAt,
+        stopMessageStage: snapshot.stage,
+        stopMessageObservationHash: snapshot.observationHash,
+        stopMessageObservationStableCount: snapshot.observationStableCount,
+        stopMessageBdWorkState: snapshot.bdWorkState
     };
 }
+function clearStopMessageState(state, now) {
+    state.stopMessageText = undefined;
+    state.stopMessageMaxRepeats = undefined;
+    state.stopMessageUsed = undefined;
+    state.stopMessageSource = undefined;
+    state.stopMessageStage = undefined;
+    state.stopMessageObservationHash = undefined;
+    state.stopMessageObservationStableCount = undefined;
+    state.stopMessageBdWorkState = undefined;
+    state.stopMessageUpdatedAt = now;
+    state.stopMessageLastUsedAt = now;
+}
 function resolveEntryEndpoint(record) {
     const raw = typeof record.entryEndpoint === 'string' && record.entryEndpoint.trim()
         ? record.entryEndpoint.trim()

package/dist/servertool/handlers/stop-message-stage-policy.d.ts

@@ -0,0 +1,22 @@
+export type StopMessageStageName = 'status_probe' | 'active_continue' | 'loop_self_check';
+export type StopMessageBdWorkState = 'active' | 'idle' | 'unknown';
+export interface StopMessageStageStateSnapshot {
+    stopMessageStage?: string;
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
+}
+export interface StopMessageStageDecision {
+    action: 'followup' | 'stop';
+    stage?: StopMessageStageName;
+    followupText?: string;
+    observationHash: string;
+    observationStableCount: number;
+    bdWorkState: StopMessageBdWorkState;
+    stopReason?: 'loop_stable' | 'bd_idle';
+}
+export declare function resolveStopMessageStageDecision(args: {
+    baseText: string;
+    state: StopMessageStageStateSnapshot;
+    capturedMessages: unknown[];
+}): StopMessageStageDecision;

package/dist/servertool/handlers/stop-message-stage-policy.js

@@ -0,0 +1,272 @@
+import { createHash } from 'node:crypto';
+import { resolveStopMessageText } from '../../router/virtual-router/stop-message-file-resolver.js';
+const DEFAULT_STATUS_TEMPLATE = [
+    '先做状态确认再继续执行：',
+    '1) 运行 `bd --no-db ready`，确认是否存在 open/in_progress 任务；',
+    '2) 若有当前任务，继续执行下一步并更新状态；',
+    '3) 若没有可推进任务，直接说明并停止。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_ACTIVE_TEMPLATE = [
+    '检测到当前存在进行中任务（in_progress），必须继续执行，不允许只汇报状态：',
+    '1) 继续当前 in_progress 任务并执行至少一个可验证动作（改代码/跑测试/更新证据）；',
+    '2) 未完成上述动作前，不要输出“已完成/已汇报”类结论；',
+    '3) 完成动作后只汇报结果与下一步。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_LOOP_TEMPLATE = [
+    '检测到可能出现重复循环，请先自检并尝试跳出：',
+    '1) 对比最近两轮是否重复同一命令/同一结论；',
+    '2) 若重复，改用新的有效动作（更具体命令、换验证路径或直接给结论）；',
+    '3) 执行后再观察状态变化；若仍无变化则停止并报告阻塞点。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const STAGE_TEMPLATE_REFS = {
+    status_probe: '<file://stopMessage/stage-status-check.md>',
+    active_continue: '<file://stopMessage/stage-active-continue.md>',
+    loop_self_check: '<file://stopMessage/stage-loop-self-check.md>'
+};
+export function resolveStopMessageStageDecision(args) {
+    const templates = resolveStageTemplates();
+    const observationHash = buildObservationHash(args.capturedMessages);
+    if (!templates.enabled) {
+        return {
+            action: 'followup',
+            followupText: args.baseText,
+            observationHash,
+            observationStableCount: 0,
+            bdWorkState: 'unknown'
+        };
+    }
+    const previousHash = normalizeText(args.state.stopMessageObservationHash);
+    const previousStableCount = toSafeInt(args.state.stopMessageObservationStableCount, 0);
+    const stableCount = previousHash && previousHash === observationHash ? previousStableCount + 1 : 0;
+    const bdWorkState = detectBdWorkState(args.capturedMessages);
+    if (bdWorkState === 'idle') {
+        return {
+            action: 'stop',
+            observationHash,
+            observationStableCount: stableCount,
+            bdWorkState,
+            stopReason: 'bd_idle'
+        };
+    }
+    if (stableCount >= 2) {
+        return {
+            action: 'stop',
+            observationHash,
+            observationStableCount: stableCount,
+            bdWorkState,
+            stopReason: 'loop_stable'
+        };
+    }
+    const stage = bdWorkState === 'active'
+        ? 'active_continue'
+        : stableCount <= 0
+            ? 'status_probe'
+            : 'loop_self_check';
+    const stageTemplate = stage === 'status_probe'
+        ? templates.statusProbeTemplate
+        : stage === 'active_continue'
+            ? templates.activeContinueTemplate
+            : templates.loopSelfCheckTemplate;
+    const followupText = buildStageMessage(stageTemplate, args.baseText);
+    return {
+        action: 'followup',
+        stage,
+        followupText,
+        observationHash,
+        observationStableCount: stableCount,
+        bdWorkState
+    };
+}
+function buildStageMessage(template, baseText) {
+    const safeBaseText = baseText.trim();
+    if (!safeBaseText) {
+        return template.trim();
+    }
+    if (template.includes('{{BASE_STOP_MESSAGE}}')) {
+        return template.replaceAll('{{BASE_STOP_MESSAGE}}', safeBaseText).trim();
+    }
+    return `${template.trim()}\n\n原始约束：\n${safeBaseText}`.trim();
+}
+function resolveStageTemplates() {
+    const mode = resolveStageMode();
+    if (mode === 'off') {
+        return {
+            enabled: false,
+            statusProbeTemplate: '',
+            activeContinueTemplate: '',
+            loopSelfCheckTemplate: ''
+        };
+    }
+    const statusProbeTemplate = loadStageTemplate('status_probe');
+    const activeContinueTemplate = loadStageTemplate('active_continue');
+    const loopSelfCheckTemplate = loadStageTemplate('loop_self_check');
+    const hasUserTemplate = Boolean(statusProbeTemplate || activeContinueTemplate || loopSelfCheckTemplate);
+    const enabled = mode === 'on' || hasUserTemplate;
+    if (!enabled) {
+        return {
+            enabled: false,
+            statusProbeTemplate: '',
+            activeContinueTemplate: '',
+            loopSelfCheckTemplate: ''
+        };
+    }
+    return {
+        enabled: true,
+        statusProbeTemplate: statusProbeTemplate || DEFAULT_STATUS_TEMPLATE,
+        activeContinueTemplate: activeContinueTemplate || DEFAULT_ACTIVE_TEMPLATE,
+        loopSelfCheckTemplate: loopSelfCheckTemplate || DEFAULT_LOOP_TEMPLATE
+    };
+}
+function resolveStageMode() {
+    const raw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_MODE).toLowerCase();
+    if (raw === '1' || raw === 'true' || raw === 'on') {
+        return 'on';
+    }
+    if (raw === '0' || raw === 'false' || raw === 'off') {
+        return 'off';
+    }
+    if (raw === 'auto') {
+        return 'auto';
+    }
+    return 'on';
+}
+function loadStageTemplate(stage) {
+    const envRef = stage === 'status_probe'
+        ? normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_STATUS_REF)
+        : stage === 'active_continue'
+            ? normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_ACTIVE_REF)
+            : normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_LOOP_REF);
+    const ref = envRef || STAGE_TEMPLATE_REFS[stage];
+    if (!ref) {
+        return null;
+    }
+    try {
+        const resolved = resolveStopMessageText(ref);
+        return normalizeText(resolved) || null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectBdWorkState(messages) {
+    const normalizedTail = messages
+        .slice(-30)
+        .map((message) => normalizeMessageForHeuristics(message))
+        .filter(Boolean)
+        .join('\n')
+        .toLowerCase();
+    if (!normalizedTail.includes('bd')) {
+        return 'unknown';
+    }
+    const idlePatterns = [
+        /\bno\s+(ready|open|in_progress)\b/i,
+        /\b0\s+(ready|open|in_progress)\b/i,
+        /\bnothing\s+(to\s+do|ready|in\s+progress)\b/i,
+        /\ball\s+(tasks?|issues?)\s+(done|closed)\b/i,
+        /没有可(做|推进)任务/i,
+        /无\s*(ready|open|in_progress)\s*任务/i
+    ];
+    if (idlePatterns.some((pattern) => pattern.test(normalizedTail))) {
+        return 'idle';
+    }
+    const activePatterns = [
+        /\bin_progress\b/i,
+        /\bready\b/i,
+        /\bblocked\b/i,
+        /\bopen\b/i,
+        /\bepic status\b/i,
+        /\bshow\s+[a-z0-9._-]+\b/i
+    ];
+    if (activePatterns.some((pattern) => pattern.test(normalizedTail))) {
+        return 'active';
+    }
+    return 'unknown';
+}
+function buildObservationHash(messages) {
+    const tail = messages
+        .slice(-20)
+        .map((message) => normalizeMessageForHash(message))
+        .filter(Boolean)
+        .join('\n');
+    if (!tail) {
+        return 'empty';
+    }
+    return createHash('sha1').update(tail).digest('hex').slice(0, 16);
+}
+function normalizeMessageForHash(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    const role = normalizeText(record.role).toLowerCase() || 'unknown';
+    const text = extractMessageText(record.content || record.output || record.input || '');
+    if (!text) {
+        return role;
+    }
+    return `${role}:${text.slice(0, 400)}`;
+}
+function normalizeMessageForHeuristics(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    const role = normalizeText(record.role).toLowerCase();
+    const text = extractMessageText(record.content || record.output || record.input || '');
+    return `${role}:${text}`.trim();
+}
+function extractMessageText(value) {
+    if (typeof value === 'string') {
+        return normalizeWhitespace(value);
+    }
+    if (Array.isArray(value)) {
+        const chunks = [];
+        for (const entry of value) {
+            const text = extractMessageText(entry);
+            if (text) {
+                chunks.push(text);
+            }
+        }
+        return normalizeWhitespace(chunks.join('\n'));
+    }
+    if (!value || typeof value !== 'object') {
+        return '';
+    }
+    const record = value;
+    const candidates = [
+        record.text,
+        record.content,
+        record.output_text,
+        record.input_text,
+        record.arguments,
+        record.name,
+        record.result,
+        record.stdout,
+        record.stderr
+    ];
+    const chunks = [];
+    for (const candidate of candidates) {
+        const text = extractMessageText(candidate);
+        if (text) {
+            chunks.push(text);
+        }
+    }
+    return normalizeWhitespace(chunks.join('\n'));
+}
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function toSafeInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.floor(value));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.1739",
+  "version": "0.6.1749",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",