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

package/dist/scripts/benchmark-environment-bridge-tests.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Context } from '@deepseek-ai/cordis';
 import { apply } from '../src/index.js';
-import { registerBenchmarkEnvironmentBridge } from '../src/benchmark-environment-bridge.js';
+import { BENCHMARK_TOOL_RESULT_SCHEMA_VERSION, registerBenchmarkEnvironmentBridge } from '../src/benchmark-environment-bridge.js';
 import { installBenchmarkToolIsolation } from '../src/benchmark-tool-isolation.js';
 import { BENCHMARK_BRIDGE_CALL_FAILED, BENCHMARK_BRIDGE_CALL_REQUIRED, BENCHMARK_BRIDGE_RETRY_CALL_NOT_ALLOWED, BENCHMARK_BRIDGE_OUTPUT_TRUNCATED, BENCHMARK_BRIDGE_RUNNER_FAILED, BENCHMARK_BRIDGE_SPAWN_FAILED, BENCHMARK_BRIDGE_TIMED_OUT, BENCHMARK_CONFORMANCE_STATE_UNAVAILABLE, BENCHMARK_TERMINAL_INVALID, MAX_CONFORMANCE_RETRIES, benchmarkChildFailureForConformanceCode, createBenchmarkAgentConformance, installBenchmarkAgentConformance, parseBenchmarkTerminal, validateTerminalOutputConfig } from '../src/benchmark-agent-conformance.js';
 import { BENCHMARK_CHILD_DIAGNOSTIC_MAX_BYTES, BENCHMARK_CHILD_DIAGNOSTIC_SCHEMA, appendBoundedChildDiagnostic, classifyBenchmarkChildFailure, classifyBenchmarkTurnEnd, createBenchmarkDiagnosticArbiter, parseBenchmarkChildDiagnostic } from '../src/benchmark-headless-child-diagnostics.js';
@@ -314,6 +314,30 @@ for (const invalid of [
     '<done>{"ok":</done>'
 ])assert.equal(parseBenchmarkTerminal(invalid, projection.terminal).ok, false);
 assert.equal(parseBenchmarkTerminal(`<done>{"x":"${'y'.repeat(1024)}"}</done>`, projection.terminal).ok, false);
+for (const [raw, expectOk] of [
+    [
+        '<think>plan it</think><done>{"ok":true}</done>',
+        true
+    ],
+    [
+        '<think>a</think>\n<THINK>b</THINK>\n<done>{"ok":true}</done>',
+        true
+    ],
+    [
+        '<done>{"ok":true}</done><think>after</think>',
+        true
+    ],
+    [
+        '<think>unclosed<done>{"ok":true}</done>',
+        false
+    ],
+    [
+        'prose<think>x</think><done>{"ok":true}</done>',
+        false
+    ]
+]){
+    assert.equal(parseBenchmarkTerminal(raw, projection.terminal).ok, expectOk, raw);
+}
 function turnStart(turn = 1) {
     return {
         type: 'turn/start',
@@ -343,17 +367,15 @@ function toolCall(callId = 'call-1', options = {}) {
             callId,
             name: projection.toolName,
             arguments: JSON.stringify({
-                query: {
-                    action,
-                    tool,
-                    arguments: {}
-                }
+                action,
+                tool,
+                arguments: {}
             })
         }
     };
 }
 function toolResult(callId = 'call-1', options = {}) {
-    const { turn = 1, step = 1, ok = true, isError = false, error = 'runner_failed' } = options;
+    const { turn = 1, step = 1, ok = true, isError = false, error = 'runner_failed', outcome, payload } = options;
     return {
         type: 'tool/result',
         data: {
@@ -372,13 +394,16 @@ function toolResult(callId = 'call-1', options = {}) {
                         content: [
                             {
                                 type: 'text',
-                                text: JSON.stringify(ok ? {
+                                text: JSON.stringify(payload ?? (outcome ? {
+                                    ok: true,
+                                    outcome
+                                } : ok ? {
                                     ok: true,
                                     result: {}
                                 } : {
                                     ok: false,
                                     error
-                                })
+                                }))
                             }
                         ]
                     }
@@ -387,7 +412,107 @@ function toolResult(callId = 'call-1', options = {}) {
         }
     };
 }
-function assistant(text, options = {}) {
+{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall());
+    state.observe(toolResult('call-1', {
+        outcome: {
+            schema_version: 'gotry_benchmark_tool_result_v1',
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'steer',
+        mode: 'terminal'
+    }, 'domain outcome alone permits tagged terminal');
+    state.observe(assistant('<done>{"status":"miss"}</done>', {
+        step: 2
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'accept'
+    }, 'domain-only tagged terminal is accepted');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall());
+    state.observe(toolResult('call-1', {
+        outcome: {
+            schema_version: 'gotry_benchmark_tool_result_v1',
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }
+    }));
+    state.observe(toolCall('call-2', {
+        step: 2
+    }));
+    state.observe(toolResult('call-2'));
+    state.observe(assistant('<done>{"status":"succeeded"}</done>', {
+        step: 3
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'accept'
+    }, 'domain outcome followed by concrete result accepts');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall());
+    state.observe(toolResult('call-1', {
+        outcome: {
+            schema_version: 'gotry_benchmark_tool_result_v1',
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }
+    }));
+    state.observe(toolCall('call-2', {
+        step: 2
+    }));
+    state.observe(toolResult('call-2', {
+        ok: false,
+        error: 'runner_failed'
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'reject',
+        code: BENCHMARK_BRIDGE_RUNNER_FAILED
+    }, 'infra failure overrides domain-only outcome');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall());
+    state.observe(toolResult('call-1', {
+        payload: {
+            ok: true,
+            result: {},
+            outcome: {
+                status: 'miss'
+            }
+        }
+    }));
+    state.observe(assistant('<done>{"status":"succeeded"}</done>'));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'reject',
+        code: BENCHMARK_BRIDGE_CALL_FAILED
+    }, 'ambiguous ok wrapper with result and outcome fails closed');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall());
+    state.observe(toolResult('call-1', {
+        payload: {
+            ok: true,
+            outcome: {}
+        }
+    }));
+    state.observe(assistant('<done>{"status":"miss"}</done>'));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'reject',
+        code: BENCHMARK_BRIDGE_CALL_FAILED
+    }, 'malformed inner domain outcome fails closed');
+}function assistant(text, options = {}) {
     const { turn = 1, step = 2, interrupted = false } = options;
     return {
         type: 'assistant/message',
@@ -566,6 +691,69 @@ function assistant(text, options = {}) {
     assert.deepEqual(state.stopping(1), {
         kind: 'accept'
     }, 'a later failed optional call does not erase an already paired successful result');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall('successful', {
+        step: 1
+    }));
+    state.observe(toolResult('successful', {
+        step: 1
+    }));
+    state.observe(assistant('<done>{"status":"succeeded"}</done>', {
+        step: 2
+    }));
+    state.observe(toolCall('domain', {
+        step: 3
+    }));
+    state.observe(toolResult('domain', {
+        step: 3,
+        outcome: {
+            schema_version: 'gotry_benchmark_tool_result_v1',
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'steer',
+        mode: 'terminal'
+    }, 'a terminal before the latest domain response is stale');
+    state.observe(assistant('<done>{"status":"succeeded"}</done>', {
+        step: 4
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'accept'
+    }, 'a fresh terminal after the latest domain response may reuse the earlier concrete result');
+}{
+    const state = createBenchmarkAgentConformance(projection);
+    state.observe(turnStart());
+    state.observe(toolCall('successful', {
+        step: 1
+    }));
+    state.observe(toolResult('successful', {
+        step: 1
+    }));
+    state.observe(assistant('<done>{"status":"succeeded"}</done>', {
+        step: 2
+    }));
+    state.observe(toolCall('failed', {
+        step: 3
+    }));
+    state.observe(toolResult('failed', {
+        step: 3,
+        ok: false
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'steer',
+        mode: 'terminal'
+    }, 'a terminal before a later optional failure is stale');
+    state.observe(assistant('<done>{"status":"succeeded"}</done>', {
+        step: 4
+    }));
+    assert.deepEqual(state.stopping(1), {
+        kind: 'accept'
+    }, 'a fresh terminal may still converge after an optional failure when a concrete result exists');
 }{
     const state = createBenchmarkAgentConformance(projection);
     state.observe(turnStart());
@@ -816,16 +1004,77 @@ function assistant(text, options = {}) {
         waitForExit: async ()=>true
     };
 }
+function okEnvelope(result) {
+    return JSON.stringify({
+        schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+        status: 'ok',
+        result
+    });
+}
+function lookupInputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            city: {
+                type: 'string',
+                enum: [
+                    'Dubai',
+                    'Abu Dhabi'
+                ],
+                description: 'Declared city name.'
+            },
+            payload: {
+                type: 'string'
+            },
+            notes: {
+                type: 'string'
+            },
+            executable: {
+                type: 'string'
+            },
+            cwd: {
+                type: 'string'
+            },
+            argv: {
+                type: 'array',
+                items: {
+                    type: 'string'
+                }
+            }
+        },
+        required: [
+            'city'
+        ],
+        additionalProperties: false
+    };
+}
+function bridgeCall(tool, argumentsValue) {
+    return {
+        action: 'call',
+        tool,
+        arguments: argumentsValue
+    };
+}
 async function assertRealCordisWaterfallOrdering() {
     const ctx = new Context();
     const bridge = {
         name: 'gotry_benchmark_environment',
         description: 'benchmark bridge',
         parameters: {
-            query: {
-                type: 'json',
-                required: true
-            }
+            oneOf: [
+                {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            const: 'tools'
+                        }
+                    },
+                    required: [
+                        'action'
+                    ],
+                    additionalProperties: false
+                }
+            ]
         }
     };
     const exactSchema = structuredClone(bridge);
@@ -957,7 +1206,7 @@ try {
     assert.equal(parseBenchmarkChildDiagnostic(boundedControl.toString('utf8')), 'child_bridge_timed_out', 'rolling tail preserves a final structured reason after bounded noise');
     const configPath = join(root, 'bridge.json');
     writeFileSync(configPath, JSON.stringify({
-        schema_version: 'gotry_benchmark_environment_bridge_v2',
+        schema_version: 'gotry_benchmark_environment_bridge_v3',
         enabled: true,
         executable: process.execPath,
         cwd: root,
@@ -967,20 +1216,54 @@ try {
             '--lang',
             'en'
         ],
-        allowed_tools: [
-            'lookup',
-            'constructor',
-            'toString'
+        tools: [
+            {
+                name: 'lookup',
+                description: 'Lookup one declared city.',
+                input_schema: lookupInputSchema(),
+                output_keys: [
+                    'city',
+                    'nested'
+                ],
+                domain_outcomes: [
+                    {
+                        status: 'miss',
+                        code: 'NOT_FOUND',
+                        recovery: 'revise_arguments'
+                    },
+                    {
+                        status: 'error',
+                        code: 'AMBIGUOUS',
+                        recovery: 'choose_alternative'
+                    }
+                ]
+            },
+            {
+                name: 'constructor',
+                description: 'Construct one declared city.',
+                input_schema: lookupInputSchema(),
+                output_keys: [
+                    'legacy'
+                ],
+                domain_outcomes: [
+                    {
+                        status: 'error',
+                        code: 'INVALID',
+                        recovery: 'retry_same'
+                    }
+                ]
+            },
+            {
+                name: 'toString',
+                description: 'Stringify one declared city.',
+                input_schema: lookupInputSchema(),
+                output_keys: [
+                    'city',
+                    'nested'
+                ],
+                domain_outcomes: []
+            }
         ],
-        allowed_output_keys: {
-            lookup: [
-                'city',
-                'nested'
-            ],
-            constructor: [
-                'legacy'
-            ]
-        },
         timeout_ms: 20,
         max_output_bytes: 4_096,
         terminal_output: {
@@ -1026,7 +1309,11 @@ try {
     let timeoutSignal;
     const outcomes = [
         {
-            stdout: '{"result":[{"city":"Dubai"}]}'
+            stdout: okEnvelope([
+                {
+                    city: 'Dubai'
+                }
+            ])
         }
     ];
     process.env.GOTRY_BENCHMARK_BRIDGE_PARENT_SENTINEL = 'must-not-cross-boundary';
@@ -1086,7 +1373,7 @@ try {
             spawn (spec) {
                 spawnSpecs.push(spec);
                 const outcome = outcomes.shift() ?? {
-                    stdout: '{"result":{}}'
+                    stdout: okEnvelope({})
                 };
                 if (outcome.spawnError) throw new Error('fake spawn failed');
                 if (outcome.waitForAbort) {
@@ -1603,17 +1890,57 @@ try {
     }, 'agent disposal releases its quarantined isolation and conformance effects');
     const bridge = registered.find((tool)=>tool.name === 'gotry_benchmark_environment');
     assert.ok(bridge.execute, 'registered bridge exposes execute');
+    const parameters = bridge.parameters;
+    assert.equal(Array.isArray(parameters.oneOf), true, 'v3 bridge exposes flat descriptor-derived model branches');
+    const lookupBranch = parameters.oneOf.find((branch)=>branch?.properties?.tool?.const === 'lookup');
+    assert.ok(lookupBranch, 'model schema contains the configured lookup tool branch');
+    assert.equal(lookupBranch.description, 'Lookup one declared city.', 'descriptor description reaches the model-visible call branch');
+    assert.deepEqual(lookupBranch.required, [
+        'action',
+        'tool',
+        'arguments'
+    ]);
+    assert.equal(lookupBranch.additionalProperties, false);
+    assert.deepEqual(lookupBranch.properties.arguments.required, [
+        'city'
+    ]);
+    assert.equal(lookupBranch.properties.arguments.additionalProperties, false);
+    assert.equal(lookupBranch.properties.arguments.properties.city.type, 'string');
+    assert.deepEqual(lookupBranch.properties.arguments.properties.city.enum, [
+        'Dubai',
+        'Abu Dhabi'
+    ]);
+    assert.equal(Object.isFrozen(bridge.parameters), true, 'registered raw parameters are frozen');
+    assert.equal(Object.isFrozen(lookupBranch.properties.arguments.properties.city.enum), true, 'descriptor-derived nested schema is frozen');
+    assert.throws(()=>{
+        lookupBranch.properties.arguments.properties.city.enum.push('escape');
+    }, TypeError);
+    const beforeProtocolRejected = spawnSpecs.length;
+    await assert.rejects(()=>bridge.execute({
+            query: bridgeCall('lookup', {
+                city: 'Dubai'
+            })
+        }, null), /invalid arguments/, 'legacy nested query envelope is rejected by the flat protocol');
+    await assert.rejects(()=>bridge.execute({}, null), /invalid arguments/, 'empty object is rejected by the flat protocol');
+    await assert.rejects(()=>bridge.execute({
+            action: 'tools',
+            tool: 'lookup'
+        }, null), /invalid arguments/, 'mixed action/tool fields are rejected by the flat protocol');
+    await assert.rejects(()=>bridge.execute({
+            ...bridgeCall('lookup', {
+                city: 'Dubai'
+            }),
+            extra: true
+        }, null), /invalid arguments/, 'extra top-level fields are rejected by the flat protocol');
+    await assert.rejects(()=>bridge.execute(bridgeCall('lookup', {
+            city: 'Sharjah'
+        }), null), /invalid arguments/, 'invalid descriptor argument values are rejected by the flat protocol');
+    assert.equal(spawnSpecs.length, beforeProtocolRejected, 'flat protocol rejections happen before spawn');
     const args = {
         city: 'Dubai',
         payload: '$(touch /tmp/nope)'
     };
-    const result = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: args
-        }
-    }, null);
+    const result = await bridge.execute(bridgeCall('lookup', args), null);
     assert.deepEqual(spawnSpecs[0]?.argv, [
         process.execPath,
         '-m',
@@ -1650,17 +1977,13 @@ try {
         ]
     }, 'one-line JSON stdout becomes structured result');
     outcomes.push({
-        stdout: '{"result":{"city":"Dubai"}}'
+        stdout: okEnvelope({
+            city: 'Dubai'
+        })
     });
-    const unmappedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'toString',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const unmappedResult = await bridge.execute(bridgeCall('toString', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(unmappedResult, {
         ok: true,
         result: {
@@ -1668,17 +1991,13 @@ try {
         }
     }, 'allowed tool without a positive mapping retains the recursive denylist only');
     outcomes.push({
-        stdout: '{"result":{"legacy":"value"}}'
+        stdout: okEnvelope({
+            legacy: 'value'
+        })
     });
-    const legacyResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'constructor',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const legacyResult = await bridge.execute(bridgeCall('constructor', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(legacyResult, {
         ok: true,
         result: {
@@ -1686,33 +2005,27 @@ try {
         }
     }, 'mapped constructor accepts its declared positive key');
     outcomes.push({
-        stdout: '{"result":{"city":"Dubai"}}'
+        stdout: okEnvelope({
+            city: 'Dubai'
+        })
     });
-    const constructorUnexpected = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'constructor',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const constructorUnexpected = await bridge.execute(bridgeCall('constructor', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(constructorUnexpected, {
         ok: false,
         error: 'forbidden_output'
     }, 'mapped constructor rejects undeclared positive keys');
     outcomes.push({
-        stdout: '{"result":{"nested":{"city":"Dubai"}}}'
-    });
-    const nestedAllowedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
+        stdout: okEnvelope({
+            nested: {
                 city: 'Dubai'
             }
-        }
-    }, null);
+        })
+    });
+    const nestedAllowedResult = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(nestedAllowedResult, {
         ok: true,
         result: {
@@ -1722,33 +2035,31 @@ try {
         }
     }, 'configured positive output allowlist accepts declared nested keys');
     outcomes.push({
-        stdout: '{"result":{"city":"Dubai","unexpected":"secret"}}'
+        stdout: okEnvelope({
+            city: 'Dubai',
+            unexpected: 'secret'
+        })
     });
-    const unexpectedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const unexpectedResult = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(unexpectedResult, {
         ok: false,
         error: 'forbidden_output'
     }, 'configured positive output allowlist rejects unexpected keys without reflecting them');
     outcomes.push({
-        stdout: '{"result":[{"city":"Dubai","nested":{"unexpected":"secret"}}]}'
-    });
-    const nestedUnexpectedResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
+        stdout: okEnvelope([
+            {
+                city: 'Dubai',
+                nested: {
+                    unexpected: 'secret'
+                }
             }
-        }
-    }, null);
+        ])
+    });
+    const nestedUnexpectedResult = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(nestedUnexpectedResult, {
         ok: false,
         error: 'forbidden_output'
@@ -1773,54 +2084,125 @@ try {
         'gоld'
     ]){
         outcomes.push({
-            stdout: JSON.stringify({
-                result: {
-                    nested: {
-                        [forbidden]: 'secret'
-                    }
+            stdout: okEnvelope({
+                nested: {
+                    [forbidden]: 'secret'
                 }
             })
         });
-        const forbiddenResult = await bridge.execute({
-            query: {
-                action: 'call',
-                tool: 'lookup',
-                arguments: {
-                    city: 'Dubai'
-                }
-            }
-        }, null);
+        const forbiddenResult = await bridge.execute(bridgeCall('lookup', {
+            city: 'Dubai'
+        }), null);
         assert.deepEqual(forbiddenResult, {
             ok: false,
             error: 'forbidden_output'
         }, `recursive no-oracle key ${forbidden} is rejected without reflecting its name`);
     }
     outcomes.push({
-        stdout: '{"result":"the hidden answer"}'
+        stdout: okEnvelope('the hidden answer')
     });
-    const primitiveOutput = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const primitiveOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(primitiveOutput, {
         ok: false,
         error: 'invalid_output'
     }, 'primitive result strings cannot bypass the structured visible-output boundary');
-    const beforeOversized = spawnSpecs.length;
-    const oversized = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                blob: 'x'.repeat(65_537)
+    outcomes.push({
+        stdout: okEnvelope([
+            'PRIVATE_ARRAY_VALUE'
+        ])
+    });
+    const primitiveArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(primitiveArrayOutput, {
+        ok: false,
+        error: 'forbidden_output'
+    }, 'top-level primitive arrays cannot bypass the positive output-key boundary');
+    assert.equal(JSON.stringify(primitiveArrayOutput).includes('PRIVATE_ARRAY_VALUE'), false, 'rejected primitive array values are not reflected');
+    outcomes.push({
+        stdout: okEnvelope([
+            [
+                "PRIVATE_NESTED_ARRAY_VALUE"
+            ]
+        ])
+    });
+    const nestedPrimitiveArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(nestedPrimitiveArrayOutput, {
+        ok: false,
+        error: 'forbidden_output'
+    }, 'nested primitive arrays without a declared-key ancestor fail closed');
+    assert.equal(JSON.stringify(nestedPrimitiveArrayOutput).includes('PRIVATE_NESTED_ARRAY_VALUE'), false, 'rejected nested primitive array values are not reflected');
+    outcomes.push({
+        stdout: okEnvelope([
+            {
+                city: 'Dubai'
+            },
+            'PRIVATE_MIXED_ARRAY_VALUE'
+        ])
+    });
+    const mixedArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(mixedArrayOutput, {
+        ok: false,
+        error: 'forbidden_output'
+    }, 'a valid record cannot mask an unkeyed primitive sibling');
+    assert.equal(JSON.stringify(mixedArrayOutput).includes('PRIVATE_MIXED_ARRAY_VALUE'), false, 'rejected mixed-array primitive values are not reflected');
+    outcomes.push({
+        stdout: okEnvelope([])
+    });
+    const emptyArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(emptyArrayOutput, {
+        ok: true,
+        result: []
+    }, 'an empty top-level result array is an explicit non-reflecting collection');
+    outcomes.push({
+        stdout: okEnvelope([
+            {
+                city: 'Dubai'
+            }
+        ])
+    });
+    const recordArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(recordArrayOutput, {
+        ok: true,
+        result: [
+            {
+                city: 'Dubai'
             }
+        ]
+    }, 'top-level arrays of records remain valid when every leaf is covered by a declared key');
+    outcomes.push({
+        stdout: okEnvelope({
+            city: [
+                'Dubai'
+            ]
+        })
+    });
+    const keyedPrimitiveArrayOutput = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(keyedPrimitiveArrayOutput, {
+        ok: true,
+        result: {
+            city: [
+                'Dubai'
+            ]
         }
-    }, null);
+    }, 'primitive arrays remain valid below a declared output key');
+    const beforeOversized = spawnSpecs.length;
+    const oversized = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai',
+        notes: 'x'.repeat(65_537)
+    }), null);
     assert.deepEqual(oversized, {
         ok: false,
         error: 'invalid_arguments',
@@ -1832,34 +2214,20 @@ try {
     for(let index = 0; index < 13; index++)deep = {
         next: deep
     };
-    const deepResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: deep
-        }
-    }, null);
-    assert.deepEqual(deepResult, {
-        ok: false,
-        error: 'invalid_arguments',
-        reason: 'serialization_limit'
-    });
-    assert.equal(spawnSpecs.length, beforeDeep, 'over-deep arguments are rejected before spawn');
+    await assert.rejects(()=>bridge.execute(bridgeCall('lookup', {
+            city: 'Dubai',
+            ...deep
+        }), null), /invalid arguments/);
+    assert.equal(spawnSpecs.length, beforeDeep, 'schema-invalid deep arguments are rejected before spawn');
     const beforeOverride = spawnSpecs.length;
-    const overrideResult = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai',
-                executable: '/tmp/evil',
-                cwd: '/tmp/evil',
-                argv: [
-                    '--unsafe'
-                ]
-            }
-        }
-    }, null);
+    const overrideResult = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai',
+        executable: '/tmp/evil',
+        cwd: '/tmp/evil',
+        argv: [
+            '--unsafe'
+        ]
+    }), null);
     assert.deepEqual(spawnSpecs[beforeOverride]?.argv, [
         process.execPath,
         '-m',
@@ -1879,43 +2247,56 @@ try {
     ], 'model executable/cwd/argv fields remain data and cannot override config');
     assert.equal(overrideResult.ok, true, 'override-shaped arguments still use the configured bridge');
     outcomes.push({
-        stdout: '{"result":{"city":"Dubai"}}',
+        stdout: okEnvelope({
+            city: 'Dubai'
+        }),
         lossy: true
     });
-    const truncated = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const truncated = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(truncated, {
         ok: false,
         error: 'output_truncated'
     }, 'lossy stdout is rejected without parsing partial output');
     outcomes.push({
-        stdout: '{"result":{"city":"Dubai"}}',
+        stdout: okEnvelope({
+            city: 'Dubai'
+        }),
         stderr: 'private runner diagnostic',
         exitCode: 17,
         signal: 'SIGTERM'
     });
-    const failed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const failed = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(failed, {
         ok: false,
         error: 'runner_failed',
         exit_code: 17,
         signal: 'SIGTERM'
     }, 'nonzero runner result is structured without stderr echo');
+    const errorsTable = await bridge.execute({
+        action: 'errors'
+    }, null);
+    assert.ok(errorsTable.ok === true && errorsTable.errors, 'bridge failure contract is discoverable');
+    for (const code of [
+        'invalid_action',
+        'disallowed_tool',
+        'invalid_arguments',
+        'timed_out',
+        'output_truncated',
+        'invalid_json',
+        'invalid_output',
+        'runner_failed',
+        'spawn_failed',
+        'forbidden_output'
+    ]){
+        const row = errorsTable.errors?.[code];
+        assert.ok(row && typeof row.recoverable === 'boolean' && row.remedy.length > 0, `failure contract contains ${code} with recovery guidance`);
+    }
+    assert.equal(errorsTable.errors?.invalid_arguments?.recoverable, true, 'invalid caller arguments are recoverable');
+    assert.equal(errorsTable.errors?.forbidden_output?.recoverable, false, 'policy-boundary output is not recoverable');
     for (const stdout of [
         'not-json',
         '{"result":1}{"result":2}'
@@ -1923,32 +2304,127 @@ try {
         outcomes.push({
             stdout
         });
-        const malformed = await bridge.execute({
-            query: {
-                action: 'call',
-                tool: 'lookup',
-                arguments: {
-                    city: 'Dubai'
-                }
-            }
-        }, null);
+        const malformed = await bridge.execute(bridgeCall('lookup', {
+            city: 'Dubai'
+        }), null);
         assert.deepEqual(malformed, {
             ok: false,
             error: 'invalid_json'
         }, 'malformed or multi-value JSON is rejected');
     }
     outcomes.push({
-        spawnError: true
+        stdout: JSON.stringify({
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        })
+    });
+    const miss = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(miss, {
+        ok: true,
+        outcome: {
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }
+    }, 'exit-zero domain miss is a successful typed outcome');
+    outcomes.push({
+        stdout: JSON.stringify({
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'error',
+            code: 'AMBIGUOUS',
+            recovery: 'choose_alternative'
+        })
     });
-    const spawnFailed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
+    const domainError = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
+    assert.deepEqual(domainError, {
+        ok: true,
+        outcome: {
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'error',
+            code: 'AMBIGUOUS',
+            recovery: 'choose_alternative'
+        }
+    }, 'declared exit-zero domain error is transport success');
+    for (const invalidEnvelope of [
+        {
+            schema_version: 'legacy',
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        },
+        {
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'miss',
+            code: 'UNKNOWN',
+            recovery: 'revise_arguments'
+        },
+        {
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'retry_same'
+        },
+        {
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'error',
+            code: 'AMBIGUOUS',
+            recovery: 'choose_alternative',
+            message: 'private free text'
+        }
+    ]){
+        outcomes.push({
+            stdout: JSON.stringify(invalidEnvelope)
+        });
+        assert.deepEqual(await bridge.execute(bridgeCall('lookup', {
+            city: 'Dubai'
+        }), null), {
+            ok: false,
+            error: 'invalid_output'
+        }, 'undeclared or non-exact domain envelope fails closed');
+    }
+    outcomes.push({
+        stdout: JSON.stringify({
+            result: {
                 city: 'Dubai'
             }
-        }
-    }, null);
+        })
+    });
+    assert.deepEqual(await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null), {
+        ok: false,
+        error: 'invalid_output'
+    }, 'legacy versionless result envelope is rejected');
+    outcomes.push({
+        stdout: JSON.stringify({
+            schema_version: BENCHMARK_TOOL_RESULT_SCHEMA_VERSION,
+            status: 'miss',
+            code: 'NOT_FOUND',
+            recovery: 'revise_arguments'
+        }),
+        exitCode: 23
+    });
+    assert.deepEqual(await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null), {
+        ok: false,
+        error: 'runner_failed',
+        exit_code: 23,
+        signal: null
+    }, 'nonzero exit remains infrastructure failure even when stdout resembles a domain envelope');
+    outcomes.push({
+        spawnError: true
+    });
+    const spawnFailed = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(spawnFailed, {
         ok: false,
         error: 'spawn_failed'
@@ -1956,15 +2432,9 @@ try {
     outcomes.push({
         spawnReject: true
     });
-    const asyncSpawnFailed = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const asyncSpawnFailed = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(asyncSpawnFailed, {
         ok: false,
         error: 'spawn_failed'
@@ -1972,55 +2442,47 @@ try {
     outcomes.push({
         waitForAbort: true
     });
-    const timedOut = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null);
+    const timedOut = await bridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null);
     assert.deepEqual(timedOut, {
         ok: false,
         error: 'timed_out'
     }, 'deadline abort is surfaced as timed_out');
     assert.equal(timeoutSignal?.aborted, true, 'timeout abort signal is fired');
     const beforeInvalidArgs = spawnSpecs.length;
-    assert.deepEqual(await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: [
-                'not',
-                'plain'
-            ]
-        }
-    }, null), {
-        ok: false,
-        error: 'invalid_arguments'
-    });
+    await assert.rejects(()=>bridge.execute(bridgeCall('lookup', [
+            'not',
+            'plain'
+        ]), null), /invalid arguments/);
     assert.equal(spawnSpecs.length, beforeInvalidArgs, 'non-object arguments are rejected before spawn');
-    assert.deepEqual(await bridge.execute({
-        query: {
+    for (const [label, argumentsValue] of [
+        [
+            'missing required city',
+            {}
+        ],
+        [
+            'wrong city type',
+            {
+                city: 7
+            }
+        ],
+        [
+            'undeclared country',
+            {
+                city: 'Dubai',
+                country: 'AE'
+            }
+        ]
+    ]){
+        await assert.rejects(()=>bridge.execute(bridgeCall('lookup', argumentsValue), null), /invalid arguments/, `${label} is rejected by the descriptor-derived runtime validator`);
+    }
+    assert.equal(spawnSpecs.length, beforeInvalidArgs, 'required, type, and closed-object argument failures all happen before spawn');
+    await assert.rejects(()=>bridge.execute({
             action: 'inspect'
-        }
-    }, null), {
-        ok: false,
-        error: 'invalid_action'
-    }, 'unknown action is rejected structurally');
+        }, null), /invalid arguments/);
     const beforeRejected = spawnSpecs.length;
-    const rejected = await bridge.execute({
-        query: {
-            action: 'call',
-            tool: 'delete_all',
-            arguments: {}
-        }
-    }, null);
-    assert.deepEqual(rejected, {
-        ok: false,
-        error: 'disallowed_tool'
-    }, 'disallowed tool is rejected structurally');
+    await assert.rejects(()=>bridge.execute(bridgeCall('delete_all', {}), null), /invalid arguments/);
     assert.equal(spawnSpecs.length, beforeRejected, 'disallowed tool is rejected before spawn');
     const spacedConfigPath = join(root, ' benchmark-environment-config.json ');
     writeFileSync(spacedConfigPath, readFileSync(configPath));
@@ -2105,7 +2567,8 @@ try {
     assert.deepEqual(disabledVariables, [
         'current_date',
         'time_anchor_card',
-        'motivation_brief'
+        'motivation_brief',
+        'channel_routing_card'
     ], 'normal product mode keeps its prompt variables');
     const whitespace = [];
     const whitespaceCtx = {
@@ -2206,7 +2669,7 @@ try {
         else process.env.GOTRY_LLM_MODEL = originalModelOverride;
     }
     const validConfig = {
-        schema_version: 'gotry_benchmark_environment_bridge_v2',
+        schema_version: 'gotry_benchmark_environment_bridge_v3',
         enabled: true,
         executable: process.execPath,
         cwd: root,
@@ -2216,8 +2679,38 @@ try {
             '--lang',
             'en'
         ],
-        allowed_tools: [
-            'lookup'
+        tools: [
+            {
+                name: 'lookup',
+                description: 'Lookup one declared city.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        city: {
+                            type: 'string',
+                            enum: [
+                                'Dubai',
+                                'Abu Dhabi'
+                            ],
+                            description: 'Declared city name.'
+                        }
+                    },
+                    required: [
+                        'city'
+                    ],
+                    additionalProperties: false
+                },
+                output_keys: [
+                    'city'
+                ],
+                domain_outcomes: [
+                    {
+                        status: 'miss',
+                        code: 'NOT_FOUND',
+                        recovery: 'revise_arguments'
+                    }
+                ]
+            }
         ],
         timeout_ms: 20,
         max_output_bytes: 4_096,
@@ -2231,6 +2724,86 @@ try {
             network: 'denied'
         }
     };
+    const clonedConfig = ()=>JSON.parse(JSON.stringify(validConfig));
+    const configWithTool = (mutate)=>{
+        const config = clonedConfig();
+        mutate(config.tools[0]);
+        return config;
+    };
+    const nestedInputSchema = (objectLevels)=>{
+        let child = {
+            type: 'string'
+        };
+        for(let index = 0; index < objectLevels; index += 1){
+            child = {
+                type: 'object',
+                properties: {
+                    next: child
+                },
+                required: [
+                    'next'
+                ],
+                additionalProperties: false
+            };
+        }
+        return child;
+    };
+    const flatInputSchema = (count)=>({
+            type: 'object',
+            properties: Object.fromEntries(Array.from({
+                length: count
+            }, (_, index)=>[
+                    `p${index}`,
+                    {
+                        type: 'string'
+                    }
+                ])),
+            required: [],
+            additionalProperties: false
+        });
+    const totalEnumInputSchema = (groups)=>({
+            type: 'object',
+            properties: Object.fromEntries(Array.from({
+                length: groups
+            }, (_, group)=>[
+                    `e${group}`,
+                    {
+                        type: 'string',
+                        enum: Array.from({
+                            length: 64
+                        }, (_, index)=>`v${group}_${index}`)
+                    }
+                ])),
+            required: [],
+            additionalProperties: false
+        });
+    const byteSizedInputSchema = (targetBytes)=>{
+        const properties = Object.fromEntries(Array.from({
+            length: 64
+        }, (_, index)=>[
+                `b${index}`,
+                {
+                    type: 'string',
+                    description: ''
+                }
+            ]));
+        const schema = {
+            type: 'object',
+            properties,
+            required: [],
+            additionalProperties: false
+        };
+        let remaining = targetBytes - Buffer.byteLength(JSON.stringify(schema), 'utf8');
+        assert.ok(remaining >= 0 && remaining <= 64 * 512, 'byte-boundary fixture has enough bounded description capacity');
+        for (const property of Object.values(properties)){
+            const added = Math.min(512, remaining);
+            property.description = 'x'.repeat(added);
+            remaining -= added;
+        }
+        assert.equal(remaining, 0, 'byte-boundary fixture reaches the requested serialized size');
+        assert.equal(Buffer.byteLength(JSON.stringify(schema), 'utf8'), targetBytes);
+        return schema;
+    };
     const frozenProjection = registerBenchmarkEnvironmentBridge(configPath, ()=>{}, {
         spawn: (_spec)=>fakeHandle({
                 stdout: '{"result":{}}'
@@ -2271,7 +2844,7 @@ try {
                 return ()=>{};
             },
             effect (action) {
-                return action();
+                return runEffect(action);
             },
             agents: {
                 list () {
@@ -2305,62 +2878,286 @@ try {
         }), /benchmark environment bridge configuration unavailable/, 'unknown top-level config key fails hard');
     assert.throws(()=>bridgeRegistrationFor({
             ...validConfig,
-            schema_version: 'gotry_benchmark_environment_bridge_v1'
-        }), /benchmark environment bridge configuration unavailable/, 'v1 config cannot silently omit the Round 3 terminal semantics');
-    assert.throws(()=>bridgeRegistrationFor({
-            ...validConfig,
-            allowed_tools: [
-                'lookup',
-                'lookup'
+            tools: [
+                {
+                    ...validConfig.tools[0],
+                    input_schema: {
+                        type: 'object'
+                    }
+                }
             ]
-        }), /benchmark environment bridge configuration unavailable/, 'duplicate allowed tool fails hard');
+        }), /benchmark environment bridge configuration unavailable/, 'v3 rejects an open annotation-only input schema');
     assert.throws(()=>bridgeRegistrationFor({
             ...validConfig,
-            allowed_output_keys: {}
-        }), /benchmark environment bridge configuration unavailable/, 'empty output-key mapping fails hard');
+            schema_version: 'gotry_benchmark_environment_bridge_v1'
+        }), /benchmark environment bridge configuration unavailable/, 'v1 config cannot silently omit the Round 3 terminal semantics');
     assert.throws(()=>bridgeRegistrationFor({
             ...validConfig,
-            allowed_output_keys: {
-                lookup: []
+            tools: [
+                validConfig.tools[0],
+                validConfig.tools[0]
+            ]
+        }), /benchmark environment bridge configuration unavailable/, 'duplicate tool descriptor fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            delete tool.output_keys;
+        })), /benchmark environment bridge configuration unavailable/, 'missing output_keys fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.output_keys = [];
+        })), /benchmark environment bridge configuration unavailable/, 'empty output allowlist fails closed at registration');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.output_keys = [
+                'city',
+                'city'
+            ];
+        })), /benchmark environment bridge configuration unavailable/, 'duplicate output key fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.output_keys = [
+                'not a key'
+            ];
+        })), /benchmark environment bridge configuration unavailable/, 'non-identifier output key fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            delete tool.domain_outcomes;
+        })), /benchmark environment bridge configuration unavailable/, 'missing domain_outcomes fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.domain_outcomes = [
+                {
+                    status: 'unknown',
+                    code: 'NOT_FOUND',
+                    recovery: 'none'
+                }
+            ];
+        })), /benchmark environment bridge configuration unavailable/, 'unknown domain status fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.domain_outcomes = [
+                {
+                    status: 'miss',
+                    code: 'NOT_FOUND',
+                    recovery: 'free_text'
+                }
+            ];
+        })), /benchmark environment bridge configuration unavailable/, 'free-text domain recovery fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.domain_outcomes = [
+                {
+                    status: 'miss',
+                    code: 'NOT_FOUND',
+                    recovery: 'none'
+                },
+                {
+                    status: 'error',
+                    code: 'NOT_FOUND',
+                    recovery: 'none'
+                }
+            ];
+        })), /benchmark environment bridge configuration unavailable/, 'duplicate domain code fails hard');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.name = 'lookup;rm';
+        })), /benchmark environment bridge configuration unavailable/, 'shell metacharacter tool identifier fails hard');
+    for (const [label, schema] of [
+        [
+            'reference keyword',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        $ref: '#/city'
+                    }
+                },
+                required: [
+                    'city'
+                ],
+                additionalProperties: false
             }
-        }), /benchmark environment bridge configuration unavailable/, 'empty output-key allowlist fails hard');
-    assert.throws(()=>bridgeRegistrationFor({
-            ...validConfig,
-            allowed_output_keys: {
-                unknown: [
+        ],
+        [
+            'default keyword',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string',
+                        default: 'Dubai'
+                    }
+                },
+                required: [
                     'city'
-                ]
+                ],
+                additionalProperties: false
             }
-        }), /benchmark environment bridge configuration unavailable/, 'output-key mapping for unknown tool fails hard');
-    assert.throws(()=>bridgeRegistrationFor({
-            ...validConfig,
-            allowed_output_keys: {
-                lookup: [
+        ],
+        [
+            'examples keyword',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string',
+                        examples: [
+                            'Dubai'
+                        ]
+                    }
+                },
+                required: [
+                    'city'
+                ],
+                additionalProperties: false
+            }
+        ],
+        [
+            'unknown keyword',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string',
+                        title: 'City'
+                    }
+                },
+                required: [
+                    'city'
+                ],
+                additionalProperties: false
+            }
+        ],
+        [
+            'open nested object',
+            {
+                type: 'object',
+                properties: {
+                    nested: {
+                        type: 'object',
+                        properties: {},
+                        required: []
+                    }
+                },
+                required: [
+                    'nested'
+                ],
+                additionalProperties: false
+            }
+        ],
+        [
+            'array without items',
+            {
+                type: 'object',
+                properties: {
+                    values: {
+                        type: 'array'
+                    }
+                },
+                required: [
+                    'values'
+                ],
+                additionalProperties: false
+            }
+        ],
+        [
+            'duplicate required',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string'
+                    }
+                },
+                required: [
                     'city',
                     'city'
-                ]
+                ],
+                additionalProperties: false
             }
-        }), /benchmark environment bridge configuration unavailable/, 'duplicate output key fails hard');
-    assert.throws(()=>bridgeRegistrationFor({
-            ...validConfig,
-            allowed_output_keys: {
-                lookup: [
-                    'not a key'
-                ]
+        ],
+        [
+            'unknown required',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string'
+                    }
+                },
+                required: [
+                    'country'
+                ],
+                additionalProperties: false
+            }
+        ],
+        [
+            'type-mismatched enum',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string',
+                        enum: [
+                            'Dubai',
+                            7
+                        ]
+                    }
+                },
+                required: [
+                    'city'
+                ],
+                additionalProperties: false
             }
-        }), /benchmark environment bridge configuration unavailable/, 'non-identifier output key fails hard');
+        ],
+        [
+            'duplicate enum',
+            {
+                type: 'object',
+                properties: {
+                    city: {
+                        type: 'string',
+                        enum: [
+                            'Dubai',
+                            'Dubai'
+                        ]
+                    }
+                },
+                required: [
+                    'city'
+                ],
+                additionalProperties: false
+            }
+        ]
+    ]){
+        assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+                tool.input_schema = schema;
+            })), /benchmark environment bridge configuration unavailable/, `${label} fails closed`);
+    }
+    assert.equal(bridgeRegistrationFor(configWithTool((tool)=>{
+        tool.input_schema = nestedInputSchema(8);
+    })), true, 'schema depth eight is accepted');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.input_schema = nestedInputSchema(9);
+        })), /benchmark environment bridge configuration unavailable/, 'schema depth nine is rejected');
+    assert.equal(bridgeRegistrationFor(configWithTool((tool)=>{
+        tool.input_schema = flatInputSchema(255);
+    })), true, 'the 256-node total boundary is accepted');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.input_schema = flatInputSchema(256);
+        })), /benchmark environment bridge configuration unavailable/, 'the 256-node total boundary plus one is rejected');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.input_schema = flatInputSchema(257);
+        })), /benchmark environment bridge configuration unavailable/, 'the property total bound rejects 257 properties');
+    assert.equal(bridgeRegistrationFor(configWithTool((tool)=>{
+        tool.input_schema = totalEnumInputSchema(4);
+    })), true, 'the 256-enum-value total boundary is accepted');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.input_schema = totalEnumInputSchema(5);
+        })), /benchmark environment bridge configuration unavailable/, 'the enum-value total bound rejects values above 256');
+    assert.equal(bridgeRegistrationFor(configWithTool((tool)=>{
+        tool.input_schema = byteSizedInputSchema(16 * 1024);
+    })), true, 'the 16 KiB schema boundary is accepted');
+    assert.throws(()=>bridgeRegistrationFor(configWithTool((tool)=>{
+            tool.input_schema = byteSizedInputSchema(16 * 1024 + 1);
+        })), /benchmark environment bridge configuration unavailable/, 'the schema byte boundary plus one is rejected');
     assert.throws(()=>bridgeRegistrationFor({
             ...validConfig,
             argv_prefix: [
                 'agent\n--unsafe'
             ]
         }), /benchmark environment bridge configuration unavailable/, 'argv control separator fails hard');
-    assert.throws(()=>bridgeRegistrationFor({
-            ...validConfig,
-            allowed_tools: [
-                'lookup;rm'
-            ]
-        }), /benchmark environment bridge configuration unavailable/, 'shell metacharacter tool identifier fails hard');
     assert.throws(()=>bridgeRegistrationFor({
             ...validConfig,
             isolation: {
@@ -2410,20 +3207,20 @@ try {
     writeFileSync(widePath, JSON.stringify(validConfig));
     chmodSync(widePath, 0o666);
     assert.throws(()=>loadConfigRegistration(widePath, root), /benchmark environment bridge configuration unavailable/, 'group/world writable config fails hard');
-    const legacyConfigPath = join(root, 'legacy-bridge.json');
-    writeFileSync(legacyConfigPath, JSON.stringify(validConfig));
-    const legacyTools = [];
-    const legacyCtx = {
+    const strictConfigPath = join(root, 'strict-bridge.json');
+    writeFileSync(strictConfigPath, JSON.stringify(validConfig));
+    const strictTools = [];
+    const strictCtx = {
         tools: {
             register (tool) {
-                legacyTools.push(tool);
+                strictTools.push(tool);
                 return ()=>{};
             },
             get (name) {
-                return legacyTools.find((tool)=>tool.name === name);
+                return strictTools.find((tool)=>tool.name === name);
             },
             schemas () {
-                return legacyTools.map((tool)=>({
+                return strictTools.map((tool)=>({
                         name: tool.name
                     }));
             }
@@ -2448,33 +3245,29 @@ try {
         },
         subprocess: {
             spawn: (_spec)=>fakeHandle({
-                    stdout: '{"result":{"city":"Dubai"}}'
+                    stdout: okEnvelope({
+                        city: 'Dubai'
+                    })
                 })
         }
     };
-    apply(legacyCtx, {
+    apply(strictCtx, {
         stateRoot: root,
         timeoutMs: 20,
         hbcliBin: '',
         sessionAccess: 'off',
-        benchmarkEnvironmentConfigPath: legacyConfigPath
+        benchmarkEnvironmentConfigPath: strictConfigPath
     });
-    const legacyBridge = legacyTools.find((tool)=>tool.name === 'gotry_benchmark_environment');
-    assert.ok(legacyBridge?.execute, 'legacy config without allowed_output_keys registers the bridge');
-    assert.deepEqual(await legacyBridge.execute({
-        query: {
-            action: 'call',
-            tool: 'lookup',
-            arguments: {
-                city: 'Dubai'
-            }
-        }
-    }, null), {
+    const strictBridge = strictTools.find((tool)=>tool.name === 'gotry_benchmark_environment');
+    assert.ok(strictBridge?.execute, 'strict v3 config registers the bridge');
+    assert.deepEqual(await strictBridge.execute(bridgeCall('lookup', {
+        city: 'Dubai'
+    }), null), {
         ok: true,
         result: {
             city: 'Dubai'
         }
-    }, 'legacy config without allowed_output_keys still executes safe structured output');
+    }, 'strict v3 result envelope executes safe structured output');
     console.log('BENCHMARK ENVIRONMENT BRIDGE TESTS: registration + TDD bridge contract assertions');
 } catch (error) {
     console.error(error);