@fitlab-ai/agent-infra 0.11.13 → 0.11.14

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

@@ -8,7 +8,7 @@ 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 { 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;
@@ -97,7 +98,7 @@ async function taskFinalization(args: string[] = []): Promise<void> {
       beforeLifecycle: async (currentTaskId) => {
         if (currentTaskId !== taskId) throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
         await quiesceSandboxControlForTaskCompletion(
-          path.join(resolveTaskRuntimeRoot(taskId, { repoRoot }), 'sandbox-control'),
+          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',

package/lib/internal/task-validate.ts

@@ -2,27 +2,9 @@ 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.ts';
-import { detectEngine } from '../sandbox/engine.ts';
-import { runEngine } from '../sandbox/shell.ts';
-import { sandboxBranchLabel, sandboxLabel } from '../sandbox/constants.ts';
-import { fetchSandboxRows, selectSandboxContainer } from '../sandbox/commands/list-running.ts';
-import { containerNameCandidates } from '../sandbox/constants.ts';
 import { resolveSandboxTarget } from '../sandbox/workspace-identity.ts';
-import { sandboxControlPaths } from '../sandbox/workspace-view.ts';
-import {
-  appendSandboxControlAudit,
-  readActiveLease,
-  readSandboxControlStatus
-} from '../sandbox/control/state.ts';
-import type { SandboxControlLease } from '../sandbox/control/protocol.ts';
-import { readSandboxControlManifest } from '../sandbox/control/lifecycle.ts';
-import {
-  SANDBOX_CONTROL_FUTURE_SKEW_MS,
-  SANDBOX_CONTROL_STATUS_STALE_MS
-} from '../sandbox/control/protocol.ts';
-import { getProcessStartTime } from '../server/process-state.ts';
+import { resolveBranchWorktree } from '../git/branch-worktree.ts';
 import { assertGitWorktreeBinding } from '../git/worktree-identity.ts';
 import { createManualValidationEvidence, manualValidationEvidenceSummary } from '../task/manual-validation-evidence.ts';
 import type { ManualValidationCleanup } from '../task/manual-validation-evidence.ts';
@@ -31,7 +13,6 @@ import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-in
 
 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;
 
 type ValidateOptions = {
   target: string;
@@ -108,20 +89,6 @@ function git(root: string, args: string[]): string {
   return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
 }
 
-function waitForState(statusDir: string, predicate: (state: ReturnType<typeof readSandboxControlStatus>) => boolean, timeoutMs = 5_000): void {
-  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: string, commit: string, options: ValidateOptions) {
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-validation-'));
   const worktree = path.join(tempRoot, 'worktree');
@@ -150,109 +117,28 @@ function snapshotValidation(repoRoot: string, commit: string, options: ValidateO
 }
 
 function inplaceValidation(config: ReturnType<typeof loadConfig>, target: ReturnType<typeof resolveSandboxTarget>, options: ValidateOptions) {
-  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: SandboxControlLease = {
-    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: string[] = [];
     try {
-      const currentBranch = git(manifest.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
-      if (currentBranch !== originalBranch) git(manifest.worktreeRoot, ['switch', originalBranch]);
+      const currentBranch = git(worktree.worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+      if (currentBranch !== 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')) as { nonce?: unknown };
-      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;
   }
 }
 

package/lib/platform/release-notes.ts

@@ -136,8 +136,8 @@ async function releaseNoteContext(
   options: ReleaseNoteOptions = {}
 ) {
   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/lib/sandbox/commands/control-status.ts

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

package/lib/sandbox/commands/create.ts

@@ -1108,7 +1108,6 @@ export async function create(
   const container = containerName(effectiveConfig, branch);
   const controlPaths = sandboxControlPaths({
     base: effectiveConfig.controlBase,
-    repoRoot: effectiveConfig.repoRoot,
     project: effectiveConfig.project,
     container,
     identity: target.workspace
@@ -1493,6 +1492,7 @@ export async function create(
               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'
@@ -1588,8 +1588,6 @@ export async function create(
                 ]
                 : []),
               '-e',
-              `AGENT_INFRA_CONTROL_TOKEN=${control.token}`,
-              '-e',
               `AGENT_INFRA_CONTROL_GENERATION=${control.generation}`,
               '-e',
               'AGENT_INFRA_CONTROL_DIR=/run/agent-infra/control',
@@ -1598,7 +1596,10 @@ export async function create(
               '-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/lib/sandbox/config.ts

@@ -237,3 +237,16 @@ export function loadConfig({
     }
   };
 }
+
+export function loadSandboxControlLocation(repoRoot = detectRepoRoot()): Readonly<{
+  controlBase: string;
+  project: string;
+}> | null {
+  const configPath = path.join(repoRoot, '.agents', '.airc.json');
+  if (!fs.existsSync(configPath)) return null;
+  const airc = JSON.parse(fs.readFileSync(configPath, 'utf8')) as AircConfig;
+  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 };
+}

package/lib/sandbox/control/audit.ts

@@ -41,8 +41,7 @@ const AUDIT_MAX_BYTES = 1024 * 1024;
 
 export function requestAuditFields(manifest: SandboxControlManifest, request: SandboxControlRequest) {
   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
   };
 }