@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/dist/lib/run/index.js

@@ -7,57 +7,98 @@ import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.js'
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.js';
 import { getSkillRunSpec } from './skills.js';
 import { runHostCommand } from './host.js';
-const USAGE = `Usage: ai run <skill> [task-ref] [args...] [--tui <name>] [--recreate]
+const USAGE = `Usage: ai run --skill <skill> [--task <task-ref>] [--tui <name>] [--recreate] [-- <skill-args...>]
 
 Task skills are scheduled inside the sandbox tmux session; ai run returns once
 the tmux window is created. --recreate authorizes container-only replacement
 when in-place sandbox recovery fails; it is not included in the TUI prompt.
 
 Examples:
-  ai run create-task "describe the task" --tui codex
-  ai run code-task #7 --tui codex --recreate`;
-function extractTui(args) {
-    const rest = [];
+  ai run --skill create-task "describe the task" --tui codex
+  ai run --skill code-task --task 7 --tui codex --recreate`;
+function optionValue(args, index, option) {
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        throw new Error(`${option} requires a value`);
+    return value;
+}
+function extractHostOptions(args) {
+    const positionals = [];
+    const forwarded = [];
+    let skill = null;
+    let taskRef = null;
     let tui = null;
+    let recreate = false;
+    let separator = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if (arg === '--tui') {
-            const value = args[i + 1];
-            if (!value)
-                throw new Error('--tui requires a value');
-            tui = value;
+        if (separator) {
+            forwarded.push(arg);
+        }
+        else if (arg === '--') {
+            separator = true;
+        }
+        else if (arg === '--skill') {
+            if (skill !== null)
+                throw new Error("duplicate option '--skill'");
+            skill = optionValue(args, i, '--skill');
+            i += 1;
+        }
+        else if (arg === '--task') {
+            if (taskRef !== null)
+                throw new Error("duplicate option '--task'");
+            taskRef = optionValue(args, i, '--task');
+            i += 1;
+        }
+        else if (arg === '--tui') {
+            if (tui !== null)
+                throw new Error("duplicate option '--tui'");
+            tui = optionValue(args, i, '--tui');
             i += 1;
-            continue;
         }
-        rest.push(arg);
+        else if (arg === '--recreate') {
+            if (recreate)
+                throw new Error("duplicate option '--recreate'");
+            recreate = true;
+        }
+        else if (arg.startsWith('-')) {
+            throw new Error(`Unknown option '${arg}'`);
+        }
+        else {
+            positionals.push(arg);
+        }
     }
-    return { rest, tui };
+    return { positionals, forwarded, skill, taskRef, tui, recreate };
 }
 export function parseRunArgs(args) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
         throw new Error(USAGE);
     }
-    const { rest: withRecoveryFlags, tui } = extractTui(args);
-    const recreate = withRecoveryFlags.includes('--recreate');
-    const rest = withRecoveryFlags.filter((arg) => arg !== '--recreate');
-    const [skill = '', maybeTaskRef, ...remaining] = rest;
+    const { positionals, forwarded, skill, taskRef, tui, recreate } = extractHostOptions(args);
+    if (!skill)
+        throw new Error("option '--skill' is required");
     const spec = getSkillRunSpec(skill);
     if (!spec)
         throw new Error(`Unknown skill '${skill}'`);
     if (spec.kind === 'create') {
+        if (taskRef !== null)
+            throw new Error("create-task does not accept '--task'");
         if (recreate)
             throw new Error('--recreate is only valid for sandbox task runs');
-        const createArgs = rest.slice(1);
+        const createArgs = [...positionals, ...forwarded];
         if (createArgs.length === 0)
             throw new Error('create-task requires a description');
         return { skill, taskRef: null, args: createArgs, tui };
     }
-    if (!maybeTaskRef)
+    if (positionals.length > 0) {
+        throw new Error('ai run requires --skill and --task; positional host arguments are not supported');
+    }
+    if (taskRef === null)
         throw new Error(`${skill} requires a task-ref`);
     return {
         skill,
-        taskRef: maybeTaskRef,
-        args: remaining,
+        taskRef,
+        args: forwarded,
         tui,
         ...(recreate ? { recreate: true } : {})
     };
@@ -155,8 +196,7 @@ export async function runSkill(args, options = {}) {
     const commandConfig = options.command ?? config?.command ?? {};
     assertAllowedByConfig(parsed.skill, commandConfig);
     const tui = selectTui(parsed.skill, { cliTui: parsed.tui, command: commandConfig });
-    const promptArgs = parsed.taskRef === null ? parsed.args : [parsed.taskRef, ...parsed.args];
-    const prompt = renderPrompt({ tui, skill: parsed.skill, args: promptArgs });
+    const prompt = renderPrompt({ tui, skill: parsed.skill, args: parsed.args });
     const [file, argv] = buildTuiCommand(tui, prompt);
     const command = [file, ...argv];
     if (parsed.taskRef === null) {

package/dist/lib/sandbox/config.js

@@ -67,6 +67,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
     const agentClients = normalizeAgentClients(airc);
     const defaults = cloneDefaults();
     const sandbox = airc.sandbox ?? {};
+    const delivery = airc.delivery ?? {};
     const engine = validateSandboxEngine(sandbox.engine ?? defaults.engine, { platformFn });
     const project = airc.project;
     if (!project || typeof project !== 'string') {
@@ -111,6 +112,10 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         tools,
         customTools,
         agentClientState: agentClients.state,
+        delivery: {
+            remote: typeof delivery.remote === 'string' ? delivery.remote : 'origin',
+            baseRef: typeof delivery.baseRef === 'string' ? delivery.baseRef : 'main'
+        },
         refreshIntervalDays: asNonNegativeIntegerOrDefault(sandbox.refreshIntervalDays, defaults.refreshIntervalDays),
         dockerfile,
         vm: {

package/dist/lib/sandbox/control/client.js

@@ -3,23 +3,25 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { SANDBOX_CONTROL_ADMISSION_WINDOW_MS, SANDBOX_CONTROL_MAX_BYTES, SANDBOX_CONTROL_STATUS_STALE_MS, isSandboxControlFamily } from './protocol.js';
 import { normalizeAgentToken } from '../../agent-clients/tokens.js';
-import { readSandboxControlStatus } from './state.js';
+import { readSandboxControlPayload, readSandboxControlStatus } from './state.js';
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
 export class SandboxControlClientError extends Error {
     detail;
     accepted;
-    constructor(detail, accepted = false) {
+    requestId;
+    constructor(detail, accepted = false, requestId = null) {
         super(detail.message);
         this.name = 'SandboxControlClientError';
         this.detail = detail;
         this.accepted = accepted;
+        this.requestId = requestId;
     }
 }
 function sleep(milliseconds) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 }
-function clientError(code, message, retryable, accepted = false) {
-    throw new SandboxControlClientError({ code, message: `${code}: ${message}`, retryable }, accepted);
+function clientError(code, message, retryable, accepted = false, requestId = null) {
+    throw new SandboxControlClientError({ code, message: `${code}: ${message}`, retryable }, accepted, requestId);
 }
 function preflight(statusDir, generation, now = Date.now()) {
     let status;
@@ -47,12 +49,35 @@ function preflight(statusDir, generation, now = Date.now()) {
 function parseResponse(raw, id) {
     const response = JSON.parse(raw);
     if (response.version !== 2 || response.id !== id
-        || !['accepted', 'completed', 'rejected'].includes(response.phase)
-        || (response.phase === 'completed' && !Number.isInteger(response.exitCode))) {
-        clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response is invalid', false);
+        || !['completed', 'rejected'].includes(response.phase)
+        || (response.phase === 'completed' && !Number.isInteger(response.exitCode))
+        || (response.outputState !== undefined && response.outputState !== 'available' && response.outputState !== 'unavailable')
+        || (response.outputState === 'available' && !response.payload)
+        || (response.outputState === 'unavailable' && response.payload !== null && response.payload !== undefined)) {
+        clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response is invalid', false, false, id);
     }
     return response;
 }
+function readPublishedResponse(raw, id, channelDir) {
+    const response = parseResponse(raw, id);
+    if (response.outputState !== 'available')
+        return response;
+    const filePath = path.join(channelDir, 'responses', `${id}.payload.json`);
+    let payload;
+    try {
+        payload = readSandboxControlPayload(filePath);
+    }
+    catch {
+        clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker payload is missing or invalid', false, true, id);
+    }
+    if (!response.payload || response.payload.version !== payload.version
+        || response.payload.id !== payload.id || response.payload.generation !== payload.generation
+        || response.payload.stdoutBytes !== payload.stdoutBytes || response.payload.stderrBytes !== payload.stderrBytes
+        || response.payload.stdoutSha256 !== payload.stdoutSha256 || response.payload.stderrSha256 !== payload.stderrSha256) {
+        clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker payload reference is invalid', false, true, id);
+    }
+    return { ...response, stdout: payload.stdout, stderr: payload.stderr };
+}
 function cancelPendingRequest(requestPath) {
     try {
         fs.unlinkSync(requestPath);
@@ -70,13 +95,16 @@ function exchangeSandboxControl(request, params) {
     preflight(statusDir, request.generation);
     const encoded = `${JSON.stringify(request)}\n`;
     if (Buffer.byteLength(encoded, 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
-        clientError('SANDBOX_CONTROL_REQUEST_TOO_LARGE', 'request exceeds the control limit', false);
+        clientError('SANDBOX_CONTROL_REQUEST_TOO_LARGE', 'request exceeds the control limit', false, false, request.id);
     }
     const requestsDir = path.join(channelDir, 'requests');
     const responsesDir = path.join(channelDir, 'responses');
     const temporary = path.join(requestsDir, `.${request.id}.tmp`);
     const requestPath = path.join(requestsDir, `${request.id}.json`);
     const responsePath = path.join(responsesDir, `${request.id}.json`);
+    if (fs.existsSync(responsePath)) {
+        clientError('SANDBOX_CONTROL_REQUEST_REPLAYED', 'request id already has a terminal response', false, false, request.id);
+    }
     fs.writeFileSync(temporary, encoded, { mode: 0o600, flag: 'wx' });
     fs.renameSync(temporary, requestPath);
     const deadline = Date.now() + (params.timeoutMs ?? 30_000);
@@ -84,6 +112,9 @@ function exchangeSandboxControl(request, params) {
     let malformedResponseRaw = null;
     let malformedResponseObservedAt = 0;
     while (Date.now() < deadline) {
+        const acceptedPath = path.join(responsesDir, `${request.id}.accepted.json`);
+        if (fs.existsSync(acceptedPath))
+            accepted = true;
         if (fs.existsSync(responsePath)) {
             let raw;
             try {
@@ -96,7 +127,7 @@ function exchangeSandboxControl(request, params) {
             }
             let response;
             try {
-                response = parseResponse(raw, request.id);
+                response = readPublishedResponse(raw, request.id, channelDir);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -108,7 +139,7 @@ function exchangeSandboxControl(request, params) {
                     malformedResponseObservedAt = now;
                 }
                 else if (now - malformedResponseObservedAt >= SANDBOX_CONTROL_RESPONSE_SETTLE_MS) {
-                    clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response remained malformed', false, accepted);
+                    clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response remained malformed', false, accepted, request.id);
                 }
                 sleep(25);
                 continue;
@@ -117,7 +148,6 @@ function exchangeSandboxControl(request, params) {
                 accepted = true;
             }
             else {
-                fs.rmSync(responsePath, { force: true });
                 return response;
             }
         }
@@ -128,18 +158,69 @@ function exchangeSandboxControl(request, params) {
             catch (error) {
                 if (cancelPendingRequest(requestPath))
                     throw error;
-                clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request was claimed before broker availability was lost; inspect domain state before retrying', false, true);
+                clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request was claimed before broker availability was lost; inspect domain state before retrying', false, true, request.id);
             }
         }
         sleep(25);
     }
     if (accepted) {
-        clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'accepted request did not produce a final result; inspect domain state before retrying', false, true);
+        clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'accepted request did not produce a final result; inspect domain state before retrying', false, true, request.id);
     }
     if (!cancelPendingRequest(requestPath)) {
-        clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request was claimed but no acceptance result was observed; inspect domain state before retrying', false, true);
+        clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request was claimed but no acceptance result was observed; inspect domain state before retrying', false, true, request.id);
+    }
+    clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', `broker did not accept the request within ${params.timeoutMs ?? 30_000}ms`, true, false, request.id);
+}
+export function recoverSandboxControl(requestId, params = {}) {
+    if (!/^[a-f0-9-]{16,64}$/u.test(requestId)) {
+        clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'request id is invalid', false, true);
+    }
+    const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
+    const responsePath = path.join(channelDir, 'responses', `${requestId}.json`);
+    const deadline = Date.now() + (params.timeoutMs ?? 30_000);
+    let accepted = false;
+    let malformedResponseRaw = null;
+    let malformedResponseObservedAt = 0;
+    while (Date.now() < deadline) {
+        if (fs.existsSync(path.join(channelDir, 'responses', `${requestId}.accepted.json`)))
+            accepted = true;
+        if (fs.existsSync(responsePath)) {
+            let raw;
+            try {
+                raw = fs.readFileSync(responsePath, 'utf8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            let response;
+            try {
+                response = readPublishedResponse(raw, requestId, channelDir);
+                malformedResponseRaw = null;
+            }
+            catch (error) {
+                if (!(error instanceof SyntaxError))
+                    throw error;
+                const now = Date.now();
+                if (malformedResponseRaw !== raw) {
+                    malformedResponseRaw = raw;
+                    malformedResponseObservedAt = now;
+                }
+                else if (now - malformedResponseObservedAt >= SANDBOX_CONTROL_RESPONSE_SETTLE_MS) {
+                    clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response remained malformed', false, accepted, requestId);
+                }
+                sleep(25);
+                continue;
+            }
+            if (response.phase === 'accepted')
+                accepted = true;
+            else
+                return response;
+        }
+        sleep(25);
     }
-    clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', `broker did not accept the request within ${params.timeoutMs ?? 30_000}ms`, true);
+    clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'request did not produce a final result; inspect domain state before retrying', false, accepted, requestId);
 }
 function authority(params) {
     const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;

package/dist/lib/sandbox/control/executor.js

@@ -191,7 +191,7 @@ function finalizationResult(result) {
 }
 export async function executeRequest(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
-        const result = createTask(request.candidate, { repoRoot: manifest.repoRoot });
+        const result = await createTask(request.candidate, { repoRoot: manifest.repoRoot });
         return {
             exitCode: result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0,
             stdout: `${JSON.stringify(result)}\n`,
@@ -255,7 +255,7 @@ export async function executeRequest(manifest, manifestPath, request, options =
             manifestPath,
             requestId: request.id
         }), operation);
-        return finalizationResult(result);
+        return finalizationResult(await result);
     }
     const boundArgs = bindSandboxControlTask(request, manifest.taskId);
     if (request.family === 'task-orchestration') {
@@ -325,7 +325,7 @@ export async function executeRequest(manifest, manifestPath, request, options =
     }
     if (operation.family !== 'task-lifecycle')
         throw new Error('SANDBOX_CONTROL_LIFECYCLE_OPERATION_INVALID');
-    return format(dispatchTaskControlOperation(context, operation));
+    return format(await dispatchTaskControlOperation(context, operation));
 }
 export async function runSandboxControlExecutor(requestPath, nonce) {
     const gateOwner = await waitForGate(nonce);

package/dist/lib/sandbox/control/lifecycle.js

@@ -448,25 +448,27 @@ function readSandboxControlManifestValue(manifestPath) {
         'mode', 'processingDir', 'project', 'publicStatusDir', 'repoRoot', 'runtimeDir',
         'taskId', 'token', 'worktreeRoot'
     ];
-    if ('version' in candidate || typeof candidate.runtimeDir !== 'string'
-        || Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
-        throw new Error('SANDBOX_CONTROL_MANIFEST_REBUILD_REQUIRED: container-only recreation/rebuild is required');
+    if (Object.keys(manifest).sort().join(',') !== expectedKeys.sort().join(',')) {
+        throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
     if (typeof candidate.containerIdentity !== 'object' || candidate.containerIdentity === null
         || Array.isArray(candidate.containerIdentity))
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     const containerIdentity = candidate.containerIdentity;
-    if (typeof candidate.engine !== 'string' || candidate.engine.length === 0
+    if (Object.keys(containerIdentity).sort().join(',') !== 'id,labels'
+        || typeof candidate.engine !== 'string' || candidate.engine.length === 0
         || typeof candidate.repoRoot !== 'string' || typeof candidate.worktreeRoot !== 'string'
         || typeof candidate.project !== 'string' || typeof candidate.container !== 'string'
         || typeof containerIdentity.id !== 'string' || containerIdentity.id.length === 0
         || typeof containerIdentity.labels !== 'object' || containerIdentity.labels === null
         || Array.isArray(containerIdentity.labels)
         || Object.values(containerIdentity.labels).some((value) => typeof value !== 'string')
-        || typeof candidate.branch !== 'string' || !['task-bound', 'branch-only'].includes(candidate.mode ?? '')
+        || typeof candidate.branch !== 'string'
+        || (candidate.mode !== 'task-bound' && candidate.mode !== 'branch-only')
         || (candidate.taskId !== null && typeof candidate.taskId !== 'string')
         || typeof candidate.channelDir !== 'string' || typeof candidate.publicStatusDir !== 'string'
-        || typeof candidate.processingDir !== 'string' || typeof candidate.token !== 'string'
+        || typeof candidate.processingDir !== 'string' || typeof candidate.runtimeDir !== 'string'
+        || typeof candidate.token !== 'string'
         || typeof candidate.generation !== 'string'
         || (candidate.mode === 'task-bound' && (typeof candidate.taskId !== 'string' || candidate.taskId.length === 0))
         || (candidate.mode === 'branch-only' && candidate.taskId !== null))
@@ -480,7 +482,27 @@ function readSandboxControlManifestValue(manifestPath) {
     if (path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
         throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
     }
-    return candidate;
+    const normalized = {
+        engine: candidate.engine,
+        repoRoot: candidate.repoRoot,
+        worktreeRoot: candidate.worktreeRoot,
+        project: candidate.project,
+        container: candidate.container,
+        containerIdentity: {
+            id: containerIdentity.id,
+            labels: { ...containerIdentity.labels }
+        },
+        branch: candidate.branch,
+        mode: candidate.mode,
+        taskId: candidate.taskId,
+        token: candidate.token,
+        generation: candidate.generation,
+        channelDir: candidate.channelDir,
+        publicStatusDir: candidate.publicStatusDir,
+        processingDir: candidate.processingDir,
+        runtimeDir: candidate.runtimeDir
+    };
+    return normalized;
 }
 export function readSandboxControlManifest(manifestPath) {
     return readSandboxControlManifestValue(manifestPath);

package/dist/lib/sandbox/control/protocol.js

@@ -1,6 +1,11 @@
+import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate } from '../../task/create.js';
 import { normalizeAgentToken } from '../../agent-clients/tokens.js';
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
+export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
+export const SANDBOX_CONTROL_MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
+export const SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES = 1024 * 1024;
+export const SANDBOX_CONTROL_RESERVATION_BYTES = SANDBOX_CONTROL_MAX_TERMINAL_RECORD_BYTES + 4 * 1024;
 export const SANDBOX_CONTROL_ADMISSION_WINDOW_MS = 2_000;
 export const SANDBOX_CONTROL_STATUS_INTERVAL_MS = 250;
 export const SANDBOX_CONTROL_STATUS_STALE_MS = 1_500;
@@ -26,6 +31,78 @@ export class SandboxControlProtocolError extends Error {
 function fail(code, message, retryable = false) {
     throw new SandboxControlProtocolError(code, message, retryable);
 }
+export function parseSandboxControlResultEvidence(value) {
+    const evidence = value;
+    const keys = evidence && typeof evidence === 'object' ? Object.keys(evidence).sort().join(',') : '';
+    if (keys !== 'captureState,exitCode,generation,id,stderrBytes,stderrSha256,stdoutBytes,stdoutSha256,version'
+        || evidence?.version !== 1
+        || typeof evidence.id !== 'string' || !/^[a-f0-9-]{16,64}$/u.test(evidence.id)
+        || typeof evidence.generation !== 'string' || evidence.generation.length === 0
+        || !Number.isSafeInteger(evidence.exitCode)
+        || !Number.isSafeInteger(evidence.stdoutBytes) || evidence.stdoutBytes < 0
+        || !Number.isSafeInteger(evidence.stderrBytes) || evidence.stderrBytes < 0
+        || evidence.stdoutBytes + evidence.stderrBytes > SANDBOX_CONTROL_MAX_RESPONSE_BYTES
+        || typeof evidence.stdoutSha256 !== 'string' || !/^[a-f0-9]{64}$/u.test(evidence.stdoutSha256)
+        || typeof evidence.stderrSha256 !== 'string' || !/^[a-f0-9]{64}$/u.test(evidence.stderrSha256)
+        || evidence.captureState !== 'metadata-only') {
+        throw new Error('SANDBOX_CONTROL_RESULT_EVIDENCE_INVALID');
+    }
+    return evidence;
+}
+function validPayloadReference(value, id, generation) {
+    const payload = value;
+    const keys = payload && typeof payload === 'object' ? Object.keys(payload).sort().join(',') : '';
+    return keys === 'generation,id,stderrBytes,stderrSha256,stdoutBytes,stdoutSha256,version'
+        && payload?.version === 1
+        && payload.id === id
+        && payload.generation === generation
+        && Number.isSafeInteger(payload.stdoutBytes) && payload.stdoutBytes >= 0
+        && Number.isSafeInteger(payload.stderrBytes) && payload.stderrBytes >= 0
+        && payload.stdoutBytes + payload.stderrBytes <= SANDBOX_CONTROL_MAX_RESPONSE_BYTES
+        && typeof payload.stdoutSha256 === 'string' && /^[a-f0-9]{64}$/u.test(payload.stdoutSha256)
+        && typeof payload.stderrSha256 === 'string' && /^[a-f0-9]{64}$/u.test(payload.stderrSha256);
+}
+export function parseSandboxControlPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+    const payload = value;
+    const reference = {
+        version: payload.version,
+        id: payload.id,
+        generation: payload.generation,
+        stdoutBytes: payload.stdoutBytes,
+        stderrBytes: payload.stderrBytes,
+        stdoutSha256: payload.stdoutSha256,
+        stderrSha256: payload.stderrSha256
+    };
+    const keys = Object.keys(payload).sort().join(',');
+    if (keys !== 'generation,id,stderr,stderrBytes,stderrSha256,stdout,stdoutBytes,stdoutSha256,version'
+        || !validPayloadReference(reference, reference.id, reference.generation)
+        || typeof payload.stdout !== 'string' || typeof payload.stderr !== 'string'
+        || Buffer.byteLength(payload.stdout, 'utf8') !== payload.stdoutBytes
+        || Buffer.byteLength(payload.stderr, 'utf8') !== payload.stderrBytes
+        || createHash('sha256').update(payload.stdout, 'utf8').digest('hex') !== payload.stdoutSha256
+        || createHash('sha256').update(payload.stderr, 'utf8').digest('hex') !== payload.stderrSha256) {
+        throw new Error('SANDBOX_CONTROL_PAYLOAD_INVALID');
+    }
+    return payload;
+}
+export function parseSandboxControlReservation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('SANDBOX_CONTROL_RESERVATION_INVALID');
+    const reservation = value;
+    const keys = Object.keys(reservation).sort().join(',');
+    if (keys !== 'bytes,createdAt,generation,id,logicalRecords,version'
+        || reservation.version !== 1
+        || typeof reservation.id !== 'string' || !/^[a-f0-9-]{16,64}$/u.test(reservation.id)
+        || typeof reservation.generation !== 'string' || reservation.generation.length === 0
+        || reservation.logicalRecords !== 1
+        || !Number.isSafeInteger(reservation.bytes) || reservation.bytes < SANDBOX_CONTROL_RESERVATION_BYTES
+        || !Number.isSafeInteger(reservation.createdAt)) {
+        throw new Error('SANDBOX_CONTROL_RESERVATION_INVALID');
+    }
+    return reservation;
+}
 export function isSandboxControlFamily(value) {
     return SANDBOX_CONTROL_FAMILIES.includes(value);
 }