@fitlab-ai/agent-infra 0.9.13 → 0.9.14

package/dist/lib/sandbox/commands/show.js

@@ -7,6 +7,7 @@ import { fetchSandboxRows, selectSandboxContainer } from './list-running.js';
 import { resolveTools, toolConfigDirCandidates } from '../tools.js';
 import { detectEngine } from '../engine.js';
 import { resolveSandboxTarget } from '../workspace-identity.js';
+import { readSandboxControlStatusForRow } from './control-status.js';
 const USAGE = `Usage: ai sandbox show <branch | TASK-id | N>
 
 Shows one sandbox's worktree path and per-tool state paths (Claude Code,
@@ -62,6 +63,21 @@ export function show(args = []) {
     p.log.step('Workspace identity');
     process.stdout.write(`  Mode: ${container?.workspaceMode ?? 'legacy-invalid'}\n`);
     process.stdout.write(`  Task: ${container?.taskId ?? '-'}\n`);
+    p.log.step('Control status');
+    const controlStatus = container
+        ? readSandboxControlStatusForRow(config, container)
+        : null;
+    if (!controlStatus) {
+        p.log.warn('  Control status unavailable');
+    }
+    else {
+        process.stdout.write(`  Health: ${controlStatus.state}\n`);
+        process.stdout.write(`  Task view: ${controlStatus.taskView.state}\n`);
+        process.stdout.write(`  Task source: ${controlStatus.taskView.observedSource ?? '-'}\n`);
+        if (controlStatus.taskView.reasonCode) {
+            process.stdout.write(`  Task view reason: ${controlStatus.taskView.reasonCode}\n`);
+        }
+    }
     for (const tool of detail.toolStates) {
         p.log.step(`${tool.name} state`);
         if (tool.entries.length === 0) {

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

@@ -4,7 +4,54 @@ 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 { readSandboxControlPayload, readSandboxControlStatus } from './state.js';
+import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
+export function classifySandboxControlEnvironment(env = process.env) {
+    const controlKeys = [
+        'AGENT_INFRA_CONTROL_TOKEN',
+        'AGENT_INFRA_CONTROL_GENERATION',
+        'AGENT_INFRA_CONTROL_DIR',
+        'AGENT_INFRA_CONTROL_STATUS_DIR'
+    ];
+    const hasControlMarker = controlKeys.some((key) => Boolean(env[key]));
+    const hasTaskIdentity = Boolean(env.AGENT_INFRA_TASK_ID);
+    const hasRuntime = Boolean(env.AGENT_INFRA_RUNTIME_DIR);
+    const hasExecutorMarker = Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
+    const hasControllerBinding = Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING);
+    const hasAnyMarker = hasControlMarker || hasTaskIdentity || hasRuntime || hasExecutorMarker || hasControllerBinding;
+    const hasCompleteControl = controlKeys.every((key) => Boolean(env[key]));
+    if (!hasAnyMarker)
+        return { kind: 'direct' };
+    if (hasExecutorMarker) {
+        return {
+            kind: 'invalid',
+            code: 'TASK_CONTROL_TRANSPORT_INVALID',
+            message: 'executor context is only valid for sandbox-control execute'
+        };
+    }
+    if (hasControllerBinding) {
+        return {
+            kind: 'invalid',
+            code: 'TASK_CONTROL_TRANSPORT_INVALID',
+            message: 'sandbox client control configuration is incomplete or conflicting'
+        };
+    }
+    if (!hasCompleteControl) {
+        return {
+            kind: 'invalid',
+            code: 'TASK_CONTROL_TRANSPORT_INVALID',
+            message: 'sandbox client control configuration is incomplete or conflicting'
+        };
+    }
+    if (hasTaskIdentity !== hasRuntime) {
+        return {
+            kind: 'invalid',
+            code: 'TASK_CONTROL_TRANSPORT_INVALID',
+            message: 'sandbox task identity and runtime binding must be provided together'
+        };
+    }
+    return { kind: 'controlled', mode: hasTaskIdentity ? 'task-bound' : 'branch-only' };
+}
 export class SandboxControlClientError extends Error {
     detail;
     accepted;
@@ -23,7 +70,12 @@ function sleep(milliseconds) {
 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()) {
+function hasTaskBoundMarker(env = process.env) {
+    return Boolean(env.AGENT_INFRA_TASK_ID)
+        && Boolean(env.AGENT_INFRA_CONTROL_TOKEN || env.AGENT_INFRA_CONTROL_GENERATION
+            || env.AGENT_INFRA_CONTROL_STATUS_DIR || env.AGENT_INFRA_RUNTIME_DIR || env.AGENT_INFRA_CONTROL_DIR);
+}
+function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(), env = process.env) {
     let status;
     try {
         status = readSandboxControlStatus(statusDir);
@@ -45,8 +97,25 @@ function preflight(statusDir, generation, now = Date.now()) {
     }
     if (status.state !== 'healthy')
         clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', 'broker is not ready', true);
+    if (taskViewEffect && hasTaskBoundMarker(env)) {
+        const view = taskViewFromStatus(status);
+        if (view.taskId !== env.AGENT_INFRA_TASK_ID) {
+            clientError('SANDBOX_TASK_VIEW_TASK_ID_MISMATCH', 'task view task id does not match the sandbox task marker', false);
+        }
+        const access = accessSandboxTaskView(view, taskViewEffect);
+        if (!access.allowed) {
+            clientError(access.reasonCode ?? 'SANDBOX_TASK_VIEW_DENIED', access.message ?? 'task view denied', false);
+        }
+    }
+}
+function taskViewEffectForRequest(request) {
+    if (request.family === 'task-lifecycle' || request.family === 'task-finalization')
+        return 'progress';
+    if (request.family === 'task-orchestration')
+        return request.args[1] === 'status' ? 'diagnostic' : 'progress';
+    return null;
 }
-function parseResponse(raw, id) {
+function parseResponse(raw, id, accepted = false) {
     const response = JSON.parse(raw);
     if (response.version !== 2 || response.id !== id
         || !['completed', 'rejected'].includes(response.phase)
@@ -54,12 +123,12 @@ function parseResponse(raw, id) {
         || (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);
+        clientError('SANDBOX_CONTROL_RESPONSE_INVALID', 'broker response is invalid', false, accepted, id);
     }
     return response;
 }
-function readPublishedResponse(raw, id, channelDir) {
-    const response = parseResponse(raw, id);
+function readPublishedResponse(raw, id, channelDir, accepted = false) {
+    const response = parseResponse(raw, id, accepted);
     if (response.outputState !== 'available')
         return response;
     const filePath = path.join(channelDir, 'responses', `${id}.payload.json`);
@@ -92,7 +161,8 @@ function cancelPendingRequest(requestPath) {
 function exchangeSandboxControl(request, params) {
     const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
     const statusDir = params.statusDir ?? process.env.AGENT_INFRA_CONTROL_STATUS_DIR ?? '/run/agent-infra/control-status';
-    preflight(statusDir, request.generation);
+    const taskViewEffect = taskViewEffectForRequest(request);
+    preflight(statusDir, request.generation, taskViewEffect);
     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, false, request.id);
@@ -127,7 +197,9 @@ function exchangeSandboxControl(request, params) {
             }
             let response;
             try {
-                response = readPublishedResponse(raw, request.id, channelDir);
+                // 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);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -153,7 +225,7 @@ function exchangeSandboxControl(request, params) {
         }
         if (!accepted) {
             try {
-                preflight(statusDir, request.generation);
+                preflight(statusDir, request.generation, taskViewEffect);
             }
             catch (error) {
                 if (cancelPendingRequest(requestPath))
@@ -196,7 +268,9 @@ export function recoverSandboxControl(requestId, params = {}) {
             }
             let response;
             try {
-                response = readPublishedResponse(raw, requestId, channelDir);
+                // 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);
                 malformedResponseRaw = null;
             }
             catch (error) {

package/dist/lib/sandbox/control/completed-reentry.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveTaskWorkspace } from '../task-resolver.js';
+import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
+import { parseTypedTaskFrontmatter } from '../../task/frontmatter.js';
+import { readTaskFinalizationReceipt } from '../../task/finalization.js';
+import { inspectSandboxControlContainer } from './container-identity.js';
+import { atomicWriteJson, readSandboxControlStatus } from './state.js';
+import { taskViewForManifest } from './task-view.js';
+function evidencePath(manifest) {
+    return path.join(path.dirname(manifest.processingDir), 'completed-reentry.json');
+}
+function invalid() {
+    return new Error('SANDBOX_COMPLETED_REENTRY_EVIDENCE_INVALID');
+}
+export async function prepareCompletedReentry(manifest, inspect = inspectSandboxControlContainer) {
+    if (manifest.mode !== 'task-bound' || !manifest.taskId)
+        throw invalid();
+    assertGitWorktreeBinding(manifest.repoRoot, manifest.worktreeRoot, manifest.branch);
+    const container = await inspect(manifest);
+    if (container.state !== 'found' || container.id !== manifest.containerIdentity.id)
+        throw invalid();
+    const task = resolveTaskWorkspace(manifest.taskId, manifest.repoRoot);
+    const metadata = parseTypedTaskFrontmatter(fs.readFileSync(task.taskMd, 'utf8'));
+    if (task.state !== 'completed' || task.branch !== manifest.branch
+        || metadata.id !== manifest.taskId || metadata.status !== 'completed')
+        throw invalid();
+    const receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
+    if (!receipt || receipt.taskId !== manifest.taskId)
+        throw invalid();
+    const view = taskViewForManifest({ ...manifest, receipt });
+    if (view.state !== 'current' || view.observedSource !== 'completed' || !view.receipt)
+        throw invalid();
+    const status = readSandboxControlStatus(manifest.publicStatusDir);
+    const previous = status.taskView;
+    if (status.generation !== manifest.generation || status.activeRequestId !== null
+        || previous.taskId !== manifest.taskId || !previous.receipt
+        || previous.receipt.receiptId !== view.receipt.receiptId
+        || previous.receipt.generation !== view.receipt.generation
+        || previous.receipt.requestId !== view.receipt.requestId
+        || previous.receipt.revision > view.receipt.revision)
+        throw invalid();
+    const completedRoot = fs.realpathSync.native(path.join(manifest.repoRoot, '.agents', 'workspace', 'completed'));
+    const source = fs.realpathSync.native(path.join(completedRoot, manifest.taskId));
+    if (source !== path.join(completedRoot, manifest.taskId))
+        throw invalid();
+    const stat = fs.statSync(source, { bigint: true });
+    return {
+        taskId: manifest.taskId, generation: manifest.generation,
+        containerId: container.id, branch: manifest.branch,
+        worktreeRoot: fs.realpathSync.native(manifest.worktreeRoot),
+        source, sourceDevice: String(stat.dev), sourceInode: String(stat.ino), receipt: view.receipt
+    };
+}
+export function publishCompletedReentry(manifest, evidence) {
+    atomicWriteJson(evidencePath(manifest), evidence);
+}
+export async function completedReentryView(manifest, inspect = inspectSandboxControlContainer) {
+    const file = evidencePath(manifest);
+    if (!fs.existsSync(file))
+        return null;
+    const evidence = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const current = await prepareCompletedReentry(manifest, inspect);
+    if (JSON.stringify(evidence) !== JSON.stringify(current))
+        throw invalid();
+    return {
+        state: 'current', taskId: current.taskId, observedSource: 'completed',
+        receipt: current.receipt, reasonCode: null
+    };
+}
+export async function waitForCompletedReentry(manifest, evidence) {
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        const status = readSandboxControlStatus(manifest.publicStatusDir);
+        if (status.generation !== evidence.generation)
+            throw invalid();
+        if (status.taskView.state === 'current' && status.taskView.observedSource === 'completed'
+            && status.taskView.taskId === evidence.taskId
+            && JSON.stringify(status.taskView.receipt) === JSON.stringify(evidence.receipt))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error('SANDBOX_COMPLETED_REENTRY_STATUS_TIMEOUT');
+}
+//# sourceMappingURL=completed-reentry.js.map

package/dist/lib/sandbox/control/container-identity.js

@@ -1,15 +1,11 @@
-import { commandForEngine, runEngine, runProbe } from '../shell.js';
-function isAuthoritativeNotFound(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /(?:no such (?:container|object)|container .* not found|cannot find container)/i.test(message);
-}
+import { runProbe } from '../shell.js';
+import { captureSandboxAuthority, isSandboxAuthorityEvidence, verifySandboxAuthority } from '../engines/authority.js';
+import { discoverExactContainer } from '../engines/docker-exact-discovery.js';
 export function classifySandboxContainerInspection(expected, inspection) {
     if ('notFound' in inspection)
         return { state: 'absent', id: expected.id };
     if ('error' in inspection) {
-        return isAuthoritativeNotFound(inspection.error)
-            ? { state: 'absent', id: expected.id }
-            : { state: 'unknown', reason: `container inspection failed: ${inspection.error instanceof Error ? inspection.error.message : String(inspection.error)}` };
+        return { state: 'unknown', reason: `container inspection failed: ${inspection.error instanceof Error ? inspection.error.message : String(inspection.error)}` };
     }
     const response = inspection;
     if (typeof response.id !== 'string' || response.id !== expected.id
@@ -30,32 +26,33 @@ export function classifySandboxContainerInspection(expected, inspection) {
     };
 }
 export async function inspectSandboxControlContainer(manifest, options = {}) {
+    if (!isSandboxAuthorityEvidence(manifest.authorityEvidence)) {
+        return { state: 'unknown', reason: 'SANDBOX_AUTHORITY_EVIDENCE_MISSING' };
+    }
     try {
-        const args = ['inspect', '--format', '{{json .}}', manifest.containerIdentity.id];
-        let raw;
-        if (options.run) {
-            raw = options.run(manifest.engine, 'docker', args, options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs });
-        }
-        else {
-            const command = commandForEngine(manifest.engine, 'docker', args);
-            const result = (options.probe ?? runProbe)(command.cmd, command.args, options.timeoutMs === undefined ? {} : { timeout: options.timeoutMs });
-            if (result.status !== 0) {
-                const stderr = typeof result.stderr === 'string' ? result.stderr : result.stderr?.toString('utf8') ?? '';
-                return classifySandboxContainerInspection(manifest.containerIdentity, {
-                    error: new Error(stderr || `container inspection exited with ${result.status ?? 'unknown'}`)
-                });
-            }
-            raw = typeof result.stdout === 'string' ? result.stdout : result.stdout?.toString('utf8') ?? '';
+        const authority = captureSandboxAuthority(manifest.engine, {
+            probe: options.probe,
+            timeoutMs: options.timeoutMs,
+            lockDomain: manifest.authorityEvidence.lockDomain,
+            route: manifest.authorityEvidence
+        });
+        const authorityState = verifySandboxAuthority(manifest.authorityEvidence, authority);
+        if (authorityState.state !== 'verified') {
+            return { state: 'unknown', reason: authorityState.reason ?? 'SANDBOX_AUTHORITY_UNAVAILABLE' };
         }
-        const parsed = JSON.parse(raw);
-        const value = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
-        if (!value || Array.isArray(value))
-            return { state: 'unknown', reason: 'container inspection response is incomplete' };
-        return classifySandboxContainerInspection(manifest.containerIdentity, {
-            id: value.Id,
-            running: value.State?.Running,
-            labels: value.Config?.Labels
+        const discovered = discoverExactContainer(manifest.engine, manifest.containerIdentity.id, {
+            probe: options.probe,
+            timeoutMs: options.timeoutMs,
+            authority: manifest.authorityEvidence
         });
+        if (discovered.state === 'absent')
+            return { state: 'absent', id: discovered.id };
+        if (discovered.state === 'conflict') {
+            return { state: 'unknown', reason: `SANDBOX_CONTROL_CONTAINER_CONFLICT: ${discovered.reason}` };
+        }
+        if (discovered.state === 'unknown')
+            return discovered;
+        return classifySandboxContainerInspection(manifest.containerIdentity, discovered);
     }
     catch (error) {
         return classifySandboxContainerInspection(manifest.containerIdentity, { error });

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

@@ -1,12 +1,12 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { getProcessStartTime } from '../../server/process-state.js';
-import { createTask } from '../../task/create-service.js';
+import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
 import { applyTaskFinalization } from '../../task/finalization.js';
 import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
-import { atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
+import { appendSandboxControlAudit, atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.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';
@@ -30,6 +30,57 @@ export function assertSandboxControlExecutorAuthority(manifest, gateOwner) {
 function safeEnv(env) {
     return Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')));
 }
+function safeRealpath(value) {
+    try {
+        return fs.realpathSync.native(value);
+    }
+    catch {
+        return null;
+    }
+}
+function appendExecutorAudit(manifest, event, fields = {}) {
+    try {
+        appendSandboxControlAudit(manifest, event, { source: 'executor', ...fields });
+    }
+    catch {
+        // Diagnostics must never change the control protocol.
+    }
+}
+function requestAuditFields(manifest, manifestPath, request) {
+    const args = 'args' in request ? request.args : [];
+    const encodedArgs = JSON.stringify(args);
+    return {
+        requestId: request.id,
+        requestFamily: request.family,
+        sandboxTaskId: manifest.taskId,
+        requestGeneration: request.generation,
+        requestIssuedAt: request.issuedAt,
+        requestExpiresAt: request.expiresAt,
+        requestArgCount: args.length,
+        requestArgsSha256: createHash('sha256').update(encodedArgs, 'utf8').digest('hex'),
+        requestTaskRef: args[0] ?? null,
+        requestCommand: args[1] ?? null,
+        controllerProofPresent: request.controllerProof !== null,
+        hostCwd: process.cwd(),
+        manifestPath,
+        manifestPathRealpath: safeRealpath(manifestPath),
+        repoRoot: manifest.repoRoot,
+        repoRootRealpath: safeRealpath(manifest.repoRoot),
+        worktreeRoot: manifest.worktreeRoot,
+        worktreeRootRealpath: safeRealpath(manifest.worktreeRoot),
+        runtimeDir: manifest.runtimeDir,
+        runtimeDirRealpath: safeRealpath(manifest.runtimeDir)
+    };
+}
+function resultAuditFields(result) {
+    return {
+        exitCode: result.exitCode,
+        stdoutBytes: Buffer.byteLength(result.stdout, 'utf8'),
+        stderrBytes: Buffer.byteLength(result.stderr, 'utf8'),
+        stdoutSha256: createHash('sha256').update(result.stdout, 'utf8').digest('hex'),
+        stderrSha256: createHash('sha256').update(result.stderr, 'utf8').digest('hex')
+    };
+}
 export function nodeEntryArgs(entry, args) {
     return path.extname(entry) === '.ts'
         ? ['--experimental-strip-types', '--no-warnings', entry, ...args]
@@ -174,6 +225,20 @@ function lifecycleFailure(code, message) {
         stderr: ''
     };
 }
+function taskCreateExecutionResult(result) {
+    return {
+        exitCode: taskCreateExitCode(result),
+        stdout: `${JSON.stringify(result)}\n`,
+        stderr: ''
+    };
+}
+function taskCreateExecutionFailure(requestId, code, message) {
+    return taskCreateExecutionResult(taskCreateFailure({ code, message, retryable: false }, {
+        requestId,
+        accepted: true,
+        recovery: 'inspect-domain-state'
+    }));
+}
 function finalizationResult(result) {
     const payload = {
         version: 1,
@@ -189,14 +254,21 @@ function finalizationResult(result) {
         stderr: ''
     };
 }
-export async function executeRequest(manifest, manifestPath, request, options = {}) {
+async function executeRequestInner(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
-        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`,
-            stderr: ''
-        };
+        try {
+            const result = await createTask(request.candidate, { repoRoot: manifest.repoRoot });
+            return taskCreateExecutionResult(projectTaskCreateResult(result, {
+                requestId: request.id,
+                accepted: true,
+                recovery: 'none'
+            }));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const code = /^([A-Z][A-Z0-9_]+)/u.exec(detail)?.[1] ?? 'TASK_CREATE_EXECUTION_FAILED';
+            return taskCreateExecutionFailure(request.id, code, detail);
+        }
     }
     if (request.family === 'codex-controller') {
         try {
@@ -239,6 +311,16 @@ export async function executeRequest(manifest, manifestPath, request, options =
             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, manifestPath, request),
+                controllerCommand: request.command,
+                errorCode,
+                errorType: error instanceof Error ? error.name : typeof error,
+            });
             return controllerFailure(error);
         }
     }
@@ -300,6 +382,14 @@ export async function executeRequest(manifest, manifestPath, request, options =
             return orchestrationFailure('CODEX_SANDBOX_CONTROLLER_PROOF_INVALID', 'Controller proof is only accepted for canonical Codex prepare');
         }
     }
+    const diagnosticLog = (event, fields) => {
+        appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            ...fields
+        });
+    };
     const context = createSandboxExecutorExecutionContext({
         repoRoot: manifest.repoRoot,
         worktreeRoot: manifest.worktreeRoot,
@@ -308,6 +398,7 @@ export async function executeRequest(manifest, manifestPath, request, options =
         generation: manifest.generation,
         manifestPath,
         requestId: request.id,
+        diagnosticLog,
         ...(controllerBinding ? { controllerBinding } : {})
     });
     const format = (value) => {
@@ -327,6 +418,29 @@ export async function executeRequest(manifest, manifestPath, request, options =
         throw new Error('SANDBOX_CONTROL_LIFECYCLE_OPERATION_INVALID');
     return format(await dispatchTaskControlOperation(context, operation));
 }
+export async function executeRequest(manifest, manifestPath, request, options = {}) {
+    const fields = requestAuditFields(manifest, manifestPath, request);
+    appendExecutorAudit(manifest, 'executor-request-start', fields);
+    try {
+        const result = await executeRequestInner(manifest, manifestPath, request, options);
+        appendExecutorAudit(manifest, 'executor-request-finished', {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            ...resultAuditFields(result)
+        });
+        return result;
+    }
+    catch (error) {
+        appendExecutorAudit(manifest, 'executor-request-failed', {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            errorType: error instanceof Error ? error.name : typeof error,
+        });
+        throw error;
+    }
+}
 export async function runSandboxControlExecutor(requestPath, nonce) {
     const gateOwner = await waitForGate(nonce);
     process.disconnect?.();
@@ -335,14 +449,29 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         throw new Error('SANDBOX_CONTROL_EXECUTOR_MANIFEST_MISSING');
     const manifest = readSandboxControlManifest(manifestPath);
     const root = fs.realpathSync.native(process.cwd());
-    if (fs.realpathSync.native(manifest.repoRoot) !== root)
+    const expectedRoot = safeRealpath(manifest.repoRoot);
+    if (expectedRoot !== root) {
+        appendExecutorAudit(manifest, 'executor-root-validation-failed', {
+            hostCwd: process.cwd(),
+            observedRoot: root,
+            expectedRoot
+        });
         throw new Error('SANDBOX_CONTROL_EXECUTOR_ROOT_INVALID');
+    }
     const raw = JSON.parse(fs.readFileSync(requestPath, 'utf8'));
     const request = validateSandboxControlRequest(raw, manifest);
+    appendExecutorAudit(manifest, 'executor-request-validated', requestAuditFields(manifest, manifestPath, request));
     const requestDirectory = path.resolve(path.dirname(requestPath));
     const processingDirectory = path.resolve(path.join(manifest.processingDir, request.id));
     const channelRequestDirectory = path.resolve(path.join(manifest.channelDir, 'requests'));
     if (requestDirectory !== processingDirectory && requestDirectory !== channelRequestDirectory) {
+        appendExecutorAudit(manifest, 'executor-request-path-validation-failed', {
+            ...requestAuditFields(manifest, manifestPath, request),
+            requestPath,
+            requestDirectory,
+            processingDirectory,
+            channelRequestDirectory
+        });
         throw new Error('SANDBOX_CONTROL_EXECUTOR_REQUEST_INVALID');
     }
     let result;
@@ -351,6 +480,10 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         result = await executeRequest(manifest, manifestPath, request);
     }
     catch (error) {
+        appendExecutorAudit(manifest, 'executor-authority-or-dispatch-failed', {
+            ...requestAuditFields(manifest, manifestPath, request),
+            errorType: error instanceof Error ? error.name : typeof error,
+        });
         const detail = error instanceof Error ? error.message : String(error);
         const code = /^([A-Z][A-Z0-9_]+)/u.exec(detail)?.[1] ?? 'SANDBOX_CONTROL_EXECUTOR_FAILED';
         result = request.family === 'task-finalization'
@@ -362,9 +495,11 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
                 })}\n`,
                 stderr: ''
             }
-            : request.family === 'task-lifecycle'
-                ? lifecycleFailure(code, detail)
-                : orchestrationFailure(code, detail);
+            : request.family === 'task-create'
+                ? taskCreateExecutionFailure(request.id, code, detail)
+                : request.family === 'task-lifecycle'
+                    ? lifecycleFailure(code, detail)
+                    : orchestrationFailure(code, detail);
     }
     process.stdout.write(result.stdout);
     process.stderr.write(result.stderr);