@jsonstudio/llms 0.6.1739 → 0.6.1890

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

@@ -0,0 +1,684 @@
+import { createHash } from 'node:crypto';
+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` 与 `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 = [
+    '检测到当前仍有任务，按优先级继续执行，不允许只汇报状态：',
+    '1) 先检查是否存在 blocked 任务；若存在，先分析阻塞原因并执行解阻塞动作（补依赖/修配置/拆子任务/补证据）；',
+    '2) 需要调整执行顺序或新增动作时，必须用 bd 更新计划与状态（update/dep add/create），保持可追踪；',
+    '3) 若无 blocked，再继续当前 in_progress/open 任务并执行至少一个可验证动作（改代码/跑测试/更新证据）；',
+    '4) 未完成上述动作前，不要输出“已完成/已汇报”类结论；完成后只汇报结果与下一步。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+const DEFAULT_LOOP_TEMPLATE = [
+    '检测到可能出现重复循环，请先自检并尝试跳出：',
+    '1) 对比最近两轮是否重复同一命令/同一结论；',
+    '2) 若重复，改用新的有效动作（更具体命令、换验证路径或直接给结论）；',
+    '3) 执行后再观察状态变化；若仍无变化则停止并报告阻塞点。',
+    '',
+    '{{BASE_STOP_MESSAGE}}'
+].join('\n');
+let bdRuntimeCache = null;
+const DEFAULT_BD_TIMEOUT_MS = 1200;
+const DEFAULT_BD_CACHE_TTL_MS = 1500;
+export function resolveStopMessageStageDecision(args) {
+    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',
+            ...(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, {
+        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') {
+        if (mode !== 'on' || idleConfirmed) {
+            return {
+                action: 'stop',
+                observationHash,
+                observationStableCount: stableCount,
+                bdWorkState,
+                stopReason: 'bd_idle',
+                ...(toolSignatureHash ? { toolSignatureHash } : {})
+            };
+        }
+    }
+    if (stableCount >= 2) {
+        return {
+            action: 'stop',
+            observationHash,
+            observationStableCount: stableCount,
+            bdWorkState,
+            stopReason: 'loop_stable',
+            ...(toolSignatureHash ? { toolSignatureHash } : {})
+        };
+    }
+    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,
+        ...(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();
+    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 (!safeTemplate) {
+        return safeBaseText;
+    }
+    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');
+    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(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';
+    }
+    if (raw === '0' || raw === 'false' || raw === 'off') {
+        return 'off';
+    }
+    if (raw === 'auto') {
+        return 'auto';
+    }
+    return 'auto';
+}
+function loadStageTemplate(stage) {
+    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 detectBdWorkStateFromHeuristics(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 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)
+        .map((message) => normalizeMessageForHash(message))
+        .filter(Boolean)
+        .join('\n');
+    if (!tail) {
+        return 'empty';
+    }
+    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 '';
+    }
+    const record = message;
+    const role = normalizeText(record.role).toLowerCase() || 'unknown';
+    const text = extractMessageText(record.content || record.output || record.input || '');
+    const toolSignature = extractToolCallSignatureText(record);
+    const combined = [text, toolSignature].filter((entry) => typeof entry === 'string' && entry.trim()).join(' | ');
+    if (!combined) {
+        return role;
+    }
+    return `${role}:${combined.slice(0, 800)}`;
+}
+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 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;
+    }
+    return Math.max(0, Math.floor(value));
+}

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;