@fitlab-ai/agent-infra 0.11.12 → 0.11.14

package/dist/lib/platform/github-client.js

@@ -18,6 +18,32 @@ function boundedFailureDetail(result) {
         ? diagnostic
         : `${diagnostic.slice(0, ERROR_DETAIL_LIMIT)}… [truncated]`;
 }
+function requestDiagnostics(args, request, attempt, errorMessage) {
+    if (process.env.AGENT_INFRA_GH_DIAGNOSTICS !== '1' && !/rate.?limit/iu.test(errorMessage))
+        return '';
+    const apiIndex = args.indexOf('api');
+    const endpoint = apiIndex < 0
+        ? args.slice(0, 2).filter((arg) => !arg.startsWith('-')).join(' ')
+        : args.slice(apiIndex + 1).find((arg) => !arg.startsWith('-') && !arg.includes('=')) || 'unknown';
+    const safeEndpoint = endpoint.startsWith('http')
+        ? (() => {
+            try {
+                const url = new URL(endpoint);
+                return `${url.host}${url.pathname}`;
+            }
+            catch {
+                return 'unknown';
+            }
+        })()
+        : endpoint.split('?')[0] || 'unknown';
+    const methodIndex = args.findIndex((arg) => arg === '-X' || arg === '--method');
+    const methodFromArgs = methodIndex >= 0 ? args[methodIndex + 1] : undefined;
+    const method = methodFromArgs || request.method || (safeEndpoint === 'graphql' ? 'POST' : 'GET');
+    const tokenEnvironment = ['GH_TOKEN', 'GITHUB_TOKEN', 'GH_ENTERPRISE_TOKEN', 'GITHUB_ENTERPRISE_TOKEN']
+        .filter((name) => Boolean(process.env[name]));
+    const configDirOverride = Boolean(process.env.GH_CONFIG_DIR);
+    return ` [gh-diagnostic endpoint=${safeEndpoint} method=${method} attempt=${attempt} tokenEnv=${tokenEnvironment.join(',') || 'none'} ghConfigDirOverride=${configDirOverride}]`;
+}
 function defaultRunner(args, options) {
     const command = process.env.AGENT_INFRA_GH_BIN || 'gh';
     let prefix = [];
@@ -135,14 +161,18 @@ function createGitHubClient(options = {}) {
             if (result.status === 0)
                 return { ok: true, value: result.stdout };
             const error = classifyGitHubFailure(result);
+            const requestDetail = requestDiagnostics(args, request, attempt + 1, error.message);
+            const contextualError = requestDetail
+                ? { ...error, message: `${error.message}${requestDetail}` }
+                : error;
             if (!retryableMethod || !error.requestRetryable)
-                return { ok: false, error: clientError(error) };
+                return { ok: false, error: clientError(contextualError) };
             if (attempt >= delays.length) {
                 return {
                     ok: false,
                     error: error.code === 'NETWORK_TRANSIENT'
-                        ? { ...clientError(error), code: 'NETWORK_RETRY_EXHAUSTED', message: `${error.message} (retry exhausted)` }
-                        : clientError(error)
+                        ? { ...clientError(contextualError), code: 'NETWORK_RETRY_EXHAUSTED', message: `${contextualError.message} (retry exhausted)` }
+                        : clientError(contextualError)
                 };
             }
             sleep(delays[attempt]);

package/dist/lib/platform/release-notes.js

@@ -106,8 +106,8 @@ function configuredPlatform(cwd) {
 }
 async function releaseNoteContext(input, options = {}) {
     const historyLimit = input.historyLimit ?? 3;
-    if (!input.fromTag || !input.toTag || !input.branch || !Number.isInteger(historyLimit) || historyLimit < 1 || historyLimit > 20) {
-        return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'from-tag, to-tag, branch, and a history limit from 1 to 20 are required', retryable: false } };
+    if (!input.fromTag || !input.toTag || !input.branch || !Number.isInteger(historyLimit) || historyLimit < 1 || historyLimit > 100) {
+        return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'from-tag, to-tag, branch, and a history limit from 1 to 100 are required', retryable: false } };
     }
     const cwd = path.resolve(options.cwd || process.cwd());
     const platformType = options.platformType ?? configuredPlatform(cwd);

package/dist/lib/sandbox/commands/control-status.js

@@ -8,7 +8,6 @@ export function readSandboxControlStatusForRow(config, row) {
         : { mode: 'branch-only' };
     const control = sandboxControlPaths({
         base: config.controlBase,
-        repoRoot: config.repoRoot,
         project: config.project,
         container: row.name,
         identity

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

@@ -23,7 +23,7 @@ import { inspectSandboxControlContainer } from '../control/container-identity.js
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from '../mounts.js';
 import { materializeSandboxGitMetadata } from '../git-metadata.js';
-import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTargets, sandboxControlPaths, } from '../workspace-view.js';
+import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTargets, prepareSandboxCompletedTaskMountSource, sandboxControlPaths, } from '../workspace-view.js';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
 import { validateSelinuxDisableEnv } from '../engines/selinux.js';
 import { captureSandboxAuthority, commandForSandboxAuthority, verifySandboxAuthority } from '../engines/authority.js';
@@ -741,7 +741,6 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
     const container = containerName(effectiveConfig, branch);
     const controlPaths = sandboxControlPaths({
         base: effectiveConfig.controlBase,
-        repoRoot: effectiveConfig.repoRoot,
         project: effectiveConfig.project,
         container,
         identity: target.workspace
@@ -1038,7 +1037,10 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                             const taskSource = target.workspace.mode === 'task-bound'
                                 ? assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId)
                                 : null;
-                            prepareSandboxWorkspaceMountTargets(worktree);
+                            const completedTaskSource = target.workspace.mode === 'task-bound'
+                                ? prepareSandboxCompletedTaskMountSource(effectiveConfig.repoRoot, target.workspace.taskId)
+                                : null;
+                            prepareSandboxWorkspaceMountTargets(worktree, target.workspace.mode === 'task-bound' ? target.workspace.taskId : undefined);
                             if (previousCutoverSnapshot) {
                                 assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
                                 if (previousManifest) {
@@ -1076,11 +1078,13 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                 shellConfigHostDir: hostShellConfig.hostDir,
                                 workspaceViewRoot: workspaceView.root,
                                 controlDir: control.channelDir,
+                                ...(target.workspace.mode === 'task-bound' ? { controlRootDir: control.root } : {}),
                                 controlStatusDir: control.statusDir,
                                 ...(target.workspace.mode === 'task-bound' ? { runtimeDir: control.runtimeDir } : {}),
                                 ...(target.workspace.mode === 'task-bound'
                                     ? {
                                         taskSources: [taskSource],
+                                        completedTaskSource: completedTaskSource,
                                         taskId: target.workspace.taskId
                                     }
                                     : {})
@@ -1158,8 +1162,6 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                         ]
                                         : []),
                                     '-e',
-                                    `AGENT_INFRA_CONTROL_TOKEN=${control.token}`,
-                                    '-e',
                                     `AGENT_INFRA_CONTROL_GENERATION=${control.generation}`,
                                     '-e',
                                     'AGENT_INFRA_CONTROL_DIR=/run/agent-infra/control',
@@ -1168,7 +1170,10 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                     '-e',
                                     `AGENT_INFRA_CONTROL_ROOT_ID=${control.controlRootId}`,
                                     ...(target.workspace.mode === 'task-bound'
-                                        ? ['-e', 'AGENT_INFRA_RUNTIME_DIR=/run/agent-infra/runtime']
+                                        ? [
+                                            '-e', 'AGENT_INFRA_CONTROL_ROOT_DIR=/run/agent-infra/control-root',
+                                            '-e', 'AGENT_INFRA_RUNTIME_DIR=/run/agent-infra/runtime'
+                                        ]
                                         : []),
                                     '--label',
                                     `${sandboxRuntimeCapabilityLabel(effectiveConfig)}=${capabilityPlan.runtimeSignature}`,

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

@@ -11,11 +11,10 @@ export { containerListFormat, parseLabels } from './list-running.js';
 const USAGE = `Usage: ai sandbox ls
 
 Lists all containers for the current project. The '#' column is a
-display-only row number; the 'SHORT' column shows the active task short
-id bound to each container's branch (via
-.agents/workspace/active/.short-ids.json), or '-' if no active task is
-bound. Pass the SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').
-A SHORT value of '-' means this container has no active task short id and may
+display-only row number; the 'SHORT' column shows the task short id bound to
+each task-bound container, or '-' if no short id is registered. Pass the
+SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').
+A SHORT value of '-' means this container has no task short id and may
 be eligible for "ai sandbox rm --unbound" cleanup. Use a full TASK-id to
 remove a specific task-bound sandbox.
 

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

@@ -7,7 +7,7 @@ import { sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceM
 import { fetchSandboxRows } from './list-running.js';
 import { rmOne, rmPurge, rmUnbound } from '../removal.js';
 const USAGE = `Usage:
-  ai sandbox rm <branch | TASK-id | short id> Remove one sandbox; use a full TASK-id for a task-bound sandbox and a branch for branch-only sandboxes
+  ai sandbox rm <branch | TASK-id | short id> Remove one sandbox; use a retained short id or full TASK-id for a task-bound sandbox and a branch for branch-only sandboxes
   ai sandbox rm --unbound [--dry-run] [--yes] Remove sandboxes not bound to an active task short id
   ai sandbox rm --purge                     Tear down ALL sandboxes for the project (containers, worktrees, image, VM)`;
 function resolveMissingTaskSandboxBranch(taskId, config) {

package/dist/lib/sandbox/config.js

@@ -153,4 +153,16 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         }
     };
 }
+export function loadSandboxControlLocation(repoRoot = detectRepoRoot()) {
+    const configPath = path.join(repoRoot, '.agents', '.airc.json');
+    if (!fs.existsSync(configPath))
+        return null;
+    const airc = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (typeof airc.project !== 'string' || !airc.project)
+        return null;
+    const home = homedir();
+    if (!home)
+        throw new Error('sandbox: home directory is required');
+    return { controlBase: hostJoin(home, '.agent-infra', 'sandbox-control'), project: airc.project };
+}
 //# sourceMappingURL=config.js.map

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

@@ -14,8 +14,7 @@ const SAFE_OPERATION = /^[a-z][a-z0-9.-]{0,96}$/u;
 const AUDIT_MAX_BYTES = 1024 * 1024;
 export function requestAuditFields(manifest, request) {
     return {
-        requestId: request.id, requestFamily: request.family, sandboxTaskId: manifest.taskId,
-        requestGeneration: request.generation, requestIssuedAt: request.issuedAt, requestExpiresAt: request.expiresAt
+        requestId: request.id, requestFamily: request.family, sandboxTaskId: manifest.taskId
     };
 }
 export function resultAuditFields(result) {

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

@@ -1,9 +1,7 @@
 import fs from 'node:fs';
 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 { SANDBOX_CONTROL_MAX_BYTES, SANDBOX_CONTROL_STATUS_STALE_MS, isSandboxControlFamily } from './protocol.js';
 import { readSandboxControlPayload, readSandboxControlStatus } from './state.js';
 import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.js';
@@ -12,7 +10,6 @@ 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 {
     detail;
     accepted;
@@ -31,7 +28,7 @@ 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, taskViewEffect = null, now = Date.now(), env = process.env) {
+function preflight(statusDir, taskViewEffect = null, now = Date.now(), env = process.env) {
     if (fs.existsSync(statusDir)) {
         let identity;
         try {
@@ -43,9 +40,6 @@ function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(
                 : 'SANDBOX_CONTROL_IDENTITY_MALFORMED';
             clientError(code, 'sandbox control identity is missing or invalid', false);
         }
-        if (identity.generation !== generation) {
-            clientError('SANDBOX_CONTROL_IDENTITY_GENERATION_MISMATCH', 'sandbox control identity generation does not match the request', false);
-        }
         if (env.AGENT_INFRA_CONTROL_ROOT_ID && identity.controlRootId !== env.AGENT_INFRA_CONTROL_ROOT_ID) {
             clientError('SANDBOX_CONTROL_IDENTITY_ROOT_ID_MISMATCH', 'sandbox control identity root does not match the client configuration', false);
         }
@@ -57,9 +51,6 @@ function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(
     catch {
         clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', 'broker status is missing or invalid', true);
     }
-    if (status.generation !== generation) {
-        clientError('SANDBOX_CONTROL_GENERATION_INVALID', 'broker status generation does not match this sandbox', false);
-    }
     if (now - status.updatedAt > SANDBOX_CONTROL_STATUS_STALE_MS || status.updatedAt > now + 1_000) {
         clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', 'broker status heartbeat is stale', true);
     }
@@ -81,12 +72,11 @@ function preflight(statusDir, generation, taskViewEffect = null, now = Date.now(
             clientError(access.reasonCode ?? 'SANDBOX_TASK_VIEW_DENIED', access.message ?? 'task view denied', false);
         }
     }
+    return status.generation;
 }
 function taskViewEffectForRequest(request) {
     if (request.family === 'task-lifecycle')
         return 'progress';
-    if (request.family === 'task-finalization')
-        return 'recovery';
     return null;
 }
 function parseResponse(raw, id, accepted = false) {
@@ -169,7 +159,7 @@ 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';
     const taskViewEffect = taskViewEffectForRequest(request);
-    preflight(statusDir, request.generation, taskViewEffect);
+    const hostGeneration = preflight(statusDir, taskViewEffect);
     const identityPath = path.join(statusDir, 'identity.json');
     if (fs.existsSync(statusDir)) {
         const identity = readSandboxControlIdentitySentinel(statusDir);
@@ -180,9 +170,6 @@ function exchangeSandboxControl(request, params) {
                 || (requestTask.kind === 'task' && requestTask.taskId !== identity.taskId))) {
             clientError('SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH', 'request task does not match the sandbox identity', false);
         }
-        if (identity.mode === 'branch-only' && request.family === 'task-finalization') {
-            clientError('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks', false);
-        }
     }
     const encoded = `${JSON.stringify(request)}\n`;
     if (Buffer.byteLength(encoded, 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
@@ -220,7 +207,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, request.generation);
+                response = readPublishedResponse(raw, request.id, channelDir, accepted, hostGeneration);
                 malformedResponseRaw = null;
             }
             catch (error) {
@@ -246,7 +233,7 @@ function exchangeSandboxControl(request, params) {
         }
         if (!accepted) {
             try {
-                preflight(statusDir, request.generation, taskViewEffect);
+                preflight(statusDir, taskViewEffect);
             }
             catch (error) {
                 if (cancelPendingRequest(requestPath))
@@ -273,6 +260,9 @@ export function recoverSandboxControl(requestId, params = {}) {
             const config = loadConfig();
             const response = recoverSandboxControlFromHost(requestId, {
                 managedRoot: path.join(config.controlBase, config.project),
+                controlBase: config.controlBase,
+                project: config.project,
+                repoRoot: config.repoRoot,
                 timeoutMs: params.timeoutMs
             });
             if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
@@ -359,109 +349,24 @@ export function recoverSandboxControlFromChannel(requestId, params) {
     }
     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;
-    const generation = params.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
-    if (!token || !generation)
-        clientError('SANDBOX_CONTROL_UNAVAILABLE', 'control authority is missing', false);
-    return { token, generation };
-}
 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 === 'agent-client' || params.family === 'task-finalization') {
+    if (params.family === 'task-create') {
         clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, 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
-    };
-    return exchangeSandboxControl(request, params);
-}
-export function requestSandboxAgentOperation(params) {
-    if (!isAgentClientId(params.agentClient)) {
-        clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'agent-client id is invalid', false);
+    if (params.args[1] === 'complete') {
+        clientError('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization', 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: 'agent-client',
-        agentClient: params.agentClient,
-        operation: params.operation,
-        payload: params.payload
+        version: 5, id: randomUUID(),
+        family: params.family, args: params.args
     };
     return exchangeSandboxControl(request, params);
 }
-export function requestSandboxTaskFinalization(params) {
-    const agent = normalizeAgentToken(params.agent);
-    if (!agent)
-        clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'task-finalization agent is invalid', false);
-    const auth = authority(params);
-    const issuedAt = Date.now();
-    const id = randomUUID();
-    const request = {
-        version: 4,
-        id,
-        ...auth,
-        issuedAt,
-        expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-        family: 'task-finalization',
-        operation: 'complete',
-        agent,
-        args: []
-    };
-    let response;
-    try {
-        response = exchangeSandboxControl(request, params);
-    }
-    catch (error) {
-        if (!(error instanceof SandboxControlClientError)
-            || error.detail.code !== 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-            || !error.accepted || !error.requestId)
-            throw error;
-        return recoverAcceptedTaskFinalization(error.requestId, params);
-    }
-    if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
-        return recoverAcceptedTaskFinalization(response.id, params);
-    }
-    return response;
-}
-export function recoverAcceptedTaskFinalization(requestId, params, recover = recoverSandboxControl) {
-    const deadline = Date.now() + (params.recoveryBudgetMs ?? SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS);
-    while (Date.now() < deadline) {
-        const timeoutMs = Math.min(30_000, deadline - Date.now());
-        if (timeoutMs <= 0)
-            break;
-        try {
-            const response = recover(requestId, { timeoutMs });
-            if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
-                continue;
-            return response;
-        }
-        catch (error) {
-            if (error instanceof SandboxControlClientError
-                && error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-                && error.requestId === requestId)
-                continue;
-            throw error;
-        }
-    }
-    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);
-}
 export function requestSandboxTaskCreate(params) {
-    const auth = authority(params);
-    const issuedAt = Date.now();
     const request = {
-        version: 4, id: randomUUID(), ...auth, issuedAt,
-        expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
+        version: 5, id: randomUUID(),
         family: 'task-create', candidate: params.candidate,
     };
     return exchangeSandboxControl(request, { ...params, timeoutMs: params.timeoutMs ?? 120_000 });

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

@@ -4,15 +4,12 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { getProcessStartTime } from '../../server/process-state.js';
 import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
-import { applyTaskFinalization } from '../../task/finalization.js';
-import { serializeTaskFinalizationEnvelope } from '../../task/finalization-envelope.js';
 import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
 import { atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
 import { requestAuditFields, resultAuditFields, appendDiagnosticAudit, createSandboxControlAuditContext, appendCriticalAudit, writeSandboxControlTransition } from './audit.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
 import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../../task/control-authority.js';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest } from './lifecycle.js';
-import { executeAgentClientOperation, validateAgentClientOperation } from './agent-operation.js';
 function sameBrokerOwner(left, right) {
     return left.version === right.version
         && left.pid === right.pid
@@ -192,21 +189,6 @@ function taskCreateExecutionFailure(requestId, code, message) {
         recovery: 'inspect-domain-state'
     }));
 }
-function finalizationResult(result) {
-    const payload = {
-        version: 1,
-        status: result.status,
-        changed: result.changed,
-        accepted: true,
-        result,
-        error: result.error
-    };
-    return {
-        exitCode: result.status === 'completed' ? 0 : result.status === 'blocked' ? 2 : 1,
-        stdout: `${JSON.stringify(payload)}\n`,
-        stderr: ''
-    };
-}
 async function executeRequestInner(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
         try {
@@ -223,26 +205,6 @@ async function executeRequestInner(manifest, manifestPath, request, options = {}
             return taskCreateExecutionFailure(request.id, code, detail);
         }
     }
-    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;
-        const result = dispatchTaskControlOperation(createSandboxExecutorExecutionContext({
-            repoRoot: manifest.repoRoot,
-            worktreeRoot: manifest.worktreeRoot,
-            runtimeDir: manifest.runtimeDir,
-            taskId: manifest.taskId,
-            generation: manifest.generation,
-            manifestPath,
-            requestId: request.id
-        }), operation);
-        return finalizationResult(await result);
-    }
     const boundArgs = bindSandboxControlTask(request, manifest.taskId);
     let operation;
     try {
@@ -302,10 +264,11 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
     const gate = await waitForGate(nonce);
     const gateOwner = gate.owner;
     process.disconnect?.();
-    const manifestPath = process.env.AGENT_INFRA_EXECUTOR_MANIFEST;
-    if (!manifestPath)
+    const requestedManifestPath = process.env.AGENT_INFRA_EXECUTOR_MANIFEST;
+    if (!requestedManifestPath)
         throw new Error('SANDBOX_CONTROL_EXECUTOR_MANIFEST_MISSING');
-    const manifest = readSandboxControlManifest(manifestPath);
+    const manifest = readSandboxControlManifest(requestedManifestPath);
+    const manifestPath = fs.realpathSync.native(requestedManifestPath);
     const identity = validateSandboxControlIdentity({
         publicStatusDir: manifest.publicStatusDir,
         root: path.dirname(path.resolve(manifestPath)),
@@ -357,13 +320,13 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
                     return null;
                 }
             })()
-            : request.family === 'agent-client' ? request.operation : null;
+            : null;
         const context = createSandboxControlAuditContext(manifest, {
             requestId: request.id,
             family: request.family,
             operation: operation && typeof operation === 'object' && 'family' in operation && operation.family === 'task-lifecycle'
                 ? operation.request.intent
-                : request.family === 'task-finalization' || request.family === 'agent-client' ? request.operation : null,
+                : null,
             phase: 'started-committed',
             outcome: 'in-progress'
         });
@@ -380,22 +343,9 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         });
         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'
-            ? {
-                exitCode: 1,
-                stdout: serializeTaskFinalizationEnvelope({
-                    status: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 'unknown' : 'failed',
-                    changed: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? null : false,
-                    accepted: true,
-                    requestId: request.id,
-                    result: null,
-                    error: { code, message: detail, retryable: false }
-                }),
-                stderr: ''
-            }
-            : request.family === 'task-create'
-                ? taskCreateExecutionFailure(request.id, code, detail)
-                : lifecycleFailure(code, detail);
+        result = request.family === 'task-create'
+            ? taskCreateExecutionFailure(request.id, code, detail)
+            : lifecycleFailure(code, detail);
     }
     process.stdout.write(result.stdout);
     process.stderr.write(result.stderr);