@fitlab-ai/agent-infra 0.11.13 → 0.11.15

package/dist/lib/task/lifecycle.js

@@ -54,8 +54,24 @@ const DEFAULT_IO = {
     renameSync: (source, target) => fs.renameSync(source, target),
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
     writeFileSync: (file, content, flag) => fs.writeFileSync(file, content, { encoding: 'utf8', flag: flag ?? 'w' }),
-    unlinkSync: (file) => fs.unlinkSync(file)
+    unlinkSync: (file) => fs.unlinkSync(file),
+    rmdirSync: (directory) => fs.rmdirSync(directory),
+    readdirSync: (directory) => fs.readdirSync(directory),
+    readMountInfoSync: () => fs.readFileSync('/proc/self/mountinfo', 'utf8')
 };
+function isVirtiofsMountPoint(directory, mountInfo) {
+    const decodeMountInfoPath = (value) => value.replace(/\\([0-7]{3})/gu, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
+    const expected = path.resolve(directory);
+    return mountInfo.split('\n').some((line) => {
+        if (!line)
+            return false;
+        const fields = line.split(' ');
+        const separator = fields.indexOf('-');
+        return separator >= 0
+            && fields[separator + 1] === 'virtiofs'
+            && path.resolve(decodeMountInfoPath(fields[4] ?? '')) === expected;
+    });
+}
 function failed(request, error, extra = {}) {
     return {
         status: 'failed', changed: false, requestRef: request.taskRef, taskId: null,
@@ -215,6 +231,96 @@ function transferTaskContents(sourcePath, targetPath) {
         throw new Error('completed target does not match task source after copy');
     }
 }
+function pathExists(candidate) {
+    try {
+        fs.lstatSync(candidate);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function assertTaskControlRootPath(controlRoot, taskId, expectedProject) {
+    if (path.basename(controlRoot) !== taskId || path.basename(path.dirname(controlRoot)) !== 'tasks'
+        || (expectedProject !== undefined && path.basename(path.dirname(path.dirname(controlRoot))) !== expectedProject)) {
+        throw new Error('control root path does not match the task/project layout');
+    }
+    const managedBase = path.dirname(path.dirname(path.dirname(controlRoot)));
+    let current = managedBase;
+    for (const segment of path.relative(managedBase, controlRoot).split(path.sep).filter(Boolean)) {
+        const stat = fs.lstatSync(current);
+        if (stat.isSymbolicLink())
+            throw new Error('control root ancestor is a symbolic link');
+        current = path.join(current, segment);
+    }
+    const stat = fs.lstatSync(controlRoot);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error('control root is not a real directory');
+}
+function assertTaskControlManifestIdentity(controlRoot, taskId, repoRoot, expectedProject) {
+    const controlManifest = path.join(controlRoot, 'manifest.json');
+    if (!fs.existsSync(controlManifest))
+        throw new Error('control manifest is missing');
+    const manifestStat = fs.lstatSync(controlManifest);
+    if (!manifestStat.isFile() || manifestStat.isSymbolicLink())
+        throw new Error('control manifest is not a real file');
+    const manifest = JSON.parse(fs.readFileSync(controlManifest, 'utf8'));
+    const project = expectedProject ?? path.basename(path.dirname(path.dirname(controlRoot)));
+    if (manifest.mode !== 'task-bound' || manifest.taskId !== taskId || manifest.project !== project
+        || typeof manifest.repoRoot !== 'string' || fs.realpathSync.native(manifest.repoRoot) !== fs.realpathSync.native(repoRoot)) {
+        throw new Error('control manifest identity does not match the task');
+    }
+}
+function taskBoundControlMoveSafety(request, controlRoot, options, taskId, repoRoot, validateManifestIdentity) {
+    if (!controlRoot)
+        return null;
+    const controlManifest = path.join(controlRoot, 'manifest.json');
+    const controlLease = path.join(controlRoot, 'lease.json');
+    const stateExists = pathExists(controlRoot) || pathExists(controlManifest) || pathExists(controlLease);
+    if (stateExists) {
+        try {
+            assertTaskControlRootPath(controlRoot, taskId, options.controlProject);
+            if (validateManifestIdentity) {
+                assertTaskControlManifestIdentity(controlRoot, taskId, repoRoot, options.controlProject);
+            }
+            else {
+                const manifestStat = fs.lstatSync(controlManifest);
+                if (!manifestStat.isFile() || manifestStat.isSymbolicLink())
+                    throw new Error('control manifest is not a real file');
+            }
+        }
+        catch {
+            return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task-bound sandbox control root is missing, malformed, or belongs to another task' };
+        }
+    }
+    if (request.intent !== 'complete' && (pathExists(controlManifest) || pathExists(controlLease))) {
+        return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task-bound sandbox control state exists; stop and remove the verified sandbox before moving the task directory' };
+    }
+    return null;
+}
+function orchestrationMoveSafety(sourcePath) {
+    const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
+    if (!pathExists(orchestrationPath))
+        return null;
+    try {
+        const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8'));
+        if (run.status === 'running' || run.pendingDelegation !== null && run.pendingDelegation !== undefined) {
+            return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration has an active or pending delegation; settle it before moving the task directory' };
+        }
+    }
+    catch {
+        return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration state is unreadable; refusing to move the task directory' };
+    }
+    return null;
+}
+function runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, validateControlManifestIdentity) {
+    if (!movingTaskDirectory)
+        return null;
+    const controlSafety = taskBoundControlMoveSafety(request, options.controlRoot, options, taskId, repoRoot, validateControlManifestIdentity);
+    return controlSafety ?? orchestrationMoveSafety(sourcePath);
+}
 function targetContainsTask(targetPath, taskId, request) {
     try {
         const stat = fs.lstatSync(targetPath);
@@ -546,37 +652,6 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
     const targetPath = path.join(repoRoot, '.agents', 'workspace', spec.target, taskId);
     const requiredSteps = stepsForIntent(request.intent);
     const movingTaskDirectory = sourcePath !== targetPath;
-    const assertRuntimeMoveSafe = () => {
-        if (!movingTaskDirectory)
-            return null;
-        const controlManifest = path.join(sourcePath, '.runtime', 'sandbox-control', 'manifest.json');
-        const controlLease = path.join(sourcePath, '.runtime', 'sandbox-control', 'lease.json');
-        if (request.intent !== 'complete' && (fs.existsSync(controlManifest) || fs.existsSync(controlLease))) {
-            return {
-                code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
-                message: 'task-bound sandbox control state exists; stop and remove the verified sandbox before moving the task directory'
-            };
-        }
-        const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
-        if (fs.existsSync(orchestrationPath)) {
-            try {
-                const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8'));
-                if (run.status === 'running' || run.pendingDelegation !== null && run.pendingDelegation !== undefined) {
-                    return {
-                        code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
-                        message: 'task orchestration has an active or pending delegation; settle it before moving the task directory'
-                    };
-                }
-            }
-            catch {
-                return {
-                    code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
-                    message: 'task orchestration state is unreadable; refusing to move the task directory'
-                };
-            }
-        }
-        return null;
-    };
     const currentTaskFile = path.join(sourcePath, 'task.md');
     const existingJournal = fs.existsSync(path.join(sourcePath, '.task-lifecycle.json'));
     if (sourceState === spec.target && !existingJournal) {
@@ -599,7 +674,7 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
         && !(request.intent === 'complete' && targetContainsTask(targetPath, taskId, request))) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    const moveSafety = assertRuntimeMoveSafe();
+    const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, true);
     if (moveSafety)
         return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     const content = io.readFileSync(currentTaskFile);
@@ -757,7 +832,7 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
     if (fs.existsSync(targetPath) && !fs.existsSync(path.join(sourcePath, 'task.md')))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {
-        const moveSafety = assertRuntimeMoveSafe();
+        const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, false);
         if (moveSafety)
             return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0, timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -833,7 +908,19 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
     const activeTaskPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
     if (request.intent === 'complete' && fs.existsSync(activeTaskPath)) {
         try {
-            fs.rmdirSync(activeTaskPath);
+            let sourceIsVirtiofsMount = false;
+            try {
+                sourceIsVirtiofsMount = isVirtiofsMountPoint(activeTaskPath, io.readMountInfoSync());
+            }
+            catch { /* Platforms without mountinfo retain the ordinary directory cleanup path. */ }
+            if (sourceIsVirtiofsMount) {
+                if (io.readdirSync(activeTaskPath).length > 0) {
+                    throw new Error('virtiofs source directory is not empty after task contents were transferred');
+                }
+            }
+            else {
+                io.rmdirSync(activeTaskPath);
+            }
         }
         catch (error) {
             return failed(request, { code: 'LIFECYCLE_SOURCE_DIRECTORY_CLEANUP_FAILED', message: String(error) }, {

package/dist/lib/task/short-id.js

@@ -361,7 +361,7 @@ function loadShortIdByTaskId(repoRoot) {
     }
     return map;
 }
-function inspectShortIdRegistry(repoRoot) {
+function inspectShortIdRegistry(repoRoot, shortIdLength = configuredShortIdLength(repoRoot)) {
     const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', REGISTRY_NAME);
     if (!fs.existsSync(registryPath)) {
         return {
@@ -399,7 +399,7 @@ function inspectShortIdRegistry(repoRoot) {
         };
     }
     try {
-        const registry = validateRegistry(parsed, registryPath, configuredShortIdLength(repoRoot));
+        const registry = validateRegistry(parsed, registryPath, shortIdLength);
         const shortIds = new Map();
         for (const [key, taskId] of Object.entries(registry.ids))
             shortIds.set(taskId, key);

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.13",
-  "sourceInputHash": "70e89f362895c1f8f976011715a86b47e06c105ca4285eacbb3fa51d0459a282",
-  "internalExecutableBuildHash": "f183e6d39ba985dbb2962eb951b4019af9594361ca3c46b88bf65fff325d7ad4"
+  "packageVersion": "0.11.15",
+  "sourceInputHash": "2d62f5ec22e0e0024a0e11258cef192b9d4c80764386bc112e4c2a3a03d72a3f",
+  "internalExecutableBuildHash": "9b88774ed654efea7d31aea3790aa1194f30df1f4487f95664de03f48815123f"
 }

package/lib/agent-clients/adapter.ts

@@ -23,28 +23,6 @@ import type {
   SandboxTool,
   SandboxToolContext
 } from '../sandbox/tool-types.ts';
-import type { SandboxControlManifest } from '../sandbox/control/protocol.ts';
-
-type AgentClientSandboxControlOperation = Readonly<{
-  validate: (params: Readonly<{
-    operation: string;
-    payload: Record<string, unknown>;
-    manifest: SandboxControlManifest;
-  }>) => void;
-  execute: (params: Readonly<{
-    operation: string;
-    payload: Record<string, unknown>;
-    manifest: SandboxControlManifest;
-    manifestPath: string;
-  }>) => Promise<Readonly<{ exitCode: number; stdout: string; stderr: string }>>;
-  recover?: (params: Readonly<{
-    operation: string;
-    manifest: SandboxControlManifest;
-    manifestPath: string;
-    stdout: string | null;
-  }>) => Readonly<Record<string, unknown>>;
-}>;
-
 type AgentClientCapabilities = AgentClientCapabilityMap;
 
 type AgentClientModelSelectionContext =
@@ -147,7 +125,6 @@ type AgentClientAdapter = Readonly<{
   modelSelection: AgentClientModelSelectionContext;
   delegationEvidence: AgentClientDelegationEvidence;
   orchestrationAdapter?: AgentClientOrchestrationAdapter;
-  sandboxControlOperation?: AgentClientSandboxControlOperation;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -728,9 +705,6 @@ function defineAgentClientAdapter(
     ...(candidate.orchestrationAdapter === undefined
       ? {}
       : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
-    ...(candidate.sandboxControlOperation === undefined
-      ? {}
-      : { sandboxControlOperation: Object.freeze({ ...candidate.sandboxControlOperation }) }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
@@ -753,7 +727,6 @@ export type {
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
   AgentClientDelegationEvidence,
-  AgentClientSandboxControlOperation,
   AgentClientLifecycleRecoveryRequest,
   AgentClientLifecycleRecoveryResult,
   AgentClientOrchestrationAdapter,

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

@@ -170,8 +170,7 @@ function validateCodexLifecycleHookConfig(value: unknown): void {
 
 function parseCodexHooksList(
   value: unknown,
-  repoRoot: string,
-  expectedSource: 'direct-host' | 'isolated-user' = 'direct-host'
+  repoRoot: string
 ): readonly DiscoveredHook[] {
   const root = object(value);
   const entries = Array.isArray(root?.data) ? root.data : [];
@@ -203,10 +202,8 @@ function parseCodexHooksList(
     && 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);
@@ -628,7 +625,7 @@ function validateStaticCodexPreflight(repoRoot: string): Readonly<{ cliVersion:
 async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
   discoveredHooks: readonly DiscoveredHook[];
   hookProvenance: Readonly<{
-    hookSource: 'isolated-user' | 'managed' | 'project';
+    hookSource: 'managed' | 'project';
     hookSourcePathDigest: string;
     hookSourceHash: string;
   }>;
@@ -641,8 +638,7 @@ async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
     await transport.initialize();
     discoveredHooks = parseCodexHooksList(
       await transport.request('hooks/list', { cwds: [repoRoot] }),
-      repoRoot,
-      process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT ? 'isolated-user' : 'direct-host'
+      repoRoot
     );
   } finally { transport.close(); }
   const lifecycleHooks = LIFECYCLE_HOOKS.map(({ event, matcher, phase }) => discoveredHooks.filter((hook) =>
@@ -660,9 +656,7 @@ async function discoverLifecycleHooks(repoRoot: string): Promise<Readonly<{
     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/lib/agent-clients/adapters/codex-lifecycle/cli.ts

@@ -9,7 +9,6 @@ import {
   resolveCodexThread
 } from './app-server.ts';
 import { createCodexLifecycleStore } from './store.ts';
-import { verifyCodexSandboxControllerContextWithWarnings } from './sandbox-controller.ts';
 import type { CodexLifecycleEvent } from './evidence.ts';
 import { resolveTaskRef } from '../../../task/resolve-ref.ts';
 import { resolveTaskContext } from '../../../task/resolve-ref.ts';
@@ -103,10 +102,7 @@ function hookDefinitionHash(): string {
 }
 
 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/lib/agent-clients/adapters/codex-lifecycle/manifest-files.json

@@ -2,25 +2,18 @@
   "executableFiles": [
     "bin/internal-cli.ts",
     "lib/agent-clients/adapters/codex-lifecycle/cli.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.ts",
     "lib/internal/sandbox-control.ts",
     "lib/internal/task-orchestration.ts",
     "lib/agent-clients/adapters/codex-orchestration.ts",
     "lib/task/delegation-receipts.ts",
     "lib/task/orchestration.ts",
     "lib/agent-clients/adapters/codex-lifecycle/build-identity.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-client.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-operation.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-context.ts",
     "lib/agent-clients/adapters/codex-lifecycle/app-server.ts",
     "lib/agent-clients/adapters/codex-lifecycle/binding.ts",
     "lib/agent-clients/adapters/codex-lifecycle/evidence.ts",
     "lib/agent-clients/adapters/codex-lifecycle/store.ts",
     "lib/agent-clients/adapters/codex-lifecycle/manifest-files.json",
-    "lib/agent-clients/adapters/codex-lifecycle/controller-registration.ts",
     "lib/sandbox/control/protocol.ts",
-    "lib/sandbox/control/agent-operation.ts",
     "lib/sandbox/control/client.ts",
     "lib/sandbox/control/executor.ts",
     "lib/server/process-state.ts",

package/lib/agent-clients/adapters/codex-lifecycle/recovery.ts

@@ -216,15 +216,11 @@ function hostEvidenceMatches(
     && 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: StoredCodexLifecycle, receipt: DelegationReceipt, host: CodexLifecycleActivationEvidence): boolean {
-  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/lib/agent-clients/adapters/codex-lifecycle/store.ts

@@ -35,16 +35,13 @@ type CodexLifecycleActivationEvidence = Readonly<{
   packageVersion?: string;
   internalExecutableBuildHash?: string;
   lifecycleContractHash?: string;
-  hookSource?: 'project' | 'managed' | 'isolated-user';
+  hookSource?: 'project' | 'managed';
   hookSourcePathDigest?: string;
   hookSourceHash?: string;
   capabilitySessionId?: string;
   capabilityTurnId?: string;
-  capabilityToolUseId?: string;
   spawnToolUseId?: string;
   spawnObservedAt?: string;
-  controllerInstanceDigest?: string | null;
-  controlGeneration?: string | null;
 }>;
 
 type CodexAdapterState = Readonly<{

package/lib/agent-clients/adapters/codex-orchestration.ts

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

package/lib/agent-clients/adapters/codex.ts

@@ -6,7 +6,6 @@ import {
 } from './codex-sandbox.ts';
 import { parseCodexLifecycleBinding } from './codex-lifecycle/binding.ts';
 import { isCodexDelegationReceiptEvidence, isCodexLifecycleActivationEvidence } from './codex-lifecycle/evidence.ts';
-import { codexControllerOperation } from './codex-lifecycle/controller-operation.ts';
 
 function codexCarrierError(code: string): Error {
   const error = new Error(code);
@@ -80,7 +79,6 @@ const codexAdapter = defineAgentClientAdapter({
       return recoverStartedLifecycleFromAdapter(...args);
     }
   },
-  sandboxControlOperation: codexControllerOperation,
   project: {
     ownedPathPrefixes: ['.codex/'],
     managed: ['.codex/hooks.json', '.codex/agents/'],

package/lib/internal/cli-route-inventory.ts

@@ -38,7 +38,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/lib/internal/task-finalization.ts

@@ -7,8 +7,8 @@ import {
 import { applyTaskFinalization } from '../task/finalization.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import { resolveSandboxControlTransport } from './task-operation-registry.ts';
-import { quiesceSandboxControlForTaskCompletion } from '../sandbox/control/lifecycle.ts';
-import { resolveTaskRuntimeRoot } from '../task/runtime-paths.ts';
+import { validateSandboxControlTaskIdentity } from '../sandbox/control/lifecycle.ts';
+import { loadSandboxControlLocation } from '../sandbox/config.ts';
 import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.ts';
 import { verifyTaskEvent } from '../task/verification.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
@@ -86,7 +86,8 @@ async function taskFinalization(args: string[] = []): Promise<void> {
     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;
-    if (!statusDir || !taskId || !generation || !controlRootId || taskId !== resolved.taskId) {
+    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;
@@ -96,8 +97,8 @@ async function taskFinalization(args: string[] = []): Promise<void> {
       repoRoot,
       beforeLifecycle: async (currentTaskId) => {
         if (currentTaskId !== taskId) throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
-        await quiesceSandboxControlForTaskCompletion(
-          path.join(resolveTaskRuntimeRoot(taskId, { repoRoot }), 'sandbox-control'),
+        validateSandboxControlTaskIdentity(
+          controlRoot,
           { taskId, generation, controlRootId, statusDir }
         );
       },
@@ -111,8 +112,9 @@ async function taskFinalization(args: string[] = []): Promise<void> {
     process.exitCode = exitCode(status);
     return;
   }
+  const controlLocation = loadSandboxControlLocation(repoRoot);
   const result = await dispatchTaskControlOperation(
-    createDirectHostExecutionContext({ repoRoot }),
+    createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }),
     boundOperation
   );
   if (result.status === 'prepared') {

package/lib/internal/task-lifecycle.ts

@@ -9,6 +9,7 @@ import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import type { TaskLifecycleResult } from '../task/lifecycle.ts';
 import type { AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult } from '../agent-clients/adapter.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
+import { loadSandboxControlLocation } from '../sandbox/config.ts';
 
 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`;
 
@@ -59,8 +60,9 @@ async function taskLifecycle(args: string[] = []): Promise<void> {
     repoRoot = resolved.repoRoot;
   }
 
+  const controlLocation = loadSandboxControlLocation(repoRoot);
   const result = await dispatchTaskControlOperation(
-    createDirectHostExecutionContext({ repoRoot }),
+    createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }),
     operation
   ) as TaskLifecycleResult | LifecycleRecoveryResult;
   process.stdout.write(`${JSON.stringify(result)}\n`);

package/lib/internal/task-operation-registry.ts

@@ -60,8 +60,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     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'),
@@ -213,7 +211,7 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
 ]);
 
 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',