@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/diagnostics/native_terminal_benchmark.js

@@ -0,0 +1,1247 @@
+import cp from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer as createHttpServer } from 'node:http';
+import { syncBuiltinESMExports } from 'node:module';
+import net from 'node:net';
+import os from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { promisify } from 'node:util';
+export class NativeTerminalBenchmarkError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'NativeTerminalBenchmarkError';
+    }
+}
+function validateInitialGeometry(geometry) {
+    if (geometry && (!Number.isFinite(geometry.width) || !Number.isFinite(geometry.height)
+        || geometry.width < 520 || geometry.width > 8192 || geometry.height < 320 || geometry.height > 8192)) {
+        throw new NativeTerminalBenchmarkError('INVALID_OPTIONS', 'Initial geometry must be finite content points within 520..8192 by 320..8192');
+    }
+}
+function initialGeometryArgs(geometry) {
+    return geometry ? ['--initial-size', `${geometry.width}x${geometry.height}`] : [];
+}
+/** Milliseconds in, milliseconds out. Empty observations are unavailable. */
+export function summarizeNativeSamples(samples) {
+    if (samples.some(value => !Number.isFinite(value) || value < 0)) {
+        throw new RangeError('Timing samples must be finite nonnegative numbers');
+    }
+    if (samples.length === 0)
+        return { count: 0, mean: null, p50: null, p95: null, max: null };
+    const sorted = [...samples].sort((a, b) => a - b);
+    return { count: sorted.length, mean: sorted.reduce((sum, value) => sum + value, 0) / sorted.length,
+        p50: sorted[Math.ceil(sorted.length * 0.5) - 1], p95: sorted[Math.ceil(sorted.length * 0.95) - 1], max: sorted[sorted.length - 1] };
+}
+const execFile = promisify(cp.execFile);
+const pause = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+async function within(promise, ms) {
+    let timer;
+    try {
+        return await Promise.race([promise, new Promise(resolve => { timer = setTimeout(() => resolve(null), ms); })]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/** Public peer marker vocabulary shared by the fixture producer, observer and workload manifest. */
+export function nativeBenchmarkPeerMarkers(name) {
+    const identity = sha256(basename(name)).slice(0, 6);
+    return { ready: 'R' + identity, output: 'O' + identity, bulk: 'B' + identity };
+}
+function ownedEnvironment(root) {
+    return { HOME: join(root, 'home'), TMPDIR: join(root, 'tmp'), PATH: '/usr/bin:/bin:/opt/homebrew/bin', SHELL: '/bin/sh',
+        LANG: 'en_US.UTF-8', LC_ALL: 'en_US.UTF-8', ZTC_CONFIG_DIR: join(root, 'config'), ZTC_SESSIONS_DIR: join(root, 'sessions'),
+        ZTC_TODO_STORE: join(root, 'todos.json'), ZTC_DISABLE_AUTH_REFRESH: '1', ZTC_DISABLE_UPDATE: '1',
+        ZTC_EXTENSION_DISCOVERY: 'explicit', ZTC_SIM_DISABLE_EMBEDDINGS: '1', ZTC_AGENT_TOOL_ALLOWLIST: '[]', ZTC_PANE_ID: '0' };
+}
+async function prepareRoot(root) {
+    await mkdir(root, { recursive: true });
+    await Promise.all(['home', 'tmp', 'config', 'sessions', 'project'].map(name => mkdir(join(root, name), { recursive: true })));
+    await writeFile(join(root, 'settings.json'), JSON.stringify({ check_for_updates_on_startup: false }));
+}
+class Ipc {
+    socket;
+    log;
+    sequence = 0;
+    buffer = '';
+    events = [];
+    failure = null;
+    constructor(socket, log) {
+        this.socket = socket;
+        this.log = log;
+        socket.setEncoding('utf8');
+        socket.on('data', (chunk) => {
+            this.buffer += chunk;
+            if (this.buffer.length > 16 * 1024 * 1024) {
+                this.failure = new Error('Native IPC packet exceeds bounded measurement size');
+                socket.destroy();
+                return;
+            }
+            let newline;
+            while ((newline = this.buffer.indexOf('\n')) >= 0) {
+                const line = this.buffer.slice(0, newline);
+                this.buffer = this.buffer.slice(newline + 1);
+                try {
+                    const event = JSON.parse(line);
+                    this.events.push(event);
+                    this.log.write(JSON.stringify({ direction: 'event', atMs: performance.now(), event }) + '\n');
+                }
+                catch (error) {
+                    this.failure = new Error('Malformed native IPC JSON: ' + String(error));
+                }
+            }
+        });
+        socket.on('error', error => { this.failure = error; });
+        socket.on('close', () => { this.failure ??= new Error('Native IPC closed'); });
+    }
+    send(command) {
+        if (this.failure)
+            throw this.failure;
+        this.log.write(JSON.stringify({ direction: 'command', atMs: performance.now(), command }) + '\n');
+        this.socket.write(JSON.stringify(command) + '\n');
+    }
+    async event(type, requestId, timeoutMs = 5000) {
+        const deadline = performance.now() + timeoutMs;
+        while (performance.now() < deadline) {
+            const index = this.events.findIndex(event => event.type === type && (requestId === undefined || event.request_id === requestId));
+            if (index >= 0)
+                return this.events.splice(index, 1)[0];
+            const errorIndex = this.events.findIndex(event => event.type === 'error' && (requestId === undefined || event.request_id === requestId));
+            if (errorIndex >= 0)
+                throw new Error('Native command rejected: ' + JSON.stringify(this.events.splice(errorIndex, 1)[0]));
+            if (this.failure)
+                throw this.failure;
+            await pause(1);
+        }
+        throw new NativeTerminalBenchmarkError('READINESS_FAILED', `Native ${type} did not reply within ${timeoutMs} ms`);
+    }
+    async request(type, resultType, fields = {}, timeoutMs) {
+        const id = 'benchmark-145-' + ++this.sequence;
+        this.send({ type, request_id: id, ...fields });
+        return this.event(resultType, id, timeoutMs);
+    }
+    close() { this.socket.destroy(); this.log.end(); }
+}
+class NativeSession {
+    root;
+    agent;
+    ipc;
+    ready;
+    socketReadyMs = 0;
+    child;
+    exit;
+    stderr = '';
+    started = performance.now();
+    ownedPids = new Set();
+    frameReadinessObservations = [];
+    peerMarkerOwners = new Map();
+    nativePid;
+    log;
+    constructor(root, binary, agent = false, geometry) {
+        this.root = root;
+        this.agent = agent;
+        this.log = createWriteStream(join(root, 'ipc.jsonl'));
+        const stderrLog = createWriteStream(join(root, 'process.stderr.log'));
+        const env = ownedEnvironment(root);
+        const args = agent ? ['--import', 'tsx', resolve('scripts/benchmark-zterm.ts'), '--owned-agent-runtime', root, binary, ...initialGeometryArgs(geometry)]
+            : ['--socket', join(root, 'native.sock'), '--settings', join(root, 'settings.json'), '--session', join(root, 'native-session.json'), '--title', 'ZTC 145 owned performance baseline', ...initialGeometryArgs(geometry)];
+        this.child = cp.spawn(agent ? process.execPath : binary, args, { cwd: agent ? process.cwd() : root, env,
+            stdio: ['ignore', 'ignore', 'pipe'] });
+        if (this.child.pid) {
+            this.ownedPids.add(this.child.pid);
+            if (!agent)
+                this.nativePid = this.child.pid;
+        }
+        this.child.stderr?.on('data', (chunk) => { stderrLog.write(chunk); this.stderr = (this.stderr + String(chunk)).slice(-8192); });
+        this.exit = new Promise((resolveExit, reject) => {
+            this.child.once('error', reject);
+            this.child.once('close', (code, signal) => { stderrLog.end(); resolveExit({ code, signal }); });
+        });
+    }
+    async connect() {
+        const socketPath = join(this.root, this.agent ? 'driver.sock' : 'native.sock');
+        let exited;
+        let spawnError;
+        void this.exit.then(value => { exited = value; }, error => { spawnError = error; });
+        const deadline = performance.now() + 15_000;
+        while (performance.now() < deadline) {
+            if (spawnError || exited) {
+                this.log.end();
+                throw new NativeTerminalBenchmarkError('STARTUP_FAILED', `Renderer exited ${exited?.code ?? 'spawn error'}: ${this.stderr || String(spawnError ?? exited?.signal)}`);
+            }
+            const socket = await new Promise(resolveSocket => {
+                const candidate = net.createConnection(socketPath);
+                candidate.once('connect', () => resolveSocket(candidate));
+                candidate.once('error', () => { candidate.destroy(); resolveSocket(null); });
+            });
+            if (socket) {
+                this.ipc = new Ipc(socket, this.log);
+                this.ready = await this.ipc.event('ready');
+                this.socketReadyMs = performance.now() - this.started;
+                if (this.agent) {
+                    const info = await this.ipc.event('benchmark_agent_ready');
+                    if (typeof info.native_pid === 'number') {
+                        this.ownedPids.add(info.native_pid);
+                        this.nativePid = info.native_pid;
+                    }
+                }
+                return;
+            }
+            await pause(5);
+        }
+        throw new NativeTerminalBenchmarkError('STARTUP_FAILED', `Renderer startup deadline: ${this.stderr}`);
+    }
+    async createPeer(python, mode, name, extra = [], newWindow = false) {
+        const markers = nativeBenchmarkPeerMarkers(name);
+        const priorOwner = this.peerMarkerOwners.get(markers.ready);
+        if (priorOwner !== undefined && priorOwner !== name)
+            throw new NativeTerminalBenchmarkError('MARKER_COLLISION', 'Owned peer marker collision: ' + priorOwner + ' / ' + name);
+        this.peerMarkerOwners.set(markers.ready, name);
+        await writeFile(join(this.root, name + '.markers.json'), JSON.stringify(markers));
+        const event = await this.ipc.request('create_pane', 'pane_created', { command: python,
+            args: ['-I', '-u', join(this.root, 'peer.py'), mode, join(this.root, name), ...extra], cwd: join(this.root, 'project'),
+            title: 'Owned 145 ' + name, pane_type: 'process', new_window: newWindow, env: { LC_ALL: 'en_US.UTF-8' } });
+        const pane = Number(event.pane_id);
+        await this.waitText(pane, nativeBenchmarkPeerMarkers(name).ready);
+        const record = await readJson(join(this.root, name + '.ready.json'));
+        this.ownedPids.add(Number(record.pid));
+        return pane;
+    }
+    async read(pane) {
+        const event = await this.ipc.request('read_pane', 'pane_read', { pane_id: pane, viewport: false, lines: 100 });
+        if (event.error)
+            throw new Error(String(event.error));
+        return String(event.content);
+    }
+    async write(pane, text) {
+        const result = await this.ipc.request('write_pane', 'pane_write_result', { pane_id: pane, input: text, submit: false, control: false }, 15_000);
+        if (result.error || (!result.delivered && !result.queued))
+            throw new Error('Managed write failed: ' + JSON.stringify(result));
+    }
+    async waitText(pane, marker, timeoutMs = 15_000) {
+        const deadline = performance.now() + timeoutMs;
+        let text = '';
+        while (performance.now() < deadline) {
+            text = await this.read(pane);
+            if (text.includes(marker))
+                return text;
+            await pause(2);
+        }
+        throw new NativeTerminalBenchmarkError('READINESS_FAILED', 'Owned pane marker not observed: ' + marker + '; tail=' + text.slice(-512));
+    }
+    async layout() {
+        this.ipc.send({ type: 'get_session_state' });
+        const event = await this.ipc.event('session_state');
+        return event.state;
+    }
+    async metrics() {
+        const counter = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+        const positive = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0;
+        const deadline = performance.now() + 5000;
+        while (true) {
+            const event = await this.ipc.request('get_terminal_metrics', 'terminal_metrics');
+            const values = event.frame_cpu_samples_ms;
+            const envelopeValid = Array.isArray(values) && values.length <= 120
+                && values.every(value => typeof value === 'number' && Number.isFinite(value) && value >= 0)
+                && counter(event.frame_count) && counter(event.frame_cpu_sample_count)
+                && event.frame_cpu_sample_count <= event.frame_count && values.length <= event.frame_cpu_sample_count
+                && counter(event.pane_count) && event.pane_count >= 1
+                && counter(event.viewport_cols) && counter(event.viewport_rows)
+                && positive(event.window_width_points) && positive(event.window_height_points) && positive(event.pixels_per_point)
+                && typeof event.focused === 'boolean';
+            const beforeFirstFrame = envelopeValid && event.frame_count === 0 && event.frame_cpu_sample_count === 0
+                && values.length === 0 && event.viewport_cols === 0 && event.viewport_rows === 0;
+            if (beforeFirstFrame) {
+                this.frameReadinessObservations.push({ observedAfterSpawnMs: performance.now() - this.started, metrics: event });
+                if (performance.now() >= deadline)
+                    throw new NativeTerminalBenchmarkError('READINESS_FAILED', 'Native first frame/grid was not observed within 5000 ms');
+                await pause(10);
+                continue;
+            }
+            if (!envelopeValid || Number(event.frame_count) < 1 || Number(event.viewport_cols) < 1 || Number(event.viewport_rows) < 1) {
+                throw new NativeTerminalBenchmarkError('INVALID_METRICS', 'Malformed native frame metrics; no observation was recorded');
+            }
+            return event;
+        }
+    }
+    async stop() {
+        const started = performance.now();
+        let fallback = false;
+        try {
+            this.ipc?.send({ type: this.agent ? 'benchmark_stop' : 'shutdown' });
+        }
+        catch { /* A startup failure can have no IPC connection. It remains a failed attempt. */ }
+        let result = await within(this.exit, 5000);
+        if (!result) {
+            fallback = true;
+            this.child.kill('SIGTERM');
+            result = await within(this.exit, 2000);
+        }
+        if (!result) {
+            this.child.kill('SIGKILL');
+            result = await this.exit;
+        }
+        this.ipc?.close();
+        this.log.end();
+        const after = [...this.ownedPids].map(pid => { let absent = false; try {
+            process.kill(pid, 0);
+        }
+        catch (error) {
+            absent = error.code === 'ESRCH';
+        } return { pid, absent }; });
+        let socketAbsent = false;
+        try {
+            await access(join(this.root, this.agent ? 'driver.sock' : 'native.sock'));
+        }
+        catch (error) {
+            socketAbsent = error.code === 'ENOENT';
+        }
+        let agentCleanup = {};
+        if (this.agent) {
+            try {
+                const recorded = JSON.parse(await readFile(join(this.root, 'agent-result.json'), 'utf8'));
+                agentCleanup = { rendererExit: recorded.rendererExit, nativeSocketAbsent: recorded.nativeSocketAbsent,
+                    rendererSocketPath: recorded.rendererSocketPath };
+            }
+            catch (error) {
+                agentCleanup = { rendererExit: null, nativeSocketAbsent: false, cleanupRecordError: String(error).slice(0, 512) };
+            }
+        }
+        const receipt = { code: result.code, signal: result.signal, durationMs: performance.now() - started, fallback, pids: after, socketAbsent, ...agentCleanup };
+        await writeFile(join(this.root, 'cleanup.json'), JSON.stringify(receipt, null, 2));
+        return receipt;
+    }
+}
+async function readJson(path) {
+    const deadline = performance.now() + 5000;
+    while (performance.now() < deadline) {
+        try {
+            return JSON.parse(await readFile(path, 'utf8'));
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError) && error.code !== 'ENOENT')
+                throw error;
+            await pause(5);
+        }
+    }
+    throw new Error('Owned completion record not published: ' + path);
+}
+const PEER = String.raw `
+import hashlib,json,os,select,sys,time,tty
+mode,path=sys.argv[1:3];name=os.path.basename(path);markers=json.load(open(path+'.markers.json'));tty.setraw(0)
+def record(suffix,value):
+    temp=path+suffix+'.tmp';open(temp,'w').write(json.dumps(value));os.replace(temp,path+suffix)
+def line():
+    value=b''
+    while not value.endswith(b'\n'):
+        chunk=os.read(0,1)
+        if not chunk:raise EOFError()
+        value+=chunk
+    return value[:-1]
+record('.ready.json',{'pid':os.getpid(),'mode':mode});os.write(1,(markers['ready']+'\r\n').encode())
+try:
+    if mode=='echo':
+        received=[]
+        while True:
+            value=line()
+            if value==b'QUIT':break
+            received.append(value.hex());os.write(1,b'\r\nECHO_145_'+value+b'\r\n')
+        record('.done.json',{'pid':os.getpid(),'received':received})
+    elif mode=='output':
+        payload=open(sys.argv[3],'rb').read();cadence=float(sys.argv[4]);chunk_size=int(sys.argv[5]);line()
+        started=time.monotonic_ns();record('.active.json',{'pid':os.getpid(),'startedMonotonicNs':str(started)})
+        for offset in range(0,len(payload),chunk_size):
+            data=payload[offset:offset+chunk_size];written=0
+            while written<len(data):written+=os.write(1,data[written:])
+            if cadence:time.sleep(cadence)
+        os.write(1,('\r\n'+markers['output']+'\r\n').encode())
+        record('.done.json',{'pid':os.getpid(),'bytes':len(payload),'sha256':hashlib.sha256(payload).hexdigest(),'startedMonotonicNs':str(started),'endedMonotonicNs':str(time.monotonic_ns())})
+        line()
+    elif mode=='bulk':
+        size=int(sys.argv[3]);bracketed=sys.argv[4]=='true';os.write(1,b'\x1b[?2004h' if bracketed else b'\x1b[?2004l');data=b''
+        while len(data)<size:data+=os.read(0,min(65536,size-len(data)))
+        record('.done.json',{'pid':os.getpid(),'bytes':len(data),'sha256':hashlib.sha256(data).hexdigest(),'bracketed':bracketed})
+        os.write(1,('\r\n'+markers['bulk']+'\r\n').encode());line()
+    else:raise ValueError('unknown peer mode')
+except EOFError:pass
+`;
+function payloadBytes(size, kind) {
+    const row = kind === 'ansi' ? '\x1b[38;2;12;34;56mOWNED145café\x1b[0m\n'
+        : kind === 'unicode' ? 'OWNED145 café é 中文 🦀\n' : 'OWNED145 ASCII output row\n';
+    const seed = Buffer.from(row);
+    const result = Buffer.alloc(size, 0x20);
+    for (let offset = 0; offset + seed.length <= size; offset += seed.length)
+        seed.copy(result, offset);
+    result[size - 1] = 10;
+    return result;
+}
+function bulkBytes(size) {
+    const seed = Buffer.from('café中文🦀');
+    const result = Buffer.alloc(size, 0x78);
+    for (let offset = 0; offset + seed.length <= size; offset += seed.length)
+        seed.copy(result, offset);
+    return result;
+}
+async function frameSamples(session, condition, active, smoke = false) {
+    const initial = await session.metrics();
+    const warmup = smoke ? 5 : 100;
+    const count = smoke ? 10 : 120;
+    const deadline = performance.now() + 15_000;
+    let start;
+    let end = initial;
+    let validLoad = true;
+    while (performance.now() < deadline) {
+        end = await session.metrics();
+        if (active && !await active())
+            validLoad = false;
+        if (!start && end.frame_count - initial.frame_count >= warmup)
+            start = end;
+        if (start && end.frame_cpu_sample_count - start.frame_cpu_sample_count >= count)
+            break;
+        await pause(50);
+    }
+    const sufficient = !!start && end.frame_cpu_sample_count - start.frame_cpu_sample_count >= count;
+    const values = sufficient ? end.frame_cpu_samples_ms.slice(-count) : [];
+    const layoutState = await session.layout();
+    const visiblePanes = nativeVisiblePanes(layoutState);
+    const expectedVisibleCount = condition === 'idle_one_pane' ? 1 : condition === 'four_panes' ? 4 : undefined;
+    const layoutQualified = visiblePanes !== null && (expectedVisibleCount === undefined || visiblePanes.length === expectedVisibleCount);
+    return { name: 'native_frame_cpu', condition, status: sufficient && validLoad && layoutQualified ? 'measured' : 'unqualified', layoutState, visiblePanes, expectedVisibleCount, layoutQualified,
+        initial, afterWarmup: start ?? null, final: end, samplesMs: values, summary: summarizeNativeSamples(values), producerActiveThroughout: validLoad,
+        minimumDistinctSamples: count, warmupFrames: warmup, cacheSequenceFirst: end.frame_cpu_sample_count - values.length + 1,
+        cacheSequenceLast: end.frame_cpu_sample_count, boundary: 'Previous frame CPU App/update/render; excludes vsync/GPU/presentation' };
+}
+async function echoSamples(session, pane, condition, count, active) {
+    const samples = [];
+    const payloads = [];
+    let validLoad = true;
+    const intervalStarted = performance.now();
+    for (let index = 0; index < count; index++) {
+        const targetTime = intervalStarted + index * 40;
+        await pause(Math.max(0, targetTime - performance.now()));
+        if (active && !await active())
+            validLoad = false;
+        const text = `${condition.replace(/[^a-z]/g, '')}-${String(index).padStart(4, '0')}`;
+        payloads.push(text);
+        const started = performance.now();
+        await session.write(pane, text + '\n');
+        await session.waitText(pane, 'ECHO_145_' + text);
+        samples.push(performance.now() - started);
+        if (active && !await active())
+            validLoad = false;
+    }
+    return { name: 'managed_raw_input_echo', condition, status: validLoad ? 'measured' : 'unqualified', samplesMs: samples,
+        summary: summarizeNativeSamples(samples), payloads, targetPane: pane, producerActiveThroughout: validLoad,
+        sampleIntervalMs: 40, readPollDelayMs: 2, boundary: 'Public write_pane to public read_pane echoed marker; includes IPC/polling; no physical keyboard' };
+}
+async function resources(pid) {
+    const { stdout } = await execFile('/bin/ps', ['-o', 'rss=,time=', '-p', String(pid)]);
+    const [rss, clock] = stdout.trim().split(/\s+/);
+    const pieces = clock.split(':').map(Number);
+    const cpuSeconds = pieces.reduce((total, value) => total * 60 + value, 0);
+    if (!Number.isFinite(Number(rss)) || !Number.isFinite(cpuSeconds))
+        throw new Error('Malformed owned PID resource observation');
+    return { rssBytes: Number(rss) * 1024, cpuSeconds };
+}
+async function resourceWindow(session, seconds, condition, active) {
+    const pid = session.nativePid;
+    const before = await resources(pid);
+    const started = performance.now();
+    const samples = [];
+    let producerActiveThroughout = true;
+    while (performance.now() - started < seconds * 1000) {
+        if (active && !await active())
+            producerActiveThroughout = false;
+        const value = await resources(pid);
+        samples.push({ atMs: performance.now() - started, ...value });
+        await pause(100);
+    }
+    const after = await resources(pid);
+    const elapsedMs = performance.now() - started;
+    const layoutState = await session.layout();
+    const visiblePanes = nativeVisiblePanes(layoutState);
+    const expectedVisibleCount = condition.startsWith('four_') ? 4 : 1;
+    const layoutQualified = visiblePanes !== null && visiblePanes.length === expectedVisibleCount;
+    return { name: 'native_resources', condition, status: producerActiveThroughout && layoutQualified ? 'measured' : 'unqualified', producerActiveThroughout, metrics: await session.metrics(), layout: layoutState, visiblePanes, expectedVisibleCount, layoutQualified, pid, before, after, elapsedMs, samples,
+        cpuPercentOneCore: (after.cpuSeconds - before.cpuSeconds) / (elapsedMs / 1000) * 100,
+        maximumRssMiB: Math.max(...samples.map(sample => Number(sample.rssBytes))) / 1048576, samplingIntervalMs: 100,
+        limit: 'Native PID only; sampled RSS peak lower bound; CPU excludes owned children/Node/GPU/energy' };
+}
+async function fileAbsent(path) {
+    try {
+        await access(path);
+        return false;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return true;
+        throw error;
+    }
+}
+async function hostInventory() {
+    const query = async (command, args) => {
+        try {
+            return (await execFile(command, args)).stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    };
+    return { platform: process.platform, architecture: process.arch, node: process.version,
+        model: await query('/usr/sbin/sysctl', ['-n', 'hw.model']), cpu: await query('/usr/sbin/sysctl', ['-n', 'machdep.cpu.brand_string']),
+        memoryBytes: os.totalmem(), cores: os.cpus().length, osVersion: await query('/usr/bin/sw_vers', ['-productVersion']),
+        osBuild: await query('/usr/bin/sw_vers', ['-buildVersion']), power: await query('/usr/bin/pmset', ['-g', 'batt']),
+        displayRefreshHz: null, displayPixels: null, thermalState: null,
+        exclusions: ['No device serial/UUID collected', 'Display refresh and occlusion are not inferred from grid or CPU samples'] };
+}
+/** Evaluate portable observed-data records; this verdict does not qualify the host/GUI fixture. */
+export function evaluateNativeBudget(id, attempts, budget, smoke, cleanup) {
+    const unavailable = (reason) => ({ id, status: 'unqualified', reason });
+    if (smoke)
+        return unavailable('Smoke validates the harness, not the predeclared baseline counts');
+    const validNumber = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
+    const expectedCleanupNames = [...Array.from({ length: 12 }, (_, index) => 'startup-' + index), 'main', 'actual-agent'];
+    const normalCleanup = expectedCleanupNames.every(name => cleanup.some(row => row.name === name)) && cleanup.length === 14 && new Set(cleanup.map(row => row.name)).size === 14 && cleanup.every(row => row.code === 0 && row.signal === null && row.fallback === false && row.socketAbsent === true && validNumber(row.durationMs)
+        && Array.isArray(row.pids) && row.pids.length > 0 && row.pids.every((pid) => Number.isSafeInteger(pid.pid) && Number(pid.pid) > 0 && pid.absent === true)
+        && (row.name !== 'actual-agent' || (row.rendererExit !== null && typeof row.rendererExit === 'object'
+            && row.rendererExit.code === 0 && row.rendererExit.signal === null && row.nativeSocketAbsent === true)));
+    if (!normalCleanup)
+        return unavailable('Mandatory normal process/socket cleanup is missing, unknown or unsuccessful');
+    const limits = budget.limits;
+    let relevant = attempts.filter(attempt => attempt.name === id);
+    let values = [];
+    const conditions = [];
+    const witnesses = ['echo_exact_bytes', 'paced_output_correctness', 'concurrent_bulk_correctness', 'actual_agent_correctness'];
+    const completeWitnesses = () => witnesses.every(name => attempts.filter(row => row.name === name && row.status === 'measured').length === 1);
+    if (id === 'normal_shutdown')
+        values = cleanup.map(row => Number(row.durationMs));
+    else if (id === 'native_rss_after_close') {
+        const row = relevant[0];
+        const reference = attempts.find(attempt => attempt.name === 'native_resources' && attempt.condition === 'one_usable_pane_plus_protocol_owner' && attempt.status === 'measured');
+        if (relevant.length !== 1 || !reference || !row || row.status !== 'measured' || row.cycles !== 5
+            || row.beforeCondition !== 'one_usable_pane_plus_protocol_owner' || !validNumber(row.baselineSettledMs) || row.baselineSettledMs < 2000
+            || !Array.isArray(row.samples) || row.samples.length !== 5)
+            return unavailable('First settled one-pane RSS reference or five close-cycle observations missing');
+        const referenceBytes = reference.after?.rssBytes;
+        const capturedBytes = row.before?.rssBytes;
+        if (!validNumber(referenceBytes) || !validNumber(capturedBytes) || capturedBytes !== referenceBytes
+            || row.samples.some((sample) => !validNumber(sample.rssBytes)))
+            return unavailable('RSS reference or samples malformed');
+        const growth = row.samples.map((sample) => (Number(sample.rssBytes) - capturedBytes) / 1048576);
+        const maximumGrowthMiB = Math.max(...growth);
+        return { id, status: maximumGrowthMiB > limits.max_growth ? 'failed' : 'passed', growthMiB: growth, maximumGrowthMiB, limits };
+    }
+    else if (id.startsWith('native_rss_') || id === 'native_idle_cpu') {
+        const required = id === 'native_rss_four_panes' ? ['four_panes_including_owner0', 'four_panes_output']
+            : id === 'native_idle_cpu' ? ['one_usable_pane_plus_protocol_owner', 'four_panes_including_owner0'] : ['one_usable_pane_plus_protocol_owner'];
+        relevant = required.flatMap(condition => attempts.filter(row => row.name === 'native_resources' && row.condition === condition));
+        if (relevant.length !== required.length || required.some(condition => relevant.filter(row => row.condition === condition).length !== 1)
+            || relevant.some(row => row.status !== 'measured' || !validNumber(row.elapsedMs) || row.elapsedMs < 10000))
+            return unavailable('Required complete idle/output resource intervals missing');
+        if (id === 'native_rss_four_panes' && (relevant.find(row => row.condition === 'four_panes_output').producerActiveThroughout !== true
+            || !attempts.some(row => row.name === 'four_pane_output_correctness' && row.status === 'measured')))
+            return unavailable('Four-pane output producer evidence missing');
+        values = relevant.map(row => Number(row[id === 'native_idle_cpu' ? 'cpuPercentOneCore' : 'maximumRssMiB']));
+    }
+    else {
+        if (!relevant.length || relevant.some(row => row.status !== 'measured'))
+            return unavailable('Metric attempts missing or not measured');
+        if (typeof budget.sampleCount === 'number') {
+            const warmupName = id === 'warm_shell_ready' ? 'shell_warmup' : 'startup_warmup';
+            const warmups = attempts.filter(row => row.name === warmupName);
+            const expectedIndexes = Array.from({ length: Number(budget.sampleCount) }, (_, index) => index + Number(budget.warmupLaunches));
+            const measuredIndexes = relevant.map(row => row.index);
+            if (expectedIndexes.some(index => measuredIndexes.filter(value => value === index).length !== 1)
+                || [0, 1].some(index => warmups.filter(row => row.index === index).length !== 1)
+                || relevant.length !== budget.sampleCount || warmups.length !== budget.warmupLaunches
+                || warmups.some(row => row.status !== 'measured' || !validNumber(row.durationMs))
+                || relevant.some(row => !validNumber(row.durationMs)))
+                return unavailable('Declared measured startup/warmup counts or values missing');
+            values = relevant.map(row => Number(row.durationMs));
+        }
+        else if (Array.isArray(budget.conditions)) {
+            const expectedCount = Number(budget.sampleCountPerCondition ?? budget.minimumDistinctSamplesPerCondition);
+            if (!completeWitnesses())
+                return unavailable('Exact-byte producer correctness witnesses missing or failed');
+            for (const condition of budget.conditions) {
+                const rows = relevant.filter(row => row.condition === condition);
+                const row = rows[0];
+                if (rows.length !== 1 || !Array.isArray(row.samplesMs) || row.samplesMs.length !== expectedCount
+                    || row.samplesMs.some(value => !validNumber(value)) || row.producerActiveThroughout !== true)
+                    return unavailable('Declared condition count/active producer/sample values missing');
+                if (id === 'native_frame_cpu') {
+                    const initial = row.initial;
+                    const warm = row.afterWarmup;
+                    const end = row.final;
+                    const validCounter = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+                    if (!initial || !warm || !end || !validCounter(row.warmupFrames)
+                        || [initial, warm, end].some(snapshot => !validCounter(snapshot.frame_count) || !validCounter(snapshot.frame_cpu_sample_count))
+                        || !validCounter(row.cacheSequenceFirst) || !validCounter(row.cacheSequenceLast)
+                        || Number(row.warmupFrames) < Number(budget.warmupFramesPerCondition)
+                        || Number(warm.frame_count) - Number(initial.frame_count) < Number(budget.warmupFramesPerCondition)
+                        || Number(end.frame_cpu_sample_count) - Number(warm.frame_cpu_sample_count) < expectedCount
+                        || Number(row.cacheSequenceLast) - Number(row.cacheSequenceFirst) + 1 !== expectedCount
+                        || row.cacheSequenceLast !== end.frame_cpu_sample_count)
+                        return unavailable('Full warmup or distinct frame observation span missing');
+                }
+                const samples = row.samplesMs;
+                values.push(...samples);
+                conditions.push({ condition, summary: summarizeNativeSamples(samples) });
+            }
+        }
+        else if (Array.isArray(budget.payloadClasses)) {
+            const layouts = budget.layouts;
+            if (['ascii', 'ansi', 'unicode'].some(kind => layouts.some(layout => relevant.filter(row => row.kind === kind && row.layout === layout).length !== 5))
+                || relevant.some(row => !validNumber(row.durationMs) || row.layoutQualification !== true))
+                return unavailable('Full output payload/layout matrix missing or not observed');
+            values = relevant.map(row => Number(row.durationMs));
+        }
+        else if (Array.isArray(budget.bracketedPasteModes)) {
+            return unavailable('Per-mode/per-repetition200 concurrent sentinel matrix not measured by this runner');
+        }
+    }
+    if (!values.length || values.some(value => !validNumber(value)))
+        return unavailable('Finite metric values missing');
+    const summary = summarizeNativeSamples(values);
+    const summaries = conditions.length ? conditions.map(row => row.summary) : [summary];
+    const breached = summaries.some(row => (limits.max !== undefined && Number(row.max) > limits.max)
+        || (limits.p95 !== undefined && Number(row.p95) > limits.p95)
+        || (limits.mean !== undefined && Number(row.max) > limits.mean));
+    return { id, status: breached ? 'failed' : 'passed', summary, limits, ...(conditions.length ? { conditions } : {}) };
+}
+/** Actual native process/Unix IPC measurements. All attempts and policy gaps are retained. */
+export async function runNativeTerminalBenchmark(options) {
+    if (!options.binary.trim() || !options.outputDirectory.trim() || !options.budgetsPath.trim()) {
+        throw new NativeTerminalBenchmarkError('INVALID_OPTIONS', 'binary, output directory and budgets path must be nonempty');
+    }
+    validateInitialGeometry(options.initialGeometry);
+    const outputDirectory = resolve(options.outputDirectory);
+    const binary = resolve(options.binary);
+    const budgetBytes = await readFile(options.budgetsPath);
+    const budgets = JSON.parse(budgetBytes.toString());
+    if (budgets.schemaVersion !== 1 || !Array.isArray(budgets.budgets))
+        throw new NativeTerminalBenchmarkError('INVALID_OPTIONS', 'budgets must contain schemaVersion 1 and predeclared budgets');
+    const smoke = options.profile === 'smoke';
+    const python = options.python ?? '/opt/homebrew/bin/python3';
+    await mkdir(outputDirectory, { recursive: true });
+    const attempts = [];
+    const cleanup = [];
+    const sourceFiles = ['src/diagnostics/native_terminal_benchmark.ts', 'scripts/benchmark-zterm.ts', 'src/cli_ratatui.ts',
+        'src/ui/ratatui/process.ts', 'src/ui/ratatui/protocol.ts', 'packages/ztc-core/src/protocol.rs', 'packages/zterm/src/main.rs', 'packages/zterm/src/launch_geometry.rs', 'packages/zterm/Cargo.lock'];
+    const sourceHashes = {};
+    for (const path of sourceFiles)
+        sourceHashes[path] = sha256(await readFile(resolve(path)));
+    const payloadManifest = [];
+    for (const size of [1048576, 4194304])
+        for (const kind of ['ascii', 'ansi', 'unicode']) {
+            const data = payloadBytes(size, kind);
+            const path = join(outputDirectory, `output-${size}-${kind}.bin`);
+            await writeFile(path, data);
+            payloadManifest.push({ path, size, kind, sha256: sha256(data) });
+        }
+    for (const size of [65536, 1048576]) {
+        const data = bulkBytes(size);
+        const path = join(outputDirectory, `input-${size}.bin`);
+        await writeFile(path, data);
+        payloadManifest.push({ path, size, kind: 'input_unicode', sha256: sha256(data) });
+    }
+    const manifest = { budgetSha256: sha256(budgetBytes), binary, binarySha256: sha256(await readFile(binary)), sourceHashes,
+        initialGeometry: options.initialGeometry ?? null,
+        buildProfile: options.buildProfile ?? 'unknown', compilerCommand: options.compilerCommand ?? null,
+        profile: smoke ? 'smoke' : 'baseline', startupWarmups: smoke ? 0 : 2, startupSamples: smoke ? 1 : 10, echoCount: smoke ? 5 : 200,
+        echoCadenceMs: 40, outputRepeatsPerClassLayout: smoke ? 1 : 5, bulkRepeatsPerMode: smoke ? 1 : 5,
+        payloadManifest, outputLoad: { bytes: 4194304, chunkBytes: 16384, intervalMs: 62.5, nominalDurationSeconds: 16 },
+        concurrentBulk: { bytes: 1048576, payloadByte: 120, sha256: sha256(Buffer.alloc(1048576, 0x78)), chunkBytes: 2048, intervalAfterAckMs: 32 },
+        agentLoad: { actualApp: 'RatatuiApp', providerBoundary: 'owned loopback HTTP SSE', chunkText: 'OWNED145 STREAM café 中文\n', intervalMs: 40, maxChunks: 2000 },
+        peerMarkers: { byteLength: 7, identity: 'first6 lowercase SHA256 hex of UTF8 basename', stages: { ready: 'R', output: 'O', bulk: 'B' },
+            producer: 'Python reads the same owned name.markers.json emitted by nativeBenchmarkPeerMarkers', collisionPolicy: 'Reject different-name marker collisions within an owned native session' },
+        measurementVocabulary: 'The logical send_pane_input budget boundary uses existing wire write_pane{submit:false,control:false}',
+        emittedAt: new Date().toISOString() };
+    // Freeze policy, byte payloads and cadence BEFORE the first measured process launch.
+    await writeFile(join(outputDirectory, 'workload-manifest.json'), JSON.stringify(manifest, null, 2));
+    await writeFile(join(outputDirectory, 'budgets.json'), budgetBytes);
+    const report = { schemaVersion: 1, status: 'measured', outputDirectory, manifest,
+        budgets, host: await hostInventory(), attempts, cleanup, startedAt: new Date().toISOString(),
+        limits: ['Managed IPC is not physical keyboard/clipboard/input-to-photon', 'Previous-frame CPU is not GPU/display time',
+            options.initialGeometry ? 'Explicit pre-launch content geometry requested; per-launch native metrics retained; physical measurement contract remains unqualified' : 'Native default requested content size1120x760; policy1280x800 fixed geometry remains unqualified',
+            'Focus is observed; occlusion/display-refresh/thermal state unknown', 'No signed installed app/other OS/comparator or accessibility qualification'] };
+    let ordinal = 0;
+    const start = async (name, agent = false) => {
+        // Short Unix path remains below macOS sockaddr_un capacity independently of the artifact directory.
+        const root = join('/tmp', 'ztc145-' + process.pid + '-' + ++ordinal);
+        await prepareRoot(root);
+        await writeFile(join(root, 'peer.py'), PEER);
+        const session = new NativeSession(root, binary, agent, options.initialGeometry);
+        try {
+            await session.connect();
+            const observed = await session.metrics();
+            const requested = options.initialGeometry ?? null;
+            const matches = requested !== null && Math.abs(observed.window_width_points - requested.width) < 0.01
+                && Math.abs(observed.window_height_points - requested.height) < 0.01 && observed.focused;
+            const geometry = { name: 'launch_geometry', condition: name, status: matches ? 'measured' : 'unqualified', requested, observed,
+                nativePid: session.nativePid, setup: 'native viewport before first frame', boundary: 'First usable native IPC metrics; not GPU presentation or physical measurement' };
+            await writeFile(join(root, 'launch-geometry.json'), JSON.stringify(geometry, null, 2));
+            attempts.push(geometry);
+            return session;
+        }
+        catch (error) {
+            attempts.push({ name: 'launch_geometry', condition: name, status: 'unqualified', requested: options.initialGeometry ?? null, observed: null, reason: String(error) });
+            const receipt = await session.stop();
+            cleanup.push({ name, ...receipt });
+            await copyArtifacts(root, join(outputDirectory, name));
+            await rm(root, { recursive: true, force: true });
+            throw error;
+        }
+    };
+    const finish = async (session, name) => {
+        if (session.frameReadinessObservations.length)
+            attempts.push({ name: 'native_frame_readiness', condition: name, status: 'unqualified',
+                observations: session.frameReadinessObservations, reason: 'Pre-first-frame zero counters/grid are startup diagnostics only; never timing/frame quality samples' });
+        const receipt = await session.stop();
+        cleanup.push({ name, root: session.root, ...receipt });
+        await copyArtifacts(session.root, join(outputDirectory, name));
+        await rm(session.root, { recursive: true, force: true });
+        cleanup.at(-1).rootRemoved = await fileAbsent(session.root);
+        if (receipt.code !== 0 || receipt.fallback || receipt.pids.some(value => !value.absent))
+            report.status = 'failed';
+    };
+    try {
+        for (let index = 0; index < (smoke ? 1 : 12); index++) {
+            const name = 'startup-' + index;
+            const session = await start(name);
+            try {
+                const pane = await session.createPeer(python, 'echo', 'startup-echo');
+                const elapsed = performance.now() - session.started;
+                const warmup = !smoke && index < 2;
+                attempts.push({ name: warmup ? 'startup_warmup' : 'warm_socket_startup', status: 'measured', durationMs: session.socketReadyMs, index, ready: session.ready });
+                attempts.push({ name: warmup ? 'shell_warmup' : 'warm_shell_ready', status: 'measured', durationMs: elapsed, index, pane,
+                    boundary: 'Spawn to raw-child READY readback; includes child creation and IPC polling, not shell prompt/physicalpaint' });
+                const metrics = await session.metrics();
+                attempts.push({ name: 'first_native_metrics_observation', status: 'measured', index, metrics,
+                    observedAfterSpawnMs: performance.now() - session.started, boundary: 'Observed final App update counter, not first GPU presentation' });
+                await session.write(pane, 'QUIT\n');
+                await readJson(join(session.root, 'startup-echo.done.json'));
+            }
+            finally {
+                await finish(session, name);
+            }
+        }
+        const session = await start('main');
+        try {
+            attempts.push(await awaitGeometry(session, options.awaitGeometry, outputDirectory, 'main'));
+            const echo = await session.createPeer(python, 'echo', 'echo');
+            session.ipc.send({ type: 'toggle_zoom', pane_id: echo });
+            attempts.push(...await Promise.all([echoSamples(session, echo, 'idle', smoke ? 5 : 200), frameSamples(session, 'idle_one_pane', undefined, smoke)]));
+            const firstSettledResources = await resourceWindow(session, smoke ? 0.5 : 10, 'one_usable_pane_plus_protocol_owner');
+            attempts.push(firstSettledResources);
+            const producer = await session.createPeer(python, 'output', 'paced-output', [join(outputDirectory, 'output-4194304-ascii.bin'), '0.0625', '16384']);
+            await session.write(producer, 'GO\n');
+            await readJson(join(session.root, 'paced-output.active.json'));
+            const outputActive = () => fileAbsent(join(session.root, 'paced-output.done.json'));
+            attempts.push(...await Promise.all([echoSamples(session, echo, 'bounded_other_pane_PTY_output', smoke ? 5 : 200, outputActive),
+                frameSamples(session, 'bounded_other_pane_PTY_output', outputActive, smoke)]));
+            await session.waitText(producer, nativeBenchmarkPeerMarkers('paced-output').output, 25_000);
+            await session.write(producer, 'QUIT\n');
+            const producerRecord = await readJson(join(session.root, 'paced-output.done.json'));
+            attempts.push({ name: 'paced_output_correctness', status: producerRecord.sha256 === sha256(payloadBytes(4194304, 'ascii')) && producerRecord.bytes === 4194304 ? 'measured' : 'failed', record: producerRecord });
+            session.ipc.send({ type: 'close_pane', pane_id: producer });
+            // Output matrix is bounded and predeclared; inactive tab is a real new window then focus returns to the raw foreground.
+            for (const size of (smoke ? [1048576] : [1048576, 4194304]))
+                for (const kind of (smoke ? ['ascii'] : ['ascii', 'ansi', 'unicode'])) {
+                    for (const layout of (smoke ? ['one_pane'] : ['one_pane', 'two_split_panes', 'inactive_tab']))
+                        for (let repeat = 0; repeat < (smoke ? 1 : 5); repeat++) {
+                            const key = `ingest-${size}-${kind}-${layout}-${repeat}`;
+                            const pane = await session.createPeer(python, 'output', key, [join(outputDirectory, `output-${size}-${kind}.bin`), '0', '16384'], layout === 'inactive_tab');
+                            if (layout === 'inactive_tab')
+                                session.ipc.send({ type: 'focus_pane', pane_id: echo });
+                            if (layout === 'one_pane')
+                                session.ipc.send({ type: 'toggle_zoom', pane_id: pane });
+                            const layoutState = await session.layout();
+                            const layoutQualification = qualifyNativeOutputLayout(layoutState, pane, layout);
+                            const started = performance.now();
+                            await session.write(pane, 'GO\n');
+                            await session.waitText(pane, nativeBenchmarkPeerMarkers(key).output);
+                            const durationMs = performance.now() - started;
+                            const record = await readJson(join(session.root, key + '.done.json'));
+                            attempts.push({ name: size === 1048576 ? 'output_ingest_1mib' : 'output_ingest_4mib', kind, layout, repeat, durationMs,
+                                status: record.bytes !== size || record.sha256 !== sha256(payloadBytes(size, kind)) ? 'failed' : layoutQualification ? 'measured' : 'unqualified', record, layoutState, layoutQualification,
+                                boundary: 'Parent GO write to native last-marker readback upper bound; includes child command scheduling; exact child output count/hash, not clipped history' });
+                            await session.write(pane, 'QUIT\n');
+                            session.ipc.send({ type: 'close_pane', pane_id: pane });
+                        }
+                }
+            for (const size of (smoke ? [65536] : [65536, 1048576]))
+                for (const bracketed of [false, true])
+                    for (let repeat = 0; repeat < (smoke ? 1 : 5); repeat++) {
+                        const key = `bulk-${size}-${bracketed}-${repeat}`;
+                        const pane = await session.createPeer(python, 'bulk', key, [String(size), String(bracketed)]);
+                        const data = bulkBytes(size);
+                        const started = performance.now();
+                        await session.write(pane, data.toString());
+                        const record = await readJson(join(session.root, key + '.done.json'));
+                        const durationMs = performance.now() - started;
+                        attempts.push({ name: size === 65536 ? 'bulk_raw_input_64kib' : 'bulk_raw_input_1mib', durationMs, bracketed, repeat,
+                            status: record.bytes === size && record.sha256 === sha256(data) ? 'measured' : 'failed', record,
+                            boundary: 'Public literal write_pane to child exact-byte completion; bracketed mode toggled, no OS clipboard' });
+                        await session.write(pane, 'QUIT\n');
+                        session.ipc.send({ type: 'close_pane', pane_id: pane });
+                    }
+            // Sustained bulk-input interval uses paced chunks so load stays active during all echo/frame samples.
+            const bulkSize = 1048576;
+            const bulkPane = await session.createPeer(python, 'bulk', 'paced-bulk', [String(bulkSize), 'false']);
+            const data = Buffer.alloc(bulkSize, 0x78);
+            let bulkActive = true;
+            const bulkStarted = performance.now();
+            const feeding = (async () => {
+                for (let offset = 0; offset < data.length; offset += 2048) {
+                    await session.write(bulkPane, data.subarray(offset, offset + 2048).toString());
+                    await pause(32);
+                }
+                bulkActive = false;
+            })();
+            // Chunk boundaries use ASCII for this concurrent load to avoid splitting a UTF8 codepoint across JS strings.
+            // The isolated bulk matrix above independently verifies exact UTF8 payloads.
+            attempts.push(...await Promise.all([echoSamples(session, echo, 'concurrent_bulk_input', smoke ? 5 : 200, async () => bulkActive && await fileAbsent(join(session.root, 'paced-bulk.done.json'))),
+                frameSamples(session, 'concurrent_bulk_input', async () => bulkActive && await fileAbsent(join(session.root, 'paced-bulk.done.json')), smoke)]));
+            await feeding;
+            const bulkRecord = await readJson(join(session.root, 'paced-bulk.done.json'));
+            attempts.push({ name: 'concurrent_bulk_correctness', status: bulkRecord.sha256 === sha256(data) ? 'measured' : 'failed', record: bulkRecord, producerStartedMs: bulkStarted });
+            await session.write(bulkPane, 'QUIT\n');
+            session.ipc.send({ type: 'close_pane', pane_id: bulkPane });
+            const extras = [await session.createPeer(python, 'echo', 'four-a'), await session.createPeer(python, 'echo', 'four-b')];
+            attempts.push(await frameSamples(session, 'four_panes', undefined, smoke));
+            attempts.push(await resourceWindow(session, smoke ? 0.5 : 10, 'four_panes_including_owner0'));
+            await session.write(extras[0], 'QUIT\n');
+            session.ipc.send({ type: 'close_pane', pane_id: extras[0] });
+            const fourOutput = await session.createPeer(python, 'output', 'four-output', [join(outputDirectory, 'output-4194304-ascii.bin'), '0.0625', '16384']);
+            await session.write(fourOutput, 'GO\n');
+            await readJson(join(session.root, 'four-output.active.json'));
+            attempts.push(await resourceWindow(session, smoke ? 0.5 : 10, 'four_panes_output', () => fileAbsent(join(session.root, 'four-output.done.json'))));
+            await session.waitText(fourOutput, nativeBenchmarkPeerMarkers('four-output').output, 25_000);
+            await session.write(fourOutput, 'QUIT\n');
+            session.ipc.send({ type: 'close_pane', pane_id: fourOutput });
+            const fourOutputRecord = await readJson(join(session.root, 'four-output.done.json'));
+            attempts.push({ name: 'four_pane_output_correctness', status: fourOutputRecord.bytes === 4194304 && fourOutputRecord.sha256 === sha256(payloadBytes(4194304, 'ascii')) ? 'measured' : 'failed', record: fourOutputRecord });
+            for (const pane of extras.slice(1)) {
+                await session.write(pane, 'QUIT\n');
+                session.ipc.send({ type: 'close_pane', pane_id: pane });
+            }
+            const beforeClose = firstSettledResources.after;
+            const cycleSamples = [];
+            for (let cycle = 0; cycle < (smoke ? 1 : 5); cycle++) {
+                const pane = await session.createPeer(python, 'output', 'cycle-' + cycle, [join(outputDirectory, 'output-1048576-ascii.bin'), '0', '16384']);
+                await session.write(pane, 'GO\n');
+                await session.waitText(pane, nativeBenchmarkPeerMarkers('cycle-' + cycle).output);
+                await session.write(pane, 'QUIT\n');
+                session.ipc.send({ type: 'close_pane', pane_id: pane });
+                await pause(smoke ? 100 : 2000);
+                cycleSamples.push({ cycle, ...await resources(session.nativePid) });
+            }
+            attempts.push({ name: 'native_rss_after_close', status: 'measured', before: beforeClose, samples: cycleSamples,
+                growthMiB: Math.max(...cycleSamples.map(sample => Number(sample.rssBytes) - beforeClose.rssBytes)) / 1048576, cycles: cycleSamples.length,
+                beforeCondition: firstSettledResources.condition, baselineSettledMs: firstSettledResources.elapsedMs,
+                baselineProvenance: { condition: firstSettledResources.condition, elapsedMs: firstSettledResources.elapsedMs, snapshot: firstSettledResources.after, layout: firstSettledResources.layout }, settleSeconds: smoke ? 0.1 : 2 });
+            await session.write(echo, 'QUIT\n');
+            const echoed = await readJson(join(session.root, 'echo.done.json'));
+            const expected = attempts.filter(attempt => attempt.name === 'managed_raw_input_echo').flatMap(attempt => attempt.payloads.map(text => Buffer.from(text).toString('hex')));
+            attempts.push({ name: 'echo_exact_bytes', status: JSON.stringify(echoed.received) === JSON.stringify(expected) ? 'measured' : 'failed', expected, record: echoed });
+        }
+        catch (error) {
+            attempts.push({ name: 'main_workload_failure', status: 'failed', error: String(error) });
+            report.status = 'failed';
+        }
+        finally {
+            await finish(session, 'main');
+        }
+        const agentSession = await start('actual-agent', true);
+        try {
+            attempts.push(await awaitGeometry(agentSession, options.awaitGeometry, outputDirectory, 'actual-agent'));
+            const pane = await agentSession.createPeer(python, 'echo', 'agent-echo');
+            const active = async () => { const status = await readJson(join(agentSession.root, 'agent-status.json')); return status.active === true && status.requests === 1 && Array.isArray(status.errors) && status.errors.length === 0; };
+            const agentProducerBefore = await readJson(join(agentSession.root, 'agent-status.json'));
+            attempts.push(...await Promise.all([echoSamples(agentSession, pane, 'actual_owned_agent_stream', smoke ? 5 : 200, active),
+                frameSamples(agentSession, 'actual_owned_agent_stream', active, smoke)]));
+            const agentProducerAfter = await readJson(join(agentSession.root, 'agent-status.json'));
+            attempts.push({ name: 'actual_agent_stream_progress', status: Number(agentProducerAfter.chunks) > Number(agentProducerBefore.chunks) && await active() ? 'measured' : 'unqualified', before: agentProducerBefore, after: agentProducerAfter });
+            attempts.push(...await actualShellEditorContinuation(agentSession, active));
+            await agentSession.write(pane, 'QUIT\n');
+            const echoed = await readJson(join(agentSession.root, 'agent-echo.done.json'));
+            attempts.push({ name: 'actual_agent_correctness', status: await active() && JSON.stringify(echoed.received) === JSON.stringify(attempts.find(attempt => attempt.name === 'managed_raw_input_echo' && attempt.condition === 'actual_owned_agent_stream').payloads.map(text => Buffer.from(text).toString('hex'))) ? 'measured' : 'failed', record: echoed,
+                provider: await readJson(join(agentSession.root, 'agent-status.json')) });
+        }
+        catch (error) {
+            attempts.push({ name: 'actual_agent_failure', status: 'failed', error: String(error) });
+            report.status = 'failed';
+        }
+        finally {
+            await finish(agentSession, 'actual-agent');
+        }
+    }
+    catch (error) {
+        report.status = 'failed';
+        report.failure = String(error);
+        await writeFile(join(outputDirectory, 'results.json'), JSON.stringify(report, null, 2));
+        throw error;
+    }
+    const afterHashes = {};
+    for (const path of sourceFiles)
+        afterHashes[path] = sha256(await readFile(resolve(path)));
+    report.binarySha256After = sha256(await readFile(binary));
+    report.binaryUnchanged = report.binarySha256After === manifest.binarySha256;
+    report.sourceHashesAfter = afterHashes;
+    report.sourcesUnchanged = JSON.stringify(sourceHashes) === JSON.stringify(afterHashes);
+    report.gates = budgets.budgets.map(budget => evaluateNativeBudget(String(budget.id), attempts, budget, smoke, cleanup));
+    report.releaseGate = 'unqualified';
+    report.unqualifiedMandatoryConditions = [options.initialGeometry ? 'Requested pre-launch geometry is recorded separately; frozen physical/native quality contract remains unqualified' : 'Fixed1280x800 policy geometry not controlled by this public runner',
+        'Independent physical keyboard/resize/scroll/clipboard/accessibility/comparator gates',
+        'One-pane native layout is unqualified when public snapshot still contains owner0 plus raw child; zoom intents are not assumed effective',
+        'Bulk matrix lacks200 concurrent sentinel samples for every repetition/mode; dedicated sustained bulk condition recorded',
+        'Window content points/scale/focus from passive metrics do not establish occlusion/display pixels',
+        'Native PID resource measurements do not qualify Node/owned-child CPU/RSS or total-memory budgets'];
+    if (attempts.some(attempt => attempt.status === 'failed') || !report.sourcesUnchanged || !report.binaryUnchanged)
+        report.status = 'failed';
+    report.finishedAt = new Date().toISOString();
+    await writeFile(join(outputDirectory, 'results.json'), JSON.stringify(report, null, 2));
+    return report;
+}
+async function copyArtifacts(root, destination) {
+    const { cp: copy, readdir } = await import('node:fs/promises');
+    await mkdir(destination, { recursive: true });
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        if (entry.isFile() && !entry.name.endsWith('.sock'))
+            await copy(join(root, entry.name), join(destination, entry.name));
+    }
+}
+/** Child-only actual App/Agent/native bridge; process environment is isolated before imports. */
+export async function runOwnedNativeAgentRuntime(root, binary, geometry) {
+    validateInitialGeometry(geometry);
+    const repository = process.cwd();
+    const rendererBinary = resolve(binary);
+    const sockets = new Set();
+    let activeResponse;
+    let requests = 0;
+    let chunks = 0;
+    let bytes = 0;
+    let active = false;
+    let interval;
+    const errors = [];
+    let rendererPid;
+    let rendererExit;
+    let rendererSocketPath;
+    let statusWriting = Promise.resolve();
+    const status = () => {
+        const payload = JSON.stringify({ requests, chunks, bytes, active, errors, nativePid: rendererPid,
+            monotonicAtMs: performance.now(), cadenceMs: 40, chunkText: 'OWNED145 STREAM café 中文\n' });
+        statusWriting = statusWriting.then(async () => {
+            await writeFile(join(root, 'agent-status.json.tmp'), payload);
+            const { rename } = await import('node:fs/promises');
+            await rename(join(root, 'agent-status.json.tmp'), join(root, 'agent-status.json'));
+        }).catch(error => { errors.push(String(error)); });
+    };
+    const provider = createHttpServer(async (request, response) => {
+        if (request.method === 'GET' && request.url === '/v1/models') {
+            response.setHeader('content-type', 'application/json');
+            response.end(JSON.stringify({ data: [{ id: 'owned145' }] }));
+            return;
+        }
+        if (request.method !== 'POST' || request.url !== '/v1/chat/completions') {
+            errors.push('Unexpected provider route');
+            response.writeHead(500);
+            response.end();
+            return;
+        }
+        let body = '';
+        for await (const chunk of request)
+            body += String(chunk);
+        const parsed = JSON.parse(body);
+        requests++;
+        await writeFile(join(root, 'agent-request-' + requests + '.json'), body);
+        if (requests !== 1 || parsed.model !== 'owned145' || !parsed.messages.some(message => message.role === 'user'
+            && typeof message.content === 'string' && message.content.startsWith('OWNED145_AGENT_TASK')))
+            errors.push('Unexpected actual App provider task');
+        activeResponse = response;
+        active = true;
+        response.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+        response.flushHeaders();
+        const emit = () => {
+            if (!active || response.destroyed || response.writableEnded)
+                return;
+            const content = 'OWNED145 STREAM café 中文\n';
+            response.write('data: ' + JSON.stringify({ choices: [{ index: 0, delta: { content }, finish_reason: null }] }) + '\n\n');
+            chunks++;
+            bytes += Buffer.byteLength(content);
+            status();
+            if (chunks >= 2000) {
+                active = false;
+                clearInterval(interval);
+                response.end('data: [DONE]\n\n');
+                status();
+            }
+        };
+        emit();
+        interval = setInterval(emit, 40);
+        response.once('close', () => { active = false; clearInterval(interval); status(); });
+    });
+    provider.on('connection', socket => { sockets.add(socket); socket.once('close', () => sockets.delete(socket)); });
+    await new Promise((resolveListen, reject) => { provider.once('error', reject); provider.listen(0, '127.0.0.1', resolveListen); });
+    const address = provider.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Owned provider did not listen');
+    await writeFile(join(root, 'config', 'config.json'), JSON.stringify({ provider: 'openai_compatible', model: 'owned145', authMode: 'direct',
+        apiKeys: { openai_compatible: 'OWNED_LOCAL_145' }, openaiCompatible: { baseUrl: `http://127.0.0.1:${address.port}/v1` },
+        permissionProfile: 'trusted', skills: { enabled: false }, workflows: { enabled: false }, sfx: { enabled: false },
+        recapsEnabled: false, autoContinue: false, messageDisplay: { smoothStreaming: false } }));
+    const originalSpawn = cp.spawn;
+    // The host supplies the owned executable directly; the process boundary adds benchmark options.
+    cp.spawn = ((...args) => {
+        if (String(args[0]) === rendererBinary) {
+            if (Array.isArray(args[1]))
+                args[1] = [...args[1], '--settings', join(root, 'settings.json'), '--session', join(root, 'native-session.json'), ...initialGeometryArgs(geometry)];
+            if (Array.isArray(args[1])) {
+                const socketOption = args[1].indexOf('--socket');
+                if (socketOption >= 0)
+                    rendererSocketPath = args[1][socketOption + 1];
+            }
+            const child = originalSpawn(...args);
+            rendererPid = child.pid;
+            child.once('close', (code, signal) => { rendererExit = { code, signal }; });
+            return child;
+        }
+        return originalSpawn(...args);
+    });
+    syncBuiltinESMExports();
+    const { pathToFileURL } = await import('node:url');
+    const { configStore } = await import(pathToFileURL(join(repository, 'src/config.ts')).href);
+    const { RatatuiApp } = await import(pathToFileURL(join(repository, 'src/cli_ratatui.ts')).href);
+    const { TuiProcess } = await import(pathToFileURL(join(repository, 'src/ui/ratatui/process.ts')).href);
+    await configStore.refresh();
+    process.chdir(join(root, 'project'));
+    const tui = new TuiProcess({ desktopBinaryPath: rendererBinary });
+    let ready;
+    let driver;
+    const pending = [];
+    const publish = (event) => { if (driver && !driver.destroyed)
+        driver.write(JSON.stringify(event) + '\n');
+    else
+        pending.push(event); };
+    tui.on(event => {
+        if (event.type === 'ready')
+            ready = event;
+        if (['ready', 'pane_created', 'pane_read', 'pane_write_result', 'pane_state', 'pane_list', 'session_state', 'terminal_metrics', 'error'].includes(event.type))
+            publish(event);
+    });
+    const app = new RatatuiApp({ sessionId: 'owned-native-performance-145', sessionFile: join(root, 'project', 'agent-session.json'),
+        initialPrompt: 'OWNED145_AGENT_TASK Explain this owned benchmark stream.', desktop: true, mux: true, mirror: false,
+        noBrowserOpen: true, navigatorHidden: true, tuiProcess: tui });
+    let stopping = false;
+    const stop = async () => {
+        if (stopping)
+            return;
+        stopping = true;
+        clearInterval(interval);
+        active = false;
+        if (activeResponse && !activeResponse.destroyed && !activeResponse.writableEnded)
+            activeResponse.end('data: [DONE]\n\n');
+        await app.exit(false, { announce: false, persistSession: true, terminateProcess: false });
+    };
+    const server = net.createServer(socket => {
+        driver = socket;
+        let buffer = '';
+        for (const event of pending.splice(0))
+            publish(event);
+        publish({ type: 'benchmark_agent_ready', native_pid: rendererPid, app_pid: process.pid });
+        socket.setEncoding('utf8');
+        socket.on('error', error => errors.push(String(error)));
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            let newline;
+            while ((newline = buffer.indexOf('\n')) >= 0) {
+                const packet = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                const command = JSON.parse(packet);
+                if (command.type === 'benchmark_stop')
+                    void stop();
+                else if (!tui.send(command))
+                    publish({ type: 'error', request_id: command.request_id, message: 'Actual native transport unavailable' });
+            }
+        });
+    });
+    const running = app.start();
+    let failure;
+    void running.catch(error => { failure = error; });
+    try {
+        const deadline = performance.now() + 20_000;
+        while ((!ready || !active || !rendererPid) && !failure && performance.now() < deadline)
+            await pause(10);
+        if (failure)
+            throw failure;
+        if (!ready || !active || !rendererPid)
+            throw new Error('Actual App/native/provider startup did not complete');
+        await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(join(root, 'driver.sock'), resolveListen); });
+        await running;
+    }
+    finally {
+        await stop();
+        clearInterval(interval);
+        active = false;
+        for (const socket of sockets)
+            socket.destroy();
+        if (provider.listening)
+            await new Promise(resolveClose => provider.close(() => resolveClose()));
+        driver?.destroy();
+        if (server.listening)
+            await new Promise(resolveClose => server.close(() => resolveClose()));
+        await rm(join(root, 'driver.sock'), { force: true });
+        cp.spawn = originalSpawn;
+        syncBuiltinESMExports();
+        await statusWriting;
+        await writeFile(join(root, 'agent-result.json'), JSON.stringify({ requests, chunks, bytes, errors, rendererPid, rendererExit, rendererSocketPath,
+            nativeSocketAbsent: rendererSocketPath !== undefined && await fileAbsent(rendererSocketPath),
+            providerSockets: sockets.size, active: false, cleanupCompleted: true }, null, 2));
+    }
+}
+async function awaitGeometry(session, geometry, output, condition) {
+    const initial = await session.metrics();
+    if (!geometry)
+        return { name: 'window_geometry', condition, status: 'unqualified', initial, reason: 'No controlled geometry request; actual native metrics retained' };
+    if (![geometry.width, geometry.height].every(value => Number.isFinite(value) && value > 0))
+        throw new NativeTerminalBenchmarkError('INVALID_OPTIONS', 'Window geometry must be positive finite content points');
+    const marker = { condition, root: session.root, nativePid: session.nativePid, requested: geometry, initial };
+    await writeFile(join(output, 'awaiting-geometry.json'), JSON.stringify(marker, null, 2));
+    process.stderr.write('BENCHMARK_GEOMETRY_REQUIRED ' + JSON.stringify(marker) + '\n');
+    const deadline = performance.now() + (geometry.timeoutMs ?? 120_000);
+    let observed = initial;
+    while (performance.now() < deadline) {
+        observed = await session.metrics();
+        if (Math.abs(observed.window_width_points - geometry.width) < 0.01 && Math.abs(observed.window_height_points - geometry.height) < 0.01 && observed.focused) {
+            const result = { name: 'window_geometry', condition, status: 'measured', requested: geometry, initial, observed };
+            await writeFile(join(output, 'geometry-' + condition + '.json'), JSON.stringify(result, null, 2));
+            return result;
+        }
+        await pause(100);
+    }
+    return { name: 'window_geometry', condition, status: 'unqualified', requested: geometry, initial, observed, reason: 'Actual requested geometry/focus was not observed before bounded deadline' };
+}
+function nativeLayoutLeaves(node) {
+    if (!node || typeof node !== 'object')
+        return null;
+    const layout = node;
+    if (layout.type === 'leaf')
+        return Number.isSafeInteger(layout.pane_id) && Number(layout.pane_id) >= 0 ? [Number(layout.pane_id)] : null;
+    if (layout.type !== 'split')
+        return null;
+    const first = nativeLayoutLeaves(layout.first);
+    const second = nativeLayoutLeaves(layout.second);
+    if (!first || !second)
+        return null;
+    const combined = [...first, ...second];
+    return new Set(combined).size === combined.length ? combined : null;
+}
+function nativeWindows(state) {
+    return Array.isArray(state.windows) && state.windows.length ? state.windows
+        : [{ id: 0, layout: state.layout, focused_pane_id: state.focused_pane_id }];
+}
+function nativeVisiblePanes(state) {
+    const active = nativeWindows(state).find(window => window.id === (state.active_window_id ?? 0));
+    if (!active)
+        return null;
+    const leaves = nativeLayoutLeaves(active.layout);
+    if (!leaves)
+        return null;
+    if (active.zoomed_pane_id !== undefined && active.zoomed_pane_id !== null) {
+        if (typeof active.zoomed_pane_id !== 'number' || !leaves.includes(active.zoomed_pane_id))
+            return null;
+        return [active.zoomed_pane_id];
+    }
+    return leaves;
+}
+/** Interpret the canonical Mux leaf/split tree observed through get_session_state. */
+export function qualifyNativeOutputLayout(state, pane, requested) {
+    const visible = nativeVisiblePanes(state);
+    if (!visible)
+        return false;
+    if (requested === 'inactive_tab')
+        return !visible.includes(pane) && nativeWindows(state).some(window => window.id !== (state.active_window_id ?? 0) && nativeLayoutLeaves(window.layout)?.includes(pane) === true);
+    if (requested !== 'one_pane' && requested !== 'two_split_panes')
+        return false;
+    return visible.includes(pane) && visible.length === (requested === 'one_pane' ? 1 : 2);
+}
+const shellQuote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
+async function waitExactFile(path, expected) {
+    const deadline = performance.now() + 5000;
+    while (performance.now() < deadline) {
+        try {
+            if (await readFile(path, 'utf8') === expected)
+                return;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await pause(5);
+    }
+    throw new Error('Actual owned shell/editor did not preserve exact requested file bytes: ' + path);
+}
+async function actualShellEditorContinuation(session, active) {
+    const attempts = [];
+    const shell = await session.ipc.request('create_pane', 'pane_created', { command: '/bin/sh', args: ['-i'], cwd: join(session.root, 'project'),
+        title: 'Owned 145 real shell', pane_type: 'process', env: { PS1: 'OWNED145_SH> ', LC_ALL: 'en_US.UTF-8' } });
+    const shellPane = Number(shell.pane_id);
+    await session.waitText(shellPane, 'OWNED145_SH>');
+    const shellFile = join(session.root, 'shell-exact.txt');
+    const shellPid = join(session.root, 'shell-pid.txt');
+    const text = 'SHELL145 café 中文 🦀\n';
+    const before = await active();
+    const started = performance.now();
+    await session.write(shellPane, `printf '%s' ${shellQuote(text)} > ${shellQuote(shellFile)}; printf '%s' "$$" > ${shellQuote(shellPid)}\n`);
+    await waitExactFile(shellFile, text);
+    const pid = Number(await readFile(shellPid, 'utf8'));
+    session.ownedPids.add(pid);
+    attempts.push({ name: 'actual_shell_during_agent', status: before && await active() ? 'measured' : 'unqualified', durationMs: performance.now() - started,
+        command: '/bin/sh -i', expectedUtf8Sha256: sha256(text), actualUtf8Sha256: sha256(await readFile(shellFile)), pid,
+        boundary: 'Managed command to exact real shell file completion; includes IPC/file polling; not physical typing latency' });
+    await session.write(shellPane, 'exit\n');
+    session.ipc.send({ type: 'close_pane', pane_id: shellPane });
+    const editorPath = join(session.root, 'editor-exact.txt');
+    await writeFile(editorPath, '');
+    const editor = await session.ipc.request('create_pane', 'pane_created', { command: '/usr/bin/vim', args: ['-Nu', 'NONE', '-n', editorPath],
+        cwd: join(session.root, 'project'), title: 'Owned 145 real Vim', pane_type: 'process', env: { LC_ALL: 'en_US.UTF-8' } });
+    const editorPane = Number(editor.pane_id);
+    const editorPid = join(session.root, 'editor-pid.txt');
+    await session.write(editorPane, `:call writefile([string(getpid())], ${shellQuote(editorPid)})\r`);
+    const pidDeadline = performance.now() + 5000;
+    let ownedEditorPid = 0;
+    while (performance.now() < pidDeadline) {
+        try {
+            ownedEditorPid = Number((await readFile(editorPid, 'utf8')).trim());
+            if (ownedEditorPid > 0)
+                break;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await pause(10);
+    }
+    if (!ownedEditorPid)
+        throw new Error('Real editor PID publication failed');
+    session.ownedPids.add(ownedEditorPid);
+    await session.write(editorPane, ':set paste\r');
+    const editorText = 'EDITOR145 café 中文 🦀\n';
+    const editorBefore = await active();
+    const editorStarted = performance.now();
+    await session.write(editorPane, 'i' + editorText.trimEnd() + '\x1b:wq\r');
+    await waitExactFile(editorPath, editorText);
+    attempts.push({ name: 'actual_editor_during_agent', status: editorBefore && await active() ? 'measured' : 'unqualified', durationMs: performance.now() - editorStarted,
+        command: '/usr/bin/vim -Nu NONE -n', pid: ownedEditorPid, expectedUtf8Sha256: sha256(editorText), actualUtf8Sha256: sha256(await readFile(editorPath)),
+        boundary: 'Managed native IPC input to exact actual Vim save; no physical GUI keyboard/presentation qualification' });
+    session.ipc.send({ type: 'close_pane', pane_id: editorPane });
+    return attempts;
+}