minimal-agent 0.8.2 → 0.10.0

package/plugins/ralph-wiggum/src/stopHookRunner.js

@@ -1,104 +0,0 @@
-/**
- * ============================================================
- *  plugins/ralph-wiggum/src/stopHookRunner.ts
- * ------------------------------------------------------------
- *  ralph-wiggum 私用的 stop-hook 执行器。读 hooks/hooks.json 里 Stop 事件
- *  的命令清单，stdin 传 transcript 文本，stdout 收 JSON 决策。
- *
- *  在 minimal-agent 里 stop-hook 是"咨询式"信号：
- *    - 返回 block → driver 把 reason 注入下一轮 prompt
- *    - pass / 错误 / Windows 缺 bash → 不影响循环继续
- *
- *  与框架级 hookEngine 的关系：hookEngine 服务于 UserPromptSubmit /
- *  PreToolUse / PostToolUse 等框架事件；ralph 的 Stop 是插件领域内
- *  特有的循环-反馈机制，故而独立执行，不污染框架 hookTable。
- * ============================================================
- */
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { spawn } from 'node:child_process';
-async function loadStopHookConfig(pluginRoot) {
-    const hooksJsonPath = join(pluginRoot, 'hooks', 'hooks.json');
-    try {
-        const raw = await readFile(hooksJsonPath, 'utf8');
-        const parsed = JSON.parse(raw);
-        const stopEntries = parsed?.hooks?.Stop;
-        if (!Array.isArray(stopEntries))
-            return [];
-        const commands = [];
-        for (const entry of stopEntries) {
-            const hooks = entry.hooks;
-            if (Array.isArray(hooks)) {
-                for (const h of hooks) {
-                    if (h.type === 'command' && h.command) {
-                        commands.push(h);
-                    }
-                }
-            }
-        }
-        return commands;
-    }
-    catch {
-        return [];
-    }
-}
-export async function executeStopHook(pluginRoot, transcriptText) {
-    // Windows 上 bash 通常缺失，hook 链路降级为 pass（咨询式信号不影响循环）
-    if (process.platform === 'win32') {
-        return { decision: 'pass' };
-    }
-    const hookConfigs = await loadStopHookConfig(pluginRoot);
-    for (const hookConfig of hookConfigs) {
-        const result = await runSingleStopHook(hookConfig, pluginRoot, transcriptText);
-        if (result.decision === 'block') {
-            return result;
-        }
-    }
-    return { decision: 'pass' };
-}
-function runSingleStopHook(hookConfig, pluginRoot, transcriptText) {
-    const resolvedCommand = hookConfig.command.replaceAll('${CLAUDE_PLUGIN_ROOT}', pluginRoot);
-    return new Promise((resolve) => {
-        const child = spawn('bash', [resolvedCommand], {
-            env: {
-                ...process.env,
-                CLAUDE_PLUGIN_ROOT: pluginRoot,
-            },
-        });
-        let stdout = '';
-        child.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.on('error', () => {
-            resolve({ decision: 'pass' });
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                resolve({ decision: 'pass' });
-                return;
-            }
-            const trimmed = stdout.trim();
-            if (!trimmed) {
-                resolve({ decision: 'pass' });
-                return;
-            }
-            try {
-                const parsed = JSON.parse(trimmed);
-                if (parsed.decision === 'block') {
-                    resolve({
-                        decision: 'block',
-                        reason: typeof parsed.reason === 'string' ? parsed.reason : undefined,
-                        systemMessage: typeof parsed.systemMessage === 'string' ? parsed.systemMessage : undefined,
-                    });
-                    return;
-                }
-                resolve({ decision: 'pass' });
-            }
-            catch {
-                resolve({ decision: 'pass' });
-            }
-        });
-        child.stdin.write(transcriptText);
-        child.stdin.end();
-    });
-}

package/plugins/ralph-wiggum/src/verificationGate.js

@@ -1,202 +0,0 @@
-/**
- * ============================================================
- *  src/plugins/verificationGate.ts —— ralph-loop 的"完成验证门"
- * ------------------------------------------------------------
- *  Agent 输出 <promise>DONE</promise> 哨兵后，pluginRunner 跑这里的
- *  checks。全部通过才真正退出循环；任一未通过则回 BUILD 继续干。
- *
- *  支持四种 check：
- *    - shell:<cmd>                跨平台 spawn（Windows 走 cmd /c, 其余 bash -c）
- *    - file_exists:<path>         fs.existsSync
- *    - file_contains:<file>:<re>  正则匹配文件内容
- *    - test_count:<min>           跑 `bun test`，从 stdout 解析 "N pass"
- *
- *  工作目录隔离：所有相对路径以 getWorkingDir() 为锚，子进程 cwd 也用它，
- *  确保并行 session 不会互相串台。
- * ============================================================
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-function parseVerifyArg(arg) {
-    const colonIdx = arg.indexOf(':');
-    if (colonIdx < 0)
-        return null;
-    const type = arg.slice(0, colonIdx).trim().toLowerCase();
-    const value = arg.slice(colonIdx + 1).trim();
-    switch (type) {
-        case 'shell':
-            return { type: 'shell', command: value, timeout: 30_000 };
-        case 'file_exists':
-            return { type: 'file_exists', file: value };
-        case 'file_contains': {
-            const sep = value.indexOf(':');
-            if (sep < 0)
-                return null;
-            return {
-                type: 'file_contains',
-                file: value.slice(0, sep),
-                pattern: value.slice(sep + 1),
-            };
-        }
-        case 'test_count': {
-            const count = parseInt(value, 10);
-            if (isNaN(count) || count < 0)
-                return null;
-            return { type: 'test_count', minCount: count };
-        }
-        default:
-            return null;
-    }
-}
-export function parseVerifyArgs(args) {
-    const checks = [];
-    const regex = /--verify\s+("[^"]*"|\S+)/gi;
-    let match;
-    while ((match = regex.exec(args)) !== null) {
-        const raw = match[1].replace(/^"|"$/g, '');
-        const check = parseVerifyArg(raw);
-        if (check)
-            checks.push(check);
-    }
-    return checks;
-}
-function runShell(command, timeout) {
-    return new Promise((resolve) => {
-        const isWin = process.platform === 'win32';
-        // 不显式传 cwd —— 继承 process.cwd()，main.tsx 已 chdir 到 workingDir，
-        // 而测试里直接用 process.cwd()，避免依赖 mock 的 getWorkingDir 造成串台
-        const child = isWin
-            ? spawn('cmd', ['/c', command], { timeout, env: process.env })
-            : spawn('bash', ['-c', command], { timeout, env: process.env });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (d) => {
-            stdout += d.toString();
-        });
-        child.stderr.on('data', (d) => {
-            stderr += d.toString();
-        });
-        child.on('error', () => {
-            resolve({ exitCode: null, stdout, stderr, errored: true });
-        });
-        child.on('close', (code) => {
-            resolve({ exitCode: code, stdout, stderr, errored: false });
-        });
-    });
-}
-export async function verifyShell(command, timeout) {
-    const r = await runShell(command, timeout);
-    if (r.errored) {
-        return {
-            check: { type: 'shell', command },
-            passed: false,
-            output: `执行失败`,
-        };
-    }
-    return {
-        check: { type: 'shell', command },
-        passed: r.exitCode === 0,
-        output: r.stdout.trim() || r.stderr.trim() || `exit code ${r.exitCode}`,
-    };
-}
-export function verifyFileExists(file) {
-    const exists = existsSync(file);
-    return {
-        check: { type: 'file_exists', file },
-        passed: exists,
-        output: exists ? '文件存在' : `文件不存在: ${file}`,
-    };
-}
-export function verifyFileContains(file, pattern) {
-    try {
-        const content = readFileSync(file, 'utf8');
-        const regex = new RegExp(pattern);
-        const matched = regex.test(content);
-        return {
-            check: { type: 'file_contains', file, pattern },
-            passed: matched,
-            output: matched ? `文件包含 "${pattern}"` : `文件不包含 "${pattern}"`,
-        };
-    }
-    catch {
-        return {
-            check: { type: 'file_contains', file, pattern },
-            passed: false,
-            output: `无法读取文件: ${file}`,
-        };
-    }
-}
-async function verifyTestCount(minCount) {
-    const r = await runShell(`bun test`, 60_000);
-    // bun test 把进度打在 stderr，最终统计也常在 stderr，所以合并解析
-    const combined = `${r.stdout}\n${r.stderr}`;
-    if (r.errored) {
-        return {
-            check: { type: 'test_count', minCount },
-            passed: false,
-            output: '无法执行 bun test',
-        };
-    }
-    const matches = [...combined.matchAll(/(\d+)\s+pass/gi)];
-    const count = matches.length > 0 ? parseInt(matches[matches.length - 1][1], 10) : 0;
-    const passed = count >= minCount;
-    return {
-        check: { type: 'test_count', minCount },
-        passed,
-        output: `${count} pass (需要 >=${minCount})`,
-    };
-}
-export async function runVerification(checks) {
-    if (checks.length === 0) {
-        return { passed: true, details: [], summary: '无验证项' };
-    }
-    const results = [];
-    for (const check of checks) {
-        let result;
-        switch (check.type) {
-            case 'shell':
-                result = await verifyShell(check.command ?? '', check.timeout ?? 30_000);
-                break;
-            case 'file_exists':
-                result = verifyFileExists(check.file ?? '');
-                break;
-            case 'file_contains':
-                result = verifyFileContains(check.file ?? '', check.pattern ?? '');
-                break;
-            case 'test_count':
-                result = await verifyTestCount(check.minCount ?? 0);
-                break;
-            default:
-                result = {
-                    check,
-                    passed: false,
-                    output: `未知验证类型: ${check.type}`,
-                };
-        }
-        results.push(result);
-    }
-    const allPassed = results.every((r) => r.passed);
-    const failedNames = results.filter((r) => !r.passed).map((r) => formatCheckName(r.check));
-    let summary;
-    if (allPassed) {
-        summary = `✅ 全部通过 (${results.length}/${results.length})`;
-    }
-    else {
-        summary = `❌ 验证未通过: ${failedNames.join(', ')}`;
-    }
-    return { passed: allPassed, details: results, summary };
-}
-function formatCheckName(check) {
-    switch (check.type) {
-        case 'shell':
-            return `shell(${(check.command ?? '').slice(0, 40)})`;
-        case 'file_exists':
-            return `exists(${check.file})`;
-        case 'file_contains':
-            return `contains(${check.file}:${check.pattern})`;
-        case 'test_count':
-            return `tests(>=${check.minCount})`;
-        default:
-            return check.type;
-    }
-}

package/plugins/workflow-runner/src/miniReAct.js

@@ -1,223 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/src/miniReAct.ts —— 简化版 ReAct 子循环
- * ------------------------------------------------------------
- *  本循环只做最纯净的 ReAct：调 LLM → 执行 tool_call → 喂回 → 再调 → 直到模型
- *  不再调工具或达到 maxTurns。**有三个调用方**（都要「有界、白名单、不污染主
- *  history、直接拿 StepResult」）：
- *    - execLlmStep 的 context_files 分支（llm.ts，maxTurns 默认 10）
- *    - agent: 节点（stepExecutors/agent.ts，默认 12）
- *    - onError:'recover' 恢复 agent（recovery.ts，默认 12）
- *
- *  **流式**：本循环边跑边 yield UI 事件——text（答案）/ reasoning（思维链）/
- *  tool_start/tool_end（工具）/ **stage_change（thinking→streaming→tool_executing，
- *  对齐 src/loop.ts::runQuery）**。stage_change 是 TUI LiveArea 显示的开关（idle 时
- *  LiveArea 整块隐藏），没有它则上述内层事件在 TUI 上发了也看不见。output_schema
- *  模式下**仍切 stage、但不回显 text**（避免把 JSON 原文当答案刷屏，对齐 llm.ts）。
- *
- *  为什么不复用 src/loop.ts::runQuery？
- *    - runQuery 依赖太重：history 持久化、自动压缩、反应式压缩自救、
- *      microCompact、reasoning 累积、sessionState 注入、SIGINT 标记消息等
- *    - workflow 子步骤是"短小内嵌"，不需要这些工程化保障
- *    - 独立实现可以精准控制：只用白名单工具、强 schema、重复调用 halt
- *
- *  关键决策：
- *    1. **每轮都传 responseFormat**（如果有 output_schema）。OpenAI 兼容
- *       provider 对 tool_calls + json_schema 混用通常允许：tool_calls 走 function
- *       协议，最终 assistant 的 text 是 JSON。这样比"双轮探测"简单可靠。
- *    2. **重复工具调用检测**：同 name 同 args 出现 3 次直接 halt，避免模型卡死。
- *    3. **executeTool 自带 Zod 校验和错误包装**，本循环只需透传 tool_call_id 配对。
- *    4. **maxTurns 默认 10**（vs runQuery 的 50），workflow 子步骤天生该收敛快。
- * ============================================================
- */
-import { chat, executeTool, } from '../../../src/plugin-sdk.js';
-import { extractJsonPayload } from './jsonPayload.js';
-/**
- * 执行一次 ReAct 子循环。**边跑边 yield UI 事件（stage_change / text / reasoning /
- * tool_start / tool_end），同时 return 最终 StepResult**——让 recover / agent 节点 /
- * llm+context_files 三处子 agent 的内层思考在 TUI / webchat 实时可见（之前是纯 async
- * 不 yield，"哑"的；且漏发 stage_change 时 TUI LiveArea 整块隐藏，等于没显示）。
- * 调用方用 `const result = yield* runMiniReAct(...)` 既透传事件、又拿到 StepResult。
- *
- * 抛错场景：
- *   - 用户中断（signal.aborted）
- *   - 重复工具调用 >= 3 次
- *   - 用尽 maxTurns 仍未收敛
- *   - output_schema 解析失败 / 非对象
- */
-export async function* runMiniReAct(args) {
-    const { messages, tools, output_schema, provider, signal } = args;
-    const maxTurns = args.maxTurns ?? 10;
-    // 工作消息列表：拷贝一份，避免污染调用方
-    const conv = [...messages];
-    // schema 模式：把 schema 写进 system（同 llm.ts）。保证 provider 不支持 response_format
-    // 而被 client.ts 退化掉时，模型仍知道确切字段结构、不至于瞎猜字段名。
-    if (output_schema) {
-        const hint = `\n\n最终只输出匹配以下 JSON Schema 的 JSON 对象本身（不要解释、不要 markdown 代码块）：\n${JSON.stringify(output_schema)}`;
-        const sysIdx = conv.findIndex((m) => m.role === 'system');
-        if (sysIdx >= 0) {
-            conv[sysIdx] = { ...conv[sysIdx], content: `${conv[sysIdx].content ?? ''}${hint}` };
-        }
-        else {
-            conv.unshift({ role: 'system', content: hint.trimStart() });
-        }
-    }
-    let finalText = '';
-    /** 上一轮是否仍有 tool_calls（用于检测 "用尽轮数还在调工具" 这一退出态） */
-    let lastTurnHadToolCalls = false;
-    /** 重复工具调用计数：key = `${name}:${arguments}` */
-    const toolCallSignature = new Map();
-    const responseFormat = output_schema
-        ? {
-            type: 'json_schema',
-            json_schema: {
-                name: 'minireact_output',
-                schema: output_schema,
-                strict: true,
-            },
-        }
-        : undefined;
-    for (let turn = 0; turn < maxTurns; turn++) {
-        if (signal?.aborted)
-            throw new Error('用户中断');
-        // ---- 1. 调 LLM 并累积流式响应 ----
-        let textAccum = '';
-        const toolCallsAccum = [];
-        // 进 LLM 流前本质是「等首 token」= thinking；首个 text_delta 时切 streaming（一次性）。
-        // 对齐 src/loop.ts::runQuery —— 没有这两个 stage_change，TUI LiveArea 会一直 idle 隐藏，
-        // 下面 yield 的 text/reasoning/tool 事件在 TUI 上等于白发。
-        let stageStreamingYielded = false;
-        yield { type: 'stage_change', stage: 'thinking' };
-        for await (const ev of chat({
-            provider,
-            messages: conv,
-            tools,
-            responseFormat,
-            signal,
-        })) {
-            if (ev.type === 'text_delta') {
-                textAccum += ev.delta;
-                if (!stageStreamingYielded) {
-                    stageStreamingYielded = true;
-                    yield { type: 'stage_change', stage: 'streaming' };
-                }
-                // output_schema 模式：切了 streaming 阶段但**不回显 JSON 原文**（不把结构化产出
-                // 当答案刷屏，对齐 llm.ts:121 的克制）；非 schema 模式才把答案流式 yield 给 UI。
-                if (!output_schema)
-                    yield { type: 'text', delta: ev.delta };
-            }
-            else if (ev.type === 'tool_call_delta') {
-                mergeToolCallDelta(toolCallsAccum, ev);
-            }
-            else if (ev.type === 'reasoning_delta') {
-                // 思维链字符串增量透传给 UI（reasoning_details 是结构化数组、无 delta，跳过）
-                if (ev.delta)
-                    yield { type: 'reasoning', delta: ev.delta };
-            }
-            else if (ev.type === 'done' && ev.stopReason === 'aborted') {
-                throw new Error('用户中断');
-            }
-        }
-        // ---- 2. 把 assistant 消息推入 conv ----
-        conv.push({
-            role: 'assistant',
-            content: textAccum.length > 0 ? textAccum : null,
-            ...(toolCallsAccum.length > 0 ? { tool_calls: toolCallsAccum } : {}),
-        });
-        // ---- 3. 无 tool_calls → 结束循环 ----
-        if (toolCallsAccum.length === 0) {
-            finalText = textAccum.trim();
-            lastTurnHadToolCalls = false;
-            break;
-        }
-        lastTurnHadToolCalls = true;
-        // ---- 4. 执行所有 tool_calls，结果回填为 tool 消息 ----
-        // 进工具执行 = tool_executing 阶段（驱动 TUI LiveArea 显示运行中工具，对齐 loop.ts:340）。
-        yield { type: 'stage_change', stage: 'tool_executing' };
-        for (const tc of toolCallsAccum) {
-            // 重复检测
-            const sig = `${tc.function.name}:${tc.function.arguments}`;
-            const count = (toolCallSignature.get(sig) ?? 0) + 1;
-            toolCallSignature.set(sig, count);
-            if (count >= 3) {
-                throw new Error(`miniReAct: 检测到重复工具调用（${tc.function.name} 同参数已 ${count} 次），可能陷入循环，halt。`);
-            }
-            if (signal?.aborted)
-                throw new Error('用户中断');
-            // 执行前后 yield tool_start/tool_end，让 UI 看到子 agent 在用工具（事件形状对齐
-            // src/loop.ts；miniReAct 串行执行，顺序 yield 即可，不需要 loop 的并行事件队列）。
-            yield {
-                type: 'tool_start',
-                toolName: tc.function.name,
-                toolCallId: tc.id,
-                argsPreview: previewArgs(tc.function.arguments),
-            };
-            const result = await executeTool(tc.function.name, tc.function.arguments, signal);
-            const toolContent = result.ok ? result.content : `工具错误: ${result.error}`;
-            yield {
-                type: 'tool_end',
-                toolName: tc.function.name,
-                toolCallId: tc.id,
-                ok: result.ok,
-                content: toolContent,
-            };
-            conv.push({
-                role: 'tool',
-                tool_call_id: tc.id,
-                content: toolContent,
-            });
-        }
-        // 继续下一轮
-    }
-    // 用尽 maxTurns 且最后一轮仍有 tool_calls
-    if (lastTurnHadToolCalls) {
-        throw new Error(`miniReAct: 用尽 ${maxTurns} 轮未得到最终回答（仍在调工具）`);
-    }
-    // ---- 5. 输出处理 ----
-    if (output_schema) {
-        // 同 llm.ts：先剥 <think> 思维链/围栏/前后散文再 parse（见 jsonPayload.ts 头注）。
-        const payload = extractJsonPayload(finalText);
-        let parsed;
-        try {
-            parsed = JSON.parse(payload);
-        }
-        catch (e) {
-            throw new Error(`miniReAct: output_schema 要求 JSON 但解析失败: ${e.message}\n收到: ${finalText.slice(0, 200)}`);
-        }
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            throw new Error(`miniReAct: output_schema 要求对象，得到 ${Array.isArray(parsed) ? 'array' : typeof parsed}`);
-        }
-        return {
-            raw: parsed,
-            preview: `[json+tools] ${finalText.slice(0, 180)}${finalText.length > 180 ? '...' : ''}`,
-        };
-    }
-    return {
-        raw: { text: finalText, result: finalText },
-        preview: finalText.length > 200 ? `${finalText.slice(0, 200)}...` : finalText,
-    };
-}
-// ---------------- 辅助 ----------------
-/** 把一条 tool_call_delta 合并到累积数组上（与 src/loop.ts mergeToolCallDelta 同语义） */
-function mergeToolCallDelta(acc, ev) {
-    let slot = acc[ev.index];
-    if (!slot) {
-        slot = {
-            id: '',
-            type: 'function',
-            function: { name: '', arguments: '' },
-        };
-        acc[ev.index] = slot;
-    }
-    if (ev.id)
-        slot.id = ev.id;
-    if (ev.name)
-        slot.function.name += ev.name;
-    if (ev.argumentsDelta)
-        slot.function.arguments += ev.argumentsDelta;
-}
-/** 给 tool_start 事件用的参数预览（压成一行、截断到 60 字符），与 loop.ts previewArgs 同义。 */
-function previewArgs(rawJson) {
-    const oneLine = rawJson.replace(/\s+/g, ' ').trim();
-    return oneLine.length <= 60 ? oneLine : `${oneLine.slice(0, 60)}...`;
-}

package/plugins/workflow-runner/src/voteHelpers.js

@@ -1,110 +0,0 @@
-/**
- * ============================================================
- *  voteHelpers.ts —— vote 节点的 voter 调用辅助
- * ------------------------------------------------------------
- *  对抗式审查：N 个 voter 跑同一 prompt + refuted: boolean 反向投票。
- *  策略上倾向 refuted=true（找漏洞），所以阈值算的是"驳回票数"。
- *  详见 ADR-05。
- * ============================================================
- */
-import { execLlmStep } from './stepExecutors/llm.js';
-/** voter 输出 schema（内置，不接受用户自定义） */
-export const VERDICT_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    required: ['refuted', 'reasoning'],
-    properties: {
-        refuted: { type: 'boolean', description: '是否驳回此 finding' },
-        reasoning: { type: 'string', description: '核心论证（≤200 字）' },
-    },
-};
-export function buildVoterPrompt(rules, item) {
-    const itemStr = typeof item === 'string' ? item : JSON.stringify(item, null, 2);
-    return `你是一个对抗式审查者，你的核心任务是积极找出下面这个 finding 的逻辑漏洞、证据不足、或论证它是伪命题。
-
-**被审查的 finding**：
-${itemStr}
-
-**审查规则**：
-${rules}
-
-**重要心理学定位**：你应当倾向于 refuted=true。只在你**找不到任何合理的反驳角度**且这个 finding 论证扎实时，才输出 refuted=false。"老好人式赞同"是错误的。
-
-输出 JSON，refuted=true 表示你成功找到反驳理由，false 表示你认为它确实成立。reasoning 字段写明你的核心论证（≤200 字）。`;
-}
-/** 单个 voter 调用。包装 execLlmStep，强制 VERDICT_SCHEMA + 对抗式 prompt。
- *  解析失败时默认 refuted=false（保守保留 item，避免 LLM 失误导致正确 finding 被误删）。 */
-export async function runVoter(rules, item, vars, ctx) {
-    const virtualStep = {
-        id: 'vote_voter', // 仅 ID，不影响事件流
-        llm: buildVoterPrompt(rules, item),
-        output_schema: VERDICT_SCHEMA,
-    };
-    try {
-        // execLlmStep 现为 AsyncGenerator：手动 drain 取 return 值。voter 必须静默——
-        // N 个 voter 在 Promise.all 里并行，若把它们的 text 事件向上转发会在 UI 互相打架。
-        const gen = execLlmStep(virtualStep, vars, ctx);
-        let res = await gen.next();
-        while (!res.done)
-            res = await gen.next();
-        const result = res.value;
-        const verdict = extractVerdict(result.raw);
-        if (verdict)
-            return verdict;
-        return { refuted: false, reasoning: '(voter 输出格式异常，保守保留)' };
-    }
-    catch (e) {
-        return {
-            refuted: false,
-            reasoning: `(voter 调用失败: ${e.message}，保守保留)`,
-        };
-    }
-}
-/**
- * 从 execLlmStep 的 raw 提取 { refuted, reasoning }：
- *   1. raw 直接含字段（B 改完 llm.ts 串通 output_schema 后的形态）
- *   2. raw.text / raw.result 是 JSON 字符串，parse 后含字段（B 未改完时的 fallback）
- *   3. raw.text / raw.result 含 ```json fenced block，剥壳后含字段
- *   4. 其余 → null
- */
-function extractVerdict(raw) {
-    if (typeof raw.refuted === 'boolean' &&
-        typeof raw.reasoning === 'string') {
-        return { refuted: raw.refuted, reasoning: raw.reasoning };
-    }
-    for (const k of ['text', 'result']) {
-        const v = raw[k];
-        if (typeof v !== 'string' || v.length === 0)
-            continue;
-        const parsed = tryParseJsonLike(v);
-        if (parsed &&
-            typeof parsed === 'object' &&
-            typeof parsed.refuted === 'boolean' &&
-            typeof parsed.reasoning === 'string') {
-            return {
-                refuted: parsed.refuted,
-                reasoning: parsed.reasoning,
-            };
-        }
-    }
-    return null;
-}
-function tryParseJsonLike(s) {
-    // 1. 直接 JSON
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        // 2. 剥 ```json ... ``` 围栏
-        const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/);
-        if (fence) {
-            try {
-                return JSON.parse(fence[1].trim());
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-}