@danceiny/gotry 0.0.1-rc.16 → 0.0.1-rc.18

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

@@ -0,0 +1,384 @@
+import { accessSync, constants, lstatSync, readFileSync, statSync } from 'node:fs';
+import { getuid } from 'node:process';
+import { isAbsolute } from 'node:path';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { validateTerminalOutputConfig } from './benchmark-agent-conformance.js';
+const SCHEMA_VERSION = 'gotry_benchmark_environment_bridge_v2';
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+const CONFIG_KEYS = [
+    'allowed_tools',
+    'argv_prefix',
+    'cwd',
+    'enabled',
+    'executable',
+    'isolation',
+    'max_output_bytes',
+    'schema_version',
+    'terminal_output',
+    'timeout_ms'
+];
+const OPTIONAL_CONFIG_KEYS = [
+    'allowed_output_keys'
+];
+function plainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(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) {
+    return Array.isArray(value) && 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 allowedOutputKeys(value, allowedTools) {
+    if (!plainObject(value)) return false;
+    const keys = Object.keys(value);
+    return keys.length > 0 && keys.length <= 64 && keys.every((tool)=>allowedTools.includes(tool) && identifiers(value[tool]));
+}
+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();
+    const extendedKeys = [
+        ...CONFIG_KEYS,
+        ...OPTIONAL_CONFIG_KEYS
+    ].sort();
+    if (!plainObject(value) || ![
+        baseKeys,
+        extendedKeys
+    ].some((keys)=>JSON.stringify(configKeys) === JSON.stringify(keys)) || value.schema_version !== SCHEMA_VERSION || value.enabled !== true || !existingExecutable(value.executable) || !existingDirectory(value.cwd) || !argvPrefix(value.argv_prefix) || !identifiers(value.allowed_tools) || !validBound(value.timeout_ms, 120_000) || !validBound(value.max_output_bytes, 10 * 1024 * 1024) || !validateTerminalOutputConfig(value.terminal_output) || !exactIsolation(value.isolation) || Object.hasOwn(value, 'allowed_output_keys') && !allowedOutputKeys(value.allowed_output_keys, value.allowed_tools)) return false;
+    return true;
+}
+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) ? 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'
+];
+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
+        }
+    ];
+    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
+            });
+            continue;
+        }
+        if (!plainObject(current.value)) continue;
+        for (const [key, child] of Object.entries(current.value)){
+            if (!allowed.has(key)) return false;
+            pending.push({
+                value: child,
+                depth: current.depth + 1
+            });
+        }
+    }
+    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'
+        };
+    }
+}
+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');
+    register(defineTool({
+        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: {
+            query: {
+                type: 'json',
+                required: true,
+                description: '{ action: "tools" | "call", tool?: string, arguments?: object }'
+            }
+        },
+        output: {
+            schema: {
+                type: 'json'
+            },
+            render: (_args, value)=>[
+                    {
+                        type: 'text',
+                        text: JSON.stringify(value)
+                    }
+                ]
+        },
+        async execute (args) {
+            const query = plainObject(args?.query) ? args.query : {};
+            if (query.action === 'tools') return jsonObject({
+                ok: true,
+                tools: bridge.allowed_tools
+            });
+            if (query.action !== 'call') return jsonObject({
+                ok: false,
+                error: 'invalid_action'
+            });
+            if (typeof query.tool !== 'string' || !bridge.allowed_tools.includes(query.tool)) {
+                return jsonObject({
+                    ok: false,
+                    error: 'disallowed_tool'
+                });
+            }
+            if (query.arguments !== undefined && !plainObject(query.arguments)) {
+                return jsonObject({
+                    ok: false,
+                    error: 'invalid_arguments'
+                });
+            }
+            const callArguments = query.arguments === undefined ? {} : query.arguments;
+            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';
+                handle = subprocess.spawn({
+                    argv: [
+                        bridge.executable,
+                        ...bridge.argv_prefix,
+                        'call',
+                        query.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
+                });
+                const status = await handle.done;
+                if (controller.signal.aborted) return jsonObject({
+                    ok: false,
+                    error: 'timed_out'
+                });
+                const stdout = handle.collected.stdout.readFrom(0);
+                const stderr = handle.collected.stderr.readFrom(0);
+                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'
+                });
+                const visibleResult = parsed.result ?? parsed;
+                if (!plainObject(visibleResult) && !Array.isArray(visibleResult)) return jsonObject({
+                    ok: false,
+                    error: 'invalid_output'
+                });
+                const outputKeys = bridge.allowed_output_keys && Object.hasOwn(bridge.allowed_output_keys, query.tool) ? bridge.allowed_output_keys[query.tool] : undefined;
+                if (outputKeys && !inspectAllowedOutput(visibleResult, outputKeys)) return jsonObject({
+                    ok: false,
+                    error: 'forbidden_output'
+                });
+                return jsonObject({
+                    ok: true,
+                    result: visibleResult
+                });
+            } catch  {
+                if (controller.signal.aborted) return jsonObject({
+                    ok: false,
+                    error: 'timed_out'
+                });
+                return jsonObject({
+                    ok: false,
+                    error: !handle || handle.pid === -1 ? 'spawn_failed' : 'runner_failed'
+                });
+            } finally{
+                clearTimeout(timer);
+            }
+        }
+    }));
+    return Object.freeze({
+        toolName: 'gotry_benchmark_environment',
+        allowedTools: Object.freeze([
+            ...bridge.allowed_tools
+        ]),
+        terminal: Object.freeze({
+            ...bridge.terminal_output
+        })
+    });
+}
+
+
+//# sourceURL=ts/src/benchmark-environment-bridge.ts

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

@@ -0,0 +1,173 @@
+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'
+]);
+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';
+    }
+}
+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);
+}
+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  {}
+    }
+    return undefined;
+}
+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  {}
+}
+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';
+}
+
+
+//# sourceURL=ts/src/benchmark-headless-child-diagnostics.ts

package/dist/src/benchmark-tool-isolation.js

@@ -0,0 +1,124 @@
+import { isDeepStrictEqual } from 'node:util';
+const BRIDGE_TOOL = 'gotry_benchmark_environment';
+const DENIED = 'BENCHMARK_TOOL_NOT_ALLOWED';
+const SURFACE_VIOLATION = 'BENCHMARK_TOOL_SURFACE_VIOLATION';
+function requireDisposer(value, capability) {
+    if (typeof value !== 'function') throw new Error(`benchmark environment ${capability} disposer unavailable`);
+    return value;
+}
+export function installBenchmarkToolIsolation(ctx) {
+    const rootTools = ctx.tools;
+    if (typeof rootTools.get !== 'function') throw new Error('benchmark environment root tool lookup unavailable');
+    if (typeof rootTools.schemas !== 'function') throw new Error('benchmark environment root tool schemas unavailable');
+    const bridgeDefinition = rootTools.get(BRIDGE_TOOL);
+    if (!bridgeDefinition) throw new Error('benchmark environment bridge definition unavailable');
+    const rootSchemas = rootTools.schemas();
+    const expected = Array.isArray(rootSchemas) ? rootSchemas.filter((schema)=>schema && typeof schema === 'object' && schema.name === BRIDGE_TOOL) : [];
+    if (expected.length !== 1) throw new Error('benchmark environment bridge schema unavailable');
+    const expectedSchemas = structuredClone(expected);
+    const getService = ctx.get;
+    const agents = typeof getService === 'function' ? getService.call(ctx, 'agents') : ctx.agents;
+    const listAgents = agents?.list;
+    if (typeof listAgents !== 'function') throw new Error('benchmark environment agent registry unavailable');
+    if (listAgents.call(agents).length > 0) throw new Error('benchmark environment isolation requires cold-start; live agents are not allowed');
+    const bus = ctx;
+    if (typeof bus.on !== 'function') throw new Error('benchmark environment isolation event bus unavailable');
+    if (typeof bus.effect !== 'function') throw new Error('benchmark environment isolation effect unavailable');
+    const active = new Map();
+    let stopping = false;
+    const assertSurface = (agent, schemas = rootTools.schemas(agent))=>{
+        if (!active.has(agent) || rootTools.get(BRIDGE_TOOL, agent) !== bridgeDefinition || !isDeepStrictEqual(schemas, expectedSchemas)) {
+            throw new Error(SURFACE_VIOLATION);
+        }
+    };
+    const take = (agent)=>{
+        const dispose = active.get(agent);
+        if (!dispose) return;
+        active.delete(agent);
+        return dispose();
+    };
+    requireDisposer(bus.effect(function*() {
+        yield requireDisposer(bus.on('agent/created', (payload)=>{
+            if (stopping) throw new Error(SURFACE_VIOLATION);
+            const agent = payload.agent;
+            const tools = agent?.ctx?.tools;
+            const agentEffect = agent?.ctx?.effect;
+            const agentOn = agent?.ctx?.on;
+            if (!agent) throw new Error('benchmark environment created agent unavailable');
+            if (typeof tools?.restrict !== 'function') throw new Error('benchmark environment scoped restrict unavailable');
+            if (typeof tools.guard !== 'function') throw new Error('benchmark environment scoped guard unavailable');
+            if (typeof tools.presentAs !== 'function') throw new Error('benchmark environment scoped presentAs unavailable');
+            if (typeof agentEffect !== 'function') throw new Error('benchmark environment scoped effect unavailable');
+            if (typeof agentOn !== 'function') throw new Error('benchmark environment scoped event bus unavailable');
+            if (active.has(agent)) throw new Error('benchmark environment duplicate agent isolation');
+            let owned;
+            owned = requireDisposer(agentEffect.call(agent.ctx, function*() {
+                yield ()=>{
+                    if (active.get(agent) === owned) active.delete(agent);
+                };
+                yield requireDisposer(tools.guard((execution)=>{
+                    if (stopping || execution.name !== BRIDGE_TOOL || !execution.agent) return DENIED;
+                    return rootTools.get(BRIDGE_TOOL, execution.agent) === bridgeDefinition ? undefined : DENIED;
+                }), 'scoped guard');
+                yield requireDisposer(agentOn.call(agent.ctx, 'system-prompt/assemble', async (_assembly, _context, next)=>{
+                    if (stopping) throw new Error(SURFACE_VIOLATION);
+                    if (typeof next !== 'function') throw new Error('benchmark environment scoped assembly continuation unavailable');
+                    const result = await next();
+                    if (stopping) throw new Error(SURFACE_VIOLATION);
+                    return result;
+                }, {
+                    prepend: true
+                }), 'scoped assembly listener');
+                yield requireDisposer(tools.presentAs('native'), 'scoped presentAs');
+                yield requireDisposer(tools.restrict({
+                    allow: [
+                        BRIDGE_TOOL
+                    ]
+                }), 'scoped restrict');
+            }, 'benchmark-environment-agent-tool-isolation'), 'scoped effect');
+            active.set(agent, owned);
+            try {
+                assertSurface(agent);
+            } catch (error) {
+                try {
+                    const pending = take(agent);
+                    pending?.catch(()=>undefined);
+                } catch  {}
+                throw error;
+            }
+        }), 'agent/created listener');
+        yield requireDisposer(bus.on('agent/disposed', (payload)=>{
+            if (payload.agent) return take(payload.agent);
+        }), 'agent/disposed listener');
+        yield requireDisposer(bus.on('system-prompt/assemble', async (_assembly, context, next)=>{
+            if (typeof next !== 'function') throw new Error('benchmark environment assembly continuation unavailable');
+            const result = await next();
+            const agent = context?.agent;
+            if (!agent) return result;
+            if (stopping || context?.scope !== agent || !result || typeof result !== 'object') throw new Error(SURFACE_VIOLATION);
+            assertSurface(agent, result.tools);
+            return result;
+        }, {
+            prepend: true
+        }), 'system-prompt/assemble listener');
+        yield requireDisposer(bus.on('agent/pre-step', async (payload, next)=>{
+            if (typeof next !== 'function') throw new Error('benchmark environment pre-step continuation unavailable');
+            const decision = await next();
+            const agent = payload.agent;
+            if (stopping || !agent) throw new Error(SURFACE_VIOLATION);
+            assertSurface(agent);
+            return decision;
+        }, {
+            prepend: true
+        }), 'agent/pre-step listener');
+        yield ()=>{
+            active.clear();
+        };
+        yield ()=>{
+            stopping = true;
+        };
+    }, 'benchmark-environment-tool-isolation'), 'root effect');
+}
+
+
+//# sourceURL=ts/src/benchmark-tool-isolation.ts

package/dist/src/bookable-facts.js

@@ -346,4 +346,4 @@ export function renderNightsLine(it) {
 }
 
 
-//# sourceURL=/Users/bytedance/work/gotry-publish/ts/src/bookable-facts.ts
+//# sourceURL=ts/src/bookable-facts.ts