@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.27

package/dist/src/benchmark-environment-bridge.js

@@ -0,0 +1,515 @@
+import { accessSync, constants, lstatSync, readFileSync, statSync } from 'node:fs';
+import { getuid } from 'node:process';
+import { isAbsolute } from 'node:path';
+import { assertSupportedJsonSchema, validateJsonSchemaValue, ToolArgsError, } from '@deepseek-ai/dsh-tools';
+import { validateTerminalOutputConfig, } from './benchmark-agent-conformance.js';
+// v4(#215 Round 12):terminal_output 携带 closed body schema(结构关键字白名单,
+// 禁数据值注解面);v3 及更早配置缺该面,按契约不兼容 fail-closed。
+const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v4';
+export const BENCHMARK_TOOL_RESULT_SCHEMA_VERSION = 'gotry_benchmark_tool_result_v1';
+export const BENCHMARK_DOMAIN_RECOVERIES = ['none', 'retry_same', 'revise_arguments', 'choose_alternative'];
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+const RECOVERIES = new Set(BENCHMARK_DOMAIN_RECOVERIES);
+const CONFIG_KEYS = ['argv_prefix', 'cwd', 'enabled', 'executable', 'isolation', 'max_output_bytes', 'schema_version', 'terminal_output', 'timeout_ms', 'tools'];
+const INPUT_SCHEMA_MAX_BYTES = 16 * 1024;
+const INPUT_SCHEMA_MAX_DEPTH = 8;
+const INPUT_SCHEMA_MAX_NODES = 256;
+const INPUT_SCHEMA_MAX_PROPERTIES = 256;
+const INPUT_SCHEMA_MAX_ENUM_VALUES = 256;
+const INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH = 512;
+const INPUT_SCHEMA_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'null', 'array', 'object']);
+function plainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function deepFreezeJson(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreezeJson(child);
+    return Object.freeze(value);
+}
+function existingExecutable(value) {
+    if (typeof value !== 'string' || !isAbsolute(value))
+        return false;
+    try {
+        const stat = statSync(value);
+        accessSync(value, constants.X_OK);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function existingDirectory(value) {
+    if (typeof value !== 'string' || !isAbsolute(value))
+        return false;
+    try {
+        return statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function identifiers(value, allowEmpty = false) {
+    return Array.isArray(value) && (allowEmpty || value.length > 0) && value.length <= 64 && new Set(value).size === value.length && value.every(item => typeof item === 'string' && item.length > 0 && IDENTIFIER.test(item));
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).every(key => allowed.includes(key));
+}
+function validDescription(value, required = false) {
+    if (value === undefined)
+        return !required;
+    return typeof value === 'string'
+        && (!required || value.trim().length > 0)
+        && value.length <= INPUT_SCHEMA_MAX_DESCRIPTION_LENGTH
+        && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function scalarMatches(type, value) {
+    if (type === 'string')
+        return typeof value === 'string' && value.length <= 512;
+    if (type === 'number')
+        return typeof value === 'number' && Number.isFinite(value);
+    if (type === 'integer')
+        return typeof value === 'number' && Number.isSafeInteger(value);
+    if (type === 'boolean')
+        return typeof value === 'boolean';
+    return type === 'null' && value === null;
+}
+function validInputSchema(value) {
+    if (!plainObject(value))
+        return false;
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        return false;
+    }
+    if (Buffer.byteLength(serialized, 'utf8') > INPUT_SCHEMA_MAX_BYTES)
+        return false;
+    const pending = [{ node: value, depth: 0 }];
+    const seen = new Set();
+    let nodes = 0;
+    let properties = 0;
+    let enumValues = 0;
+    while (pending.length > 0) {
+        const { node, depth } = pending.pop();
+        if (seen.has(node) || ++nodes > INPUT_SCHEMA_MAX_NODES || depth > INPUT_SCHEMA_MAX_DEPTH)
+            return false;
+        seen.add(node);
+        if (!INPUT_SCHEMA_TYPES.has(String(node.type)) || !validDescription(node.description))
+            return false;
+        if (node.type === 'object') {
+            if (!exactKeys(node, ['type', 'description', 'properties', 'required', 'additionalProperties'])
+                || !plainObject(node.properties)
+                || !Array.isArray(node.required)
+                || node.additionalProperties !== false)
+                return false;
+            const propertyEntries = Object.entries(node.properties);
+            properties += propertyEntries.length;
+            if (properties > INPUT_SCHEMA_MAX_PROPERTIES || propertyEntries.some(([key, child]) => !IDENTIFIER.test(key) || !plainObject(child)))
+                return false;
+            const required = node.required;
+            if (required.length > propertyEntries.length
+                || new Set(required).size !== required.length
+                || required.some(key => typeof key !== 'string' || !Object.hasOwn(node.properties, key)))
+                return false;
+            for (const [, child] of propertyEntries)
+                pending.push({ node: child, depth: depth + 1 });
+            continue;
+        }
+        if (node.type === 'array') {
+            if (!exactKeys(node, ['type', 'description', 'items']) || !plainObject(node.items))
+                return false;
+            pending.push({ node: node.items, depth: depth + 1 });
+            continue;
+        }
+        if (!exactKeys(node, ['type', 'description', 'enum', 'const'])
+            || (Object.hasOwn(node, 'enum') && Object.hasOwn(node, 'const')))
+            return false;
+        if (Object.hasOwn(node, 'const') && !scalarMatches(String(node.type), node.const))
+            return false;
+        if (Object.hasOwn(node, 'enum')) {
+            if (!Array.isArray(node.enum) || node.enum.length === 0 || node.enum.length > 64)
+                return false;
+            enumValues += node.enum.length;
+            if (enumValues > INPUT_SCHEMA_MAX_ENUM_VALUES
+                || new Set(node.enum).size !== node.enum.length
+                || node.enum.some(item => !scalarMatches(String(node.type), item)))
+                return false;
+        }
+    }
+    return value.type === 'object';
+}
+function toolDescriptors(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 64)
+        return false;
+    const names = new Set();
+    return value.every(item => {
+        if (!plainObject(item))
+            return false;
+        const keys = Object.keys(item).sort();
+        const required = ['description', 'domain_outcomes', 'input_schema', 'name'];
+        if (JSON.stringify(keys) !== JSON.stringify([...required, 'output_keys'].sort()))
+            return false;
+        if (typeof item.name !== 'string' || !IDENTIFIER.test(item.name) || names.has(item.name))
+            return false;
+        names.add(item.name);
+        if (!validDescription(item.description, true) || !validInputSchema(item.input_schema))
+            return false;
+        if (!Array.isArray(item.domain_outcomes) || item.domain_outcomes.length > 64)
+            return false;
+        const outcomeKeys = new Set();
+        if (!item.domain_outcomes.every(outcome => plainObject(outcome)
+            && JSON.stringify(Object.keys(outcome).sort()) === JSON.stringify(['code', 'recovery', 'status'])
+            && (outcome.status === 'miss' || outcome.status === 'error')
+            && typeof outcome.code === 'string' && IDENTIFIER.test(outcome.code)
+            && typeof outcome.recovery === 'string' && RECOVERIES.has(outcome.recovery)
+            && !outcomeKeys.has(outcome.code)
+            && (outcomeKeys.add(outcome.code), true)))
+            return false;
+        return identifiers(item.output_keys);
+    });
+}
+// These are passed as direct argv entries (never through a shell), so options
+// such as "-m" and dotted module names are valid. Keep the prefix bounded and
+// reject line/control separators that could make diagnostics ambiguous.
+function argvPrefix(value) {
+    return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every(item => typeof item === 'string'
+        && item.length > 0
+        && item.length <= 256
+        && !item.includes('\0')
+        && !item.includes('\r')
+        && !item.includes('\n'));
+}
+function exactIsolation(value) {
+    if (!plainObject(value))
+        return false;
+    const keys = Object.keys(value).sort();
+    return JSON.stringify(keys) === JSON.stringify(['mode', 'network', 'writes'])
+        && value.mode === 'host-enforced'
+        && value.writes === 'forbidden'
+        && value.network === 'denied';
+}
+function validBound(value, maximum) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= maximum;
+}
+function validate(value) {
+    const configKeys = plainObject(value) ? Object.keys(value).sort() : [];
+    const baseKeys = [...CONFIG_KEYS].sort();
+    if (!plainObject(value)
+        || JSON.stringify(configKeys) !== JSON.stringify(baseKeys)
+        || value.schema_version !== SCHEMA_VERSION
+        || value.enabled !== true
+        || !existingExecutable(value.executable)
+        || !existingDirectory(value.cwd)
+        || !argvPrefix(value.argv_prefix)
+        || !toolDescriptors(value.tools)
+        || !validBound(value.timeout_ms, 120_000)
+        || !validBound(value.max_output_bytes, 10 * 1024 * 1024)
+        || !validateTerminalOutputConfig(value.terminal_output)
+        || !exactIsolation(value.isolation))
+        return false;
+    return true;
+}
+/** Read and validate an owner-local bridge config without exposing its contents. */
+export function loadBenchmarkEnvironmentConfig(path) {
+    try {
+        if (!isAbsolute(path))
+            return null;
+        const metadata = lstatSync(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 64 * 1024)
+            return null;
+        if (typeof getuid !== 'function' || metadata.uid !== getuid())
+            return null;
+        if ((metadata.mode & 0o022) !== 0)
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return validate(parsed) ? deepFreezeJson(parsed) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function structuredObject(text) {
+    try {
+        const parsed = JSON.parse(text.trim());
+        return plainObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function jsonObject(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+const FORBIDDEN_OUTPUT_KEY_FRAGMENTS = [
+    'answer', 'expected', 'gold', 'groundtruth', 'hiddenquery', 'label',
+    'loadermetadata', 'oracle', 'reference', 'reward', 'score',
+];
+export const BRIDGE_ERROR_CONTRACT = Object.freeze({
+    invalid_action: { recoverable: true, remedy: 'action 只允许 tools、call 或 errors' },
+    disallowed_tool: { recoverable: true, remedy: '先 action=tools 列出 allowed_tools 清单,再从清单内选工具' },
+    invalid_arguments: { recoverable: true, remedy: 'arguments 必须是可序列化 JSON 对象(≤64KB、深度≤12);收窄后重试' },
+    timed_out: { recoverable: true, remedy: '上游超时;可原样重试一次或换其他工具' },
+    output_truncated: { recoverable: true, remedy: '输出超出上限;让被调工具收窄查询范围后重试' },
+    invalid_json: { recoverable: true, remedy: '上游输出不是合法 JSON;重试一次或换工具' },
+    invalid_output: { recoverable: true, remedy: '上游输出结构不符;重试或换工具' },
+    runner_failed: { recoverable: true, remedy: '上游进程非零退出;可重试一次,持续失败换工具' },
+    spawn_failed: { recoverable: false, remedy: '可执行文件不可用——环境问题,调用方不可恢复' },
+    forbidden_output: { recoverable: false, remedy: '输出含未授权键(策略边界)——不可恢复,换工具或放弃' },
+});
+function inspectOutput(value) {
+    const pending = [{ value, depth: 0 }];
+    let nodes = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (++nodes > 10_000 || current.depth > 24)
+            return 'structure_limit';
+        if (Array.isArray(current.value)) {
+            for (const child of current.value)
+                pending.push({ value: child, depth: current.depth + 1 });
+            continue;
+        }
+        if (!plainObject(current.value))
+            continue;
+        for (const [key, child] of Object.entries(current.value)) {
+            if (!/^[\x20-\x7E]+$/.test(key))
+                return 'forbidden_key';
+            const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');
+            if (FORBIDDEN_OUTPUT_KEY_FRAGMENTS.some(fragment => normalized.includes(fragment)))
+                return 'forbidden_key';
+            pending.push({ value: child, depth: current.depth + 1 });
+        }
+    }
+    return 'ok';
+}
+function inspectAllowedOutput(value, allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    const pending = [{ value, depth: 0, coveredByDeclaredKey: false }];
+    let nodes = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (++nodes > 10_000 || current.depth > 24)
+            return false;
+        if (Array.isArray(current.value)) {
+            for (const child of current.value)
+                pending.push({ value: child, depth: current.depth + 1, coveredByDeclaredKey: current.coveredByDeclaredKey });
+            continue;
+        }
+        if (!plainObject(current.value)) {
+            if (!current.coveredByDeclaredKey)
+                return false;
+            continue;
+        }
+        for (const [key, child] of Object.entries(current.value)) {
+            if (!allowed.has(key))
+                return false;
+            pending.push({ value: child, depth: current.depth + 1, coveredByDeclaredKey: true });
+        }
+    }
+    return true;
+}
+function serializedArguments(value) {
+    const seen = new Set();
+    let nodes = 0;
+    let keys = 0;
+    const inspect = (current, depth) => {
+        if (++nodes > 10_000 || depth > 12)
+            return false;
+        if (current && typeof current === 'object') {
+            if (seen.has(current))
+                return false;
+            seen.add(current);
+            if (Array.isArray(current))
+                return current.every(item => inspect(item, depth + 1));
+            return Object.entries(current).every(([key, child]) => {
+                if (++keys > 10_000)
+                    return false;
+                return inspect(key, depth + 1) && inspect(child, depth + 1);
+            });
+        }
+        return true;
+    };
+    if (!inspect(value, 0))
+        return { reason: 'serialization_limit' };
+    try {
+        const json = JSON.stringify(value);
+        if (typeof json !== 'string' || Buffer.byteLength(json, 'utf8') > 65_536)
+            return { reason: 'serialization_limit' };
+        return { json };
+    }
+    catch {
+        return { reason: 'serialization_limit' };
+    }
+}
+/** Register the opt-in model-facing bridge. */
+export function registerBenchmarkEnvironmentBridge(path, register, subprocess) {
+    const bridge = loadBenchmarkEnvironmentConfig(path);
+    if (!bridge)
+        throw new Error('benchmark environment bridge configuration unavailable');
+    if (!subprocess)
+        throw new Error('benchmark environment bridge subprocess unavailable');
+    const parameters = deepFreezeJson({
+        type: 'object',
+        description: 'Flat benchmark bridge wire: choose an action, then provide the mapped tool and its arguments.',
+        properties: {
+            action: { type: 'string', enum: ['tools', 'call', 'errors'], description: 'tools=列出可调工具;call=执行工具;errors=拉取错误契约' },
+            tool: { type: 'string', enum: bridge.tools.map(item => item.name), description: 'action=call 时选择的冻结工具名' },
+            arguments: { type: 'object', additionalProperties: true, description: 'action=call 时传给工具的参数对象' },
+        },
+        required: ['action'],
+        additionalProperties: false,
+    });
+    assertSupportedJsonSchema(parameters);
+    const definition = {
+        name: 'gotry_benchmark_environment',
+        description: 'When a prompt asks to run agent_env.cli, use action=call here with the mapped tool; arbitrary shell is not exposed.',
+        parameters,
+        output: {
+            schema: {},
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+        async execute(args) {
+            const violations = validateJsonSchemaValue(parameters, args, 'arguments');
+            if (violations.length > 0)
+                throw new ToolArgsError(violations);
+            const query = args;
+            const tool = query.tool;
+            const descriptor = bridge.tools.find(item => item.name === tool);
+            const keys = Object.keys(query);
+            if (query.action === 'tools') {
+                if (keys.length !== 1)
+                    throw new ToolArgsError(['arguments: tools action accepts no tool or arguments']);
+                return jsonObject({ ok: true, tools: bridge.tools });
+            }
+            if (query.action === 'errors') {
+                if (keys.length !== 1)
+                    throw new ToolArgsError(['arguments: errors action accepts no tool or arguments']);
+                return jsonObject({ ok: true, errors: BRIDGE_ERROR_CONTRACT });
+            }
+            if (query.action !== 'call') {
+                return jsonObject({ ok: false, error: 'invalid_action' });
+            }
+            if (keys.length !== 3 || !Object.hasOwn(query, 'tool') || !Object.hasOwn(query, 'arguments')) {
+                throw new ToolArgsError(['arguments: call action requires exactly tool and arguments']);
+            }
+            if (typeof tool !== 'string' || !descriptor) {
+                return jsonObject({ ok: false, error: 'disallowed_tool' });
+            }
+            if (!plainObject(query.arguments)) {
+                return jsonObject({ ok: false, error: 'invalid_arguments' });
+            }
+            const callArguments = query.arguments;
+            const argumentViolations = validateJsonSchemaValue(descriptor.input_schema, callArguments, 'arguments');
+            if (argumentViolations.length > 0)
+                throw new ToolArgsError(argumentViolations);
+            const serialized = serializedArguments(callArguments);
+            if (serialized.reason)
+                return jsonObject({ ok: false, error: 'invalid_arguments', reason: serialized.reason });
+            const controller = new AbortController();
+            const timer = setTimeout(() => {
+                controller.abort();
+            }, bridge.timeout_ms);
+            let handle;
+            try {
+                const env = Object.fromEntries(Object.keys(process.env).map(key => [key, undefined]));
+                for (const key of ['PATH', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TZ']) {
+                    if (process.env[key] !== undefined)
+                        env[key] = process.env[key];
+                }
+                env.PYTHONDONTWRITEBYTECODE = '1';
+                env.PYTHONNOUSERSITE = '1';
+                try {
+                    handle = subprocess.spawn({
+                        argv: [bridge.executable, ...bridge.argv_prefix, 'call', tool, serialized.json],
+                        cwd: bridge.cwd,
+                        stdio: {
+                            stdin: 'ignore',
+                            stdout: { maxBytes: bridge.max_output_bytes },
+                            stderr: { maxBytes: bridge.max_output_bytes },
+                        },
+                        graceMs: Math.min(1_000, bridge.timeout_ms),
+                        env,
+                        signal: controller.signal,
+                    });
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return jsonObject({ ok: false, error: 'timed_out' });
+                    return jsonObject({ ok: false, error: 'spawn_failed' });
+                }
+                let status;
+                try {
+                    status = await handle.done;
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return jsonObject({ ok: false, error: 'timed_out' });
+                    return jsonObject({ ok: false, error: 'spawn_failed' });
+                }
+                if (controller.signal.aborted)
+                    return jsonObject({ ok: false, error: 'timed_out' });
+                let stdout;
+                let stderr;
+                try {
+                    stdout = handle.collected.stdout.readFrom(0);
+                    stderr = handle.collected.stderr.readFrom(0);
+                }
+                catch {
+                    return jsonObject({
+                        ok: false,
+                        error: 'runner_failed',
+                        exit_code: status.exitCode,
+                        signal: status.signal ?? null,
+                    });
+                }
+                if (stdout.lossy || stderr.lossy)
+                    return jsonObject({ ok: false, error: 'output_truncated' });
+                if (status.exitCode !== 0) {
+                    return jsonObject({
+                        ok: false,
+                        error: 'runner_failed',
+                        exit_code: status.exitCode,
+                        signal: status.signal ?? null,
+                    });
+                }
+                const parsed = structuredObject(stdout.text);
+                if (!parsed)
+                    return jsonObject({ ok: false, error: 'invalid_json' });
+                const outputInspection = inspectOutput(parsed);
+                if (outputInspection === 'forbidden_key')
+                    return jsonObject({ ok: false, error: 'forbidden_output' });
+                if (outputInspection === 'structure_limit')
+                    return jsonObject({ ok: false, error: 'invalid_output' });
+                if (parsed.schema_version !== BENCHMARK_TOOL_RESULT_SCHEMA_VERSION || typeof parsed.status !== 'string') {
+                    return jsonObject({ ok: false, error: 'invalid_output' });
+                }
+                if (parsed.status === 'miss' || parsed.status === 'error') {
+                    if (typeof parsed.code !== 'string' || typeof parsed.recovery !== 'string' || !descriptor.domain_outcomes.some(outcome => outcome.status === parsed.status && outcome.code === parsed.code && outcome.recovery === parsed.recovery))
+                        return jsonObject({ ok: false, error: 'invalid_output' });
+                    if (Object.keys(parsed).sort().join(',') !== 'code,recovery,schema_version,status')
+                        return jsonObject({ ok: false, error: 'invalid_output' });
+                    return jsonObject({ ok: true, outcome: parsed });
+                }
+                if (parsed.status !== 'ok' || !Object.hasOwn(parsed, 'result') || Object.keys(parsed).sort().join(',') !== 'result,schema_version,status')
+                    return jsonObject({ ok: false, error: 'invalid_output' });
+                const visibleResult = parsed.result;
+                if (!plainObject(visibleResult) && !Array.isArray(visibleResult))
+                    return jsonObject({ ok: false, error: 'invalid_output' });
+                if (!inspectAllowedOutput(visibleResult, descriptor.output_keys))
+                    return jsonObject({ ok: false, error: 'forbidden_output' });
+                return jsonObject({ ok: true, result: visibleResult });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+    register(definition);
+    return Object.freeze({
+        toolName: 'gotry_benchmark_environment',
+        allowedTools: Object.freeze(bridge.tools.map(item => item.name)),
+        terminal: Object.freeze({ ...bridge.terminal_output }),
+    });
+}

package/dist/src/benchmark-headless-child-diagnostics.js

@@ -0,0 +1,166 @@
+/** Stable, redacted diagnostics carried on the benchmark-only control pipe. */
+import { writeSync } from 'node:fs';
+export const BENCHMARK_CHILD_DIAGNOSTIC_SCHEMA = 'gotry_benchmark_child_diagnostic_v1';
+export const BENCHMARK_CHILD_DIAGNOSTIC_FD_ENV = 'GOTRY_BENCHMARK_DIAGNOSTIC_FD';
+export const BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES = 4 * 1024;
+const FAILURE_CODES = new Set([
+    'child_output_truncated',
+    'child_signaled',
+    'child_lifecycle_failure',
+    'child_conformance_failure',
+    'child_bridge_timed_out',
+    'child_bridge_runner_failed',
+    'child_bridge_spawn_failed',
+    'child_bridge_output_truncated',
+    'child_bridge_failure',
+    'child_terminal_invalid',
+    'child_nonzero_exit',
+    'child_spawn_failure',
+    'child_model_auth',
+    'child_model_capacity',
+    'child_model_server',
+    'child_model_transport',
+    'child_model_stream',
+    'child_model_request',
+    'child_runtime_error',
+    'child_blocked',
+    'child_max_tokens',
+    'child_aborted',
+    'child_interrupted',
+]);
+const MODEL_AUTH = new Set(['AUTH', 'INVALID_CREDENTIAL', 'MISSING_CREDENTIAL']);
+const MODEL_CAPACITY = new Set(['QUOTA', 'RATE_LIMIT']);
+const MODEL_SERVER = new Set(['SERVER']);
+const MODEL_TRANSPORT = new Set(['TRANSPORT', 'TIMEOUT']);
+const MODEL_STREAM = new Set(['EMPTY_RESPONSE', 'STREAM_CLOSED', 'MALFORMED_RESPONSE', 'INVALID_RESPONSE']);
+const MODEL_REQUEST = new Set(['INVALID_REQUEST', 'CONTEXT_WINDOW_EXCEEDED', 'NO_ADAPTER', 'UNKNOWN_MODEL', 'UNSUPPORTED_OPTION']);
+/** Classify only the structured final turn/end envelope; free-form fields are ignored. */
+export function classifyBenchmarkTurnEnd(reason) {
+    if (!plainObject(reason) || typeof reason.kind !== 'string')
+        return 'child_runtime_error';
+    switch (reason.kind) {
+        case 'completed': return undefined;
+        case 'blocked': return 'child_blocked';
+        case 'max-tokens': return 'child_max_tokens';
+        case 'aborted': return 'child_aborted';
+        case 'interrupted': return 'child_interrupted';
+        case 'error': {
+            const error = plainObject(reason.error) ? reason.error : {};
+            const code = typeof error.code === 'string' ? error.code : '';
+            const status = typeof error.status === 'number' && Number.isInteger(error.status) && error.status >= 100 && error.status <= 599
+                ? error.status
+                : undefined;
+            if (MODEL_AUTH.has(code))
+                return 'child_model_auth';
+            if (MODEL_CAPACITY.has(code))
+                return 'child_model_capacity';
+            if (MODEL_SERVER.has(code))
+                return 'child_model_server';
+            if (MODEL_TRANSPORT.has(code))
+                return 'child_model_transport';
+            if (MODEL_STREAM.has(code))
+                return 'child_model_stream';
+            if (MODEL_REQUEST.has(code))
+                return 'child_model_request';
+            if (code === 'ABORTED')
+                return 'child_aborted';
+            if (status === 401 || status === 403)
+                return 'child_model_auth';
+            if (status === 429)
+                return 'child_model_capacity';
+            if (status !== undefined && status >= 500 && status <= 599)
+                return 'child_model_server';
+            return 'child_runtime_error';
+        }
+        default: return 'child_runtime_error';
+    }
+}
+/** Per-session final arbiter. It emits one best closed enum, never its payload. */
+export function createBenchmarkDiagnosticArbiter(write) {
+    const pending = new Map();
+    const emitted = new Set();
+    const rank = (code) => code.startsWith('child_bridge_') ? 4 : code === 'child_conformance_failure' ? 3 : code === 'child_runtime_error' ? 1 : 2;
+    return {
+        offer(session, code) {
+            if (code === undefined || emitted.has(session))
+                return;
+            const previous = pending.get(session);
+            if (previous === undefined || rank(code) > rank(previous))
+                pending.set(session, code);
+        },
+        flush(session) {
+            if (emitted.has(session))
+                return;
+            const code = pending.get(session);
+            if (code === undefined)
+                return;
+            emitted.add(session);
+            pending.delete(session);
+            write(code);
+        },
+    };
+}
+function plainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Keep the newest bounded bytes so a final control record cannot be displaced by noise. */
+export function appendBoundedChildDiagnostic(current, chunk) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (bytes.length >= BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES) {
+        return bytes.subarray(bytes.length - BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES);
+    }
+    if (current.length + bytes.length <= BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES) {
+        return Buffer.concat([current, bytes]);
+    }
+    const keep = BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES - bytes.length;
+    return Buffer.concat([current.subarray(current.length - keep), bytes]);
+}
+export function parseBenchmarkChildDiagnostic(raw) {
+    const lines = raw.split('\n').map(line => line.trim()).filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+            const parsed = JSON.parse(lines[index]);
+            if (!plainObject(parsed))
+                continue;
+            const keys = Object.keys(parsed).sort();
+            if (JSON.stringify(keys) !== JSON.stringify(['code', 'schema_version']))
+                continue;
+            if (parsed.schema_version !== BENCHMARK_CHILD_DIAGNOSTIC_SCHEMA)
+                continue;
+            if (typeof parsed.code !== 'string' || !FAILURE_CODES.has(parsed.code))
+                continue;
+            return parsed.code;
+        }
+        catch {
+            // The control pipe is fail-closed: malformed or unrelated records are ignored.
+        }
+    }
+    return undefined;
+}
+/** Emit one namespaced enum record without reflecting prompts, paths, or stderr. */
+export function emitBenchmarkChildDiagnostic(code) {
+    const fd = Number(process.env[BENCHMARK_CHILD_DIAGNOSTIC_FD_ENV]);
+    if (!Number.isInteger(fd) || fd < 3)
+        return;
+    const record = `\n${JSON.stringify({ schema_version: BENCHMARK_CHILD_DIAGNOSTIC_SCHEMA, code })}\n`;
+    if (Buffer.byteLength(record, 'utf8') > BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES)
+        return;
+    try {
+        writeSync(fd, record);
+    }
+    catch {
+        // Diagnostics never change the conformance decision itself.
+    }
+}
+export function classifyBenchmarkChildFailure(input) {
+    if (input.outputTruncated)
+        return 'child_output_truncated';
+    if (input.signal)
+        return 'child_signaled';
+    const structured = parseBenchmarkChildDiagnostic(input.diagnostic ?? '');
+    if (structured)
+        return structured;
+    if (input.code !== 0)
+        return 'child_nonzero_exit';
+    return 'child_lifecycle_failure';
+}