@fitlab-ai/agent-infra 0.11.12 → 0.11.14

package/dist/bin/internal-cli.js

@@ -17,9 +17,9 @@ const taskWorkflowCommand = command === 'task-artifact'
 const taskPlatformRecoveryCommand = command === 'task-platform-recovery';
 const manualValidationWorkflowCommand = command === 'manual-validation';
 const taskControlMarkers = [
-    'AGENT_INFRA_TASK_ID', 'AGENT_INFRA_CONTROL_TOKEN', 'AGENT_INFRA_CONTROL_GENERATION',
+    'AGENT_INFRA_TASK_ID', 'AGENT_INFRA_CONTROL_GENERATION',
     'AGENT_INFRA_CONTROL_DIR', 'AGENT_INFRA_CONTROL_STATUS_DIR', 'AGENT_INFRA_RUNTIME_DIR',
-    'AGENT_INFRA_CONTROL_CONTROLLER_BINDING', 'AGENT_INFRA_EXECUTOR_MANIFEST'
+    'AGENT_INFRA_EXECUTOR_MANIFEST'
 ];
 const markerlessHelp = ['--help', '-h'].includes(process.argv[3] ?? '')
     && taskControlMarkers.every((key) => !process.env[key]);
@@ -115,11 +115,6 @@ if (!controlRouted && !taskViewGuardFailed && internalRouteRegistered)
             await codexLifecycle(process.argv.slice(3));
             break;
         }
-        case 'codex-sandbox-controller': {
-            const { codexSandboxController } = await import('../lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.js');
-            await codexSandboxController(process.argv.slice(3));
-            break;
-        }
         case 'git-workflow': {
             const { gitWorkflow } = await import('../lib/internal/git-workflow.js');
             gitWorkflow(process.argv.slice(3));

package/dist/lib/agent-clients/adapter.js

@@ -434,9 +434,6 @@ function defineAgentClientAdapter(candidate) {
         ...(candidate.orchestrationAdapter === undefined
             ? {}
             : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
-        ...(candidate.sandboxControlOperation === undefined
-            ? {}
-            : { sandboxControlOperation: Object.freeze({ ...candidate.sandboxControlOperation }) }),
         project: Object.freeze({
             ownedPathPrefixes: Object.freeze(paths),
             ...projectAssets,

package/dist/lib/agent-clients/adapters/codex-lifecycle/app-server.js

@@ -114,7 +114,7 @@ function validateCodexLifecycleHookConfig(value) {
     if (!valid)
         throw new Error('CODEX_PREFLIGHT_HOOKS_INVALID: lifecycle hooks are invalid');
 }
-function parseCodexHooksList(value, repoRoot, expectedSource = 'direct-host') {
+function parseCodexHooksList(value, repoRoot) {
     const root = object(value);
     const entries = Array.isArray(root?.data) ? root.data : [];
     const entry = entries.map(object).find((candidate) => candidate?.cwd === repoRoot);
@@ -145,10 +145,8 @@ function parseCodexHooksList(value, repoRoot, expectedSource = 'direct-host') {
         && hook.currentHash.length > 0
         && hook.sourcePathDigest.length === 64
         && hook.pluginId === null
-        && (expectedSource === 'isolated-user'
-            ? hook.source === 'user' && hook.trustStatus !== 'modified'
-            : (hook.source === 'project' && hook.trustStatus === 'trusted')
-                || hook.isManaged && hook.trustStatus === 'managed')));
+        && (hook.source === 'project' && hook.trustStatus === 'trusted'
+            || hook.isManaged && hook.trustStatus === 'managed')));
     if (!valid)
         throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
     return Object.freeze(hooks);
@@ -546,7 +544,7 @@ async function discoverLifecycleHooks(repoRoot) {
     let discoveredHooks;
     try {
         await transport.initialize();
-        discoveredHooks = parseCodexHooksList(await transport.request('hooks/list', { cwds: [repoRoot] }), repoRoot, process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT ? 'isolated-user' : 'direct-host');
+        discoveredHooks = parseCodexHooksList(await transport.request('hooks/list', { cwds: [repoRoot] }), repoRoot);
     }
     finally {
         transport.close();
@@ -564,9 +562,7 @@ async function discoverLifecycleHooks(repoRoot) {
         throw new Error('CODEX_PREFLIGHT_HOOK_SOURCE_AMBIGUOUS: lifecycle hooks do not share one exact source');
     }
     const source = [...sources][0];
-    const hookSource = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT
-        ? 'isolated-user'
-        : source === 'managed' ? 'managed' : 'project';
+    const hookSource = source === 'managed' ? 'managed' : 'project';
     return {
         discoveredHooks,
         hookProvenance: Object.freeze({

package/dist/lib/agent-clients/adapters/codex-lifecycle/cli.js

@@ -4,7 +4,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread } from './app-server.js';
 import { createCodexLifecycleStore } from './store.js';
-import { verifyCodexSandboxControllerContextWithWarnings } from './sandbox-controller.js';
 import { resolveTaskRef } from '../../../task/resolve-ref.js';
 import { resolveTaskContext } from '../../../task/resolve-ref.js';
 import { hasSealableOrchestrationDelegation, readRun } from '../../../task/orchestration.js';
@@ -78,10 +77,7 @@ function hookDefinitionHash() {
     return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
 }
 function resolveLifecycleTaskContext() {
-    const controllerPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-    const taskId = controllerPath
-        ? verifyCodexSandboxControllerContextWithWarnings(controllerPath, { repoRoot: process.cwd() }).context.taskId
-        : process.env.AGENT_INFRA_TASK_ID;
+    const taskId = process.env.AGENT_INFRA_TASK_ID;
     const context = taskId
         ? resolveTaskRef(taskId, { repoRoot: process.cwd() })
         : resolveTaskContext(undefined, { repoRoot: process.cwd() });

package/dist/lib/agent-clients/adapters/codex-lifecycle/recovery.js

@@ -136,14 +136,10 @@ function hostEvidenceMatches(record, receipt, host, start) {
         && host.spawnToolUseId === start.spawnToolUseId
         && Boolean(host.spawnObservedAt)
         && host.spawnObservedAt === record.spawnObservedAt
-        && typeof host.controllerInstanceDigest === 'string'
-        && typeof host.controlGeneration === 'string'
         && hostRevisionMatches(record, receipt, host);
 }
 function hostRevisionMatches(record, receipt, host) {
-    return typeof host.controllerInstanceDigest === 'string'
-        && typeof host.controlGeneration === 'string'
-        && host.startRevision >= 1
+    return host.startRevision >= 1
         && record.revision > host.startRevision
         && record.state.child?.childThreadId === receipt.childId
         && record.state.stop?.childThreadId === receipt.childId;

package/dist/lib/agent-clients/adapters/codex-lifecycle/store.js

@@ -215,7 +215,7 @@ function createCodexLifecycleStore(options) {
             throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
         return matches[0];
     }
-    function consume(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding) {
+    function consumeWithLockMode(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding, taskLockHeld) {
         if (!consumer.trim())
             throw new Error('Codex lifecycle consumer is required');
         const current = read(childThreadId);
@@ -223,8 +223,11 @@ function createCodexLifecycleStore(options) {
         if (!binding)
             throw new Error('Codex lifecycle task receipt binding is missing');
         const spawn = current.state.spawn;
-        if (!spawn)
-            throw new Error('Codex lifecycle spawn evidence is missing');
+        if (!spawn) {
+            throw new Error(taskLockHeld
+                ? 'Codex lifecycle task receipt binding is missing'
+                : 'Codex lifecycle spawn evidence is missing');
+        }
         const key = recordKey(spawn.sessionId, spawn.turnId, spawn.toolUseId);
         return update(binding, key, (latest) => {
             if (!latest || expectedTaskBinding && JSON.stringify(latest.taskBinding) !== JSON.stringify(expectedTaskBinding)) {
@@ -241,30 +244,13 @@ function createCodexLifecycleStore(options) {
             if (latest.consumer)
                 return latest;
             return Object.freeze({ ...latest, revision: latest.revision + 1, consumer, consumedAt: now(), updatedAt: now() });
-        });
+        }, taskLockHeld);
+    }
+    function consume(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding) {
+        return consumeWithLockMode(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding, false);
     }
     function consumeWithinTaskLock(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding) {
-        if (!consumer.trim())
-            throw new Error('Codex lifecycle consumer is required');
-        const current = read(childThreadId);
-        const binding = expectedTaskBinding ?? current.taskBinding;
-        if (!binding || !current.state.spawn)
-            throw new Error('Codex lifecycle task receipt binding is missing');
-        const key = recordKey(current.state.spawn.sessionId, current.state.spawn.turnId, current.state.spawn.toolUseId);
-        return update(binding, key, (latest) => {
-            if (!latest || expectedTaskBinding && JSON.stringify(latest.taskBinding) !== JSON.stringify(expectedTaskBinding)) {
-                throw new Error('Codex lifecycle task binding does not match the expected receipt');
-            }
-            if (latest.consumer && latest.consumer !== consumer) {
-                throw new Error(`Codex lifecycle evidence was already consumed by '${latest.consumer}'`);
-            }
-            if (latest.state.status !== 'stop-ready')
-                throw new Error('Codex lifecycle evidence is not stop-ready');
-            if (expectedHookDefinitionHash && latest.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash) {
-                throw new Error('Codex lifecycle hook definition hash is stale');
-            }
-            return latest.consumer ? latest : Object.freeze({ ...latest, revision: latest.revision + 1, consumer, consumedAt: now(), updatedAt: now() });
-        }, true);
+        return consumeWithLockMode(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding, true);
     }
     function expireBefore(cutoff) {
         let changed = 0;

package/dist/lib/agent-clients/adapters/codex-orchestration.js

@@ -215,9 +215,7 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                     capabilitySessionId: evidence.parentThreadId,
                     capabilityTurnId: evidence.parentTurnId,
                     spawnToolUseId: evidence.spawnToolUseId,
-                    spawnObservedAt: record.spawnObservedAt ?? undefined,
-                    controllerInstanceDigest: null,
-                    controlGeneration: null
+                    spawnObservedAt: record.spawnObservedAt ?? undefined
                 }
             }
         }, coreOptions(options));

package/dist/lib/agent-clients/adapters/codex.js

@@ -3,7 +3,6 @@ import { hostJoin } from '../../sandbox/engines/wsl2-paths.js';
 import { codexBeforeContainerCreateHook, codexRecoveryChecks } from './codex-sandbox.js';
 import { parseCodexLifecycleBinding } from './codex-lifecycle/binding.js';
 import { isCodexDelegationReceiptEvidence, isCodexLifecycleActivationEvidence } from './codex-lifecycle/evidence.js';
-import { codexControllerOperation } from './codex-lifecycle/controller-operation.js';
 function codexCarrierError(code) {
     const error = new Error(code);
     error.name = code;
@@ -72,7 +71,6 @@ const codexAdapter = defineAgentClientAdapter({
             return recoverStartedLifecycleFromAdapter(...args);
         }
     },
-    sandboxControlOperation: codexControllerOperation,
     project: {
         ownedPathPrefixes: ['.codex/'],
         managed: ['.codex/hooks.json', '.codex/agents/'],

package/dist/lib/internal/cli-route-inventory.js

@@ -35,7 +35,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'sandbox-control': ['serve', 'execute', 'recover', 'client'],
     'agent-client': ['next-steps', 'model-selection', 'launch-carrier'],
     'codex-lifecycle': ['preflight', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
-    'codex-sandbox-controller': ['verify-context', 'run'],
     'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
     'task-delivery': ['deliver'],
     'release-workflow': ['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'],

package/dist/lib/internal/sandbox-control.js

@@ -1,18 +1,8 @@
-import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { recoverSandboxControl, requestSandboxControl, SandboxControlClientError } from '../sandbox/control/client.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.js';
-import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
-function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null, requestId = null) {
-    process.stdout.write(serializeTaskFinalizationEnvelope({ status, changed, accepted, requestId, result, error }));
-}
-function finalizationErrorStatus(error) {
-    if (error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN')
-        return 'unknown';
-    return error.retryable ? 'blocked' : 'failed';
-}
 function writeClientError(error) {
     process.stderr.write(`${error.detail.message}\n`);
     if (error.requestId)
@@ -31,72 +21,6 @@ function recoveredExitCode(response) {
     }
     return response.exitCode ?? 1;
 }
-function finalizationResponseOutput(response) {
-    try {
-        const value = JSON.parse(response.stdout);
-        if (value.version === 2
-            && value.status
-            && ['completed', 'failed', 'blocked', 'unknown'].includes(value.status)
-            && (typeof value.changed === 'boolean' || value.changed === null)) {
-            return serializeTaskFinalizationEnvelope({
-                status: value.status,
-                changed: value.changed,
-                accepted: true,
-                requestId: response.id,
-                result: value.result ?? null,
-                error: value.error ?? null
-            });
-        }
-    }
-    catch {
-        // Preserve non-envelope output for diagnostics from the executor.
-    }
-    return response.stdout;
-}
-function sandboxFinalizationClient(args) {
-    if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
-        const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'task ref, complete intent, and --agent are required', retryable: false };
-        writeFinalizationEnvelope('failed', false, error);
-        process.stderr.write('Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n');
-        process.exitCode = 1;
-        return;
-    }
-    const agent = normalizeAgentToken(args[3]);
-    if (!agent) {
-        const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: `invalid --agent: ${AGENT_USAGE_HINT}`, retryable: false };
-        writeFinalizationEnvelope('failed', false, error);
-        process.exitCode = 1;
-        return;
-    }
-    let response;
-    try {
-        response = requestSandboxTaskFinalization({ agent });
-    }
-    catch (error) {
-        if (!(error instanceof SandboxControlClientError))
-            throw error;
-        const status = finalizationErrorStatus(error.detail);
-        writeFinalizationEnvelope(status, error.accepted, error.detail, status === 'unknown' ? null : false, null, error.requestId);
-        writeClientError(error);
-        process.exitCode = error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.detail.retryable ? 2 : 1;
-        return;
-    }
-    if (response.phase === 'rejected') {
-        const error = response.error ?? {
-            code: 'SANDBOX_CONTROL_REJECTED',
-            message: 'sandbox control rejected the finalization request',
-            retryable: false
-        };
-        const status = finalizationErrorStatus(error);
-        writeFinalizationEnvelope(status, error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN', error, status === 'unknown' ? null : false, null, response.id);
-        process.stderr.write(`${error.message}\n`);
-        process.exitCode = error.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 1 : error.retryable ? 2 : 1;
-        return;
-    }
-    process.stdout.write(finalizationResponseOutput(response));
-    process.stderr.write(response.stderr);
-    process.exitCode = response.exitCode ?? 1;
-}
 async function sandboxControl(args) {
     if (!ensureInternalHandlerRoute('sandbox-control', args))
         return;
@@ -152,10 +76,6 @@ async function sandboxControl(args) {
     }
     if (internalHandlerRoute('sandbox-control', 'client', operation ?? '')) {
         const [family = '', ...commandArgs] = rest;
-        if (family === 'task-finalization') {
-            sandboxFinalizationClient(commandArgs);
-            return;
-        }
         let response;
         try {
             response = requestSandboxControl({ family, args: commandArgs });

package/dist/lib/internal/task-finalization.js

@@ -1,9 +1,12 @@
+import path from 'node:path';
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { resolveSandboxControlTransport } from './task-operation-registry.js';
-import { requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
+import { quiesceSandboxControlForTaskCompletion } from '../sandbox/control/lifecycle.js';
+import { loadSandboxControlLocation } from '../sandbox/config.js';
 import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.js';
+import { verifyTaskEvent } from '../task/verification.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
 function envelope(status, changed, accepted, result, error, requestId = null) {
@@ -64,28 +67,34 @@ async function taskFinalization(args = []) {
     };
     const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
     if (transport.kind === 'sandbox-local') {
-        try {
-            const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
-            process.stdout.write(response.stdout);
-            process.stderr.write(response.stderr);
-            process.exitCode = response.exitCode ?? 1;
-            return;
-        }
-        catch (error) {
-            const clientError = error instanceof SandboxControlClientError ? error : null;
-            const detail = clientError
-                ? clientError.detail
-                : { code: 'SANDBOX_CONTROL_CLIENT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
-            const status = detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-                ? 'unknown'
-                : detail.retryable ? 'blocked' : 'failed';
-            const changed = status === 'unknown' ? null : false;
-            process.stdout.write(envelope(status, changed, clientError?.accepted ?? false, null, detail, clientError?.requestId ?? null));
-            process.exitCode = exitCode(status);
+        const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
+        const taskId = process.env.AGENT_INFRA_TASK_ID;
+        const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
+        const controlRootId = process.env.AGENT_INFRA_CONTROL_ROOT_ID;
+        const controlRoot = process.env.AGENT_INFRA_CONTROL_ROOT_DIR;
+        if (!statusDir || !taskId || !generation || !controlRootId || !controlRoot || taskId !== resolved.taskId) {
+            const detail = { code: 'TASK_CONTROL_TRANSPORT_INVALID', message: 'sandbox task control identity is incomplete', retryable: false };
+            process.stdout.write(envelope('failed', false, true, null, detail));
+            process.exitCode = 1;
             return;
         }
+        const result = await applyTaskFinalization(boundOperation.request, {
+            repoRoot,
+            beforeLifecycle: async (currentTaskId) => {
+                if (currentTaskId !== taskId)
+                    throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
+                await quiesceSandboxControlForTaskCompletion(controlRoot, { taskId, generation, controlRootId, statusDir });
+            },
+            preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
+        });
+        const status = result.status === 'prepared' ? 'failed' : result.status;
+        process.stdout.write(envelope(status, result.changed, true, result, result.error
+            ?? (result.status === 'prepared' ? { code: 'TASK_FINALIZATION_PREPARATION_INCOMPLETE', message: 'finalization did not commit', retryable: true } : null)));
+        process.exitCode = exitCode(status);
+        return;
     }
-    const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), boundOperation);
+    const controlLocation = loadSandboxControlLocation(repoRoot);
+    const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }), boundOperation);
     if (result.status === 'prepared') {
         const detail = {
             code: 'TASK_FINALIZATION_DIRECT_COMMIT_REQUIRED',

package/dist/lib/internal/task-lifecycle.js

@@ -2,7 +2,8 @@ import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTa
 import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\n`;
+import { loadSandboxControlLocation } from '../sandbox/config.js';
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\nrecover-started: --auto\n`;
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -52,7 +53,8 @@ async function taskLifecycle(args = []) {
         }
         repoRoot = resolved.repoRoot;
     }
-    const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), operation);
+    const controlLocation = loadSandboxControlLocation(repoRoot);
+    const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }), operation);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict')
         process.exitCode = 1;

package/dist/lib/internal/task-operation-registry.js

@@ -25,8 +25,6 @@ function internalTaskRoutes() {
         descriptor('internal', 'codex-lifecycle', 'resolve-start', 'conditional', 'progress'),
         descriptor('internal', 'codex-lifecycle', 'resolve-stop', 'conditional', 'progress'),
         descriptor('internal', 'codex-lifecycle', 'consume', 'conditional', 'progress'),
-        descriptor('internal', 'codex-sandbox-controller', 'verify-context', 'task-bound', 'diagnostic'),
-        descriptor('internal', 'codex-sandbox-controller', 'run', 'task-bound', 'progress'),
         descriptor('internal', 'git-workflow', 'inspect', 'conditional', 'diagnostic'),
         descriptor('internal', 'git-workflow', 'preview-tree', 'conditional', 'diagnostic'),
         descriptor('internal', 'git-workflow', 'snapshot', 'conditional', 'diagnostic'),
@@ -175,7 +173,7 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
     ...PUBLIC_OPERATION_DESCRIPTORS
 ]);
 export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
-    'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle', 'codex-sandbox-controller',
+    'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle',
     'git-workflow', 'task-delivery', 'release-workflow', 'platform-release-notes', 'platform-security', 'platform-metadata', 'platform-context',
     'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
     'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',

package/dist/lib/internal/task-validate.js

@@ -2,26 +2,15 @@ import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
 import { loadConfig } from '../sandbox/config.js';
-import { detectEngine } from '../sandbox/engine.js';
-import { runEngine } from '../sandbox/shell.js';
-import { sandboxBranchLabel, sandboxLabel } from '../sandbox/constants.js';
-import { fetchSandboxRows, selectSandboxContainer } from '../sandbox/commands/list-running.js';
-import { containerNameCandidates } from '../sandbox/constants.js';
 import { resolveSandboxTarget } from '../sandbox/workspace-identity.js';
-import { sandboxControlPaths } from '../sandbox/workspace-view.js';
-import { appendSandboxControlAudit, readActiveLease, readSandboxControlStatus } from '../sandbox/control/state.js';
-import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
-import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from '../sandbox/control/protocol.js';
-import { getProcessStartTime } from '../server/process-state.js';
+import { resolveBranchWorktree } from '../git/branch-worktree.js';
 import { assertGitWorktreeBinding } from '../git/worktree-identity.js';
 import { createManualValidationEvidence, manualValidationEvidenceSummary } from '../task/manual-validation-evidence.js';
 import { writeJsonAtomic } from '../task/manual-validation-shared.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-validate <branch | TASK-id | N> [--scope snapshot|inplace] [--timeout <ms>] [--format text|json] [--evidence-file <path>] -- <command> [args...]`;
 const MAX_TIMEOUT_MS = 60 * 60 * 1000;
-const RECOVERY_GRACE_MS = 30_000;
 export function parseValidateArgs(args) {
     if (args.includes('--help') || args.includes('-h')) {
         return { target: '', scope: 'snapshot', timeoutMs: 300_000, format: 'text', evidenceFile: null, command: [], help: true };
@@ -100,21 +89,6 @@ function runValidationCommand(command, cwd, scope, timeoutMs, json) {
 function git(root, args) {
     return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 }
-function waitForState(statusDir, predicate, timeoutMs = 5_000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        try {
-            const status = readSandboxControlStatus(statusDir);
-            if (predicate(status))
-                return;
-        }
-        catch {
-            // Atomic status publication may be between renames.
-        }
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
-    }
-    throw new Error('SANDBOX_VALIDATION_BROKER_STATE_TIMEOUT');
-}
 function snapshotValidation(repoRoot, commit, options) {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-validation-'));
     const worktree = path.join(tempRoot, 'worktree');
@@ -146,117 +120,33 @@ function snapshotValidation(repoRoot, commit, options) {
     }
 }
 function inplaceValidation(config, target, options) {
-    const engine = detectEngine(config);
-    const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
-    const row = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, target.branch));
-    if (!row)
-        throw new Error('SANDBOX_VALIDATION_CONTAINER_NOT_FOUND');
-    const control = sandboxControlPaths({
-        base: config.controlBase, repoRoot: config.repoRoot, project: config.project,
-        container: row.name, identity: target.workspace
-    });
-    const manifest = readSandboxControlManifest(control.manifestPath);
-    const initial = readSandboxControlStatus(control.statusDir);
-    const now = Date.now();
-    if (initial.generation !== manifest.generation
-        || now - initial.updatedAt > SANDBOX_CONTROL_STATUS_STALE_MS
-        || initial.updatedAt > now + SANDBOX_CONTROL_FUTURE_SKEW_MS) {
-        throw new Error('SANDBOX_VALIDATION_BROKER_STATUS_STALE');
-    }
-    if (initial.state !== 'healthy' || initial.activeRequestId !== null) {
-        throw new Error('SANDBOX_VALIDATION_BROKER_NOT_IDLE');
-    }
-    const startTime = getProcessStartTime(process.pid);
-    if (!startTime)
-        throw new Error('SANDBOX_VALIDATION_OWNER_IDENTITY_UNAVAILABLE');
-    const leasePath = path.join(control.root, 'lease.json');
-    const nonce = randomUUID();
-    const issuedAt = Date.now();
-    const lease = {
-        version: 2, generation: manifest.generation, nonce,
-        owner: { pid: process.pid, startTime }, issuedAt,
-        expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
-        taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,
-        branch: target.branch, reason: 'manual-validation'
-    };
-    const originalBranch = git(manifest.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
-    const originalHead = git(manifest.worktreeRoot, ['rev-parse', 'HEAD']);
-    fs.writeFileSync(leasePath, `${JSON.stringify(lease)}\n`, { flag: 'wx', mode: 0o600 });
-    let stopped = false;
+    const targetRoot = resolveBranchWorktree(config.repoRoot, target.branch);
+    if (!targetRoot)
+        throw new Error(`TASK_VALIDATION_WORKTREE_NOT_FOUND: ${target.branch}`);
+    const worktree = assertGitWorktreeBinding(config.repoRoot, targetRoot, target.branch);
+    const originalBranch = git(worktree.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const originalHead = git(worktree.worktreeRoot, ['rev-parse', 'HEAD']);
     let restored = false;
     try {
-        appendSandboxControlAudit(manifest, 'lease-acquire', { ownerPid: process.pid });
-        waitForState(control.statusDir, (status) => status.state === 'parked' && status.reasonCode === 'SANDBOX_CONTROL_HANDOFF_ACTIVE');
-        if (row.running) {
-            runEngine(engine, 'docker', ['stop', row.name]);
-            stopped = true;
-        }
-        const refreshedRows = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
-        const refreshed = selectSandboxContainer([...refreshedRows.running, ...refreshedRows.nonRunning], containerNameCandidates(config, target.branch));
-        if (!refreshed || refreshed.running)
-            throw new Error('SANDBOX_VALIDATION_CONTAINER_STILL_RUNNING');
-        const activeLease = readActiveLease(manifest);
-        if (!activeLease || activeLease.nonce !== nonce)
-            throw new Error('SANDBOX_VALIDATION_LEASE_OWNERSHIP_LOST');
-        assertGitWorktreeBinding(config.repoRoot, manifest.worktreeRoot, target.branch);
-        const result = runValidationCommand(options.command, manifest.worktreeRoot, 'inplace', options.timeoutMs, options.format === 'json');
+        const result = runValidationCommand(options.command, worktree.worktreeRoot, 'inplace', options.timeoutMs, options.format === 'json');
         return { ...result, cleanup: () => restored ? 'completed' : 'pending' };
     }
     finally {
-        const recoveryErrors = [];
         try {
-            const currentBranch = git(manifest.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+            const currentBranch = git(worktree.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
             if (currentBranch !== originalBranch)
-                git(manifest.worktreeRoot, ['switch', originalBranch]);
+                git(worktree.worktreeRoot, ['switch', originalBranch]);
         }
         catch {
             try {
-                git(manifest.worktreeRoot, ['checkout', '--detach', originalHead]);
-                git(manifest.worktreeRoot, ['switch', originalBranch]);
-            }
-            catch (fallbackError) {
-                recoveryErrors.push(`git binding restore failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
-            }
-        }
-        if (stopped) {
-            try {
-                runEngine(engine, 'docker', ['start', row.name]);
-            }
-            catch (error) {
-                recoveryErrors.push(`container start failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        try {
-            const currentLease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
-            if (currentLease.nonce !== nonce)
-                throw new Error('SANDBOX_VALIDATION_LEASE_OWNERSHIP_LOST');
-        }
-        catch (error) {
-            recoveryErrors.push(error instanceof Error ? error.message : String(error));
-        }
-        if (recoveryErrors.length === 0) {
-            try {
-                fs.unlinkSync(leasePath);
-                appendSandboxControlAudit(manifest, 'lease-release', { ownerPid: process.pid });
-                waitForState(control.statusDir, (status) => status.state === 'healthy');
-                restored = true;
+                git(worktree.worktreeRoot, ['checkout', '--detach', originalHead]);
+                git(worktree.worktreeRoot, ['switch', originalBranch]);
             }
             catch (error) {
-                try {
-                    if (!fs.existsSync(leasePath)) {
-                        fs.writeFileSync(leasePath, `${JSON.stringify(lease)}\n`, { flag: 'wx', mode: 0o600 });
-                    }
-                    appendSandboxControlAudit(manifest, 'lease-release-failed', { ownerPid: process.pid });
-                }
-                catch (leaseError) {
-                    recoveryErrors.push(`lease preservation failed: ${leaseError instanceof Error ? leaseError.message : String(leaseError)}`);
-                }
-                recoveryErrors.push(error instanceof Error ? error.message : String(error));
+                throw new Error(`TASK_VALIDATION_WORKTREE_RESTORE_FAILED: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        if (recoveryErrors.length > 0) {
-            throw new Error(`SANDBOX_VALIDATION_RECOVERY_INCOMPLETE: ${recoveryErrors.join('; ')}; run 'ai sandbox start ${target.branch}'`);
-        }
+        restored = true;
     }
 }
 function errorCode(message) {