@fitlab-ai/agent-infra 0.11.10 → 0.11.12

package/dist/lib/sandbox/control/agent-operation.js

@@ -0,0 +1,34 @@
+import { getAgentClientAdapter } from '../../agent-clients/registry.js';
+function operationFor(request) {
+    const adapter = getAgentClientAdapter(request.agentClient);
+    const operation = adapter.sandboxControlOperation;
+    if (!operation)
+        throw new Error('SANDBOX_CONTROL_AGENT_OPERATION_UNSUPPORTED');
+    return operation;
+}
+function validateAgentClientOperation(request, manifest) {
+    operationFor(request).validate({
+        operation: request.operation,
+        payload: request.payload,
+        manifest
+    });
+}
+function executeAgentClientOperation(request, manifest, manifestPath, override) {
+    return (override ?? operationFor(request)).execute({
+        operation: request.operation,
+        payload: request.payload,
+        manifest,
+        manifestPath
+    });
+}
+function recoverAgentClientOperation(params) {
+    const operation = operationFor(params.request);
+    return operation.recover?.({
+        operation: params.request.operation,
+        manifest: params.manifest,
+        manifestPath: params.manifestPath,
+        stdout: params.stdout
+    }) ?? { consistent: false };
+}
+export { executeAgentClientOperation, recoverAgentClientOperation, validateAgentClientOperation };
+//# sourceMappingURL=agent-operation.js.map

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

@@ -1,13 +1,16 @@
 import fs from 'node:fs';
-import { hasTaskBoundMarker } from '../../internal/task-operation-registry.js';
 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 { isAgentClientId } from '../../agent-clients/types.js';
 import { normalizeAgentToken } from '../../agent-clients/tokens.js';
 import { readSandboxControlPayload, readSandboxControlStatus } from './state.js';
 import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.js';
 import { configuredShortIdLength, resolveShortIdReadOnly } from '../../task/short-id.js';
+import { hasTaskBoundMarker, isSandbox } from '../environment.js';
+import { loadConfig } from '../config.js';
+import { recoverSandboxControlFromHost } from './host-recovery.js';
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
 const SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS = 5 * 60_000;
 export class SandboxControlClientError extends Error {
@@ -98,7 +101,7 @@ function parseResponse(raw, id, accepted = false) {
     }
     return response;
 }
-function readPublishedResponse(raw, id, channelDir, accepted = false) {
+function readPublishedResponse(raw, id, channelDir, accepted, generation) {
     const response = parseResponse(raw, id, accepted);
     if (response.outputState !== 'available')
         return response;
@@ -112,6 +115,7 @@ function readPublishedResponse(raw, id, channelDir, accepted = false) {
     }
     if (!response.payload || response.payload.version !== payload.version
         || response.payload.id !== payload.id || response.payload.generation !== payload.generation
+        || payload.generation !== 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);
@@ -216,7 +220,7 @@ function exchangeSandboxControl(request, params) {
             try {
                 // The request-specific terminal proves the broker claimed the request; preserve recovery evidence if marker cleanup won the race.
                 accepted = true;
-                response = readPublishedResponse(raw, request.id, channelDir, accepted);
+                response = readPublishedResponse(raw, request.id, channelDir, accepted, request.generation);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -264,7 +268,40 @@ 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';
+    try {
+        if (!isSandbox()) {
+            const config = loadConfig();
+            const response = recoverSandboxControlFromHost(requestId, {
+                managedRoot: path.join(config.controlBase, config.project),
+                timeoutMs: params.timeoutMs
+            });
+            if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
+                clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'recovery evidence is unavailable; inspect domain state before retrying', false, true, requestId);
+            }
+            return response;
+        }
+        const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
+        const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
+        const identity = readSandboxControlIdentitySentinel(statusDir);
+        return recoverSandboxControlFromChannel(requestId, {
+            channelDir, generation: identity.generation, timeoutMs: params.timeoutMs
+        });
+    }
+    catch (error) {
+        if (error instanceof SandboxControlClientError)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'SANDBOX_CONTROL_RECOVERY_INVALID';
+        clientError(code, 'sandbox control recovery evidence is invalid or unavailable', false, true, requestId);
+    }
+}
+// Low-level channel reader for control integration tests and internal callers
+// that already hold a manifest-bound channel path.
+export function recoverSandboxControlFromChannel(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;
     const responsePath = path.join(channelDir, 'responses', `${requestId}.json`);
     const deadline = Date.now() + (params.timeoutMs ?? 30_000);
     let accepted = false;
@@ -287,7 +324,7 @@ export function recoverSandboxControl(requestId, params = {}) {
             try {
                 // The request-specific terminal proves the broker claimed the request; preserve recovery evidence if marker cleanup won the race.
                 accepted = true;
-                response = readPublishedResponse(raw, requestId, channelDir, accepted);
+                response = readPublishedResponse(raw, requestId, channelDir, accepted, params.generation);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -332,17 +369,34 @@ function authority(params) {
 export function requestSandboxControl(params) {
     if (!isSandboxControlFamily(params.family))
         clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' is not allowed`, false);
-    if (params.family === 'task-create' || params.family === 'codex-controller' || params.family === 'task-finalization') {
+    if (params.family === 'task-create' || params.family === 'agent-client' || params.family === 'task-finalization') {
         clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, false);
     }
     const auth = authority(params);
     const issuedAt = Date.now();
     const request = {
-        version: 3, id: randomUUID(), ...auth, issuedAt,
+        version: 4, id: randomUUID(), ...auth, issuedAt,
+        expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
+        family: params.family, args: params.args
+    };
+    return exchangeSandboxControl(request, params);
+}
+export function requestSandboxAgentOperation(params) {
+    if (!isAgentClientId(params.agentClient)) {
+        clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'agent-client id is invalid', false);
+    }
+    const auth = authority(params);
+    const issuedAt = Date.now();
+    const request = {
+        version: 4,
+        id: randomUUID(),
+        ...auth,
+        issuedAt,
         expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-        family: params.family, args: params.args,
-        controllerProcess: null,
-        controllerProof: null
+        family: 'agent-client',
+        agentClient: params.agentClient,
+        operation: params.operation,
+        payload: params.payload
     };
     return exchangeSandboxControl(request, params);
 }
@@ -353,9 +407,8 @@ export function requestSandboxTaskFinalization(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const id = randomUUID();
-    const handoffSha256 = (params.prepareHandoff ?? (() => '0'.repeat(64)))({ generation: auth.generation, requestId: id });
     const request = {
-        version: 3,
+        version: 4,
         id,
         ...auth,
         issuedAt,
@@ -363,10 +416,7 @@ export function requestSandboxTaskFinalization(params) {
         family: 'task-finalization',
         operation: 'complete',
         agent,
-        handoffSha256,
-        args: [],
-        controllerProcess: null,
-        controllerProof: null
+        args: []
     };
     let response;
     try {
@@ -391,7 +441,7 @@ export function recoverAcceptedTaskFinalization(requestId, params, recover = rec
         if (timeoutMs <= 0)
             break;
         try {
-            const response = recover(requestId, { channelDir: params.channelDir, timeoutMs });
+            const response = recover(requestId, { timeoutMs });
             if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
                 continue;
             return response;
@@ -406,156 +456,13 @@ export function recoverAcceptedTaskFinalization(requestId, params, recover = rec
     }
     clientError('SANDBOX_CONTROL_RESULT_UNKNOWN', 'accepted finalization request remained unknown after the automatic recovery budget; inspect the receipt and resume by request id', false, true, requestId);
 }
-function exactKeys(value, keys) {
-    return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
-}
-function validProcess(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const identity = value;
-    return exactKeys(identity, ['pid', 'startTime'])
-        && Number.isSafeInteger(identity.pid) && identity.pid > 0
-        && Number.isSafeInteger(identity.startTime) && identity.startTime >= 0;
-}
-function validBuild(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const build = value;
-    return exactKeys(build, ['internalExecutableBuildHash', 'lifecycleContractHash', 'packageVersion', 'protocolVersion'])
-        && build.protocolVersion === 3
-        && typeof build.packageVersion === 'string' && build.packageVersion.length > 0
-        && typeof build.internalExecutableBuildHash === 'string' && /^[a-f0-9]{64}$/u.test(build.internalExecutableBuildHash)
-        && typeof build.lifecycleContractHash === 'string' && /^[a-f0-9]{64}$/u.test(build.lifecycleContractHash);
-}
-export function parseCodexControllerResult(response) {
-    if (response.phase !== 'completed' || response.error !== null || response.stderr !== '') {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller result outer response is invalid', false, true);
-    }
-    let value;
-    try {
-        if (!response.stdout.endsWith('\n') || response.stdout.slice(0, -1).includes('\n'))
-            throw new Error('not canonical');
-        value = JSON.parse(response.stdout);
-    }
-    catch {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller result payload is invalid', false, true);
-    }
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller result payload is invalid', false, true);
-    }
-    const result = value;
-    const resultKeys = result.status === 'verified'
-        ? ['binding', 'changed', 'error', 'lease', 'status', 'version']
-        : ['changed', 'error', 'lease', 'status', 'version'];
-    if (!exactKeys(result, resultKeys)
-        || result.version !== 1 || !['opened', 'closed', 'failed', 'verified'].includes(result.status)) {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller result schema is invalid', false, true);
-    }
-    if (result.status === 'failed') {
-        const error = result.error;
-        if (response.exitCode !== 1 || result.changed !== false || result.lease !== null
-            || !error || !exactKeys(error, ['code', 'message', 'retryable'])
-            || typeof error.code !== 'string' || !/^[A-Z][A-Z0-9_]+$/u.test(error.code)
-            || typeof error.message !== 'string' || error.retryable !== false) {
-            clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller failure result is invalid', false, true);
-        }
-        clientError(error.code, error.message, false, true);
-    }
-    if (response.exitCode !== 0 || result.error !== null) {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller success result is invalid', false, true);
-    }
-    if (result.status === 'closed') {
-        if (typeof result.changed !== 'boolean' || result.lease !== null) {
-            clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller close result is invalid', false, true);
-        }
-        return result;
-    }
-    if (result.status === 'verified') {
-        const binding = result.binding;
-        if (result.changed !== false || result.lease !== null || !binding
-            || !exactKeys(binding, ['controllerInstanceDigest', 'controlGeneration', 'taskId'])
-            || typeof binding.taskId !== 'string' || binding.taskId.length === 0
-            || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0
-            || typeof binding.controllerInstanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.controllerInstanceDigest)) {
-            clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller verify result is invalid', false, true);
-        }
-        return result;
-    }
-    const lease = result.lease;
-    if (result.changed !== true || !lease
-        || !exactKeys(lease, [
-            'buildIdentity', 'controlGeneration', 'controllerInstanceDigest', 'controllerProcess',
-            'expiresAt', 'issuedAt', 'leaseId', 'leaseSecret', 'taskId', 'version'
-        ])
-        || lease.version !== 1
-        || typeof lease.leaseId !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.leaseId)
-        || typeof lease.leaseSecret !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.leaseSecret)
-        || typeof lease.taskId !== 'string' || lease.taskId.length === 0
-        || typeof lease.controlGeneration !== 'string' || lease.controlGeneration.length === 0
-        || typeof lease.controllerInstanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.controllerInstanceDigest)
-        || !validProcess(lease.controllerProcess) || !validBuild(lease.buildIdentity)
-        || !Number.isSafeInteger(lease.issuedAt) || !Number.isSafeInteger(lease.expiresAt)
-        || lease.expiresAt <= lease.issuedAt) {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller open result is invalid', false, true);
-    }
-    return result;
-}
-function requestCodexController(params) {
-    const auth = authority(params);
-    const issuedAt = Date.now();
-    const request = {
-        version: 3,
-        id: randomUUID(),
-        ...auth,
-        issuedAt,
-        expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-        family: 'codex-controller',
-        command: params.command,
-        args: [],
-        controllerProcess: params.controllerProcess,
-        controllerProof: params.controllerProof
-    };
-    const result = parseCodexControllerResult(exchangeSandboxControl(request, params));
-    if (result.status === 'opened'
-        && (result.lease.controlGeneration !== auth.generation
-            || result.lease.controllerProcess.pid !== params.controllerProcess.pid
-            || result.lease.controllerProcess.startTime !== params.controllerProcess.startTime)) {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller result does not match the request', false, true);
-    }
-    return result;
-}
-export function requestCodexControllerOpen(params) {
-    const result = requestCodexController({ ...params, command: 'open', controllerProof: null });
-    if (result.status !== 'opened')
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller open returned the wrong result', false, true);
-    return result;
-}
-export function requestCodexControllerClose(params) {
-    const result = requestCodexController({ ...params, command: 'close' });
-    if (result.status !== 'closed')
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller close returned the wrong result', false, true);
-    return result;
-}
-export function requestCodexControllerVerify(params) {
-    const result = requestCodexController({
-        ...params,
-        controllerProcess: params.controllerProof.controllerProcess,
-        command: 'verify'
-    });
-    if (result.status !== 'verified') {
-        clientError('SANDBOX_CONTROL_RESULT_INVALID', 'controller verify returned the wrong result', false, true);
-    }
-    return result;
-}
 export function requestSandboxTaskCreate(params) {
     const auth = authority(params);
     const issuedAt = Date.now();
     const request = {
-        version: 3, id: randomUUID(), ...auth, issuedAt,
+        version: 4, id: randomUUID(), ...auth, issuedAt,
         expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
         family: 'task-create', candidate: params.candidate,
-        controllerProcess: null,
-        controllerProof: null
     };
     return exchangeSandboxControl(request, { ...params, timeoutMs: params.timeoutMs ?? 120_000 });
 }

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

@@ -2,7 +2,6 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
 import { getProcessStartTime } from '../../server/process-state.js';
 import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
 import { applyTaskFinalization } from '../../task/finalization.js';
@@ -13,12 +12,7 @@ import { requestAuditFields, resultAuditFields, appendDiagnosticAudit, createSan
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
 import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../../task/control-authority.js';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest } from './lifecycle.js';
-import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
-import { closeCodexControllerRegistration, CodexControllerRegistrationError, openCodexControllerRegistration, resolveCodexControllerBinding } from './controller-registration.js';
-import { shareBranchDir } from '../constants.js';
-function handoffDirectory(manifest) {
-    return shareBranchDir({ shareBase: path.join(homedir(), '.agent-infra', 'share', manifest.project) }, manifest.branch);
-}
+import { executeAgentClientOperation, validateAgentClientOperation } from './agent-operation.js';
 function sameBrokerOwner(left, right) {
     return left.version === right.version
         && left.pid === right.pid
@@ -174,23 +168,6 @@ function waitForGate(nonce, timeoutMs = 2_000) {
         });
     });
 }
-function controllerFailure(error) {
-    const code = error instanceof CodexControllerRegistrationError
-        ? error.code
-        : /^([A-Z][A-Z0-9_]+)/u.exec(error instanceof Error ? error.message : String(error))?.[1]
-            ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
-    const message = error instanceof CodexControllerRegistrationError
-        ? error.message
-        : `${code}: controller operation failed; inspect the sandbox controller and rebuild the sandbox if needed`;
-    const payload = {
-        version: 1,
-        status: 'failed',
-        changed: false,
-        lease: null,
-        error: { code, message, retryable: false }
-    };
-    return { exitCode: 1, stdout: `${JSON.stringify(payload)}\n`, stderr: '' };
-}
 function lifecycleFailure(code, message) {
     return {
         exitCode: 1,
@@ -233,7 +210,7 @@ function finalizationResult(result) {
 async function executeRequestInner(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
         try {
-            const result = await createTask(request.candidate, { repoRoot: manifest.repoRoot });
+            const result = await (options.createTask ?? createTask)(request.candidate, { repoRoot: manifest.repoRoot });
             return taskCreateExecutionResult(projectTaskCreateResult(result, {
                 requestId: request.id,
                 accepted: true,
@@ -246,65 +223,15 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             return taskCreateExecutionFailure(request.id, code, detail);
         }
     }
-    if (request.family === 'codex-controller') {
-        try {
-            if (request.command === 'verify') {
-                const binding = (options.resolveControllerBinding ?? resolveCodexControllerBinding)({
-                    manifest,
-                    manifestPath,
-                    proof: request.controllerProof,
-                    buildIdentity: (options.buildIdentity ?? computeLifecycleBuildIdentity)(manifest.repoRoot)
-                });
-                return {
-                    exitCode: 0,
-                    stdout: `${JSON.stringify({
-                        version: 1,
-                        status: 'verified',
-                        changed: false,
-                        lease: null,
-                        binding: {
-                            taskId: manifest.taskId,
-                            controlGeneration: binding.controlGeneration,
-                            controllerInstanceDigest: binding.instanceDigest
-                        },
-                        error: null
-                    })}\n`,
-                    stderr: ''
-                };
-            }
-            const result = request.command === 'open'
-                ? openCodexControllerRegistration({
-                    manifest,
-                    manifestPath,
-                    controllerProcess: request.controllerProcess,
-                    buildIdentity: (options.buildIdentity ?? computeLifecycleBuildIdentity)(manifest.repoRoot)
-                })
-                : closeCodexControllerRegistration({
-                    manifest,
-                    manifestPath,
-                    proof: request.controllerProof
-                });
-            return { exitCode: 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
-        }
-        catch (error) {
-            const errorCode = error instanceof CodexControllerRegistrationError
-                ? error.code
-                : /^([A-Z][A-Z0-9_]+)/u.exec(error instanceof Error ? error.message : String(error))?.[1]
-                    ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
-            appendExecutorAudit(manifest, 'controller-operation-failed', {
-                ...requestAuditFields(manifest, request),
-                controllerCommand: request.command,
-                errorCode,
-                errorType: error instanceof Error ? error.name : typeof error,
-            });
-            return controllerFailure(error);
-        }
+    if (request.family === 'agent-client') {
+        validateAgentClientOperation(request, manifest);
+        return executeAgentClientOperation(request, manifest, manifestPath, options.agentClientOperation);
     }
     if (request.family === 'task-finalization') {
         const parsed = parseTaskControlOperation('task-finalization', [manifest.taskId, 'complete', '--agent', request.agent]);
         if (parsed.family !== 'task-finalization')
             throw new Error('SANDBOX_CONTROL_FINALIZATION_OPERATION_INVALID');
-        const operation = { ...parsed, request: { ...parsed.request, handoffSha256: request.handoffSha256 } };
+        const operation = parsed;
         const result = dispatchTaskControlOperation(createSandboxExecutorExecutionContext({
             repoRoot: manifest.repoRoot,
             worktreeRoot: manifest.worktreeRoot,
@@ -312,8 +239,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             taskId: manifest.taskId,
             generation: manifest.generation,
             manifestPath,
-            requestId: request.id,
-            handoffDirectory: handoffDirectory(manifest)
+            requestId: request.id
         }), operation);
         return finalizationResult(await result);
     }
@@ -334,8 +260,7 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
         taskId: manifest.taskId,
         generation: manifest.generation,
         manifestPath,
-        requestId: request.id,
-        handoffDirectory: handoffDirectory(manifest)
+        requestId: request.id
     });
     const format = (value) => {
         const result = value;
@@ -353,7 +278,8 @@ export async function executeRequest(manifest, manifestPath, request, options =
     const fields = requestAuditFields(manifest, request);
     appendExecutorAudit(manifest, 'executor-request-start', fields);
     try {
-        const result = await executeRequestInner(manifest, manifestPath, request, options);
+        let result;
+        result = await executeRequestInner(manifest, manifestPath, request, options);
         appendExecutorAudit(manifest, 'executor-request-finished', {
             requestId: request.id,
             requestFamily: request.family,
@@ -431,13 +357,13 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
                     return null;
                 }
             })()
-            : null;
+            : request.family === 'agent-client' ? request.operation : null;
         const context = createSandboxControlAuditContext(manifest, {
             requestId: request.id,
             family: request.family,
-            operation: operation?.family === 'task-lifecycle'
+            operation: operation && typeof operation === 'object' && 'family' in operation && operation.family === 'task-lifecycle'
                 ? operation.request.intent
-                : request.family === 'task-finalization' ? request.operation : null,
+                : request.family === 'task-finalization' || request.family === 'agent-client' ? request.operation : null,
             phase: 'started-committed',
             outcome: 'in-progress'
         });