@xdxer/dingtalk-agent 0.1.4-beta.8 → 0.1.4

package/dist/src/opencode-evals.js

@@ -0,0 +1,1547 @@
+// OpenCode 本地对照评测：同一 Agent body / 模型 / case 分别运行两个 Basic Skill 配置。
+// 只调用模型并保存 trace；按 case 最小授权隔离文件工具，不连接 DWS 或执行外部动作。
+import { createHash, randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, parse, 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';
+import { bundledSkillPath } from './skill-manager.js';
+import { createIsolatedOpenCodeHost } from './opencode-isolation.js';
+import { countInstructionsForPath, instructionUsesGlob } from './instruction-path.js';
+export const OPENCODE_LOAD_PROBE_PROMPT = '这是加载链路探针，不是业务问题。只依据已强制注入的 Basic Skill 正文末尾注释回答；' +
+    '若能看到 `dta-load-probe`，严格输出 `dta-load-probe=<值>`；否则严格输出 `dta-load-probe=not-loaded`。' +
+    '禁止猜测、禁止调用工具、不要补充解释。';
+export function loadProbeCorePassed(probe, engineVersion) {
+    const challenge = String(probe.challenge || '');
+    const answer = String(probe.answer || '').trim();
+    const sentinel = 'dta-load-probe=not-loaded';
+    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}';
+    if (!new RegExp(`^dta-load-probe=${uuid}$`).test(challenge) ||
+        probe.exitCode !== 0 || probe.noTools !== true || probe.directoryMatched !== true ||
+        !engineVersion || probe.openCodeVersion !== engineVersion ||
+        !Array.isArray(probe.resolvedInstructions))
+        return false;
+    const expectedCount = probe.expectsLoad === true ? 1 : probe.expectsLoad === false ? 0 : -1;
+    let resolvedCount = -1;
+    try {
+        resolvedCount = countInstructionsForPath(String(probe.sessionDirectory || ''), probe.resolvedInstructions, '.agents/skills/dingtalk-basic-behavior/SKILL.md');
+    }
+    catch {
+        return false;
+    }
+    if (resolvedCount !== expectedCount)
+        return false;
+    return probe.expectsLoad === true
+        ? probe.expected === challenge && answer === challenge && probe.exactLoaded === true
+        : probe.expected === sentinel && answer === sentinel && answer !== challenge &&
+            probe.didNotGuess === true && probe.baselineDidNotGuess === true;
+}
+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 = options.loadOnly ? [] : suite.cases.filter((item) => lanes.has(item.lane) && item.kind !== 'load-probe' &&
+        (!requestedCases.size || requestedCases.has(item.id)));
+    if (!cases.length && !options.loadOnly)
+        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, bundledSkillPath(packageRoot, 'dingtalk-basic-behavior'), 'current Skill');
+    let previousSkill = null;
+    if (options.previousSkill) {
+        // Containment and source-shape checks are separate: safeInside resolves aliases for the
+        // former, while readSkillSource must still lstat the caller-selected directory itself.
+        safeInside(root, options.previousSkill, true);
+        previousSkill = readSkillSource(root, resolve(root, options.previousSkill), 'previous Skill');
+    }
+    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');
+    }
+    // Reject source code/config execution surfaces before creating evidence or
+    // starting any OpenCode child process.
+    assertCopyableWorkspaceTree(workspace);
+    assertSafeEvalProjectConfig(workspace);
+    const runId = `opencode_eval_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const evidenceRoot = safeInside(root, options.out || join('.dingtalk-agent', 'opencode-eval-results', runId), false);
+    if (pathEntryExists(evidenceRoot)) {
+        throw new Error(`OpenCode Eval output 已存在，拒绝覆盖: ${relative(root, evidenceRoot)}`);
+    }
+    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';
+                    },
+                });
+                assertCopyableWorkspaceTree(sandbox, false);
+                initializeIsolatedWorktree(sandbox);
+                const host = createIsolatedOpenCodeHost(model.split('/')[0], options.environment || process.env);
+                const environment = { ...host.environment, PWD: sandbox };
+                try {
+                    for (const configured of configurations) {
+                        if (!configured.skill)
+                            continue;
+                        assertSkillTreeMatches(inspectSkillTree(configured.skill.path, `${configured.name} Skill`), configured.skill.tree, `${configured.name} Skill`);
+                    }
+                    const materialized = materializeConfiguration(sandbox, configuration, probe, command, environment);
+                    const configEvidence = {
+                        configuration: configuration.name,
+                        runNumber,
+                        ...materialized.evidence,
+                    };
+                    writeJson(join(evidenceRoot, 'configurations', configuration.name, `run-${runNumber}.json`), configEvidence);
+                    const probePrompt = OPENCODE_LOAD_PROBE_PROMPT;
+                    const probeExecution = runOpenCodePrompt(command, sandbox, model, probePrompt, `DTA load probe ${runNumber} ${configuration.name}`, timeoutMs, '', environment);
+                    const exactProbe = `dta-load-probe=${probe}`;
+                    const baselineSentinel = 'dta-load-probe=not-loaded';
+                    const expectedAnswer = configuration.expectsLoad ? exactProbe : baselineSentinel;
+                    const probeEvidenceDirectory = join(evidenceRoot, 'load-probes', configuration.name, `run-${runNumber}`);
+                    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,
+                        challenge: exactProbe,
+                        expected: expectedAnswer,
+                        answer: probeExecution.answer,
+                        exactLoaded: configuration.expectsLoad
+                            ? probeExecution.answer.trim() === exactProbe : null,
+                        didNotGuess: configuration.expectsLoad
+                            ? null : probeExecution.answer.trim() === baselineSentinel &&
+                            probeExecution.answer.trim() !== exactProbe,
+                        baselineDidNotGuess: configuration.expectsLoad
+                            ? null : probeExecution.answer.trim() === baselineSentinel &&
+                            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,
+                        resolvedInstructions: Array.isArray(materialized.evidence.binding?.resolvedInstructions)
+                            ? materialized.evidence.binding.resolvedInstructions : [],
+                        raw: {
+                            stdoutPath: relative(evidenceRoot, join(probeEvidenceDirectory, 'opencode.stdout.ndjson')).split('\\').join('/'),
+                            stdoutHash: sha256(probeExecution.stdout),
+                            stderrPath: relative(evidenceRoot, join(probeEvidenceDirectory, 'opencode.stderr.log')).split('\\').join('/'),
+                            stderrHash: sha256(probeExecution.stderr),
+                            exportStdoutPath: relative(evidenceRoot, join(probeEvidenceDirectory, 'opencode.export.stdout.json')).split('\\').join('/'),
+                            exportStdoutHash: sha256(probeExecution.sessionExport.stdout),
+                            exportStderrPath: relative(evidenceRoot, join(probeEvidenceDirectory, 'opencode.export.stderr.log')).split('\\').join('/'),
+                            exportStderrHash: sha256(probeExecution.sessionExport.stderr),
+                            exportExitCode: probeExecution.sessionExport.exitCode,
+                        },
+                    };
+                    loadProbes.push(probeResult);
+                    writeExecution(probeEvidenceDirectory, probePrompt, probeExecution, probeResult);
+                    const sessions = new Map();
+                    for (const testCase of cases) {
+                        const toolMode = testCase.execution?.tools || 'none';
+                        prepareOpenCodeEvalAgent(sandbox, toolMode);
+                        resolveOpenCodeEvalAgent(command, sandbox, environment);
+                        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, environment);
+                        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,
+                            sessionExport: {
+                                exitCode: execution.sessionExport.exitCode,
+                                stdoutPath: relative(evidenceRoot, join(evidenceDirectory, 'opencode.export.stdout.json')).split('\\').join('/'),
+                                stdoutHash: sha256(execution.sessionExport.stdout),
+                                stderrPath: relative(evidenceRoot, join(evidenceDirectory, 'opencode.export.stderr.log')).split('\\').join('/'),
+                                stderrHash: sha256(execution.sessionExport.stderr),
+                            },
+                            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 {
+                    host.dispose();
+                }
+            }
+        }
+    }
+    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 engineVersion = String(loadProbes[0]?.openCodeVersion || '');
+    const configurationLoadGates = Object.fromEntries(configurations.map((configuration) => {
+        const probes = loadProbes.filter((item) => item.configuration === configuration.name);
+        const passedRuns = probes.filter((item) => loadProbeCorePassed(item, engineVersion)).length;
+        const passed = probes.length === runs && passedRuns === runs;
+        return [configuration.name, { passed, passedRuns, 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 = !options.loadOnly && 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: engineVersion || null, model },
+        skills: plan.skills,
+        summary: {
+            runsPerConfiguration: runs,
+            loadGate,
+            configurationLoadGates,
+            hardGate,
+            behaviorGate,
+            falseCompletionGate,
+            behaviorScoresValid: !options.loadOnly && loadGate && hardGate,
+            primaryConfiguration,
+            comparisonConfiguration,
+            currentPassRate: loadGate && !options.loadOnly ? primaryPassRate : null,
+            comparisonPassRate: loadGate && !options.loadOnly ? comparisonPassRate : null,
+            withSkillPassRate: loadGate && !options.loadOnly ? primaryPassRate : null,
+            baselinePassRate: loadGate && !options.loadOnly ? comparisonPassRate : null,
+            discriminatingCases: loadGate && hardGate && !options.loadOnly
+                ? 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 = loadProbeCorePassed(probe, String(loadProbes[0]?.openCodeVersion || ''));
+        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 requestedPath = resolve(directory);
+    if (!pathEntryExists(requestedPath)) {
+        throw new Error(`${label} 路径不存在: ${directory}`);
+    }
+    const requestedInfo = lstatSync(requestedPath);
+    if (requestedInfo.isSymbolicLink()) {
+        throw new Error(`${label} 根目录不允许 symlink: ${directory}`);
+    }
+    if (!requestedInfo.isDirectory()) {
+        throw new Error(`${label} 根路径必须是目录: ${directory}`);
+    }
+    const path = realpathSync(requestedPath);
+    const tree = inspectSkillTree(path, label);
+    const skillPath = join(path, 'SKILL.md');
+    if (!tree.some((entry) => entry.path === 'SKILL.md' && entry.kind === 'file')) {
+        throw new Error(`${label} 缺少普通文件 SKILL.md: ${directory}`);
+    }
+    const body = readFileSync(skillPath, 'utf8');
+    const skillEntry = tree.find((entry) => entry.path === 'SKILL.md' && entry.kind === 'file');
+    if (skillEntry.hash !== sha256(body)) {
+        throw new Error(`${label} SKILL.md 在读取期间发生变化`);
+    }
+    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');
+    const snapshotTreeEntry = tree.find((entry) => entry.path === 'snapshot.json' && entry.kind === 'file');
+    let snapshot = null;
+    if (snapshotTreeEntry) {
+        try {
+            const snapshotBody = readFileSync(snapshotPath, 'utf8');
+            if (snapshotTreeEntry.hash !== sha256(snapshotBody)) {
+                throw new Error('changed while reading');
+            }
+            const parsed = JSON.parse(snapshotBody);
+            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 = tree
+            .filter((entry) => entry.kind === 'file' && entry.path !== 'snapshot.json')
+            .map((entry) => entry.path)
+            .sort();
+        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 = tree.find((entry) => entry.path === file && entry.kind === 'file');
+            if (!candidate || candidate.hash !== 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, tree };
+}
+function inspectSkillTree(directory, label) {
+    const rootInfo = lstatSync(directory);
+    if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) {
+        throw new Error(`${label} 根路径必须是普通目录`);
+    }
+    const entries = [];
+    const pending = [''];
+    while (pending.length) {
+        const prefix = pending.pop();
+        const current = prefix ? join(directory, prefix) : directory;
+        for (const entry of readdirSync(current, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            const relativePath = (prefix ? `${prefix}/${entry.name}` : entry.name)
+                .split('\\').join('/');
+            const candidate = join(directory, relativePath);
+            const before = lstatSync(candidate);
+            if (before.isSymbolicLink()) {
+                throw new Error(`${label} 不允许 symlink: ${relativePath}`);
+            }
+            if (before.isDirectory()) {
+                entries.push({ path: relativePath, kind: 'directory' });
+                pending.push(relativePath);
+                continue;
+            }
+            if (!before.isFile()) {
+                throw new Error(`${label} 不允许特殊文件: ${relativePath}`);
+            }
+            if (before.nlink !== 1) {
+                throw new Error(`${label} 不允许 hardlink: ${relativePath}`);
+            }
+            const hash = sha256(readFileSync(candidate));
+            const after = lstatSync(candidate);
+            if (!after.isFile() || after.isSymbolicLink() || after.nlink !== 1 ||
+                after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size) {
+                throw new Error(`${label} 文件在校验期间发生变化: ${relativePath}`);
+            }
+            entries.push({ path: relativePath, kind: 'file', hash });
+        }
+    }
+    return entries.sort((left, right) => left.path.localeCompare(right.path));
+}
+function assertSkillTreeMatches(actual, expected, label) {
+    if (stableJson(actual) !== stableJson(expected)) {
+        throw new Error(`${label} 全树在加载前发生漂移`);
+    }
+}
+function materializeConfiguration(sandbox, configuration, probe, command, environment) {
+    const target = join(sandbox, '.agents', 'skills', 'dingtalk-basic-behavior');
+    mkdirSync(dirname(target), { recursive: true });
+    rmSync(target, { recursive: true, force: true });
+    if (configuration.expectsLoad && configuration.skill) {
+        const sourceTree = inspectSkillTree(configuration.skill.path, `${configuration.name} Skill source`);
+        assertSkillTreeMatches(sourceTree, configuration.skill.tree, `${configuration.name} Skill source`);
+        const sourceSkillPath = join(configuration.skill.path, 'SKILL.md');
+        const sourceBody = readFileSync(sourceSkillPath, 'utf8');
+        if (sha256(sourceBody) !== configuration.skill.hash) {
+            throw new Error(`${configuration.name} Skill source SKILL.md 在复制前发生漂移`);
+        }
+        cpSync(configuration.skill.path, target, { recursive: true });
+        const copiedTree = inspectSkillTree(target, `${configuration.name} Skill copy`);
+        assertSkillTreeMatches(copiedTree, sourceTree, `${configuration.name} Skill copy`);
+        const instrumentedBody = `${sourceBody.trimEnd()}\n\n<!-- dta-load-probe:${probe} -->\n`;
+        const targetSkillPath = join(target, 'SKILL.md');
+        const temporarySkillPath = join(target, `.SKILL.md.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+        try {
+            writeFileSync(temporarySkillPath, instrumentedBody, { flag: 'wx' });
+            renameSync(temporarySkillPath, targetSkillPath);
+        }
+        finally {
+            if (pathEntryExists(temporarySkillPath))
+                rmSync(temporarySkillPath, { force: true });
+        }
+        const instrumentedTree = sourceTree.map((entry) => entry.path === 'SKILL.md'
+            ? { ...entry, hash: sha256(instrumentedBody) }
+            : entry);
+        assertSkillTreeMatches(inspectSkillTree(target, `${configuration.name} instrumented Skill`), instrumentedTree, `${configuration.name} instrumented Skill`);
+        prepareOpenCodeEvalAgent(sandbox);
+        const binding = bindRequiredBasicSkill(sandbox);
+        const preflight = verifyRequiredBasicSkill(binding, command, environment);
+        const resolved = resolvedConfig(command, sandbox, environment);
+        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,
+                resolvedConfig: resolved.summary,
+            },
+        };
+    }
+    removeRequiredBasicSkillInstruction(sandbox);
+    prepareOpenCodeEvalAgent(sandbox);
+    const baselineConfig = resolvedConfig(command, sandbox, environment);
+    return {
+        openCodeVersion: baselineConfig.openCodeVersion,
+        evidence: {
+            strategy: 'baseline-no-basic-body',
+            source: null,
+            probe: null,
+            localBasicSkillPresent: existsSync(target),
+            resolvedConfig: baselineConfig.summary,
+        },
+    };
+}
+function resolvedConfig(command, cwd, environment) {
+    const version = spawnSync(command, ['--version'], {
+        cwd, env: environment, encoding: 'utf8', timeout: 30_000, maxBuffer: 1024 * 1024,
+    });
+    const child = spawnSync(command, ['debug', 'config', '--pure'], {
+        cwd, env: environment, 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}`);
+    }
+    if (version.error || version.status !== 0 || !String(version.stdout || '').trim()) {
+        throw new Error(`OpenCode version preflight 失败: ${version.error?.message || version.stderr}`);
+    }
+    const value = JSON.parse(String(child.stdout || '{}'));
+    const verified = validateIsolatedResolvedConfig(value, cwd);
+    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: verified.instructions,
+            default_agent: value.default_agent || null,
+            permission: { skill: permission.skill || null },
+            evalAgent: agent['dta-eval'] || null,
+        },
+    };
+}
+function validateIsolatedResolvedConfig(value, workspace) {
+    const source = JSON.parse(readFileSync(join(workspace, 'opencode.json'), 'utf8'));
+    const expectedInstructions = source.instructions === undefined ? [] : source.instructions;
+    if (!Array.isArray(expectedInstructions) ||
+        expectedInstructions.some((item) => typeof item !== 'string')) {
+        throw new Error('OpenCode Eval project instructions 非法');
+    }
+    const instructions = value.instructions === undefined ? [] : value.instructions;
+    if (!Array.isArray(instructions) || instructions.some((item) => typeof item !== 'string') ||
+        stableJson(instructions) !== stableJson(expectedInstructions)) {
+        throw new Error('OpenCode resolved instructions 被用户级、远端或托管 config 污染');
+    }
+    const plugins = value.plugin === undefined ? [] : value.plugin;
+    if (!Array.isArray(plugins) || plugins.length > 0) {
+        throw new Error('OpenCode resolved plugin 不为空，隔离失败');
+    }
+    const mcp = value.mcp === undefined ? {} : value.mcp;
+    if (!mcp || typeof mcp !== 'object' || Array.isArray(mcp) || Object.keys(mcp).length > 0) {
+        throw new Error('OpenCode resolved MCP 不为空，隔离失败');
+    }
+    if (value.share !== undefined && value.share !== 'disabled') {
+        throw new Error('OpenCode resolved share 未禁用');
+    }
+    const provider = value.provider === undefined ? {} : value.provider;
+    if (!provider || typeof provider !== 'object' || Array.isArray(provider) ||
+        Object.keys(provider).length > 0) {
+        throw new Error('OpenCode resolved provider 不为空，隔离评测拒绝项目级 provider 覆盖');
+    }
+    return { instructions: [...instructions] };
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+export function prepareOpenCodeEvalAgent(workspace, tools = 'none', allowedReadPaths = []) {
+    const path = join(workspace, 'opencode.json');
+    const parsed = existsSync(path)
+        ? JSON.parse(readFileSync(path, 'utf8'))
+        : { $schema: 'https://opencode.ai/config.json' };
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('OpenCode Eval opencode.json 必须是 object');
+    }
+    const config = parsed;
+    if (config.instructions !== undefined &&
+        (!Array.isArray(config.instructions) ||
+            config.instructions.some((item) => typeof item !== 'string'))) {
+        throw new Error('OpenCode Eval instructions 必须是 string array');
+    }
+    for (const instruction of config.instructions || []) {
+        const raw = instruction.trim();
+        const candidate = resolve(workspace, raw);
+        if (!raw || /^https?:\/\//i.test(raw) || raw.startsWith('~/') ||
+            raw.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(raw) ||
+            raw.split(/[\\/]/).includes('..') || instructionUsesGlob(raw) ||
+            !isWorkspacePathInside(workspace, candidate) || !existsSync(candidate)) {
+            throw new Error(`OpenCode Eval instruction 必须是 sandbox 内已存在的本地相对文件: ${instruction}`);
+        }
+        const info = lstatSync(candidate);
+        if (!info.isFile() || info.isSymbolicLink()) {
+            throw new Error(`OpenCode Eval instruction 不是普通文件: ${instruction}`);
+        }
+    }
+    if (config.plugin !== undefined &&
+        (!Array.isArray(config.plugin) || config.plugin.length > 0)) {
+        throw new Error('OpenCode Eval 隔离工作区不允许 plugin');
+    }
+    if (config.mcp !== undefined &&
+        (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp) ||
+            Object.keys(config.mcp).length > 0)) {
+        throw new Error('OpenCode Eval 隔离工作区不允许 MCP');
+    }
+    if (config.agent !== undefined &&
+        (!config.agent || typeof config.agent !== 'object' || Array.isArray(config.agent))) {
+        throw new Error('OpenCode Eval agent 必须是 object');
+    }
+    if (config.skills !== undefined &&
+        (!config.skills || typeof config.skills !== 'object' || Array.isArray(config.skills) ||
+            Object.keys(config.skills).length > 0)) {
+        throw new Error('OpenCode Eval 隔离工作区不允许 skills.paths/urls');
+    }
+    for (const key of ['provider', 'formatter', 'lsp']) {
+        const value = config[key];
+        if (value !== undefined &&
+            (!value || typeof value !== 'object' || Array.isArray(value) ||
+                Object.keys(value).length > 0)) {
+            throw new Error(`OpenCode Eval 隔离工作区不允许项目级 ${key}`);
+        }
+    }
+    const evalAgent = {
+        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 },
+        permission: tools === 'none'
+            ? { '*': 'deny', external_directory: 'deny' }
+            : tools === 'workspace-read'
+                ? {
+                    '*': 'deny',
+                    read: allowedReadPaths.length
+                        ? Object.fromEntries([
+                            ['*', 'deny'],
+                            ...allowedReadPaths.flatMap((item) => {
+                                const absolute = resolve(workspace, item);
+                                const variants = [item, absolute];
+                                if (existsSync(absolute)) {
+                                    const real = realpathSync(absolute);
+                                    variants.push(real, relative(parse(real).root, real));
+                                }
+                                return [...new Set(variants)].map((path) => [path, 'allow']);
+                            }),
+                        ])
+                        : 'allow',
+                    external_directory: 'deny',
+                }
+                : { '*': 'deny', read: 'allow', edit: 'allow', external_directory: 'deny' },
+    };
+    // Rebuild from an allowlist. Provider identity/credentials come only from the
+    // isolated host and explicit --model; executable project surfaces such as
+    // formatter, LSP, plugin, MCP and arbitrary agents never enter the probe.
+    const safeConfig = {
+        $schema: typeof config.$schema === 'string'
+            ? config.$schema : 'https://opencode.ai/config.json',
+        instructions: [...(config.instructions || [])],
+        permission: {
+            skill: { '*': 'deny', 'dingtalk-basic-behavior': 'allow' },
+        },
+        agent: { 'dta-eval': evalAgent },
+        plugin: [],
+        mcp: {},
+        share: 'disabled',
+        autoupdate: false,
+    };
+    atomicJson(path, safeConfig);
+}
+export function resolveOpenCodeEvalAgent(command, workspace, environment = process.env) {
+    const child = spawnSync(command, ['debug', 'config', '--pure'], {
+        cwd: workspace,
+        env: environment,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 4 * 1024 * 1024,
+    });
+    if (child.error || child.status !== 0) {
+        throw new Error(`OpenCode eval agent config preflight 失败: ${child.error?.message || String(child.stderr || child.stdout || '').trim()}`);
+    }
+    const value = JSON.parse(String(child.stdout || '{}'));
+    validateIsolatedResolvedConfig(value, workspace);
+    const agents = value.agent && typeof value.agent === 'object' && !Array.isArray(value.agent)
+        ? value.agent : {};
+    const agent = agents['dta-eval'];
+    if (!agent || typeof agent !== 'object' || Array.isArray(agent)) {
+        throw new Error('OpenCode resolved config 缺少 dta-eval agent');
+    }
+    const source = JSON.parse(readFileSync(join(workspace, 'opencode.json'), 'utf8'));
+    const expected = source?.agent?.['dta-eval'];
+    const normalized = { ...agent };
+    if (normalized.options && typeof normalized.options === 'object' &&
+        !Array.isArray(normalized.options) && Object.keys(normalized.options).length === 0) {
+        delete normalized.options;
+    }
+    if (stableJson(normalized) !== stableJson(expected)) {
+        throw new Error('OpenCode resolved dta-eval 被外部 config 注入或扩权');
+    }
+    return agent;
+}
+export function readOpenCodeVersion(command, workspace, environment = process.env) {
+    const child = spawnSync(command, ['--version'], {
+        cwd: workspace,
+        env: environment,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 1024 * 1024,
+    });
+    const version = String(child.stdout || '').trim();
+    if (child.error || child.status !== 0 || !version) {
+        throw new Error(`OpenCode version preflight 失败: ${child.error?.message || String(child.stderr || child.stdout || '').trim()}`);
+    }
+    return version;
+}
+export function runOpenCodePrompt(command, cwd, model, prompt, title, timeoutMs, sessionId = '', environment = process.env) {
+    const args = [
+        'run', '--pure', '--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,
+        env: environment,
+        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, cwd)))];
+    const toolTrace = toolEvents.map((event) => ({
+        name: String(event.part?.tool || event.part?.name || event.tool || event.name || ''),
+        paths: [...new Set(extractToolPaths(event, cwd))],
+        status: String(event.part?.state?.status || event.status || ''),
+        readWindow: extractReadWindow(event),
+    })).filter((item) => item.name);
+    const sessionEvidence = verifySessionDirectory(command, String(session || ''), cwd, environment);
+    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,
+        sessionExport: {
+            exitCode: sessionEvidence.exitCode,
+            stdout: sessionEvidence.stdout,
+            stderr: sessionEvidence.stderr,
+        },
+    };
+}
+function verifySessionDirectory(command, sessionId, expected, environment) {
+    if (!sessionId) {
+        return { matched: false, directory: '', exitCode: null, stdout: '', stderr: '' };
+    }
+    const child = spawnSync(command, ['export', sessionId], {
+        cwd: expected,
+        env: environment,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 8 * 1024 * 1024,
+    });
+    const stdout = String(child.stdout || '');
+    const stderr = String(child.stderr || child.error?.message || '');
+    if (child.error || child.status !== 0) {
+        return { matched: false, directory: '', exitCode: child.status, stdout, stderr };
+    }
+    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,
+            exitCode: child.status,
+            stdout,
+            stderr,
+        };
+    }
+    catch {
+        return { matched: false, directory: '', exitCode: child.status, stdout, stderr };
+    }
+}
+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);
+    writeFileSync(join(directory, 'opencode.export.stdout.json'), execution.sessionExport.stdout);
+    writeFileSync(join(directory, 'opencode.export.stderr.log'), execution.sessionExport.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 rootLexical = resolve(root);
+    const rootReal = realpathSync(rootLexical);
+    const requested = resolve(rootLexical, path);
+    if (mustExist) {
+        if (!existsSync(requested))
+            throw new Error(`OpenCode Eval 路径不存在: ${path}`);
+        const candidate = realpathSync(requested);
+        if (!isWorkspacePathInside(rootReal, candidate)) {
+            throw new Error(`OpenCode Eval 路径真实位置越出当前目录: ${path}`);
+        }
+        return candidate;
+    }
+    const lexicalRel = relative(rootLexical, requested);
+    let rel = lexicalRel;
+    if (!relativeIsInside(lexicalRel)) {
+        let ancestor = requested;
+        while (!pathEntryExists(ancestor) && dirname(ancestor) !== ancestor)
+            ancestor = dirname(ancestor);
+        const projected = resolve(realpathSync(ancestor), relative(ancestor, requested));
+        if (!isWorkspacePathInside(rootReal, projected)) {
+            throw new Error(`OpenCode Eval 路径必须位于当前目录内: ${path}`);
+        }
+        rel = relative(rootReal, projected);
+    }
+    const resolved = resolve(rootReal, rel);
+    let cursor = rootReal;
+    for (const segment of rel.split(/[\\/]/).filter(Boolean)) {
+        cursor = join(cursor, segment);
+        if (!pathEntryExists(cursor))
+            break;
+        const info = lstatSync(cursor);
+        if (info.isSymbolicLink()) {
+            throw new Error(`OpenCode Eval 输出路径不允许 symlink: ${relative(rootReal, cursor)}`);
+        }
+        if (cursor !== resolved && !info.isDirectory()) {
+            throw new Error(`OpenCode Eval 输出路径祖先不是目录: ${relative(rootReal, cursor)}`);
+        }
+    }
+    let ancestor = resolved;
+    while (!pathEntryExists(ancestor) && dirname(ancestor) !== ancestor)
+        ancestor = dirname(ancestor);
+    const projected = resolve(realpathSync(ancestor), relative(ancestor, resolved));
+    if (!isWorkspacePathInside(rootReal, projected)) {
+        throw new Error(`OpenCode Eval 输出路径真实位置越出当前目录: ${path}`);
+    }
+    return resolved;
+}
+function relativeIsInside(rel) {
+    const separator = process.platform === 'win32' ? '\\' : '/';
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${separator}`));
+}
+function assertCopyableWorkspaceTree(root, excludeControl = true) {
+    const pending = [root];
+    while (pending.length) {
+        const directory = pending.pop();
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            const rel = relative(root, path);
+            const first = rel.split(/[\\/]/)[0];
+            if (excludeControl && ['.git', '.dingtalk-agent'].includes(first))
+                continue;
+            if (first === '.opencode') {
+                throw new Error('OpenCode Eval workspace 不允许 .opencode 可执行扩展目录');
+            }
+            const info = lstatSync(path);
+            if (info.isSymbolicLink()) {
+                throw new Error(`OpenCode Eval workspace 不允许 symlink: ${rel}`);
+            }
+            if (info.isDirectory())
+                pending.push(path);
+            else if (!info.isFile()) {
+                throw new Error(`OpenCode Eval workspace 不允许特殊文件: ${rel}`);
+            }
+        }
+    }
+}
+function assertSafeEvalProjectConfig(workspace) {
+    const path = join(workspace, 'opencode.json');
+    if (!existsSync(path))
+        return;
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('OpenCode Eval opencode.json 必须是 object');
+    }
+    const config = parsed;
+    const instructions = config.instructions === undefined ? [] : config.instructions;
+    if (!Array.isArray(instructions) || instructions.some((item) => typeof item !== 'string')) {
+        throw new Error('OpenCode Eval instructions 必须是 string array');
+    }
+    for (const instruction of instructions) {
+        const raw = instruction.trim();
+        const candidate = resolve(workspace, raw);
+        if (!raw || /^https?:\/\//i.test(raw) || raw.startsWith('~/') ||
+            raw.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(raw) ||
+            raw.split(/[\\/]/).includes('..') || instructionUsesGlob(raw) ||
+            !isWorkspacePathInside(workspace, candidate) || !existsSync(candidate) ||
+            !lstatSync(candidate).isFile()) {
+            throw new Error(`OpenCode Eval instruction 必须是 sandbox 内已存在的本地相对文件: ${instruction}`);
+        }
+    }
+    const forbidden = ['provider', 'formatter', 'lsp', 'skills'];
+    for (const key of forbidden) {
+        const value = config[key];
+        if (value !== undefined &&
+            (!value || typeof value !== 'object' || Array.isArray(value) ||
+                Object.keys(value).length > 0)) {
+            throw new Error(`OpenCode Eval 隔离工作区不允许项目级 ${key}`);
+        }
+    }
+    if (config.plugin !== undefined &&
+        (!Array.isArray(config.plugin) || config.plugin.length > 0)) {
+        throw new Error('OpenCode Eval 隔离工作区不允许 plugin');
+    }
+    if (config.mcp !== undefined &&
+        (!config.mcp || typeof config.mcp !== 'object' || Array.isArray(config.mcp) ||
+            Object.keys(config.mcp).length > 0)) {
+        throw new Error('OpenCode Eval 隔离工作区不允许 MCP');
+    }
+}
+function initializeIsolatedWorktree(workspace) {
+    const command = process.env.DTA_GIT_BIN ||
+        (existsSync('/usr/bin/git') ? '/usr/bin/git' : 'git');
+    const child = spawnSync(command, ['init', '--quiet'], {
+        cwd: workspace,
+        encoding: 'utf8',
+        timeout: 30_000,
+        maxBuffer: 1024 * 1024,
+    });
+    if (child.error || child.status !== 0) {
+        throw new Error(`OpenCode Eval 无法初始化隔离 git worktree: ${child.error?.message || String(child.stderr || child.stdout || '').trim()}`);
+    }
+}
+function pathEntryExists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function extractToolPaths(event, cwd) {
+    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;
+            values.push(value.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(value)
+                ? resolve(value) : resolve(cwd, value));
+        }
+    }
+    return values;
+}
+function extractReadWindow(event) {
+    const input = event.part?.state?.input;
+    return {
+        offset: Number.isInteger(input?.offset) ? Number(input.offset) : null,
+        limit: Number.isInteger(input?.limit) ? Number(input.limit) : null,
+    };
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'case';
+}
+//# sourceMappingURL=opencode-evals.js.map