@fitlab-ai/agent-infra 0.11.13 → 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-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/task-finalization.js

@@ -4,7 +4,7 @@ import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { resolveSandboxControlTransport } from './task-operation-registry.js';
 import { quiesceSandboxControlForTaskCompletion } from '../sandbox/control/lifecycle.js';
-import { resolveTaskRuntimeRoot } from '../task/runtime-paths.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';
@@ -71,7 +71,8 @@ async function taskFinalization(args = []) {
         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;
@@ -82,7 +83,7 @@ async function taskFinalization(args = []) {
             beforeLifecycle: async (currentTaskId) => {
                 if (currentTaskId !== taskId)
                     throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
-                await quiesceSandboxControlForTaskCompletion(path.join(resolveTaskRuntimeRoot(taskId, { repoRoot }), 'sandbox-control'), { taskId, generation, controlRootId, statusDir });
+                await quiesceSandboxControlForTaskCompletion(controlRoot, { taskId, generation, controlRootId, statusDir });
             },
             preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
         });
@@ -92,7 +93,8 @@ async function taskFinalization(args = []) {
         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,6 +2,7 @@ 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';
+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`);
@@ -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) {

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

@@ -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
@@ -1079,6 +1078,7 @@ 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'
@@ -1162,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',
@@ -1172,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/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) {