firedrill-run 2.2.5 → 3.0.1

package/dist/cli/src/runner-trial-protocol.js

@@ -0,0 +1,289 @@
+import { createHash } from 'node:crypto';
+import { CliError } from './http.js';
+const CHUNK = 16384, HASH = /^[a-f0-9]{64}$/;
+const EVENTS = new Set(['trial.preparing', 'trial.world_unavailable', 'trial.execution_receipt', 'trial.elapsed', 'runner.started',
+    'driver.ready', 'driver.ingress_observed', 'driver.action_started', 'driver.action_finished',
+    'task.progress', 'conversation.progress', 'voice.progress', 'browser.capture_progress', 'desktop.capture_progress', 'dependency.request', 'dependency.response',
+    'world.time.started', 'world.time.advanced', 'world.time.finished', 'world.continuity.started', 'world.agent.observed', 'world.interaction.observed',
+    'world.event.intent', 'world.event.observed', 'world.continuity.finished', 'world.control.observed']);
+const fail = () => new CliError('local_trial_evidence_invalid', 'The saved drill evidence could not be confirmed. No target was restarted.');
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const exact = (value, keys) => Object.keys(value).sort().join(',') === keys;
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const offset = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const originalReports = new WeakMap();
+/** Retain the controller's exact committed JSON bytes. Re-encoding parsed JSON
+ * in JS can change integer precision or Python's finite numeric representation
+ * and would invalidate an otherwise identical live/final event digest. */
+export function trialReportBytes(value) {
+    const body = originalReports.get(value);
+    if (!body)
+        throw fail();
+    return Buffer.from(body);
+}
+export function trialStatus(value) {
+    if (value === null)
+        return;
+    if (!object(value) || (value.state === 'failed' ? !exact(value, 'code,state') || typeof value.code !== 'string'
+        || !/^[a-z][a-z0-9_]{0,127}$/.test(value.code) : !exact(value, 'state') || !['executing', 'finished'].includes(String(value.state))))
+        throw fail();
+}
+export function inspectTrialEvent(value, execution, sequence) {
+    if (!object(value) || !exact(value, 'at,content,execution_id,kind,sequence') || value.sequence !== sequence
+        || !offset(value.sequence) || value.execution_id !== execution || !EVENTS.has(String(value.kind))
+        || typeof value.at !== 'string' || !Number.isFinite(Date.parse(value.at)) || !object(value.content))
+        throw fail();
+    if (value.kind === 'task.progress') {
+        const content = value.content;
+        const counts = ['poll_requests', 'responses', 'retained_responses', 'omitted_responses'];
+        if (!exact(content, 'accepted_http_status,completion_status_observed,last_http_status,omitted_responses,poll_requests,reason,responses,retained_responses,schema,state')
+            || content.schema !== 'firedrill.http-task-progress.v1'
+            || !['pending', 'completed', 'failed', 'unconfirmed', 'rejected'].includes(String(content.state))
+            || !['', 'acceptance_unconfirmed', 'identifier_unavailable', 'status_unavailable', 'request_unavailable', 'deadline', 'canceled', 'evidence_unavailable'].includes(String(content.reason))
+            || counts.some(key => !offset(content[key]))
+            || Number(content.responses) !== Number(content.retained_responses) + Number(content.omitted_responses)
+            || Number(content.responses) > Number(content.poll_requests) + 1
+            || [content.accepted_http_status, content.last_http_status].some(status => status !== null && (!Number.isInteger(status) || Number(status) < 200 || Number(status) > 599))
+            || content.accepted_http_status !== null && Number(content.accepted_http_status) > 299
+            || typeof content.completion_status_observed !== 'boolean'
+            || content.completion_status_observed !== ['completed', 'failed'].includes(String(content.state))
+            || ['completed', 'failed', 'pending'].includes(String(content.state)) && content.reason !== ''
+            || ['completed', 'failed'].includes(String(content.state)) && (content.accepted_http_status === null
+                || Number(content.poll_requests) < 1 || Number(content.responses) < 2 || content.last_http_status === null
+                || Number(content.last_http_status) > 299)
+            || content.state === 'pending' && (content.accepted_http_status === null || Number(content.responses) < 1)
+            || content.state === 'rejected' && (content.accepted_http_status !== null || content.poll_requests !== 0
+                || content.responses !== 1 || content.last_http_status === null || Number(content.last_http_status) < 400 || Number(content.last_http_status) > 499))
+            throw fail();
+    }
+    if (value.kind === 'voice.progress') {
+        const content = value.content, stream = content.message_stream;
+        if (!exact(content, 'media_observed,message_stream,messages,omitted_messages,schema,state')
+            || content.schema !== 'firedrill.voice-progress.v1' || !['active', 'closed', 'interrupted'].includes(String(content.state))
+            || typeof content.media_observed !== 'boolean' || !offset(content.messages) || !offset(content.omitted_messages)
+            || Number(content.messages) + Number(content.omitted_messages) > 100000 || !object(stream)
+            || !exact(stream, 'attempt_number,id') || typeof stream.id !== 'string'
+            || !/^[a-f0-9]{8}-[a-f0-9]{4}-5[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(stream.id)
+            || !Number.isSafeInteger(stream.attempt_number) || Number(stream.attempt_number) < 1 || Number(stream.attempt_number) > 2147483647)
+            throw fail();
+        // Cloud validates the execution-derived UUID and current exact attempt.
+        // This transport parser alone never establishes invocation or compliance.
+    }
+    if (value.kind === 'world.interaction.observed') {
+        const content = value.content;
+        const uuid = (one) => typeof one === 'string' && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(one);
+        if (!exact(content, 'basis,cause_event_key,inputs,message_stream_id,plan_sha256,request_id,responses,sequence,state')
+            || content.basis !== 'original_conversation_input_coordinator' || typeof content.plan_sha256 !== 'string' || !HASH.test(content.plan_sha256)
+            || !['active', 'waiting_for_input', 'closed'].includes(String(content.state))
+            || !Number.isSafeInteger(content.sequence) || Number(content.sequence) < 1 || Number(content.sequence) > 200001
+            || [content.inputs, content.responses].some(one => !offset(one) || Number(one) > 100000)
+            || Number(content.responses) > Number(content.inputs) || Number(content.inputs) > Number(content.responses) + 1
+            || content.state === 'active' && Number(content.inputs) !== Number(content.responses) + 1
+            || content.state === 'waiting_for_input' && (content.inputs === 0 || content.inputs !== content.responses)
+            || !uuid(content.message_stream_id) || !(uuid(content.request_id) || content.request_id === null && content.inputs === 0 && content.state === 'closed')
+            || content.cause_event_key !== null && (typeof content.cause_event_key !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(content.cause_event_key)))
+            throw fail();
+        // Central admission checks exact attempt-derived stream/cause identities,
+        // original accepted plan, retained progress and phase transition ordering.
+    }
+    return value;
+}
+/** Committed controller records only. Model frames may be interleaved. Files
+ * stream to a private disk sink, never to an unbounded in-memory accumulator. */
+export function liveEventReader(operation, execution, scenario, retain, retainArtifact) {
+    let pending = null;
+    let file = null;
+    let after = 0, artifactAfter = 0;
+    return { get pending() { return pending !== null || file !== null; }, close: async () => {
+            if (file) {
+                await file.writer.abort();
+                file = null;
+            }
+            pending = null;
+        }, accept: async (frame) => {
+            if (frame.schema !== 'firedrill.local-execution-frame.v1' || frame.id !== operation)
+                throw fail();
+            if (frame.kind === 'live_artifact') {
+                if (pending || file || !exact(frame, 'artifact,id,kind,schema'))
+                    throw fail();
+                artifact(frame.artifact, execution, scenario);
+                const metadata = { ...frame.artifact };
+                if (metadata.id !== artifactAfter + '.bin' || metadata.kind === 'result')
+                    throw fail();
+                file = { metadata, bytes: 0, sequence: 0, digest: createHash('sha256'), writer: await retainArtifact(metadata) };
+                return;
+            }
+            if (file) {
+                if (frame.kind === 'live_artifact_chunk') {
+                    if (!exact(frame, 'data,id,kind,schema,sequence') || frame.sequence !== file.sequence
+                        || typeof frame.data !== 'string' || !frame.data.length || frame.data.length > 4 * Math.ceil(CHUNK / 3))
+                        throw fail();
+                    const bytes = Buffer.from(frame.data, 'base64');
+                    if (!bytes.length || bytes.length > CHUNK || bytes.toString('base64') !== frame.data
+                        || file.bytes + bytes.length > file.metadata.size)
+                        throw fail();
+                    await file.writer.write(bytes);
+                    file.digest.update(bytes);
+                    file.bytes += bytes.length;
+                    file.sequence++;
+                    return;
+                }
+                if (frame.kind !== 'live_artifact_end' || !exact(frame, 'id,kind,schema,sequence')
+                    || frame.sequence !== file.sequence || file.bytes !== file.metadata.size
+                    || file.digest.digest('hex') !== file.metadata.sha256)
+                    throw fail();
+                await file.writer.commit();
+                file = null;
+                artifactAfter++;
+                return;
+            }
+            if (frame.kind === 'live_event') {
+                if (pending || !exact(frame, 'id,kind,schema,sha256,size') || !offset(frame.size) || !frame.size
+                    || frame.size > 2 * 1024 ** 2 || typeof frame.sha256 !== 'string' || !HASH.test(frame.sha256))
+                    throw fail();
+                pending = { size: frame.size, sha256: frame.sha256, bytes: 0, sequence: 0, chunks: [] };
+                return;
+            }
+            if (!pending)
+                throw fail();
+            if (frame.kind === 'live_event_chunk') {
+                if (!exact(frame, 'data,id,kind,schema,sequence') || frame.sequence !== pending.sequence
+                    || typeof frame.data !== 'string' || !frame.data.length || frame.data.length > 4 * Math.ceil(CHUNK / 3))
+                    throw fail();
+                const bytes = Buffer.from(frame.data, 'base64');
+                if (!bytes.length || bytes.length > CHUNK || bytes.toString('base64') !== frame.data || pending.bytes + bytes.length > pending.size)
+                    throw fail();
+                pending.chunks.push(bytes);
+                pending.bytes += bytes.length;
+                pending.sequence++;
+                return;
+            }
+            if (frame.kind !== 'live_event_end' || !exact(frame, 'id,kind,schema,sequence')
+                || frame.sequence !== pending.sequence || pending.bytes !== pending.size)
+                throw fail();
+            const bytes = Buffer.concat(pending.chunks, pending.size);
+            if (hash(bytes) !== pending.sha256)
+                throw fail();
+            let value;
+            try {
+                value = JSON.parse(bytes.toString('utf8'));
+            }
+            catch {
+                throw fail();
+            }
+            const event = inspectTrialEvent(value, execution, after);
+            if (event.kind === 'trial.execution_receipt')
+                throw fail();
+            await retain(bytes, event);
+            pending = null;
+            after++;
+        } };
+}
+function artifact(value, execution, scenario) {
+    if (!object(value) || !exact(value, 'execution_id,id,kind,scenario_key,sha256,size')
+        || typeof value.id !== 'string' || !/^(0|[1-9][0-9]{0,9})\.bin$/.test(value.id)
+        || !['transcript', 'tool_trace', 'result', 'state_snapshot', 'browser_capture', 'desktop_capture', 'trace', 'dataset_application', 'recording_combined', 'recording_stereo', 'recording_customer', 'recording_assistant', 'recording_segment'].includes(String(value.kind))
+        || !offset(value.size) || value.size > 512 * 1024 ** 2 || typeof value.sha256 !== 'string' || !HASH.test(value.sha256)
+        || value.execution_id !== execution || value.scenario_key !== scenario)
+        throw fail();
+}
+export { artifact as inspectTrialArtifact };
+export function inspectTrialReport(value, operation, execution, scenario, launch, after, artifactAfter) {
+    if (!object(value) || !exact(value, 'artifact_offset,artifacts,artifacts_more,events,events_more,execution_id,launch,offset,schema,status')
+        || value.schema !== 'firedrill.trial-progress.v1' || value.execution_id !== execution
+        || !object(value.launch) || value.launch.launch_id !== operation || value.launch.state !== launch.state
+        || !exact(value.launch, launch.state === 'exited' ? 'exit_code,launch_id,state' : 'launch_id,state')
+        || value.launch.exit_code !== launch.exit_code || !Array.isArray(value.events) || value.events.length > 1
+        || !Array.isArray(value.artifacts) || value.artifacts.length > 1 || value.offset !== after + value.events.length
+        || value.artifact_offset !== artifactAfter + value.artifacts.length
+        || typeof value.events_more !== 'boolean' || typeof value.artifacts_more !== 'boolean'
+        || value.events_more && !value.events.length || value.artifacts_more && !value.artifacts.length)
+        throw fail();
+    trialStatus(value.status);
+    for (const item of value.events)
+        inspectTrialEvent(item, execution, after);
+    for (const item of value.artifacts) {
+        artifact(item, execution, scenario);
+        if (item.id !== artifactAfter + '.bin')
+            throw fail();
+    }
+    return value;
+}
+/** Fixed post-launch journal reader. No arbitrary commands, filenames or URLs. */
+export function trialReader(operation, execution, scenario, launch, emit, reply) {
+    let reading = false, epoch = 0;
+    const exclusive = async (work) => {
+        if (reading)
+            throw fail();
+        reading = true;
+        try {
+            return await work();
+        }
+        finally {
+            reading = false;
+        }
+    };
+    return {
+        report: (after, artifactAfter) => exclusive(async () => {
+            if (!offset(after) || !offset(artifactAfter))
+                throw fail();
+            await emit('trial_report', { after, artifact_after: artifactAfter });
+            const header = await reply('trial_report');
+            if (!exact(header, 'id,kind,schema,sha256,size') || !offset(header.size) || !header.size || header.size > 4 * 1024 ** 2
+                || typeof header.sha256 !== 'string' || !HASH.test(header.sha256))
+                throw fail();
+            const parts = [];
+            let length = 0, sequence = 0;
+            while (length < header.size) {
+                const frame = await reply('report_chunk');
+                if (!exact(frame, 'data,id,kind,schema,sequence') || frame.sequence !== sequence++ || typeof frame.data !== 'string'
+                    || frame.data.length > 4 * Math.ceil(CHUNK / 3))
+                    throw fail();
+                const bytes = Buffer.from(frame.data, 'base64');
+                if (!bytes.length || bytes.length > CHUNK || bytes.toString('base64') !== frame.data || length + bytes.length > header.size)
+                    throw fail();
+                parts.push(bytes);
+                length += bytes.length;
+            }
+            const end = await reply('report_end'), body = Buffer.concat(parts);
+            if (!exact(end, 'id,kind,schema,sequence') || end.sequence !== sequence || hash(body) !== header.sha256)
+                throw fail();
+            let value;
+            try {
+                value = JSON.parse(body.toString('utf8'));
+            }
+            catch {
+                throw fail();
+            }
+            const report = inspectTrialReport(value, operation, execution, scenario, launch, after, artifactAfter);
+            originalReports.set(report, body);
+            return report;
+        }),
+        artifact: metadata => exclusive(async () => {
+            artifact(metadata, execution, scenario);
+            metadata = { ...metadata };
+            const current = ++epoch; // Invalidate earlier readers before selection.
+            await emit('trial_artifact', { artifact: metadata.id });
+            const frame = await reply('trial_artifact');
+            if (!exact(frame, 'artifact,id,kind,schema'))
+                throw fail();
+            artifact(frame.artifact, execution, scenario);
+            const actual = frame.artifact;
+            if (Object.keys(metadata).some(key => metadata[key] !== actual[key]))
+                throw fail();
+            return { read: (position, length) => exclusive(async () => {
+                    if (current !== epoch || !offset(position) || !offset(length) || length < 1 || length > CHUNK || position + length > metadata.size)
+                        throw fail();
+                    await emit('export_chunk', { offset: position, length });
+                    const row = await reply('export_chunk');
+                    if (!exact(row, 'data,id,kind,length,offset,schema,sha256') || row.offset !== position || row.length !== length
+                        || typeof row.data !== 'string' || row.data.length > 4 * Math.ceil(CHUNK / 3))
+                        throw fail();
+                    const bytes = Buffer.from(row.data, 'base64');
+                    if (bytes.length !== length || bytes.toString('base64') !== row.data || hash(bytes) !== row.sha256)
+                        throw fail();
+                    return bytes;
+                }) };
+        }),
+    };
+}

package/dist/cli/src/runner-trial-sync.js

@@ -0,0 +1,110 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, open, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { privateDirectory } from './credentials.js';
+import { CliError } from './http.js';
+import { identifier } from './world-contracts.js';
+import { localTrialCollection } from './runner-trial-journal.js';
+import { synchronizeTrialEvidence as synchronize, trialTransferKey as transferKey } from './runner-trial-transfer.js';
+import { acquireLocalEvidence, assertEvidenceRetentionCurrent, evidenceRetentionSignal } from './runner-evidence-retention.js';
+/** Explicit transfer-only recovery of the exact journal. No Docker/target/model
+ * invocation, lease renewal, new transfer identity or campaign outcome inference.
+ */
+export async function syncLocalTrialEvidence(scope, operation, signal, output) {
+    operation = identifier(operation);
+    const evidence = await acquireLocalEvidence(scope, operation);
+    try {
+        return await synchronizeRetainedTrial(scope, operation, AbortSignal.any([signal, evidence.signal]), evidence.retention, output);
+    }
+    finally {
+        await evidence.close();
+    }
+}
+async function synchronizeRetainedTrial(scope, operation, signal, retention, output) {
+    signal = evidenceRetentionSignal(retention, signal);
+    const collection = await localTrialCollection(scope, operation, retention), retained = collection.journal, owner = retained.owner;
+    if (!owner.evidenceUpload)
+        return { state: 'local_only', provenance: 'customer_device', cloud_completion_recorded: false };
+    const directory = join(await privateDirectory(), `trial-${identifier(scope.owner)}-${identifier(scope.workspace)}-${operation}`);
+    const lock = join(directory, 'cloud-sync.lock');
+    // All new sync ownership is the outer kernel lock. Preserve ambiguous old
+    // directory locks; no PID/time-based takeover or silent removal is allowed.
+    if (await lstat(lock).then(() => true).catch(error => { if (error.code === 'ENOENT')
+        return false; throw error; }))
+        throw new CliError('local_evidence_legacy_lock', 'This older drill transfer has an ambiguous cloud-sync.lock. Inspect that exact legacy lock before continuing; it was not removed.');
+    // This is one reconciliation pass, not a catalogue of all prior receipts.
+    // Every original deterministic transfer is still read back and every local
+    // byte is checked. Restarting synchronization never restarts the target.
+    const journal = { schema: 'firedrill.local-trial-sync.v2', operation_id: operation, job_id: owner.job,
+        manifest_sha256: retained.manifest_sha256, state: 'synchronizing', reports_retained: 0, artifacts_retained: 0,
+        last_transfer: null, pending: null, cloud_completion_recorded: false };
+    const persist = async () => {
+        assertEvidenceRetentionCurrent(retention);
+        const target = join(directory, 'cloud-receipts.json'), temporary = target + '.' + randomUUID() + '.tmp', file = await open(temporary, 'wx', 0o600);
+        try {
+            await file.writeFile(JSON.stringify(journal));
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        await rename(temporary, target);
+        const parent = await open(directory, constants.O_RDONLY | (constants.O_DIRECTORY ?? 0));
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+    };
+    {
+        await persist();
+        const active = AbortSignal.any([signal, AbortSignal.timeout(30 * 60 * 1000)]);
+        let after = 0, artifactAfter = 0, unavailable = 0;
+        let notified = 0;
+        const progress = (force = false) => {
+            const now = Date.now();
+            if (!force && now - notified < 1000)
+                return;
+            notified = now;
+            output?.('local_trial_sync_progress', { operation_id: operation, job_id: owner.job,
+                reports_retained: journal.reports_retained, artifacts_retained: journal.artifacts_retained,
+                unavailable_artifacts: unavailable, state: journal.state, provenance: 'customer_device', cloud_completion_recorded: false }, `Cloud receipts checked: ${journal.reports_retained} report pages, ${journal.artifacts_retained} evidence files.`);
+        };
+        progress(true);
+        const pending = async (value) => { journal.pending = value; await persist(); };
+        for await (const page of collection.pages(active)) {
+            const document = { kind: 'trial_report', receipt: { size: page.size, sha256: page.sha256 },
+                position: page.position, after, artifact_after: artifactAfter, launch: retained.observation.launch, status: retained.observation.status };
+            const key = transferKey(operation, 'report:' + page.position);
+            const artifact = await synchronize(owner, retained.manifest_sha256, key, document, async (offset, length) => { assertEvidenceRetentionCurrent(retention); return page.bytes.subarray(offset, offset + length); }, active, pending);
+            journal.last_transfer = { key, artifact };
+            journal.reports_retained++;
+            await persist();
+            progress();
+            after = page.report.offset;
+            artifactAfter = page.report.artifact_offset;
+            for (const metadata of page.report.artifacts) {
+                if (Number(metadata.id.split('.')[0]) >= retained.artifacts_retained) {
+                    unavailable++;
+                    continue;
+                }
+                await collection.artifact(metadata, async (read) => {
+                    const key = transferKey(operation, 'artifact:' + metadata.id);
+                    const artifact = await synchronize(owner, retained.manifest_sha256, key, { kind: 'trial_artifact', receipt: { size: metadata.size, sha256: metadata.sha256 }, metadata,
+                        launch: retained.observation.launch, status: retained.observation.status }, read, active, pending);
+                    journal.last_transfer = { key, artifact };
+                    journal.artifacts_retained++;
+                    await persist();
+                    progress();
+                }, active);
+            }
+        }
+        journal.state = retained.stage === 'local_collected' && unavailable === 0 ? 'cloud_staged' : 'cloud_staged_partial';
+        await persist();
+        progress(true);
+        return { state: journal.state, transfers: journal.reports_retained + journal.artifacts_retained, unavailable_artifacts: unavailable,
+            provenance: 'customer_device', cloud_completion_recorded: false };
+    }
+}

package/dist/cli/src/runner-trial-transfer.js

@@ -0,0 +1,107 @@
+import { createHash } from 'node:crypto';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { api } from './auth.js';
+import { CliError } from './http.js';
+import { historicalRunnerSigner } from './runner-identity.js';
+import { identifier } from './world-contracts.js';
+import { localEvidenceReceiptMatches } from '../../contracts/local-evidence-contracts.js';
+const CHUNK = 1024 ** 2;
+const hash = (body) => createHash('sha256').update(body).digest('hex');
+const fail = () => new CliError('local_trial_sync_unconfirmed', 'Drill evidence is not confirmed in the cloud. Its exact private journal remains; no target was run again.');
+function canonical(value) {
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    if (value && typeof value === 'object')
+        return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key])).join(',') + '}';
+    const body = JSON.stringify(value);
+    if (body === undefined)
+        throw fail();
+    return body;
+}
+export function trialTransferKey(operation, name) {
+    const bytes = createHash('sha256').update('firedrill.local-trial-transfer.v1\0' + operation + '\0' + name).digest().subarray(0, 16);
+    bytes[6] = (bytes[6] & 15) | 128;
+    bytes[8] = (bytes[8] & 63) | 128;
+    const hex = bytes.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function match(receipt, owner, key, document, manifest) {
+    if (!localEvidenceReceiptMatches(receipt, { ...owner, manifestSha256: manifest }, key)
+        || receipt.schema !== 'firedrill.local-trial-evidence-receipt.v1' || receipt.job_id !== owner.job
+        || receipt.transfer_key !== key || receipt.lease_id !== owner.lease || receipt.provenance !== 'customer_device'
+        || receipt.cloud_completion_recorded !== false || !Array.isArray(receipt.chunks)
+        || !['not_retained', 'receiving', 'verifying', 'retained'].includes(receipt.state)
+        || receipt.state !== 'not_retained' && (receipt.request_digest !== hash(canonical(document)) || canonical(receipt.document) !== canonical(document)))
+        throw fail();
+    if (receipt.state !== 'retained' && (receipt.upload_available !== true || !Number.isFinite(Date.parse(receipt.server_time))
+        || !Number.isFinite(Date.parse(receipt.upload_until)) || Date.parse(receipt.upload_until) <= Date.parse(receipt.server_time)))
+        throw fail();
+}
+/** One exact resumable file intent. Live retention is not a closing declaration.
+ * An uncertain write is reconciled by GET only. The caller owns durable bytes,
+ * current consent, bounded cancellation and queue state, never a target retry. */
+export async function synchronizeTrialEvidence(owner, manifest, key, document, read, signal, pending) {
+    const path = `/api/workspaces/${identifier(owner.workspace)}/local-runners/${identifier(owner.device)}/jobs/${identifier(owner.job)}/claims/${identifier(owner.request)}/trial-evidence/${identifier(key)}`;
+    const auth = { actor: owner.owner, workspace: owner.workspace, signal };
+    let receipt = await api(path, auth);
+    match(receipt, owner, key, document, manifest);
+    const signer = await historicalRunnerSigner(owner, owner.device, signal);
+    const send = async (action, fields) => {
+        const sent = Date.parse(receipt.server_time);
+        if (!Number.isSafeInteger(sent))
+            throw fail();
+        await pending({ key, action, ...(action === 'chunk' ? { index: Number(fields.index) } : {}) });
+        const proof = await signer.sign({ schema: 'firedrill.local-trial-evidence-write.v1', job_id: owner.job,
+            attempt_id: owner.attempt, lease_id: owner.lease, request_key: owner.request, device_key: owner.device,
+            native_session_id: signer.nativeSession, transfer_key: key, manifest_sha256: manifest, sent_at_ms: sent, action, ...fields });
+        try {
+            receipt = await api(path, { ...auth, method: 'POST', body: proof });
+        }
+        catch (error) {
+            if (!(error instanceof CliError) || !['connection_uncertain', 'response_unavailable'].includes(error.code))
+                throw error;
+            receipt = await api(path, auth);
+        }
+        match(receipt, owner, key, document, manifest);
+    };
+    if (receipt.state === 'not_retained') {
+        await send('register', { document });
+        if (receipt.state === 'not_retained')
+            throw fail();
+    }
+    const digest = createHash('sha256'), count = Math.ceil(document.receipt.size / CHUNK);
+    for (let index = 0; index < count; index++) {
+        signal.throwIfAborted();
+        const size = Math.min(CHUNK, document.receipt.size - index * CHUNK), bytes = await read(index * CHUNK, size);
+        if (bytes.length !== size)
+            throw fail();
+        digest.update(bytes);
+        const sha256 = hash(bytes), previous = receipt.chunks.find(value => value.index === index);
+        if (previous && (previous.size !== size || previous.sha256 !== sha256))
+            throw fail();
+        if (receipt.state === 'receiving' && !previous?.retained)
+            await send('chunk', { index, sha256, data: bytes.toString('base64') });
+        // A previously published identical live artifact may be linked without
+        // another upload. Still hash EVERY local byte before accepting its receipt.
+        if (receipt.state !== 'retained' && !receipt.chunks.some(value => value.index === index
+            && value.size === size && value.sha256 === sha256 && value.retained))
+            throw fail();
+    }
+    if (digest.digest('hex') !== document.receipt.sha256)
+        throw fail();
+    if (receipt.state === 'receiving' || receipt.state === 'verifying')
+        await send('commit', {});
+    while (receipt.state === 'verifying') {
+        if (!receipt.authorization_current)
+            throw new CliError('local_trial_sync_authorization_required', 'Authorize this saved transfer from a current terminal session. Execution will not be restarted.');
+        await sleep(1000, undefined, { signal });
+        receipt = await api(path, auth);
+        match(receipt, owner, key, document, manifest);
+    }
+    const artifact = receipt.artifact;
+    if (receipt.state !== 'retained' || !artifact || identifier(artifact.id) !== artifact.id || !/^[1-9][0-9]*$/.test(artifact.generation)
+        || artifact.size !== document.receipt.size || artifact.sha256 !== document.receipt.sha256)
+        throw fail();
+    await pending(null);
+    return artifact;
+}

package/dist/cli/src/runner-voice.js

@@ -0,0 +1,40 @@
+import { API_ORIGIN, CliError } from './http.js';
+import { identifier } from './world-contracts.js';
+export const voiceOperations = { voice_llm: 'chat/completions', voice_stt: 'audio/transcriptions', voice_tts: 'audio/speech' };
+const invalid = () => new CliError('local_voice_configuration_invalid', 'The saved speech connection does not match this drill. No agent was started.');
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+export function voiceSession(value) {
+    if (!record(value) || Object.keys(value).sort().join(',') !== 'agent_name,agent_name_variable,key_variable,kind,mode,secret_variable,source_process,url_variable'
+        || value.kind !== 'livekit' || value.mode !== 'isolated' || typeof value.source_process !== 'string'
+        || !/^[a-z0-9][a-z0-9_-]{0,127}$/.test(value.source_process) || typeof value.agent_name !== 'string'
+        || value.agent_name.length > 128 || /[^\x20-\x7e]/.test(value.agent_name))
+        throw invalid();
+    const names = [value.url_variable, value.key_variable, value.secret_variable];
+    if (value.agent_name_variable !== null)
+        names.push(value.agent_name_variable);
+    if (names.some(name => typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(name)
+        || ['PATH', 'HOME', 'TMPDIR', 'USER', 'LOGNAME', 'SHELL', 'PORT'].includes(name.toUpperCase())
+        || /^(LD_|PYTHON|HARNESS_|ALK_|FD_|PORT_)/.test(name.toUpperCase())) || new Set(names).size !== names.length)
+        throw invalid();
+}
+export function voiceChannels(value, enabled) {
+    if (!Array.isArray(value) || value.length !== (enabled ? 3 : 0))
+        throw invalid();
+    const roles = new Set(), ids = new Set();
+    for (const row of value) {
+        if (!record(row) || Object.keys(row).sort().join(',') !== 'endpoint,model,role,token'
+            || typeof row.role !== 'string' || !Object.hasOwn(voiceOperations, row.role) || roles.has(row.role)
+            || typeof row.model !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(row.model)
+            || typeof row.endpoint !== 'string' || typeof row.token !== 'string' || !/^[A-Za-z0-9_-]{32,256}$/.test(row.token))
+            throw invalid();
+        const endpoint = new URL(row.endpoint);
+        if (endpoint.origin !== API_ORIGIN || endpoint.username || endpoint.password || endpoint.search || endpoint.hash
+            || !/^\/api\/internal\/model\/[a-f0-9-]{36}$/.test(endpoint.pathname))
+            throw invalid();
+        const id = identifier(endpoint.pathname.split('/').at(-1));
+        if (ids.has(id))
+            throw invalid();
+        ids.add(id);
+        roles.add(row.role);
+    }
+}

package/dist/cli/src/runner-world-claim.js

@@ -0,0 +1,21 @@
+import { readLocalClaim } from './runner-claim-reads.js';
+import { CliError } from './http.js';
+export const localWorldClaimPath = (owner) => `/api/workspaces/${owner.workspace}/local-runners/${owner.device}/jobs/${owner.job}/claims/${owner.request}`;
+/** Read current original authority. Neither this read nor a signed command
+ * extends presence, a lease, target lifetime or evidence-retention authority. */
+export async function localWorldClaimTime(owner, signal) {
+    signal.throwIfAborted();
+    const current = await readLocalClaim(owner, owner.device, owner.job, owner.request, signal);
+    const claim = current?.claim, identity = current?.world_session, sent = Date.parse(current?.server_time);
+    if (!current || current.job_id !== owner.job || current.grant_id !== owner.grant || current.device_key !== owner.device
+        || current.payload_digest !== owner.payloadDigest || current.purpose !== 'world_session'
+        || !identity || identity.session_id !== owner.session.session_id || identity.input_sha256 !== owner.session.input_sha256
+        || identity.configuration_id !== owner.session.configuration_id || identity.expires_at !== owner.session.expires_at
+        || !claim || claim.id !== owner.lease || claim.request_key !== owner.request || claim.attempt_id !== owner.attempt
+        || claim.state !== 'claimed' || !Number.isSafeInteger(sent) || !Number.isSafeInteger(Date.parse(claim.expires_at))
+        || !Number.isSafeInteger(Date.parse(owner.session.expires_at))
+        || Date.parse(claim.expires_at) <= sent || Date.parse(claim.expires_at) > Date.parse(owner.session.expires_at)) {
+        throw new CliError('local_world_claim_changed', 'This local world no longer has its original execution authority. No command was sent.');
+    }
+    return sent;
+}