@danceiny/gotry 0.0.1-rc.19 → 0.0.1-rc.21

package/dist/scripts/map-tools-vendor-package-proof.js

@@ -0,0 +1,276 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import assert from 'node:assert/strict';
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const upstreamLicenseSha256 = 'b6bbb0c73a02cf8d2c304e9f208b41c32f0a810fabe366986e2b14ac3338f618';
+const upstreamVendorFileCount = 32;
+const upstreamVendorAggregateSha256 = 'd82a38adace8bfe574dcecb4222da5c994a1b9e8792f78dc2dad3a7f50c9925a';
+const expectedTools = [
+    'map_bicycling_route',
+    'map_driving_route',
+    'map_geocode',
+    'map_poi_search',
+    'map_reverse_geocode',
+    'map_transit_route',
+    'map_walking_route'
+];
+function sha256(path) {
+    return createHash('sha256').update(readFileSync(path)).digest('hex');
+}
+function vendorAggregate(root) {
+    const files = [];
+    const walk = (directory)=>{
+        for (const entry of readdirSync(directory, {
+            withFileTypes: true
+        })){
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) walk(path);
+            else files.push(path.slice(root.length + 1).replaceAll('\\', '/'));
+        }
+    };
+    walk(root);
+    files.sort();
+    const digest = createHash('sha256');
+    for (const relative of files){
+        digest.update(relative);
+        digest.update('\0');
+        digest.update(readFileSync(join(root, relative)));
+        digest.update('\0');
+    }
+    return {
+        count: files.length,
+        sha256: digest.digest('hex')
+    };
+}
+function assertAlpha3LockClosure() {
+    const manifest = JSON.parse(readFileSync(join(repoRoot, 'ts/package.json'), 'utf8'));
+    assert.equal(manifest.dependencies?.['dsh-map-tools'], undefined, 'external map-tools dependency must stay removed');
+    const lock = JSON.parse(readFileSync(join(repoRoot, 'ts/package-lock.json'), 'utf8'));
+    assert.equal(lock.packages?.['']?.dependencies?.['dsh-map-tools'], undefined, 'lock root must not resolve external map-tools');
+    assert.equal(lock.packages?.['node_modules/dsh-map-tools'], undefined, 'lock must not carry external map-tools');
+    const dshEntries = Object.entries(lock.packages ?? {}).filter(([path])=>/(?:^|\/)node_modules\/@deepseek-ai\/(?:dsh|dsh-[^/]+)$/.test(path));
+    assert.ok(dshEntries.length >= 10, 'expected dsh-tools peer closure in the ts lock');
+    for (const [path, entry] of dshEntries){
+        assert.equal(entry.version, '0.1.2-alpha.3', `${path} drifted outside the alpha.3 closure`);
+    }
+    return {
+        packages: dshEntries.length,
+        version: '0.1.2-alpha.3'
+    };
+}
+function findPackageRoot(entry) {
+    let cursor = dirname(entry);
+    for(;;){
+        const manifestPath = join(cursor, 'package.json');
+        if (existsSync(manifestPath)) {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            if (manifest.name === '@danceiny/gotry') return cursor;
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor) throw new Error(`cannot locate @danceiny/gotry package root from ${entry}`);
+        cursor = parent;
+    }
+}
+function assertBinTargetsPackage(binPath, expectedTarget) {
+    const resolvedExpectedTarget = realpathSync(expectedTarget);
+    if (realpathSync(binPath) === resolvedExpectedTarget) return;
+    const shim = readFileSync(binPath, 'utf8');
+    assert.ok(Buffer.byteLength(shim, 'utf8') <= 32_768, 'clean-install gotry shim is unexpectedly large');
+    const lines = shim.trimEnd().split(/\r?\n/);
+    const markers = lines.filter((line)=>line.startsWith('# cmd-shim-target='));
+    assert.equal(markers.length, 1, 'pnpm gotry shim must contain exactly one target marker');
+    assert.equal(lines.at(-1), markers[0], 'pnpm gotry shim target marker must be the final line');
+    const markerTarget = markers[0].slice('# cmd-shim-target='.length);
+    assert.ok(isAbsolute(markerTarget), 'pnpm gotry shim target must be absolute');
+    assert.equal(realpathSync(markerTarget), resolvedExpectedTarget, 'GOTRY_MAP_TOOLS_E2E_BIN shim must target this installed GoTry package');
+}
+function prepareProofPackage(cleanInstalledBin) {
+    if (cleanInstalledBin) {
+        const binPath = resolve(cleanInstalledBin);
+        assert.equal(basename(binPath), 'gotry', 'clean-install executable must use the gotry bin name');
+        assert.equal(basename(dirname(binPath)), '.bin', 'clean-install executable must come from node_modules/.bin');
+        assert.equal(basename(dirname(dirname(binPath))), 'node_modules', 'clean-install executable must come from a consumer install');
+        const consumerRoot = dirname(dirname(dirname(binPath)));
+        const packageMain = createRequire(join(consumerRoot, 'package.json')).resolve('@danceiny/gotry');
+        const packageRoot = findPackageRoot(packageMain);
+        const installedManifest = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+        assert.equal(installedManifest.name, '@danceiny/gotry', 'clean-install executable must belong to GoTry');
+        const declaredBin = typeof installedManifest.bin === 'string' ? installedManifest.bin : installedManifest.bin?.gotry;
+        assert.equal(declaredBin, 'bin/gotry-inner.js', 'installed package must declare the production gotry bin');
+        assertBinTargetsPackage(binPath, join(packageRoot, declaredBin));
+        return {
+            packageRoot
+        };
+    }
+    const proofRoot = mkdtempSync(join(repoRoot, '.tmp-map-tools-proof-'));
+    try {
+        const packOutput = execFileSync('npm', [
+            'pack',
+            '--ignore-scripts',
+            '--json',
+            '--pack-destination',
+            proofRoot
+        ], {
+            cwd: repoRoot,
+            encoding: 'utf8'
+        });
+        const packInfo = JSON.parse(packOutput);
+        assert.equal(packInfo.length, 1, 'npm pack must produce one artifact');
+        const tarball = join(proofRoot, packInfo[0].filename);
+        assert.ok(existsSync(tarball), `packed artifact missing: ${tarball}`);
+        const unpackRoot = join(proofRoot, 'unpacked');
+        mkdirSync(unpackRoot);
+        execFileSync('tar', [
+            '-xzf',
+            tarball,
+            '-C',
+            unpackRoot
+        ]);
+        const packageRoot = join(unpackRoot, 'package');
+        symlinkSync(join(repoRoot, 'node_modules'), join(packageRoot, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
+        return {
+            packageRoot,
+            proofRoot
+        };
+    } catch (error) {
+        rmSync(proofRoot, {
+            recursive: true,
+            force: true
+        });
+        throw error;
+    }
+}
+const cleanInstalledBin = process.env.GOTRY_MAP_TOOLS_E2E_BIN;
+const { packageRoot, proofRoot } = prepareProofPackage(cleanInstalledBin);
+try {
+    const lockedDsh = assertAlpha3LockClosure();
+    const vendorRoot = join(packageRoot, 'ts/dsh-runtime/vendor/dsh-map-tools');
+    const requiredFiles = [
+        'LICENSE',
+        'package.json',
+        'cordis.patch.yml',
+        'lib/index.js',
+        'lib/settings-ns.js',
+        'lib/config.js',
+        'lib/tools/geocode.js',
+        'lib/tools/routes.js',
+        'lib/tools/poi.js'
+    ];
+    for (const relative of requiredFiles){
+        assert.ok(existsSync(join(vendorRoot, relative)), `required vendor file missing: ${relative}`);
+    }
+    const vendorTree = vendorAggregate(vendorRoot);
+    assert.equal(vendorTree.count, upstreamVendorFileCount, 'vendored payload file count drifted');
+    assert.equal(vendorTree.sha256, upstreamVendorAggregateSha256, 'vendored payload aggregate drifted');
+    const vendorPackage = JSON.parse(readFileSync(join(vendorRoot, 'package.json'), 'utf8'));
+    assert.equal(vendorPackage.name, 'dsh-map-tools');
+    assert.equal(vendorPackage.version, '0.5.1');
+    assert.equal(vendorPackage.license, 'MIT');
+    assert.equal(sha256(join(vendorRoot, 'LICENSE')), upstreamLicenseSha256, 'upstream MIT license changed');
+    const packageRequire = createRequire(join(packageRoot, 'package.json'));
+    const dshTools = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-tools/package.json'), 'utf8'));
+    const dshSettings = JSON.parse(readFileSync(packageRequire.resolve('@deepseek-ai/dsh-settings/package.json'), 'utf8'));
+    assert.equal(dshTools.version, '0.1.2-alpha.3');
+    assert.equal(dshSettings.version, '0.1.2-alpha.3');
+    const settingsApi = await import(pathToFileURL(packageRequire.resolve('@deepseek-ai/dsh-settings')).href);
+    assert.equal(typeof settingsApi.SettingsProvider?.prototype?.installSection, 'function', 'real alpha.3 SettingsProvider.installSection API must be present');
+    const plugin = await import(pathToFileURL(join(vendorRoot, 'lib/index.js')).href);
+    const registered = [];
+    const settingsCalls = [];
+    const context = {
+        tools: {
+            register (tool) {
+                registered.push(tool);
+                return ()=>undefined;
+            }
+        },
+        effect (effect) {
+            effect();
+        },
+        inject (dependencies, callback) {
+            if (dependencies.includes('settings')) {
+                callback({
+                    settings: {
+                        installSection: (...args)=>{
+                            settingsCalls.push(args);
+                        }
+                    }
+                });
+            } else if (dependencies.includes('webServer')) {
+                callback({
+                    webServer: {
+                        register: ()=>undefined
+                    }
+                });
+            } else {
+                throw new Error(`unexpected dependency injection: ${dependencies.join(',')}`);
+            }
+        }
+    };
+    plugin.apply(context, {
+        provider: 'osm',
+        amapKey: '',
+        timeoutMs: 1000,
+        maxQps: 2,
+        defaultMode: 'driving',
+        language: 'zh'
+    });
+    assert.deepEqual(registered.map((tool)=>tool.name).sort(), expectedTools, 'exactly seven map tools must register');
+    assert.equal(settingsCalls.length, 1, 'alpha.3 settings section must be installed once');
+    assert.equal(settingsCalls[0][1], 'dsh-map-tools', 'settings namespace must be stable');
+    assert.equal(typeof settingsCalls[0][4], 'object', 'alpha.3 installSection hooks must be supplied');
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async ()=>{
+        throw new Error('network forbidden by package proof');
+    };
+    try {
+        const geocode = registered.find((tool)=>tool.name === 'map_geocode');
+        assert.ok(geocode, 'map_geocode must be registered');
+        const result = await geocode.execute({
+            address: '116.397428,39.90923'
+        }, {
+            signal: new AbortController().signal
+        });
+        assert.equal(result.provider, 'inline');
+        assert.deepEqual(result.location, [
+            116.397428,
+            39.90923
+        ]);
+    } finally{
+        globalThis.fetch = originalFetch;
+    }
+    console.log(JSON.stringify({
+        proof: 'map-tools-vendor-package',
+        status: 'PASS',
+        artifactMode: cleanInstalledBin ? 'clean-installed-tarball' : 'packed-unpacked-focused',
+        vendored: {
+            sourcePackage: 'dsh-map-tools@0.5.1',
+            licenseSha256: upstreamLicenseSha256,
+            vendorFileCount: vendorTree.count,
+            vendorAggregateSha256: vendorTree.sha256
+        },
+        artifactVendor: vendorRoot,
+        dshClosure: {
+            tools: dshTools.version,
+            settings: dshSettings.version,
+            ...lockedDsh
+        },
+        tools: registered.map((tool)=>tool.name).sort(),
+        inlineCoordinate: {
+            provider: 'inline',
+            network: 'forbidden'
+        }
+    }, null, 2));
+} finally{
+    if (proofRoot) rmSync(proofRoot, {
+        recursive: true,
+        force: true
+    });
+}
+
+
+//# sourceURL=ts/scripts/map-tools-vendor-package-proof.ts

package/dist/scripts/persona-surface-guard-tests.js

@@ -8,12 +8,17 @@ assert.ok(patch.includes('绝不把 gotry_* 名字传给 skill 加载器'), '应
 const markers = new Set([
     ...patch.matchAll(/\((\d{1,2})\)/g)
 ].map((m)=>Number(m[1])));
-for(let i = 1; i <= 22; i += 1){
+for(let i = 1; i <= 23; i += 1){
     assert.ok(markers.has(i), `行为契约 (${i}) 应存在`);
 }
-assert.equal(markers.size, 22, `契约条目应恰为 22 条,实际 ${markers.size}`);
+assert.equal(markers.size, 23, `契约条目应恰为 23 条,实际 ${markers.size}`);
 assert.ok(patch.includes('改回 tool call'), '应指引失败后改回 tool call');
-console.log('PERSONA SURFACE GUARD TESTS: 3/3 OK(表层规则句 / 22 条契约完整 / skill 失败行为指引)');
+assert.ok(patch.includes('澄清卡/访谈/选项里向用户列出的候选时段示例'), '#2 回归:候选时段示例条款应存在');
+assert.ok(patch.includes('已过的节日不进示例枚举'), '应禁止已过节日进澄清卡示例枚举');
+assert.ok(patch.includes('(23)子任务等待纪律'), '#194 回归:子任务等待纪律条款应存在');
+assert.ok(patch.includes('对子代理绝不调用 job_output/job_kill'), '应禁止对子代理调用 job_output/job_kill');
+assert.ok(patch.includes("job_output/job_kill 只用于"), '应限定 job_output/job_kill 的适用面');
+console.log('PERSONA SURFACE GUARD TESTS: 5/5 OK(表层规则句 / 23 条契约完整 / skill 失败行为指引 / 澄清卡示例过锚点卡 / 子任务等待纪律)');
 
 
 //# sourceURL=ts/scripts/persona-surface-guard-tests.ts

package/dist/src/benchmark-agent-conformance.js

@@ -12,6 +12,26 @@ export const BENCHMARK_BRIDGE_RETRY_CALL_NOT_ALLOWED = 'BENCHMARK_BRIDGE_RETRY_C
 export const BENCHMARK_CONFORMANCE_STATE_UNAVAILABLE = 'BENCHMARK_CONFORMANCE_STATE_UNAVAILABLE';
 const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_.-]*$/;
 const MAX_TERMINAL_BYTES = 1024 * 1024;
+const BENCHMARK_TOOL_RESULT_SCHEMA_VERSION = 'gotry_benchmark_tool_result_v1';
+const BENCHMARK_DOMAIN_RECOVERIES = new Set([
+    'none',
+    'retry_same',
+    'revise_arguments',
+    'choose_alternative'
+]);
+const TERMINAL_BODY_SCHEMA_MAX_BYTES = 16 * 1024;
+const TERMINAL_BODY_SCHEMA_MAX_DEPTH = 8;
+const TERMINAL_BODY_SCHEMA_MAX_NODES = 256;
+const TERMINAL_BODY_SCHEMA_MAX_PROPERTIES = 256;
+const TERMINAL_BODY_SCALAR_TYPES = new Set([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'null'
+]);
+const TERMINAL_BODY_VALUE_MAX_NODES = 10_000;
+const TERMINAL_BODY_VALUE_MAX_DEPTH = 24;
 function plainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -19,9 +39,143 @@ export function validateTerminalOutputConfig(value) {
     if (!plainObject(value)) return false;
     const keys = Object.keys(value).sort();
     return JSON.stringify(keys) === JSON.stringify([
+        'body_schema',
         'max_bytes',
         'tag'
-    ]) && typeof value.tag === 'string' && IDENTIFIER.test(value.tag) && typeof value.max_bytes === 'number' && Number.isInteger(value.max_bytes) && value.max_bytes >= 1 && value.max_bytes <= MAX_TERMINAL_BYTES;
+    ]) && typeof value.tag === 'string' && IDENTIFIER.test(value.tag) && typeof value.max_bytes === 'number' && Number.isInteger(value.max_bytes) && value.max_bytes >= 1 && value.max_bytes <= MAX_TERMINAL_BYTES && validateTerminalBodySchema(value.body_schema);
+}
+export function validateTerminalBodySchema(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    } catch  {
+        return false;
+    }
+    if (typeof serialized !== 'string' || Buffer.byteLength(serialized, 'utf8') > TERMINAL_BODY_SCHEMA_MAX_BYTES) return false;
+    const pending = [
+        {
+            node: value,
+            depth: 0
+        }
+    ];
+    const seen = new Set();
+    let nodes = 0;
+    let properties = 0;
+    while(pending.length > 0){
+        const { node, depth } = pending.pop();
+        if (!plainObject(node) || seen.has(node) || ++nodes > TERMINAL_BODY_SCHEMA_MAX_NODES || depth > TERMINAL_BODY_SCHEMA_MAX_DEPTH) return false;
+        seen.add(node);
+        const type = node.type;
+        if (type === 'object') {
+            if (!exactKeys(node, [
+                'type',
+                'properties',
+                'required',
+                'additionalProperties'
+            ]) || !plainObject(node.properties) || !Array.isArray(node.required) || node.additionalProperties !== false) return false;
+            const entries = Object.entries(node.properties);
+            properties += entries.length;
+            if (properties > TERMINAL_BODY_SCHEMA_MAX_PROPERTIES || entries.some(([key, child])=>key.length === 0 || key.length > 64 || !plainObject(child))) return false;
+            if (node.required.length > entries.length || new Set(node.required).size !== node.required.length || node.required.some((key)=>typeof key !== 'string' || !Object.hasOwn(node.properties, key))) return false;
+            for (const [, child] of entries)pending.push({
+                node: child,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (type === 'array') {
+            if (!exactKeys(node, [
+                'type',
+                'items'
+            ]) || !plainObject(node.items)) return false;
+            pending.push({
+                node: node.items,
+                depth: depth + 1
+            });
+            continue;
+        }
+        if (typeof type !== 'string' || !TERMINAL_BODY_SCALAR_TYPES.has(type) || !exactKeys(node, [
+            'type'
+        ])) return false;
+    }
+    return plainObject(value) && value.type === 'object';
+}
+function exactKeys(value, allowed) {
+    return Object.keys(value).every((key)=>allowed.includes(key));
+}
+export function validateTerminalBodyValue(value, schema) {
+    const pending = [
+        {
+            value,
+            schema,
+            depth: 0
+        }
+    ];
+    let nodes = 0;
+    while(pending.length > 0){
+        const current = pending.pop();
+        if (++nodes > TERMINAL_BODY_VALUE_MAX_NODES || current.depth > TERMINAL_BODY_VALUE_MAX_DEPTH) return false;
+        const { schema: node } = current;
+        if (node.type === 'object') {
+            const record = current.value;
+            if (!plainObject(record)) return false;
+            const properties = node.properties;
+            for (const key of node.required){
+                if (!Object.hasOwn(record, key)) return false;
+            }
+            for (const [key, child] of Object.entries(record)){
+                const childSchema = properties[key];
+                if (!childSchema) return false;
+                pending.push({
+                    value: child,
+                    schema: childSchema,
+                    depth: current.depth + 1
+                });
+            }
+            continue;
+        }
+        if (node.type === 'array') {
+            if (!Array.isArray(current.value)) return false;
+            for (const item of current.value)pending.push({
+                value: item,
+                schema: node.items,
+                depth: current.depth + 1
+            });
+            continue;
+        }
+        if (node.type === 'string') {
+            if (typeof current.value !== 'string') return false;
+            continue;
+        }
+        if (node.type === 'boolean') {
+            if (typeof current.value !== 'boolean') return false;
+            continue;
+        }
+        if (node.type === 'null') {
+            if (current.value !== null) return false;
+            continue;
+        }
+        if (node.type === 'integer') {
+            if (typeof current.value !== 'number' || !Number.isSafeInteger(current.value)) return false;
+            continue;
+        }
+        if (typeof current.value !== 'number' || !Number.isFinite(current.value)) return false;
+    }
+    return true;
+}
+export function terminalSchemaOutline(schema) {
+    const render = (node, depth)=>{
+        if (depth > TERMINAL_BODY_SCHEMA_MAX_DEPTH) return '…';
+        if (node.type === 'object') {
+            const properties = node.properties;
+            const required = new Set(node.required);
+            const parts = Object.entries(properties).map(([key, child])=>`${required.has(key) ? '' : '?'}${key}:${render(child, depth + 1)}`);
+            return `object{${parts.join(',')}}`;
+        }
+        if (node.type === 'array') return `array<${render(node.items, depth + 1)}>`;
+        return node.type;
+    };
+    return render(schema, 0);
 }
 function invalidTerminal() {
     return {
@@ -44,10 +198,12 @@ export function parseBenchmarkTerminal(raw, config) {
     if (body.length === 0 || body.includes('```')) return invalidTerminal();
     try {
         const value = JSON.parse(body);
-        return plainObject(value) ? {
+        if (!plainObject(value)) return invalidTerminal();
+        if (!validateTerminalBodyValue(value, config.body_schema)) return invalidTerminal();
+        return {
             ok: true,
             value
-        } : invalidTerminal();
+        };
     } catch  {
         return invalidTerminal();
     }
@@ -90,13 +246,23 @@ function bridgeResultStatus(data, callId) {
     try {
         const parsed = JSON.parse(text);
         if (!plainObject(parsed)) return undefined;
-        if (parsed.ok === true) return {
-            ok: true
+        const keys = Object.keys(parsed).sort().join(',');
+        if (parsed.ok === true && keys === 'ok,result' && (plainObject(parsed.result) || Array.isArray(parsed.result))) return {
+            kind: 'result'
         };
+        if (parsed.ok === true && keys === 'ok,outcome' && plainObject(parsed.outcome)) {
+            const outcomeKeys = Object.keys(parsed.outcome).sort().join(',');
+            if (outcomeKeys === 'code,recovery,schema_version,status' && parsed.outcome.schema_version === BENCHMARK_TOOL_RESULT_SCHEMA_VERSION && (parsed.outcome.status === 'miss' || parsed.outcome.status === 'error') && typeof parsed.outcome.code === 'string' && IDENTIFIER.test(parsed.outcome.code) && typeof parsed.outcome.recovery === 'string' && BENCHMARK_DOMAIN_RECOVERIES.has(parsed.outcome.recovery)) return {
+                kind: 'domain'
+            };
+            return undefined;
+        }
         if (parsed.ok === false && typeof parsed.error === 'string') {
+            const exactFailure = parsed.error === 'runner_failed' ? keys === 'error,ok' || keys === 'error,exit_code,ok,signal' && (parsed.exit_code === null || typeof parsed.exit_code === 'number' && Number.isInteger(parsed.exit_code)) && (parsed.signal === null || typeof parsed.signal === 'string') : parsed.error === 'invalid_arguments' ? keys === 'error,ok,reason' && typeof parsed.reason === 'string' : keys === 'error,ok';
+            if (!exactFailure) return undefined;
             const code = parsed.error === 'timed_out' ? BENCHMARK_BRIDGE_TIMED_OUT : parsed.error === 'runner_failed' ? BENCHMARK_BRIDGE_RUNNER_FAILED : parsed.error === 'spawn_failed' ? BENCHMARK_BRIDGE_SPAWN_FAILED : parsed.error === 'output_truncated' ? BENCHMARK_BRIDGE_OUTPUT_TRUNCATED : BENCHMARK_BRIDGE_CALL_FAILED;
             return {
-                ok: false,
+                kind: 'failure',
                 code
             };
         }
@@ -164,8 +330,11 @@ export function createBenchmarkAgentConformance(projection) {
                 const callId = event.data.message.source.callId;
                 if (typeof callId !== 'string' || !state.validCallIds.has(callId)) return;
                 const resultStatus = bridgeResultStatus(event.data, callId);
-                if (resultStatus?.ok === true) {
+                if (typeof event.data.step === 'number') state.lastBridgeResponseStep = event.data.step;
+                if (resultStatus?.kind === 'result') {
                     state.successfulResultStep = typeof event.data.step === 'number' ? event.data.step : state.successfulResultStep;
+                } else if (resultStatus?.kind === 'domain') {
+                    state.domainOutcomeStep = typeof event.data.step === 'number' ? event.data.step : state.domainOutcomeStep;
                 } else {
                     state.bridgeCallFailed = true;
                     state.bridgeFailureCode = resultStatus?.code ?? BENCHMARK_BRIDGE_CALL_FAILED;
@@ -194,13 +363,13 @@ export function createBenchmarkAgentConformance(projection) {
                     code: BENCHMARK_BRIDGE_RETRY_CALL_NOT_ALLOWED
                 };
             }
-            if (state.successfulResultStep === undefined) {
-                if (state.bridgeCallFailed) {
-                    return {
-                        kind: 'reject',
-                        code: state.bridgeFailureCode ?? BENCHMARK_BRIDGE_CALL_FAILED
-                    };
-                }
+            if (state.bridgeCallFailed && state.successfulResultStep === undefined) {
+                return {
+                    kind: 'reject',
+                    code: state.bridgeFailureCode ?? BENCHMARK_BRIDGE_CALL_FAILED
+                };
+            }
+            if (state.successfulResultStep === undefined && state.domainOutcomeStep === undefined) {
                 if (state.retryCount >= MAX_CONFORMANCE_RETRIES) {
                     return {
                         kind: 'reject',
@@ -215,7 +384,7 @@ export function createBenchmarkAgentConformance(projection) {
                 };
             }
             const terminal = state.lastAssistant;
-            const terminalIsValid = terminal !== undefined && !terminal.interrupted && terminal.step > state.successfulResultStep && parseBenchmarkTerminal(terminal.text, projection.terminal).ok;
+            const terminalIsValid = terminal !== undefined && !terminal.interrupted && terminal.step > state.lastBridgeResponseStep && parseBenchmarkTerminal(terminal.text, projection.terminal).ok;
             if (terminalIsValid) return {
                 kind: 'accept'
             };
@@ -243,7 +412,7 @@ function requireDisposer(value, capability) {
     return value;
 }
 function correctionMessage(mode, projection) {
-    const text = mode === 'call' ? `BENCHMARK_CONFORMANCE_CALL: Execute exactly one native ${projection.toolName} action:"call" now. Describing an intended CLI, shell, or Python command does not execute it.` : `BENCHMARK_CONFORMANCE_TERMINAL: Reuse the existing successful tool result. Do not call any tool. Reply only <${projection.terminal.tag}>{"result":"..."}</${projection.terminal.tag}> with one JSON object.`;
+    const text = mode === 'call' ? `BENCHMARK_CONFORMANCE_CALL: Execute exactly one native ${projection.toolName} action:"call" now. Describing an intended CLI, shell, or Python command does not execute it.` : `BENCHMARK_CONFORMANCE_TERMINAL: Reuse the existing successful tool result. Do not call any tool. Reply only <${projection.terminal.tag}> with one JSON object matching exactly ${terminalSchemaOutline(projection.terminal.body_schema)} — no extra keys, no missing keys, exact types.`;
     return createUserMessage({
         content: [
             {
@@ -259,6 +428,7 @@ function correctionMessage(mode, projection) {
 }
 function systemSection(projection) {
     const allowed = projection.allowedTools.join(', ');
+    const outline = terminalSchemaOutline(projection.terminal.body_schema);
     return {
         name: 'benchmark:agent-conformance',
         text: [
@@ -266,7 +436,7 @@ function systemSection(projection) {
             `- Translate every task instruction to use a CLI, shell, Python, or agent_env.cli into the native tool ${projection.toolName}; do not merely describe the intended command.`,
             `- Call it with exactly {"action":"call","tool":"<one of: ${allowed}>","arguments":{...}}.`,
             '- action:"tools" is discovery only and does not satisfy the required environment call.',
-            `- After a successful tool result, reply only <${projection.terminal.tag}>{...one JSON object...}</${projection.terminal.tag}> with no prose or code fence.`,
+            `- After a successful tool result, reply only <${projection.terminal.tag}> with one JSON object matching exactly ${outline} — no extra keys, no missing keys, exact types; no prose or code fence.`,
             '- If a terminal-format correction arrives, reuse the existing result and do not call the tool again.'
         ].join('\n')
     };