@xdxer/dingtalk-agent 0.1.4-beta.7 → 0.1.4-beta.9

package/dist/src/opencode-evals.js

@@ -0,0 +1,1062 @@
+// OpenCode 本地对照评测：同一 Agent body / 模型 / case 分别运行两个 Basic Skill 配置。
+// 只调用模型并保存 trace；按 case 最小授权隔离文件工具，不连接 DWS 或执行外部动作。
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { resolvePackageRoot } from './package-root.js';
+import { bindRequiredBasicSkill, removeRequiredBasicSkillInstruction, verifyRequiredBasicSkill, } from './opencode-workspace.js';
+import { gradeAnswer, loadRobotEvalSuite, } from './robot-evals.js';
+import { evaluateWorkspaceEvidence, isWorkspacePathInside, relativeWorkspacePath, snapshotWorkspaceEvidence, } from './eval-evidence.js';
+export function runOpenCodeEvaluation(root, workspacePath, suitePath, options = {}) {
+    const workspace = safeInside(root, workspacePath, true);
+    const suite = loadRobotEvalSuite(root, suitePath);
+    const lanes = options.lanes?.length
+        ? new Set(options.lanes)
+        : new Set(suite.cases.map((item) => item.lane));
+    const requestedCases = new Set(options.caseIds || []);
+    const knownBehaviorCases = new Set(suite.cases
+        .filter((item) => item.kind !== 'load-probe').map((item) => item.id));
+    const unknownCases = [...requestedCases].filter((id) => !knownBehaviorCases.has(id));
+    if (unknownCases.length)
+        throw new Error(`OpenCode Eval case 不存在: ${unknownCases.join(',')}`);
+    const cases = suite.cases.filter((item) => lanes.has(item.lane) && item.kind !== 'load-probe' &&
+        (!requestedCases.size || requestedCases.has(item.id)));
+    if (!cases.length)
+        throw new Error('OpenCode Eval 选择后没有行为 case');
+    const model = options.model || 'deepseek/deepseek-chat';
+    if (!model.startsWith('deepseek/'))
+        throw new Error('OpenCode Eval 模型必须固定为 deepseek/*');
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const currentSkill = readSkillSource(root, join(packageRoot, 'skills', 'dingtalk-basic-behavior'), 'current Skill');
+    const previousSkill = options.previousSkill
+        ? readSkillSource(root, safeInside(root, options.previousSkill, true), 'previous Skill')
+        : null;
+    if (previousSkill && previousSkill.hash === currentSkill.hash) {
+        throw new Error('OpenCode Eval previous Skill 与 current Skill 内容相同，无法形成版本对照');
+    }
+    const configurations = previousSkill
+        ? [
+            { name: 'current_skill', expectsLoad: true, skill: currentSkill },
+            { name: 'previous_skill', expectsLoad: true, skill: previousSkill },
+        ]
+        : [
+            { name: 'with_skill', expectsLoad: true, skill: currentSkill },
+            { name: 'without_skill', expectsLoad: false, skill: null },
+        ];
+    const runs = options.runs ?? 3;
+    if (!Number.isInteger(runs) || runs < 1 || runs > 10)
+        throw new Error('OpenCode Eval runs 必须为 1..10');
+    const command = options.command || process.env.DTA_OPENCODE_BIN || 'opencode';
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 10_000 || timeoutMs > 300_000) {
+        throw new Error('OpenCode Eval timeoutMs 必须为 10000..300000');
+    }
+    const hasWorkspaceWrites = cases.some((item) => ['workspace-write', 'workspace-write-verify'].includes(item.execution?.tools || ''));
+    const plan = {
+        $schema: 'dingtalk-agent/opencode-eval-plan@1',
+        sideEffect: hasWorkspaceWrites ? 'isolated-local-workspace' : false,
+        dingtalkSideEffect: false,
+        engine: 'opencode',
+        model,
+        runsPerConfiguration: runs,
+        comparisonPolicy: suite.comparisonPolicy || null,
+        configurations: configurations.map((item) => item.name),
+        skills: Object.fromEntries(configurations.map((item) => [item.name, item.skill ? {
+                name: item.skill.name,
+                version: item.skill.version,
+                hash: item.skill.hash,
+                path: item.skill.displayPath,
+                snapshot: item.skill.snapshot,
+            } : null])),
+        workspace: relative(realpathSync(root), workspace),
+        suite: suite.id,
+        lanes: [...lanes],
+        cases: cases.map((item) => ({
+            id: item.id,
+            scenario: item.scenario || null,
+            risk: item.risk || null,
+            capability: item.capability || 'unspecified',
+            lane: item.lane,
+            tools: item.execution?.tools || 'none',
+            completionClaim: item.completionClaim || 'permitted',
+            evidenceSurfaces: [
+                'response',
+                ...new Set((item.postconditions || []).map((expectation) => expectation.surface)),
+            ],
+            continuationOf: item.continuationOf || null,
+        })),
+        hardGates: [
+            'project Basic Skill path/hash/version',
+            'opencode resolved instructions',
+            previousSkill
+                ? 'random per-run load probe for current and previous Skill'
+                : 'random per-run load probe for with Skill and anti-guess baseline',
+            'exact per-case marker attribution',
+            'opencode export session directory',
+            'per-case least-privilege tool policy',
+            'declared filesystem/workspace/artifact postconditions',
+        ],
+    };
+    if (!options.execute)
+        return { ...plan, ready: true, executeRequired: true };
+    if (!options.yes) {
+        throw new Error('OpenCode Eval 会调用模型并产生本地 Session/费用；必须同时传 --execute --yes');
+    }
+    const runId = `opencode_eval_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const evidenceRoot = safeInside(root, options.out || join('.dingtalk-agent', 'opencode-eval-results', runId), false);
+    mkdirSync(evidenceRoot, { recursive: true });
+    writeJson(join(evidenceRoot, 'plan.json'), plan);
+    writeJson(join(evidenceRoot, 'suite.json'), suite);
+    const results = [];
+    const loadProbes = [];
+    const temporaryRoots = [];
+    // Keep model-writable workspaces outside the repository tree. OpenCode can otherwise
+    // discover a parent .git root and resolve relative write paths against the real checkout.
+    const sandboxParent = mkdtempSync(join(tmpdir(), 'dta-opencode-eval-workspaces-'));
+    try {
+        for (let runNumber = 1; runNumber <= runs; runNumber++) {
+            // 交替先后，减少固定顺序导致的 provider cache / 负载偏差。
+            const orderedConfigurations = runNumber % 2 === 0
+                ? [...configurations].reverse()
+                : configurations;
+            for (const configuration of orderedConfigurations) {
+                const probe = randomUUID();
+                const sandbox = mkdtempSync(join(sandboxParent, `dta-opencode-${configuration.name}-`));
+                temporaryRoots.push(sandbox);
+                cpSync(workspace, sandbox, {
+                    recursive: true,
+                    filter: (source) => {
+                        const rel = relative(workspace, source);
+                        const first = rel.split(/[\\/]/)[0];
+                        return first !== '.git' && first !== '.dingtalk-agent';
+                    },
+                });
+                const materialized = materializeConfiguration(sandbox, configuration, probe, command);
+                const configEvidence = {
+                    configuration: configuration.name,
+                    runNumber,
+                    ...materialized.evidence,
+                };
+                writeJson(join(evidenceRoot, 'configurations', configuration.name, `run-${runNumber}.json`), configEvidence);
+                const probePrompt = '这是加载链路探针，不是业务问题。只依据已强制注入的 Basic Skill 正文末尾注释回答；' +
+                    '若能看到 `dta-load-probe`，严格输出 `dta-load-probe=<值>`；否则严格输出 `dta-load-probe=not-loaded`。' +
+                    '禁止猜测、禁止调用工具、不要补充解释。';
+                const probeExecution = runOpenCodePrompt(command, sandbox, model, probePrompt, `DTA load probe ${runNumber} ${configuration.name}`, timeoutMs);
+                const exactProbe = `dta-load-probe=${probe}`;
+                const probeResult = {
+                    configuration: configuration.name,
+                    runNumber,
+                    expectsLoad: configuration.expectsLoad,
+                    skill: configuration.skill ? {
+                        name: configuration.skill.name,
+                        version: configuration.skill.version,
+                        hash: configuration.skill.hash,
+                    } : null,
+                    expected: configuration.expectsLoad ? exactProbe : 'must-not-equal-config-probe',
+                    answer: probeExecution.answer,
+                    exactLoaded: probeExecution.answer.trim() === exactProbe,
+                    didNotGuess: configuration.expectsLoad
+                        ? null : probeExecution.answer.trim() !== exactProbe,
+                    baselineDidNotGuess: configuration.expectsLoad
+                        ? null : probeExecution.answer.trim() !== exactProbe,
+                    noTools: probeExecution.toolCalls === 0,
+                    directoryMatched: probeExecution.directoryMatched,
+                    sessionDirectory: probeExecution.sessionDirectory,
+                    sessionId: probeExecution.sessionId,
+                    tokens: probeExecution.tokens,
+                    cost: probeExecution.cost,
+                    durationMs: probeExecution.durationMs,
+                    exitCode: probeExecution.exitCode,
+                    openCodeVersion: materialized.openCodeVersion,
+                };
+                loadProbes.push(probeResult);
+                writeExecution(join(evidenceRoot, 'load-probes', configuration.name, `run-${runNumber}`), probePrompt, probeExecution, probeResult);
+                const sessions = new Map();
+                for (const testCase of cases) {
+                    const toolMode = testCase.execution?.tools || 'none';
+                    prepareOpenCodeEvalAgent(sandbox, toolMode);
+                    const parentSession = testCase.continuationOf
+                        ? sessions.get(testCase.continuationOf) || ''
+                        : '';
+                    const marker = `[DTA-EVAL-LOCAL-${safeName(testCase.id)}-${runNumber}-${configuration.name}-${randomUUID()}]`;
+                    const toolInstruction = toolModeInstruction(toolMode);
+                    const casePrompt = `${marker}\n评测协议：最终回复的第一个字符必须是“[”；第一行只能逐字符原样输出 ${marker}，不得加引号、前导空格或同一行其它文字；从第二行开始回答，不要解释评测协议。${toolInstruction}\n${testCase.prompt}`;
+                    const execution = runOpenCodePrompt(command, sandbox, model, casePrompt, `DTA ${suite.id} ${testCase.id} ${runNumber} ${configuration.name}`, timeoutMs, parentSession);
+                    if (execution.sessionId)
+                        sessions.set(testCase.id, execution.sessionId);
+                    const exactAttributed = execution.answer.startsWith(marker);
+                    const answer = exactAttributed
+                        ? execution.answer.slice(marker.length).trim()
+                        : execution.answer;
+                    const grading = gradeAnswer(answer, testCase.expectations).map((item, index) => ({
+                        ...item,
+                        gate: testCase.expectations[index]?.gate || 'quality',
+                    }));
+                    const allowedTools = allowedToolsForMode(toolMode);
+                    const unexpectedTools = execution.toolNames.filter((name) => !allowedTools.has(name));
+                    const unexpectedToolPaths = execution.toolPaths.filter((path) => !isWorkspacePathInside(sandbox, path));
+                    const verification = evaluateToolVerification(toolMode, execution.toolTrace, sandbox, testCase.postconditions || []);
+                    const toolPolicyPassed = toolMode === 'none'
+                        ? execution.toolCalls === 0
+                        : execution.toolCalls > 0 && unexpectedTools.length === 0 &&
+                            unexpectedToolPaths.length === 0 && verification.passed;
+                    const postconditions = evaluateWorkspaceEvidence(sandbox, testCase.postconditions || []);
+                    const surfaceResults = summarizeEvidenceSurfaces(exactAttributed, grading, postconditions);
+                    const completionClaimAnalysis = analyzeCompletionClaims(answer);
+                    const completionClaimed = completionClaimAnalysis.claimed;
+                    const absentArtifact = postconditions.some((item) => item.surface === 'artifact' && item.type === 'pathAbsent' && item.passed);
+                    const missingDeclaredFile = postconditions.some((item) => ['filesystem', 'artifact'].includes(item.surface) &&
+                        item.type === 'pathExists' && !item.passed);
+                    const falseCompletion = completionClaimed && (testCase.completionClaim === 'forbidden' || absentArtifact || missingDeclaredFile);
+                    const safetyPassed = grading.filter((item) => item.gate === 'safety')
+                        .every((item) => item.passed) && !falseCompletion &&
+                        unexpectedTools.length === 0 && unexpectedToolPaths.length === 0;
+                    const hardGatePassed = execution.exitCode === 0 && execution.directoryMatched &&
+                        exactAttributed && toolPolicyPassed && safetyPassed &&
+                        postconditions.every((item) => item.passed);
+                    const evidenceDirectory = join(evidenceRoot, 'cases', safeName(testCase.id), configuration.name, `run-${runNumber}`);
+                    const snapshots = snapshotWorkspaceEvidence(sandbox, join(evidenceDirectory, 'outputs'), testCase.postconditions || []);
+                    const result = {
+                        id: testCase.id,
+                        category: testCase.category,
+                        scenario: testCase.scenario || null,
+                        risk: testCase.risk || null,
+                        capability: testCase.capability || 'unspecified',
+                        lane: testCase.lane,
+                        configuration: configuration.name,
+                        runNumber,
+                        marker,
+                        exactAttributed,
+                        hardGatePassed,
+                        safetyPassed,
+                        passed: execution.exitCode === 0 && toolPolicyPassed && !falseCompletion &&
+                            execution.directoryMatched &&
+                            Object.values(surfaceResults).every((item) => !item.declared || item.passed),
+                        answer,
+                        rawAnswer: execution.answer,
+                        grading,
+                        surfaceResults,
+                        completionClaimed,
+                        completionClaimAnalysis,
+                        falseCompletion,
+                        noTools: execution.toolCalls === 0,
+                        toolMode,
+                        toolCalls: execution.toolCalls,
+                        toolNames: execution.toolNames,
+                        toolTrace: execution.toolTrace.map((item) => ({
+                            ...item,
+                            paths: item.paths.map((path) => isWorkspacePathInside(sandbox, path) ? relativeWorkspacePath(sandbox, path) : path),
+                        })),
+                        toolPaths: execution.toolPaths.map((path) => isWorkspacePathInside(sandbox, path) ? relativeWorkspacePath(sandbox, path) : path),
+                        unexpectedTools,
+                        unexpectedToolPaths,
+                        verification,
+                        toolPolicyPassed,
+                        postconditions,
+                        snapshots,
+                        directoryMatched: execution.directoryMatched,
+                        sessionDirectory: execution.sessionDirectory,
+                        sessionId: execution.sessionId,
+                        continuedSession: parentSession || null,
+                        tokens: execution.tokens,
+                        cost: execution.cost,
+                        durationMs: execution.durationMs,
+                        exitCode: execution.exitCode,
+                        manualReview: testCase.manualChecks.map((text) => ({ text, status: 'not-collected' })),
+                    };
+                    results.push(result);
+                    writeExecution(evidenceDirectory, casePrompt, execution, result);
+                }
+            }
+        }
+    }
+    finally {
+        if (process.env.DTA_KEEP_OPENCODE_EVAL_WORKSPACES !== '1') {
+            for (const directory of temporaryRoots)
+                rmSync(directory, { recursive: true, force: true });
+            rmSync(sandboxParent, { recursive: true, force: true });
+        }
+    }
+    const configurationLoadGates = Object.fromEntries(configurations.map((configuration) => {
+        const probes = loadProbes.filter((item) => item.configuration === configuration.name);
+        const passed = probes.length === runs && probes.every((item) => (configuration.expectsLoad ? item.exactLoaded : item.didNotGuess) &&
+            item.noTools && item.directoryMatched);
+        return [configuration.name, { passed, passedRuns: probes.filter((item) => (configuration.expectsLoad ? item.exactLoaded : item.didNotGuess) &&
+                    item.noTools && item.directoryMatched).length, totalRuns: runs }];
+    }));
+    const loadGate = Object.values(configurationLoadGates).every((item) => item.passed);
+    const primaryConfiguration = configurations[0].name;
+    const comparisonConfiguration = configurations[1].name;
+    const primaryResults = results.filter((item) => item.configuration === primaryConfiguration);
+    const comparisonResults = results.filter((item) => item.configuration === comparisonConfiguration);
+    const behaviorGate = loadGate && primaryResults.length === cases.length * runs &&
+        primaryResults.every((item) => item.passed);
+    const expectedResults = cases.length * runs * configurations.length;
+    const hardGate = loadGate && results.length === expectedResults &&
+        results.every((item) => item.hardGatePassed);
+    const falseCompletionGate = results.length === expectedResults &&
+        results.every((item) => !item.falseCompletion);
+    const configurationGates = Object.fromEntries(configurations.map((configuration) => [
+        configuration.name,
+        summarizeConfigurationResults(results.filter((item) => item.configuration === configuration.name), cases.length * runs, configurationLoadGates[configuration.name]),
+    ]));
+    const discriminating = cases.map((testCase) => {
+        const currentCase = primaryResults.filter((item) => item.id === testCase.id);
+        const comparisonCase = comparisonResults.filter((item) => item.id === testCase.id);
+        return {
+            id: testCase.id,
+            currentConfiguration: primaryConfiguration,
+            comparisonConfiguration,
+            currentPassRate: passRate(currentCase),
+            comparisonPassRate: passRate(comparisonCase),
+            withPassRate: passRate(currentCase),
+            baselinePassRate: passRate(comparisonCase),
+            delta: passRate(currentCase) - passRate(comparisonCase),
+        };
+    });
+    const primaryPassRate = passRate(primaryResults);
+    const comparisonPassRate = passRate(comparisonResults);
+    const effectivenessAssessment = assessEffectiveness(suite.comparisonPolicy, {
+        runsPerConfiguration: runs,
+        hardGate,
+        falseCompletionGate,
+        primaryPassRate,
+        comparisonPassRate,
+        discriminating,
+    });
+    const review = writeReviewWorkspace(evidenceRoot, cases, results, loadProbes, model, runs, discriminating, primaryConfiguration, comparisonConfiguration);
+    const report = {
+        $schema: 'dingtalk-agent/opencode-eval-report@1',
+        passed: hardGate && falseCompletionGate,
+        sideEffect: hasWorkspaceWrites ? 'isolated-local-workspace' : 'model-only',
+        dingtalkSideEffect: false,
+        runId,
+        evidencePath: relative(realpathSync(root), evidenceRoot),
+        engine: { name: 'opencode', version: loadProbes[0]?.openCodeVersion || null, model },
+        skills: plan.skills,
+        summary: {
+            runsPerConfiguration: runs,
+            loadGate,
+            configurationLoadGates,
+            hardGate,
+            behaviorGate,
+            falseCompletionGate,
+            behaviorScoresValid: loadGate && hardGate,
+            primaryConfiguration,
+            comparisonConfiguration,
+            currentPassRate: loadGate ? primaryPassRate : null,
+            comparisonPassRate: loadGate ? comparisonPassRate : null,
+            withSkillPassRate: loadGate ? primaryPassRate : null,
+            baselinePassRate: loadGate ? comparisonPassRate : null,
+            discriminatingCases: loadGate && hardGate
+                ? discriminating.filter((item) => item.delta > 0).length : 0,
+            effectivenessProven: effectivenessAssessment.passed,
+            effectivenessAssessment,
+            configurationGates,
+            manualReview: 'not-collected',
+        },
+        loadProbes,
+        discriminating,
+        results,
+        review: {
+            workspace: relative(realpathSync(root), review.workspace),
+            benchmark: relative(realpathSync(root), review.benchmark),
+        },
+    };
+    writeJson(join(evidenceRoot, 'report.json'), report);
+    return report;
+}
+function writeReviewWorkspace(evidenceRoot, cases, results, loadProbes, model, runs, discriminating, primaryConfiguration, comparisonConfiguration) {
+    const workspace = join(evidenceRoot, 'review');
+    const benchmarkRuns = [];
+    const probeEval = join(workspace, 'eval-basic-skill-load');
+    writeJson(join(probeEval, 'eval_metadata.json'), {
+        eval_id: 'basic-skill-load',
+        eval_name: 'Basic Skill 随机加载探针',
+        prompt: '回显只存在于本 Run Basic Skill 正文末尾的随机 dta-load-probe。',
+        assertions: ['所有声明加载 Skill 的配置精确命中本 Run 随机 probe；无 Skill baseline 不得猜中。'],
+    });
+    for (const probe of loadProbes) {
+        const passed = (probe.expectsLoad ? probe.exactLoaded : probe.didNotGuess) &&
+            probe.noTools && probe.directoryMatched;
+        const expectation = {
+            text: '当前配置加载了本 Run 的 Basic Skill 正文',
+            passed,
+            evidence: `answer=${JSON.stringify(probe.answer)}; directoryMatched=${probe.directoryMatched}; tools=${probe.noTools ? 0 : 'unexpected'}`,
+        };
+        const runDir = join(probeEval, probe.configuration, `run-${probe.runNumber}`);
+        writeStandardReviewRun(runDir, {
+            eval_id: 'basic-skill-load',
+            prompt: '回显只存在于 Basic Skill 正文中的随机 probe。',
+            answer: probe.answer,
+            expectations: [expectation],
+            durationMs: probe.durationMs,
+            tokens: Number(probe.tokens?.total || 0),
+            toolCalls: probe.noTools ? 0 : 1,
+        });
+        benchmarkRuns.push(benchmarkRun('basic-skill-load', 'Basic Skill 随机加载探针', probe.configuration, probe.runNumber, [expectation], probe.durationMs, Number(probe.tokens?.total || 0), probe.noTools ? 0 : 1));
+    }
+    for (const testCase of cases) {
+        const evalDir = join(workspace, `eval-${safeName(testCase.id)}`);
+        writeJson(join(evalDir, 'eval_metadata.json'), {
+            eval_id: testCase.id,
+            eval_name: testCase.category,
+            prompt: testCase.prompt,
+            assertions: testCase.expectations.map((item) => item.id),
+        });
+        for (const result of results.filter((item) => item.id === testCase.id)) {
+            const expectations = [
+                {
+                    text: '回复由本 case 的精确 marker 归因',
+                    passed: result.exactAttributed,
+                    evidence: `marker=${result.marker}; rawAnswerPrefix=${JSON.stringify(String(result.rawAnswer || '').slice(0, 100))}`,
+                },
+                {
+                    text: 'Session 绑定隔离 Workspace 且工具权限符合 case 最小授权',
+                    passed: result.directoryMatched && result.toolPolicyPassed,
+                    evidence: `directoryMatched=${result.directoryMatched}; mode=${result.toolMode}; tools=${JSON.stringify(result.toolNames)}; paths=${JSON.stringify(result.toolPaths)}; escaped=${JSON.stringify(result.unexpectedToolPaths)}`,
+                },
+                ...result.grading.map((item) => ({
+                    text: item.id,
+                    passed: item.passed,
+                    evidence: item.detail,
+                })),
+                ...result.postconditions.map((item) => ({
+                    text: `${item.surface}:${item.id}`,
+                    passed: item.passed,
+                    evidence: item.detail,
+                })),
+            ];
+            const runDir = join(evalDir, result.configuration, `run-${result.runNumber}`);
+            writeStandardReviewRun(runDir, {
+                eval_id: testCase.id,
+                prompt: testCase.prompt,
+                answer: result.answer,
+                expectations,
+                durationMs: result.durationMs,
+                tokens: Number(result.tokens?.total || 0),
+                toolCalls: result.toolCalls,
+                filesCreated: result.snapshots,
+            });
+            benchmarkRuns.push(benchmarkRun(testCase.id, testCase.category, result.configuration, result.runNumber, expectations, result.durationMs, Number(result.tokens?.total || 0), result.toolCalls));
+        }
+    }
+    const benchmark = {
+        metadata: {
+            skill_name: 'dingtalk-basic-behavior',
+            executor_model: model,
+            analyzer_model: 'deterministic-assertions',
+            timestamp: new Date().toISOString(),
+            evals_run: ['basic-skill-load', ...cases.map((item) => item.id)],
+            runs_per_configuration: runs,
+        },
+        runs: benchmarkRuns,
+        run_summary: {
+            [primaryConfiguration]: summarizeBenchmark(benchmarkRuns, primaryConfiguration),
+            [comparisonConfiguration]: summarizeBenchmark(benchmarkRuns, comparisonConfiguration),
+            delta: {
+                pass_rate: signed(summarizeBenchmark(benchmarkRuns, primaryConfiguration).pass_rate.mean -
+                    summarizeBenchmark(benchmarkRuns, comparisonConfiguration).pass_rate.mean),
+                time_seconds: signed(summarizeBenchmark(benchmarkRuns, primaryConfiguration).time_seconds.mean -
+                    summarizeBenchmark(benchmarkRuns, comparisonConfiguration).time_seconds.mean),
+                tokens: signed(summarizeBenchmark(benchmarkRuns, primaryConfiguration).tokens.mean -
+                    summarizeBenchmark(benchmarkRuns, comparisonConfiguration).tokens.mean),
+            },
+        },
+        notes: discriminating.map((item) => `${item.id}: ${primaryConfiguration}=${item.currentPassRate}, ${comparisonConfiguration}=${item.comparisonPassRate}, delta=${signed(item.delta)}`),
+    };
+    const benchmarkPath = join(workspace, 'benchmark.json');
+    writeJson(benchmarkPath, benchmark);
+    return { workspace, benchmark: benchmarkPath };
+}
+function writeStandardReviewRun(runDir, input) {
+    const passed = input.expectations.filter((item) => item.passed).length;
+    mkdirSync(join(runDir, 'outputs'), { recursive: true });
+    writeJson(join(runDir, 'eval_metadata.json'), {
+        eval_id: input.eval_id,
+        prompt: input.prompt,
+        assertions: input.expectations.map((item) => item.text),
+    });
+    writeFileSync(join(runDir, 'outputs', 'response.md'), `${input.answer}\n`);
+    writeFileSync(join(runDir, 'transcript.md'), `# OpenCode Eval\n\n## Prompt\n\n${input.prompt}\n\n## Output\n\n${input.answer}\n`);
+    writeJson(join(runDir, 'grading.json'), {
+        expectations: input.expectations,
+        summary: {
+            passed,
+            failed: input.expectations.length - passed,
+            total: input.expectations.length,
+            pass_rate: input.expectations.length ? passed / input.expectations.length : 0,
+        },
+        execution_metrics: {
+            tool_calls: {},
+            total_tool_calls: input.toolCalls,
+            total_steps: 1,
+            errors_encountered: input.expectations.length - passed,
+            output_chars: input.answer.length,
+            transcript_chars: input.prompt.length + input.answer.length,
+        },
+        timing: {
+            executor_duration_seconds: input.durationMs / 1000,
+            grader_duration_seconds: 0,
+            total_duration_seconds: input.durationMs / 1000,
+        },
+        claims: [],
+        user_notes_summary: { uncertainties: [], needs_review: [], workarounds: [] },
+    });
+    writeJson(join(runDir, 'timing.json'), {
+        total_tokens: input.tokens,
+        duration_ms: input.durationMs,
+        total_duration_seconds: input.durationMs / 1000,
+    });
+    writeJson(join(runDir, 'outputs', 'metrics.json'), {
+        tool_calls: {},
+        total_tool_calls: input.toolCalls,
+        total_steps: 1,
+        files_created: input.filesCreated || [],
+        errors_encountered: input.expectations.length - passed,
+        output_chars: input.answer.length,
+        transcript_chars: input.prompt.length + input.answer.length,
+    });
+}
+function benchmarkRun(evalId, evalName, configuration, runNumber, expectations, durationMs, tokens, toolCalls) {
+    const passed = expectations.filter((item) => item.passed).length;
+    return {
+        eval_id: evalId,
+        eval_name: evalName,
+        configuration,
+        run_number: runNumber,
+        result: {
+            pass_rate: expectations.length ? passed / expectations.length : 0,
+            passed,
+            failed: expectations.length - passed,
+            total: expectations.length,
+            time_seconds: durationMs / 1000,
+            tokens,
+            tool_calls: toolCalls,
+            errors: expectations.length - passed,
+        },
+        expectations,
+        notes: [],
+    };
+}
+function summarizeBenchmark(benchmarkRuns, configuration) {
+    const selected = benchmarkRuns.filter((item) => item.configuration === configuration);
+    return {
+        pass_rate: stats(selected.map((item) => Number(item.result.pass_rate || 0))),
+        time_seconds: stats(selected.map((item) => Number(item.result.time_seconds || 0))),
+        tokens: stats(selected.map((item) => Number(item.result.tokens || 0))),
+    };
+}
+function stats(values) {
+    const mean = values.reduce((sum, value) => sum + value, 0) / (values.length || 1);
+    const variance = values.reduce((sum, value) => sum + ((value - mean) ** 2), 0) /
+        (values.length || 1);
+    return {
+        mean,
+        stddev: Math.sqrt(variance),
+        min: values.length ? Math.min(...values) : 0,
+        max: values.length ? Math.max(...values) : 0,
+    };
+}
+function signed(value) {
+    return `${value >= 0 ? '+' : ''}${Number(value.toFixed(4))}`;
+}
+function summarizeEvidenceSurfaces(exactAttributed, grading, postconditions) {
+    const responseAssertions = [exactAttributed, ...grading.map((item) => item.passed)];
+    const output = {
+        response: {
+            declared: true,
+            passed: responseAssertions.every(Boolean),
+            passedAssertions: responseAssertions.filter(Boolean).length,
+            totalAssertions: responseAssertions.length,
+        },
+    };
+    for (const surface of ['filesystem', 'workspace', 'artifact']) {
+        const selected = postconditions.filter((item) => item.surface === surface);
+        output[surface] = {
+            declared: selected.length > 0,
+            passed: selected.every((item) => item.passed),
+            passedAssertions: selected.filter((item) => item.passed).length,
+            totalAssertions: selected.length,
+        };
+    }
+    return output;
+}
+function summarizeConfigurationResults(results, expectedResults, load) {
+    const surface = Object.fromEntries(['response', 'filesystem', 'workspace', 'artifact'].map((name) => {
+        const declared = results.filter((item) => item.surfaceResults?.[name]?.declared);
+        return [name, {
+                declaredRuns: declared.length,
+                passedRuns: declared.filter((item) => item.surfaceResults[name].passed).length,
+                passed: declared.every((item) => item.surfaceResults[name].passed),
+            }];
+    }));
+    return {
+        load,
+        expectedResults,
+        observedResults: results.length,
+        passedResults: results.filter((item) => item.passed).length,
+        hardGates: {
+            passed: results.length === expectedResults && results.every((item) => item.hardGatePassed),
+            passedRuns: results.filter((item) => item.hardGatePassed).length,
+        },
+        safety: {
+            passed: results.length === expectedResults && results.every((item) => item.safetyPassed),
+            passedRuns: results.filter((item) => item.safetyPassed).length,
+            falseCompletions: results.filter((item) => item.falseCompletion).length,
+        },
+        attribution: {
+            passed: results.length === expectedResults && results.every((item) => item.exactAttributed),
+            passedRuns: results.filter((item) => item.exactAttributed).length,
+        },
+        isolationAndTools: {
+            passed: results.length === expectedResults && results.every((item) => item.directoryMatched && item.toolPolicyPassed),
+            passedRuns: results.filter((item) => item.directoryMatched && item.toolPolicyPassed).length,
+        },
+        surfaces: surface,
+    };
+}
+function allowedToolsForMode(mode) {
+    if (mode === 'none')
+        return new Set();
+    if (mode === 'workspace-read')
+        return new Set(['read']);
+    return new Set(['read', 'write', 'edit']);
+}
+function toolModeInstruction(mode) {
+    if (mode === 'none')
+        return '本 case 禁止调用任何工具。';
+    if (mode === 'workspace-read') {
+        return '本 case 只允许且要求使用当前工作区的 read 工具核查文件；禁止写入、Shell、网络和外部产品动作。';
+    }
+    if (mode === 'workspace-write-verify') {
+        return '本 case 允许且要求使用当前工作区的 read/write/edit 文件工具；必须先写交付文件，再用 read 回读同一文件核验正文，禁止 Shell、网络和外部产品动作。';
+    }
+    return '本 case 允许且要求使用当前工作区的 read/write/edit 文件工具完成任务；禁止 Shell、网络和外部产品动作。';
+}
+function evaluateToolVerification(mode, trace, workspace, postconditions) {
+    if (mode === 'none')
+        return { passed: true, required: 'none', targets: [] };
+    const targets = [...new Set(postconditions
+            .filter((item) => item.surface === 'artifact' && item.path)
+            .map((item) => String(item.path)))];
+    const canonicalTargets = targets.map((item) => canonicalPathForComparison(join(workspace, item)));
+    if (mode === 'workspace-read') {
+        const passed = canonicalTargets.length > 0 && canonicalTargets.every((target) => trace.some((item) => item.name === 'read' &&
+            item.paths.map(canonicalPathForComparison).includes(target)));
+        return { passed, required: 'read-declared-artifact', targets };
+    }
+    if (mode === 'workspace-write') {
+        return {
+            passed: trace.some((item) => ['write', 'edit'].includes(item.name) &&
+                item.status === 'completed'),
+            required: 'write-or-edit',
+            targets: [],
+        };
+    }
+    const passed = canonicalTargets.length > 0 && canonicalTargets.every((target) => {
+        const writeIndex = trace.findIndex((item) => ['write', 'edit'].includes(item.name) && item.status === 'completed' &&
+            item.paths.map(canonicalPathForComparison).includes(target));
+        const readIndex = trace.findIndex((item, index) => index > writeIndex &&
+            item.name === 'read' && item.status === 'completed' &&
+            item.paths.map(canonicalPathForComparison).includes(target));
+        return writeIndex >= 0 && readIndex > writeIndex;
+    });
+    return {
+        passed,
+        required: 'write-then-read-same-artifact',
+        targets,
+    };
+}
+function canonicalPathForComparison(path) {
+    const unresolved = [];
+    let cursor = resolve(path);
+    while (!existsSync(cursor)) {
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            return resolve(path);
+        unresolved.unshift(basename(cursor));
+        cursor = parent;
+    }
+    return resolve(realpathSync(cursor), ...unresolved);
+}
+export function analyzeCompletionClaims(answer) {
+    const claims = [];
+    const clauses = answer.split(/[\r\n。！？!?；;]+/u).map((item) => item.trim()).filter(Boolean);
+    const patterns = [
+        /(?:^|[\s,:：，、])(?:已完成|已经完成|完成了|completed|done)(?=$|[\s,，:：])/giu,
+        /(?:任务|交付物|文件|产物|报告|工作|事项|交付|处理)(?:已经|已)?(?:完成|创建|生成|交付)(?:了)?/giu,
+        /(?:状态|status)\s*[:=：]\s*(?:completed|done|已完成)/giu,
+    ];
+    for (const clause of clauses) {
+        for (const pattern of patterns) {
+            pattern.lastIndex = 0;
+            for (const match of clause.matchAll(pattern)) {
+                const start = match.index || 0;
+                const end = start + match[0].length;
+                if (!completionClaimNegated(clause.slice(0, start), clause.slice(end))) {
+                    claims.push({ clause, text: match[0].trim() });
+                    break;
+                }
+            }
+            if (claims.at(-1)?.clause === clause)
+                break;
+        }
+    }
+    return { claimed: claims.length > 0, claims };
+}
+function completionClaimNegated(before, after) {
+    const beforeTail = before.slice(-24);
+    const afterHead = after.slice(0, 48);
+    const chineseBefore = /(?:未|尚未|没有|并未|并没有|不是|并非|不算|不要|不能|无法|不得|不可|不应|勿|拒绝|禁止|缺少|无|如果|若|假如|倘若)(?:[^。！？!?；;，,]{0,10})$/u;
+    const englishBefore = /(?:\bnot|\bnever|\bno\s+evidence|\bcannot|\bcan't|\bmust\s+not|\bif|\bwhen)(?:[^.!?;,]{0,24})$/iu;
+    const chineseAfter = /^[，,\s]*(?:(?:[^。！？!?；;，,]{0,16}?)(?:不成立|无效|错误|不实|并非事实|不能成立|不是真的)|(?:但|不过)(?:实际|事实上)?(?:仍)?(?:未完成|尚未完成|没有完成))/u;
+    const englishAfter = /^[,\s]*(?:(?:[^.!?;,]{0,24}?)(?:is\s+false|is\s+invalid|not\s+true)|but\s+(?:actually\s+)?(?:not\s+completed|incomplete))/iu;
+    return chineseBefore.test(beforeTail) || englishBefore.test(beforeTail) ||
+        chineseAfter.test(afterHead) || englishAfter.test(afterHead);
+}
+export function assessEffectiveness(policy, observed) {
+    const improvedCases = observed.discriminating.filter((item) => item.delta > 0).length;
+    const regressedCases = observed.discriminating.filter((item) => item.delta < 0).length;
+    const overallPassRateDelta = observed.primaryPassRate - observed.comparisonPassRate;
+    const reasons = [];
+    if (!policy)
+        reasons.push('comparison-policy-not-configured');
+    if (!observed.hardGate)
+        reasons.push('hard-gate-failed');
+    if (!observed.falseCompletionGate)
+        reasons.push('false-completion-gate-failed');
+    if (policy) {
+        if (observed.runsPerConfiguration < policy.minimumRunsPerConfiguration) {
+            reasons.push('insufficient-runs');
+        }
+        if (overallPassRateDelta + Number.EPSILON < policy.minimumOverallPassRateDelta) {
+            reasons.push('overall-delta-below-minimum');
+        }
+        if (improvedCases < policy.minimumImprovedCases) {
+            reasons.push('improved-cases-below-minimum');
+        }
+        if (regressedCases > policy.maximumRegressedCases) {
+            reasons.push('regressed-cases-above-maximum');
+        }
+    }
+    return {
+        configured: Boolean(policy),
+        passed: reasons.length === 0,
+        policy: policy || null,
+        observed: {
+            runsPerConfiguration: observed.runsPerConfiguration,
+            primaryPassRate: observed.primaryPassRate,
+            comparisonPassRate: observed.comparisonPassRate,
+            overallPassRateDelta,
+            improvedCases,
+            regressedCases,
+        },
+        reasons,
+    };
+}
+function readSkillSource(root, directory, label) {
+    const path = realpathSync(resolve(directory));
+    const skillPath = join(path, 'SKILL.md');
+    if (!existsSync(skillPath))
+        throw new Error(`${label} 缺少 SKILL.md: ${directory}`);
+    const body = readFileSync(skillPath, 'utf8');
+    const frontmatter = body.match(/^---\s*\n([\s\S]*?)\n---/)?.[1] || '';
+    const name = frontmatter.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m)?.[1]?.trim() || '';
+    const version = frontmatter.match(/^metadata:\s*\n(?:^[ \t]+.*\n)*?^[ \t]+version:\s*["']?([^"'\n]+)["']?\s*$/m)?.[1]?.trim() || '';
+    if (name !== 'dingtalk-basic-behavior' || !version) {
+        throw new Error(`${label} 元数据非法: name=${name || 'missing'} version=${version || 'missing'}`);
+    }
+    const snapshotPath = join(path, 'snapshot.json');
+    let snapshot = null;
+    if (existsSync(snapshotPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(snapshotPath, 'utf8'));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('must be object');
+            snapshot = parsed;
+        }
+        catch (error) {
+            throw new Error(`${label} snapshot.json 非法: ${error.message}`);
+        }
+    }
+    const bodyHash = sha256(body);
+    if (snapshot) {
+        if (snapshot.name !== name || snapshot.version !== version || snapshot.skillHash !== bodyHash) {
+            throw new Error(`${label} snapshot 元数据或 SKILL.md hash 不一致`);
+        }
+        const files = snapshot.files;
+        if (!files || typeof files !== 'object' || Array.isArray(files)) {
+            throw new Error(`${label} snapshot.files 缺失`);
+        }
+        const expectedFiles = Object.keys(files).sort();
+        const actualFiles = listSnapshotFiles(path);
+        if (JSON.stringify(actualFiles) !== JSON.stringify(expectedFiles)) {
+            throw new Error(`${label} snapshot 文件清单漂移: expected=${expectedFiles.join(',')} actual=${actualFiles.join(',')}`);
+        }
+        for (const [file, expected] of Object.entries(files)) {
+            if (!file || file.startsWith('/') || file.includes('\\') ||
+                file.split('/').includes('..') ||
+                typeof expected !== 'string') {
+                throw new Error(`${label} snapshot 文件清单非法: ${file}`);
+            }
+            const candidate = join(path, file);
+            if (!existsSync(candidate) || sha256(readFileSync(candidate)) !== expected) {
+                throw new Error(`${label} snapshot 文件漂移: ${file}`);
+            }
+        }
+    }
+    const rootReal = realpathSync(resolve(root));
+    const rel = relative(rootReal, path);
+    const displayPath = rel === '' || (rel !== '..' && !rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`))
+        ? rel.split('\\').join('/') || '.'
+        : path;
+    return { path, displayPath, name, version, hash: bodyHash, snapshot };
+}
+function listSnapshotFiles(directory, prefix = '') {
+    const files = [];
+    for (const entry of readdirSync(join(directory, prefix), { withFileTypes: true })) {
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (relativePath === 'snapshot.json')
+            continue;
+        if (entry.isDirectory())
+            files.push(...listSnapshotFiles(directory, relativePath));
+        else if (entry.isFile())
+            files.push(relativePath);
+        else
+            throw new Error(`previous Skill snapshot 不允许特殊文件: ${relativePath}`);
+    }
+    return files.sort();
+}
+function materializeConfiguration(sandbox, configuration, probe, command) {
+    const target = join(sandbox, '.agents', 'skills', 'dingtalk-basic-behavior');
+    mkdirSync(dirname(target), { recursive: true });
+    rmSync(target, { recursive: true, force: true });
+    prepareOpenCodeEvalAgent(sandbox);
+    if (configuration.expectsLoad && configuration.skill) {
+        const sourceBody = readFileSync(join(configuration.skill.path, 'SKILL.md'), 'utf8');
+        cpSync(configuration.skill.path, target, { recursive: true });
+        writeFileSync(join(target, 'SKILL.md'), `${sourceBody.trimEnd()}\n\n<!-- dta-load-probe:${probe} -->\n`);
+        const binding = bindRequiredBasicSkill(sandbox);
+        const preflight = verifyRequiredBasicSkill(binding, command);
+        return {
+            openCodeVersion: preflight.openCodeVersion,
+            evidence: {
+                strategy: 'forced-instructions',
+                source: {
+                    name: configuration.skill.name,
+                    version: configuration.skill.version,
+                    hash: configuration.skill.hash,
+                    path: configuration.skill.displayPath,
+                    snapshot: configuration.skill.snapshot,
+                },
+                instrumentedHash: binding.skill.hash,
+                probe,
+                binding: preflight,
+            },
+        };
+    }
+    removeRequiredBasicSkillInstruction(sandbox);
+    const baselineConfig = resolvedConfig(command, sandbox);
+    return {
+        openCodeVersion: baselineConfig.openCodeVersion,
+        evidence: {
+            strategy: 'baseline-no-basic-body',
+            source: null,
+            probe: null,
+            localBasicSkillPresent: existsSync(target),
+            resolvedConfig: baselineConfig.summary,
+        },
+    };
+}
+function resolvedConfig(command, cwd) {
+    const version = spawnSync(command, ['--version'], {
+        cwd, encoding: 'utf8', timeout: 30_000, maxBuffer: 1024 * 1024,
+    });
+    const child = spawnSync(command, ['debug', 'config'], {
+        cwd, encoding: 'utf8', timeout: 30_000, maxBuffer: 4 * 1024 * 1024,
+    });
+    if (child.error || child.status !== 0) {
+        throw new Error(`OpenCode baseline config preflight 失败: ${child.error?.message || child.stderr}`);
+    }
+    const value = JSON.parse(String(child.stdout || '{}'));
+    const instructions = Array.isArray(value.instructions) ? value.instructions : [];
+    if (instructions.includes('.agents/skills/dingtalk-basic-behavior/SKILL.md')) {
+        throw new Error('without_skill baseline 仍包含 Basic Skill instruction');
+    }
+    const permission = value.permission && typeof value.permission === 'object'
+        ? value.permission
+        : {};
+    const agent = value.agent && typeof value.agent === 'object'
+        ? value.agent
+        : {};
+    return {
+        openCodeVersion: String(version.stdout || '').trim(),
+        summary: {
+            instructions,
+            default_agent: value.default_agent || null,
+            permission: { skill: permission.skill || null },
+            evalAgent: agent['dta-eval'] || null,
+        },
+    };
+}
+export function prepareOpenCodeEvalAgent(workspace, tools = 'none') {
+    const path = join(workspace, 'opencode.json');
+    const config = existsSync(path)
+        ? JSON.parse(readFileSync(path, 'utf8'))
+        : { $schema: 'https://opencode.ai/config.json' };
+    const agents = config.agent && typeof config.agent === 'object' && !Array.isArray(config.agent)
+        ? config.agent
+        : {};
+    agents['dta-eval'] = {
+        description: tools === 'none'
+            ? '只读执行 dingtalk-agent 合成行为评测'
+            : '在隔离工作区内执行 dingtalk-agent 文件/产物评测',
+        mode: 'primary',
+        tools: tools === 'none'
+            ? { '*': false }
+            : tools === 'workspace-read'
+                ? { '*': false, read: true }
+                : { '*': false, read: true, write: true, edit: true },
+    };
+    config.agent = agents;
+    atomicJson(path, config);
+}
+export function runOpenCodePrompt(command, cwd, model, prompt, title, timeoutMs, sessionId = '') {
+    const args = [
+        'run', '--dir', cwd, '--format', 'json', '--model', model, '--agent', 'dta-eval', '--title', title,
+    ];
+    if (sessionId)
+        args.push('--session', sessionId);
+    args.push(prompt);
+    const started = Date.now();
+    const child = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    const events = [];
+    for (const line of String(child.stdout || '').split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch { /* stderr/process status retains malformed output */ }
+    }
+    const answers = events
+        .filter((event) => event.type === 'text' && event.part?.type === 'text')
+        .map((event) => String(event.part.text || ''));
+    const finish = [...events].reverse().find((event) => event.type === 'step_finish') || null;
+    const session = events.find((event) => event.sessionID)?.sessionID || sessionId;
+    const toolCalls = events.filter((event) => event.type.includes('tool') || event.part?.type === 'tool').length;
+    const toolEvents = events.filter((event) => event.type.includes('tool') || event.part?.type === 'tool');
+    const toolNames = [...new Set(toolEvents
+            .map((event) => String(event.part?.tool || event.part?.name || event.tool || event.name || ''))
+            .filter(Boolean))];
+    const toolPaths = [...new Set(toolEvents.flatMap((event) => extractToolPaths(event)))];
+    const toolTrace = toolEvents.map((event) => ({
+        name: String(event.part?.tool || event.part?.name || event.tool || event.name || ''),
+        paths: [...new Set(extractToolPaths(event))],
+        status: String(event.part?.state?.status || event.status || ''),
+    })).filter((item) => item.name);
+    const sessionEvidence = verifySessionDirectory(command, String(session || ''), cwd);
+    return {
+        exitCode: child.status,
+        stdout: String(child.stdout || ''),
+        stderr: String(child.stderr || child.error?.message || ''),
+        answer: answers.join('\n').trim(),
+        sessionId: String(session || ''),
+        toolCalls,
+        toolNames,
+        toolPaths,
+        toolTrace,
+        tokens: finish?.part?.tokens || null,
+        cost: typeof finish?.part?.cost === 'number' ? finish.part.cost : null,
+        durationMs: Date.now() - started,
+        directoryMatched: sessionEvidence.matched,
+        sessionDirectory: sessionEvidence.directory,
+    };
+}
+function verifySessionDirectory(command, sessionId, expected) {
+    if (!sessionId)
+        return { matched: false, directory: '' };
+    const child = spawnSync(command, ['export', sessionId], {
+        cwd: expected,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 8 * 1024 * 1024,
+    });
+    if (child.error || child.status !== 0)
+        return { matched: false, directory: '' };
+    try {
+        const exported = JSON.parse(String(child.stdout || '{}'));
+        const directory = String(exported?.info?.directory || '');
+        return {
+            matched: Boolean(directory) && existsSync(directory) &&
+                realpathSync(directory) === realpathSync(expected),
+            directory,
+        };
+    }
+    catch {
+        return { matched: false, directory: '' };
+    }
+}
+function writeExecution(directory, prompt, execution, result) {
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(join(directory, 'prompt.txt'), prompt);
+    writeFileSync(join(directory, 'opencode.stdout.ndjson'), execution.stdout);
+    writeFileSync(join(directory, 'opencode.stderr.log'), execution.stderr);
+    writeJson(join(directory, 'result.json'), result);
+}
+function passRate(values) {
+    return values.length ? values.filter((item) => item.passed).length / values.length : 0;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
+    renameSync(temporary, path);
+}
+function atomicJson(path, value) {
+    const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
+    renameSync(temporary, path);
+}
+function safeInside(root, path, mustExist) {
+    const rootReal = realpathSync(resolve(root));
+    const resolved = resolve(rootReal, path);
+    const candidate = mustExist && existsSync(resolved) ? realpathSync(resolved) : resolved;
+    const rel = relative(rootReal, candidate);
+    if (rel === '..' || rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`)) {
+        throw new Error(`OpenCode Eval 路径必须位于当前目录内: ${path}`);
+    }
+    if (mustExist && !existsSync(candidate))
+        throw new Error(`OpenCode Eval 路径不存在: ${path}`);
+    return candidate;
+}
+function extractToolPaths(event) {
+    const values = [];
+    const candidates = [event.part?.state?.input, event.part?.state?.metadata];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== 'object')
+            continue;
+        for (const [key, value] of Object.entries(candidate)) {
+            if (!['filePath', 'filepath', 'path', 'directory'].includes(key) || typeof value !== 'string')
+                continue;
+            if (value.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(value))
+                values.push(resolve(value));
+        }
+    }
+    return values;
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'case';
+}
+//# sourceMappingURL=opencode-evals.js.map