@jsonstudio/llms 0.6.1749 → 0.6.1892

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

@@ -1,22 +1,43 @@
 export type StopMessageStageName = 'status_probe' | 'active_continue' | 'loop_self_check';
 export type StopMessageBdWorkState = 'active' | 'idle' | 'unknown';
+export type StopMessageBdMode = 'auto' | 'runtime' | 'heuristic';
 export interface StopMessageStageStateSnapshot {
     stopMessageStage?: string;
+    stopMessageStageMode?: 'on' | 'off' | 'auto' | string;
     stopMessageObservationHash?: string;
     stopMessageObservationStableCount?: number;
     stopMessageBdWorkState?: string;
 }
+export interface StopMessageBdCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+}
+export type StopMessageBdCommandRunner = (args: string[], options: {
+    cwd: string;
+    timeoutMs: number;
+}) => StopMessageBdCommandResult;
 export interface StopMessageStageDecision {
     action: 'followup' | 'stop';
     stage?: StopMessageStageName;
     followupText?: string;
     observationHash: string;
     observationStableCount: number;
+    toolSignatureHash?: string;
     bdWorkState: StopMessageBdWorkState;
-    stopReason?: 'loop_stable' | 'bd_idle';
+    stopReason?: 'loop_stable' | 'bd_idle' | 'mode_off';
 }
 export declare function resolveStopMessageStageDecision(args: {
     baseText: string;
     state: StopMessageStageStateSnapshot;
     capturedMessages: unknown[];
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    nowMs?: number;
 }): StopMessageStageDecision;
+export declare function resolveBdWorkStateFromRuntime(options?: {
+    bdCommandRunner?: StopMessageBdCommandRunner;
+    nowMs?: number;
+    cwd?: string;
+}): StopMessageBdWorkState;
+export declare function resetStopMessageBdRuntimeCacheForTests(): void;

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

@@ -1,18 +1,24 @@
 import { createHash } from 'node:crypto';
-import { resolveStopMessageText } from '../../router/virtual-router/stop-message-file-resolver.js';
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadStopMessageStageTemplate } from '../../router/virtual-router/stop-message-stage-template-files.js';
 const DEFAULT_STATUS_TEMPLATE = [
     '先做状态确认再继续执行：',
-    '1) 运行 `bd --no-db ready`，确认是否存在 open/in_progress 任务；',
-    '2) 若有当前任务，继续执行下一步并更新状态；',
-    '3) 若没有可推进任务，直接说明并停止。',
+    '1) 运行 `bd --no-db ready` 与 `bd --no-db list --status in_progress --json --limit 5`，确认是否有可继续任务；',
+    '2) 若存在 blocked，先分析阻塞原因并制定解决方案；若仅有 in_progress/open，则直接推进可验证动作；',
+    '3) 若 ready 为空，再检查 `bd --no-db list --status blocked --json --limit 5` 与 `bd --no-db epic status`，判断是否仍有未完成工作；',
+    '4) 若仍有未完成工作，优先解 blocked；必要时用 bd update/dep add/create 同步计划后继续执行;',
+    '5) 仅当确认确实无任务可推进时，基于当前上下文判断是否需要 `bd --no-db create` 新任务；不需要才停止。',
     '',
     '{{BASE_STOP_MESSAGE}}'
 ].join('\n');
 const DEFAULT_ACTIVE_TEMPLATE = [
-    '检测到当前存在进行中任务（in_progress），必须继续执行，不允许只汇报状态：',
-    '1) 继续当前 in_progress 任务并执行至少一个可验证动作（改代码/跑测试/更新证据）；',
-    '2) 未完成上述动作前，不要输出“已完成/已汇报”类结论；',
-    '3) 完成动作后只汇报结果与下一步。',
+    '检测到当前仍有任务，按优先级继续执行，不允许只汇报状态：',
+    '1) 先检查是否存在 blocked 任务；若存在，先分析阻塞原因并执行解阻塞动作（补依赖/修配置/拆子任务/补证据）；',
+    '2) 需要调整执行顺序或新增动作时，必须用 bd 更新计划与状态（update/dep add/create），保持可追踪；',
+    '3) 若无 blocked，再继续当前 in_progress/open 任务并执行至少一个可验证动作（改代码/跑测试/更新证据）；',
+    '4) 未完成上述动作前，不要输出“已完成/已汇报”类结论；完成后只汇报结果与下一步。',
     '',
     '{{BASE_STOP_MESSAGE}}'
 ].join('\n');
@@ -24,35 +30,57 @@ const DEFAULT_LOOP_TEMPLATE = [
     '',
     '{{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>'
-};
+let bdRuntimeCache = null;
+const DEFAULT_BD_TIMEOUT_MS = 1200;
+const DEFAULT_BD_CACHE_TTL_MS = 1500;
 export function resolveStopMessageStageDecision(args) {
-    const templates = resolveStageTemplates();
+    const mode = resolveStageMode(args.state.stopMessageStageMode);
     const observationHash = buildObservationHash(args.capturedMessages);
+    const toolSignatureHash = buildToolSignatureHash(args.capturedMessages);
+    if (mode === 'off') {
+        return {
+            action: 'stop',
+            observationHash,
+            observationStableCount: 0,
+            bdWorkState: 'unknown',
+            stopReason: 'mode_off',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
+        };
+    }
+    const templates = resolveStageTemplates(mode);
     if (!templates.enabled) {
         return {
             action: 'followup',
             followupText: args.baseText,
             observationHash,
             observationStableCount: 0,
-            bdWorkState: 'unknown'
+            bdWorkState: 'unknown',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
         };
     }
     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);
+    const bdWorkState = detectBdWorkState(args.capturedMessages, {
+        bdCommandRunner: args.bdCommandRunner,
+        nowMs: args.nowMs
+    });
+    const previousStage = normalizeStageName(args.state.stopMessageStage);
+    const previousBdWorkState = normalizeBdWorkState(args.state.stopMessageBdWorkState);
+    const idleConfirmed = bdWorkState === 'idle' &&
+        previousBdWorkState === 'idle' &&
+        previousStage === 'status_probe';
     if (bdWorkState === 'idle') {
-        return {
-            action: 'stop',
-            observationHash,
-            observationStableCount: stableCount,
-            bdWorkState,
-            stopReason: 'bd_idle'
-        };
+        if (mode !== 'on' || idleConfirmed) {
+            return {
+                action: 'stop',
+                observationHash,
+                observationStableCount: stableCount,
+                bdWorkState,
+                stopReason: 'bd_idle',
+                ...(toolSignatureHash ? { toolSignatureHash } : {})
+            };
+        }
     }
     if (stableCount >= 2) {
         return {
@@ -60,7 +88,8 @@ export function resolveStopMessageStageDecision(args) {
             observationHash,
             observationStableCount: stableCount,
             bdWorkState,
-            stopReason: 'loop_stable'
+            stopReason: 'loop_stable',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
         };
     }
     const stage = bdWorkState === 'active'
@@ -80,29 +109,87 @@ export function resolveStopMessageStageDecision(args) {
         followupText,
         observationHash,
         observationStableCount: stableCount,
-        bdWorkState
+        bdWorkState,
+        ...(toolSignatureHash ? { toolSignatureHash } : {})
     };
 }
+export function resolveBdWorkStateFromRuntime(options) {
+    const mode = resolveBdMode();
+    const nowMs = typeof options?.nowMs === 'number' && Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+    const cwd = resolveBdWorkingDirectory(options?.cwd);
+    const ttlMs = resolveBdCacheTtlMs();
+    if (ttlMs > 0 &&
+        bdRuntimeCache &&
+        bdRuntimeCache.mode === mode &&
+        bdRuntimeCache.cwd === cwd &&
+        bdRuntimeCache.expiresAt > nowMs) {
+        return bdRuntimeCache.state;
+    }
+    const commandRunner = options?.bdCommandRunner ?? runBdCommand;
+    const timeoutMs = resolveBdTimeoutMs();
+    const inProgress = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'in_progress', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (inProgress === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (inProgress === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const ready = runBdQuery(commandRunner, ['--no-db', 'ready', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (ready === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (ready === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const open = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'open', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (open === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (open === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    const blocked = runBdQuery(commandRunner, ['--no-db', 'list', '--status', 'blocked', '--json', '--limit', '1'], {
+        cwd,
+        timeoutMs
+    });
+    if (blocked === 'active') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'active');
+    }
+    if (blocked === 'unknown') {
+        return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'unknown');
+    }
+    return writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, 'idle');
+}
+export function resetStopMessageBdRuntimeCacheForTests() {
+    bdRuntimeCache = null;
+}
 function buildStageMessage(template, baseText) {
     const safeBaseText = baseText.trim();
-    if (!safeBaseText) {
-        return template.trim();
+    const safeTemplate = typeof template === 'string' ? template.trim() : '';
+    if (safeTemplate.includes('{{BASE_STOP_MESSAGE}}')) {
+        const replaced = safeTemplate.replaceAll('{{BASE_STOP_MESSAGE}}', safeBaseText).replace(/\n{3,}/g, '\n\n').trim();
+        if (replaced) {
+            return replaced;
+        }
     }
-    if (template.includes('{{BASE_STOP_MESSAGE}}')) {
-        return template.replaceAll('{{BASE_STOP_MESSAGE}}', safeBaseText).trim();
+    if (!safeTemplate) {
+        return safeBaseText;
     }
-    return `${template.trim()}\n\n原始约束：\n${safeBaseText}`.trim();
-}
-function resolveStageTemplates() {
-    const mode = resolveStageMode();
-    if (mode === 'off') {
-        return {
-            enabled: false,
-            statusProbeTemplate: '',
-            activeContinueTemplate: '',
-            loopSelfCheckTemplate: ''
-        };
+    if (!safeBaseText) {
+        return safeTemplate;
     }
+    return `${safeTemplate}\n\n原始约束：\n${safeBaseText}`.trim();
+}
+function resolveStageTemplates(mode) {
     const statusProbeTemplate = loadStageTemplate('status_probe');
     const activeContinueTemplate = loadStageTemplate('active_continue');
     const loopSelfCheckTemplate = loadStageTemplate('loop_self_check');
@@ -123,7 +210,11 @@ function resolveStageTemplates() {
         loopSelfCheckTemplate: loopSelfCheckTemplate || DEFAULT_LOOP_TEMPLATE
     };
 }
-function resolveStageMode() {
+function resolveStageMode(modeFromState) {
+    const stateMode = normalizeStageMode(modeFromState);
+    if (stateMode) {
+        return stateMode;
+    }
     const raw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_STAGE_MODE).toLowerCase();
     if (raw === '1' || raw === 'true' || raw === 'on') {
         return 'on';
@@ -134,27 +225,29 @@ function resolveStageMode() {
     if (raw === 'auto') {
         return 'auto';
     }
-    return 'on';
+    return 'auto';
 }
 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;
+    const loaded = loadStopMessageStageTemplate(stage);
+    return loaded.text || null;
+}
+function detectBdWorkState(messages, options) {
+    const mode = resolveBdMode();
+    if (mode !== 'heuristic') {
+        const runtimeState = resolveBdWorkStateFromRuntime({
+            bdCommandRunner: options?.bdCommandRunner,
+            nowMs: options?.nowMs
+        });
+        if (runtimeState === 'active' || runtimeState === 'idle') {
+            return runtimeState;
+        }
+        if (mode === 'runtime') {
+            return 'unknown';
+        }
     }
+    return detectBdWorkStateFromHeuristics(messages);
 }
-function detectBdWorkState(messages) {
+function detectBdWorkStateFromHeuristics(messages) {
     const normalizedTail = messages
         .slice(-30)
         .map((message) => normalizeMessageForHeuristics(message))
@@ -188,6 +281,174 @@ function detectBdWorkState(messages) {
     }
     return 'unknown';
 }
+function writeBdRuntimeCacheAndReturn(mode, cwd, nowMs, ttlMs, state) {
+    if (ttlMs > 0) {
+        bdRuntimeCache = {
+            mode,
+            cwd,
+            expiresAt: nowMs + ttlMs,
+            state
+        };
+    }
+    return state;
+}
+function resolveBdMode() {
+    const modeRaw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_MODE).toLowerCase();
+    if (modeRaw === 'runtime' || modeRaw === 'real') {
+        return 'runtime';
+    }
+    if (modeRaw === 'heuristic' || modeRaw === 'text') {
+        return 'heuristic';
+    }
+    const legacyRuntimeRaw = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_RUNTIME).toLowerCase();
+    if (legacyRuntimeRaw === '1' || legacyRuntimeRaw === 'true' || legacyRuntimeRaw === 'on') {
+        return 'runtime';
+    }
+    if (legacyRuntimeRaw === '0' || legacyRuntimeRaw === 'false' || legacyRuntimeRaw === 'off') {
+        return 'heuristic';
+    }
+    return 'auto';
+}
+function resolveBdCacheTtlMs() {
+    const parsed = parseNonNegativeInteger(process.env.ROUTECODEX_STOPMESSAGE_BD_CACHE_TTL_MS);
+    if (typeof parsed === 'number') {
+        return parsed;
+    }
+    return DEFAULT_BD_CACHE_TTL_MS;
+}
+function resolveBdTimeoutMs() {
+    const parsed = parsePositiveInteger(process.env.ROUTECODEX_STOPMESSAGE_BD_TIMEOUT_MS);
+    if (typeof parsed === 'number') {
+        return parsed;
+    }
+    return DEFAULT_BD_TIMEOUT_MS;
+}
+function parseNonNegativeInteger(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function parsePositiveInteger(value) {
+    const parsed = parseNonNegativeInteger(value);
+    if (typeof parsed !== 'number' || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function resolveBdWorkingDirectory(cwdOverride) {
+    const fromOverride = normalizeText(cwdOverride);
+    if (fromOverride) {
+        return path.resolve(fromOverride);
+    }
+    const fromEnv = normalizeText(process.env.ROUTECODEX_STOPMESSAGE_BD_WORKDIR);
+    if (fromEnv) {
+        return path.resolve(fromEnv);
+    }
+    const current = process.cwd();
+    return findBdProjectRoot(current) || current;
+}
+function findBdProjectRoot(startDirectory) {
+    let current = path.resolve(startDirectory);
+    while (true) {
+        const beadsDir = path.join(current, '.beads');
+        const issuesJsonlPath = path.join(beadsDir, 'issues.jsonl');
+        if (fs.existsSync(issuesJsonlPath)) {
+            return current;
+        }
+        if (fs.existsSync(beadsDir)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function runBdCommand(args, options) {
+    try {
+        const result = childProcess.spawnSync('bd', args, {
+            cwd: options.cwd,
+            encoding: 'utf8',
+            timeout: options.timeoutMs,
+            maxBuffer: 1024 * 1024
+        });
+        return {
+            status: result.status,
+            stdout: typeof result.stdout === 'string' ? result.stdout : String(result.stdout ?? ''),
+            stderr: typeof result.stderr === 'string' ? result.stderr : String(result.stderr ?? ''),
+            error: result.error
+        };
+    }
+    catch (error) {
+        return {
+            status: null,
+            stdout: '',
+            stderr: '',
+            error
+        };
+    }
+}
+function runBdQuery(commandRunner, args, options) {
+    const result = commandRunner(args, options);
+    if (result.error || result.status !== 0) {
+        return 'unknown';
+    }
+    const list = parseJsonArrayOutput(result.stdout);
+    if (!list) {
+        return 'unknown';
+    }
+    return list.length > 0 ? 'active' : 'idle';
+}
+function parseJsonArrayOutput(stdout) {
+    const trimmed = typeof stdout === 'string' ? stdout.trim() : '';
+    if (!trimmed) {
+        return [];
+    }
+    const parsedDirect = parseJsonArray(trimmed);
+    if (parsedDirect) {
+        return parsedDirect;
+    }
+    const firstBracket = trimmed.indexOf('[');
+    const lastBracket = trimmed.lastIndexOf(']');
+    if (firstBracket >= 0 && lastBracket > firstBracket) {
+        const arraySlice = trimmed.slice(firstBracket, lastBracket + 1).trim();
+        const parsedSlice = parseJsonArray(arraySlice);
+        if (parsedSlice) {
+            return parsedSlice;
+        }
+    }
+    return null;
+}
+function parseJsonArray(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (value && typeof value === 'object') {
+            const record = value;
+            if (Array.isArray(record.items)) {
+                return record.items;
+            }
+            if (Array.isArray(record.issues)) {
+                return record.issues;
+            }
+            if (Array.isArray(record.data)) {
+                return record.data;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 function buildObservationHash(messages) {
     const tail = messages
         .slice(-20)
@@ -199,6 +460,125 @@ function buildObservationHash(messages) {
     }
     return createHash('sha1').update(tail).digest('hex').slice(0, 16);
 }
+function stableStringifyForObservation(value) {
+    if (value === null)
+        return 'null';
+    const type = typeof value;
+    if (type === 'string')
+        return JSON.stringify(value);
+    if (type === 'number')
+        return Number.isFinite(value) ? String(value) : 'null';
+    if (type === 'boolean')
+        return value ? 'true' : 'false';
+    if (type === 'undefined' || type === 'function' || type === 'symbol')
+        return 'null';
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringifyForObservation(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const chunks = [];
+        for (const key of keys) {
+            const child = record[key];
+            if (typeof child === 'undefined') {
+                continue;
+            }
+            chunks.push(`${JSON.stringify(key)}:${stableStringifyForObservation(child)}`);
+        }
+        return `{${chunks.join(',')}}`;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'null';
+    }
+}
+function normalizeToolArgumentsForObservation(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return '{}';
+        }
+        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+            try {
+                return stableStringifyForObservation(JSON.parse(trimmed));
+            }
+            catch {
+                return normalizeWhitespace(trimmed);
+            }
+        }
+        return normalizeWhitespace(trimmed);
+    }
+    if (typeof value === 'undefined') {
+        return '{}';
+    }
+    return stableStringifyForObservation(value);
+}
+function extractToolCallSignatureText(record) {
+    const signatures = [];
+    const appendSignature = (nameValue, argsValue) => {
+        const name = normalizeText(nameValue).toLowerCase();
+        if (!name) {
+            return;
+        }
+        const args = normalizeToolArgumentsForObservation(argsValue);
+        signatures.push(`${name}(${args})`);
+    };
+    const scan = (node) => {
+        if (!node) {
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node) {
+                scan(item);
+            }
+            return;
+        }
+        if (typeof node !== 'object') {
+            return;
+        }
+        const current = node;
+        if (current.function && typeof current.function === 'object' && !Array.isArray(current.function)) {
+            const fn = current.function;
+            appendSignature(fn.name, fn.arguments);
+        }
+        if (normalizeText(current.type).toLowerCase() === 'function_call') {
+            appendSignature(current.name, current.arguments);
+        }
+        if (typeof current.name === 'string' && Object.prototype.hasOwnProperty.call(current, 'arguments')) {
+            appendSignature(current.name, current.arguments);
+        }
+        if (current.function_call && typeof current.function_call === 'object' && !Array.isArray(current.function_call)) {
+            const fnCall = current.function_call;
+            appendSignature(fnCall.name, fnCall.arguments);
+        }
+    };
+    scan(record.tool_calls);
+    scan(record.tool_call);
+    scan(record.function_call);
+    scan(record.output);
+    return signatures.join('; ');
+}
+function buildToolSignatureHash(messages) {
+    const signatures = messages
+        .slice(-20)
+        .map((message) => extractToolSignatureForHash(message))
+        .filter(Boolean)
+        .join('\n');
+    if (!signatures) {
+        return undefined;
+    }
+    return createHash('sha1').update(signatures).digest('hex').slice(0, 16);
+}
+function extractToolSignatureForHash(message) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return '';
+    }
+    const record = message;
+    return extractToolCallSignatureText(record);
+}
 function normalizeMessageForHash(message) {
     if (!message || typeof message !== 'object' || Array.isArray(message)) {
         return '';
@@ -206,10 +586,12 @@ function normalizeMessageForHash(message) {
     const record = message;
     const role = normalizeText(record.role).toLowerCase() || 'unknown';
     const text = extractMessageText(record.content || record.output || record.input || '');
-    if (!text) {
+    const toolSignature = extractToolCallSignatureText(record);
+    const combined = [text, toolSignature].filter((entry) => typeof entry === 'string' && entry.trim()).join(' | ');
+    if (!combined) {
         return role;
     }
-    return `${role}:${text.slice(0, 400)}`;
+    return `${role}:${combined.slice(0, 800)}`;
 }
 function normalizeMessageForHeuristics(message) {
     if (!message || typeof message !== 'object' || Array.isArray(message)) {
@@ -264,6 +646,36 @@ function normalizeWhitespace(text) {
 function normalizeText(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function normalizeStageName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'status_probe' || normalized === 'active_continue' || normalized === 'loop_self_check') {
+        return normalized;
+    }
+    return undefined;
+}
+function normalizeBdWorkState(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'active' || normalized === 'idle' || normalized === 'unknown') {
+        return normalized;
+    }
+    return undefined;
+}
+function normalizeStageMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
+        return normalized;
+    }
+    return undefined;
+}
 function toSafeInt(value, fallback) {
     if (typeof value !== 'number' || !Number.isFinite(value)) {
         return fallback;

package/dist/servertool/handlers/vision.js

@@ -66,7 +66,7 @@ const handler = async (ctx) => {
         }
     };
 };
-registerServerToolHandler('vision_auto', handler, { trigger: 'auto' });
+registerServerToolHandler('vision_auto', handler, { trigger: 'auto', hook: { phase: 'post', priority: 60 } });
 export async function executeVisionBackendPlan(args) {
     const plan = args.plan;
     const options = args.options;