@fitlab-ai/agent-infra 0.11.13 → 0.11.15

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/pr-change-report.ts

@@ -429,12 +429,15 @@ function runMechanicalChangeReport(repoRoot: string, baseSha: string, headSha: s
   return validated.value;
 }
 
+const DOCUMENTATION_CATEGORY = { label: '文档', prefixes: ['docs/'] } as const;
+
 const CHANGE_CATEGORIES = [
   { label: '运行时代码', prefixes: ['bin/', 'lib/', 'src/', 'scripts/'] },
   { label: '测试与校验', prefixes: ['test/', 'tests/'] },
   { label: '模板与生成内容', prefixes: ['templates/'] },
   { label: '技能与协作配置', prefixes: ['.agents/'] },
-  { label: '文档与其他', prefixes: [] }
+  DOCUMENTATION_CATEGORY,
+  { label: '其他', prefixes: [] }
 ] as const;
 
 function emptyChangeTotals(): ChangeTotals {
@@ -443,7 +446,10 @@ function emptyChangeTotals(): ChangeTotals {
 
 function categoryForChangeFile(file: ChangeFile): (typeof CHANGE_CATEGORIES)[number] {
   const filePath = file.newPath || file.oldPath || '';
-  return CHANGE_CATEGORIES.find((category) => category.prefixes.some((prefix) => filePath.startsWith(prefix))) || CHANGE_CATEGORIES[CHANGE_CATEGORIES.length - 1]!;
+  const category = CHANGE_CATEGORIES.find((entry) => entry.prefixes.some((prefix) => prefix && filePath.startsWith(prefix)));
+  if (category) return category;
+  if (/\.(?:md|mdx|markdown|rst)$/i.test(filePath)) return DOCUMENTATION_CATEGORY;
+  return CHANGE_CATEGORIES[CHANGE_CATEGORIES.length - 1]!;
 }
 
 function summarizeChangeCategories(files: ChangeFile[]): Array<{ label: string; totals: ChangeTotals }> {
@@ -553,7 +559,7 @@ function renderEvidence(evidence: Evidence): string {
 function renderPrechecks(checks: Precheck[]): string[] {
   return checks.flatMap((check) => [
     `- **${PRECHECK_LABELS[check.id]}（${check.id}）**：${check.verdict === 'pass' ? '通过' : '需复核'}。${escapeReportText(check.rationale)}`,
-    ...check.evidence.slice(0, 1).map(renderEvidence)
+    ...check.evidence.map(renderEvidence)
   ]);
 }
 

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/process-data/index.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 import { detectRepoRoot } from '../task/resolve-ref.ts';
@@ -52,16 +53,26 @@ function parseArgs(args: string[], valueOptions: Set<string>, booleanOptions: Se
 }
 
 function dataRoot(repoRoot: string, requested?: string): string {
-  const workspace = path.resolve(repoRoot, '.agents', 'workspace');
-  const resolved = path.resolve(repoRoot, requested ?? path.join('.agents', 'workspace', 'process-data'));
+  let boundary = repoRoot;
+  let input = requested;
+  if (input === undefined) {
+    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { project?: unknown };
+    if (typeof config.project !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(config.project)) {
+      throw new Error('.agents/.airc.json must contain a valid project name in its project field');
+    }
+    boundary = path.resolve(os.homedir());
+    input = path.join(boundary, '.agent-infra', 'data-store', config.project);
+  }
+  const resolved = path.resolve(repoRoot, input);
   const relative = path.relative(repoRoot, resolved);
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('data root must be inside the repository');
+  if (requested !== undefined && (!relative || relative.startsWith('..') || path.isAbsolute(relative))) throw new Error('data root must be inside the repository');
+  const workspace = path.resolve(repoRoot, '.agents', 'workspace');
   const taskRoots = ['active', 'blocked', 'completed', 'archive'].map((state) => path.join(workspace, state));
   if (resolved === workspace || taskRoots.some((taskRoot) => resolved === taskRoot || resolved.startsWith(`${taskRoot}${path.sep}`))) {
     throw new Error('data root cannot be the workspace root or a task directory');
   }
   let current = resolved;
-  while (current !== repoRoot) {
+  while (current !== boundary) {
     if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) throw new Error('data root cannot traverse a symlink');
     current = path.dirname(current);
   }

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
   };
 }
 

package/lib/sandbox/control/client.ts

@@ -2,17 +2,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import {
-  SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
   SANDBOX_CONTROL_MAX_BYTES,
   SANDBOX_CONTROL_STATUS_STALE_MS,
   isSandboxControlFamily,
   type SandboxControlError,
   type SandboxControlRequest,
   type SandboxControlResponse,
-  type SandboxAgentClientRequest,
   type SandboxTaskCreateRequest
 } from './protocol.ts';
-import { isAgentClientId } from '../../agent-clients/types.ts';
 import { readSandboxControlPayload, readSandboxControlStatus } from './state.ts';
 import type { TaskCreateCandidateV1 } from '../../task/create.ts';
 import { accessSandboxTaskView, taskViewFromStatus, type TaskViewAccessEffect } from './task-view.ts';
@@ -53,11 +50,10 @@ function clientError(
 
 function preflight(
   statusDir: string,
-  generation: string,
   taskViewEffect: TaskViewAccessEffect | null = null,
   now = Date.now(),
   env: NodeJS.ProcessEnv = process.env
-): void {
+): string {
   if (fs.existsSync(statusDir)) {
     let identity;
     try {
@@ -68,9 +64,6 @@ function preflight(
         : 'SANDBOX_CONTROL_IDENTITY_MALFORMED';
       clientError(code, 'sandbox control identity is missing or invalid', false);
     }
-    if (identity.generation !== generation) {
-      clientError('SANDBOX_CONTROL_IDENTITY_GENERATION_MISMATCH', 'sandbox control identity generation does not match the request', false);
-    }
     if (env.AGENT_INFRA_CONTROL_ROOT_ID && identity.controlRootId !== env.AGENT_INFRA_CONTROL_ROOT_ID) {
       clientError('SANDBOX_CONTROL_IDENTITY_ROOT_ID_MISMATCH', 'sandbox control identity root does not match the client configuration', false);
     }
@@ -81,9 +74,6 @@ function preflight(
   } catch {
     clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', 'broker status is missing or invalid', true);
   }
-  if (status.generation !== generation) {
-    clientError('SANDBOX_CONTROL_GENERATION_INVALID', 'broker status generation does not match this sandbox', false);
-  }
   if (now - status.updatedAt > SANDBOX_CONTROL_STATUS_STALE_MS || status.updatedAt > now + 1_000) {
     clientError('SANDBOX_CONTROL_BROKER_UNAVAILABLE', 'broker status heartbeat is stale', true);
   }
@@ -107,6 +97,7 @@ function preflight(
       );
     }
   }
+  return status.generation;
 }
 
 function taskViewEffectForRequest(request: SandboxControlRequest): TaskViewAccessEffect | null {
@@ -201,7 +192,7 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
   const channelDir = params.channelDir ?? process.env.AGENT_INFRA_CONTROL_DIR ?? '/run/agent-infra/control';
   const statusDir = params.statusDir ?? process.env.AGENT_INFRA_CONTROL_STATUS_DIR ?? '/run/agent-infra/control-status';
   const taskViewEffect = taskViewEffectForRequest(request);
-  preflight(statusDir, request.generation, taskViewEffect);
+  const hostGeneration = preflight(statusDir, taskViewEffect);
   const identityPath = path.join(statusDir, 'identity.json');
   if (fs.existsSync(statusDir)) {
     const identity = readSandboxControlIdentitySentinel(statusDir);
@@ -246,7 +237,7 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
       try {
         // The request-specific terminal proves the broker claimed the request; preserve recovery evidence if marker cleanup won the race.
         accepted = true;
-        response = readPublishedResponse(raw, request.id, channelDir, accepted, request.generation);
+        response = readPublishedResponse(raw, request.id, channelDir, accepted, hostGeneration);
         malformedResponseRaw = null;
       } catch (error) {
         if (!(error instanceof SyntaxError)) throw error;
@@ -268,7 +259,7 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
     }
     if (!accepted) {
       try {
-        preflight(statusDir, request.generation, taskViewEffect);
+        preflight(statusDir, taskViewEffect);
       } catch (error) {
         if (cancelPendingRequest(requestPath)) throw error;
         clientError(
@@ -314,6 +305,9 @@ export function recoverSandboxControl(requestId: string, params: Readonly<{
       const config = loadConfig();
       const response = recoverSandboxControlFromHost(requestId, {
         managedRoot: path.join(config.controlBase, config.project),
+        controlBase: config.controlBase,
+        project: config.project,
+        repoRoot: config.repoRoot,
         timeoutMs: params.timeoutMs
       });
       if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
@@ -402,72 +396,30 @@ export function recoverSandboxControlFromChannel(requestId: string, params: Read
   );
 }
 
-function authority(params: { token?: string; generation?: string }): { token: string; generation: string } {
-  const token = params.token ?? process.env.AGENT_INFRA_CONTROL_TOKEN;
-  const generation = params.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
-  if (!token || !generation) clientError('SANDBOX_CONTROL_UNAVAILABLE', 'control authority is missing', false);
-  return { token, generation };
-}
-
 export function requestSandboxControl(params: Readonly<{
   family: string; args: string[]; channelDir?: string; statusDir?: string;
-  token?: string; generation?: string; timeoutMs?: number;
+  timeoutMs?: number;
 }>): SandboxControlResponse {
   if (!isSandboxControlFamily(params.family)) clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' is not allowed`, false);
-  if (params.family === 'task-create' || params.family === 'agent-client') {
+  if (params.family === 'task-create') {
     clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, false);
   }
   if (params.args[1] === 'complete') {
     clientError('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization', false);
   }
-  const auth = authority(params);
-  const issuedAt = Date.now();
   const request: SandboxControlRequest = {
-    version: 4, id: randomUUID(), ...auth, issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
+    version: 5, id: randomUUID(),
     family: params.family as 'task-lifecycle', args: params.args
   };
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxAgentOperation(params: Readonly<{
-  agentClient: string;
-  operation: string;
-  payload: Record<string, unknown>;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-}>): SandboxControlResponse {
-  if (!isAgentClientId(params.agentClient)) {
-    clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'agent-client id is invalid', false);
-  }
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const request: SandboxAgentClientRequest = {
-    version: 4,
-    id: randomUUID(),
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: 'agent-client',
-    agentClient: params.agentClient,
-    operation: params.operation,
-    payload: params.payload
-  };
-  return exchangeSandboxControl(request, params);
-}
-
 export function requestSandboxTaskCreate(params: Readonly<{
   candidate: TaskCreateCandidateV1; channelDir?: string; statusDir?: string;
-  token?: string; generation?: string; timeoutMs?: number;
+  timeoutMs?: number;
 }>): SandboxControlResponse {
-  const auth = authority(params);
-  const issuedAt = Date.now();
   const request: SandboxTaskCreateRequest = {
-    version: 4, id: randomUUID(), ...auth, issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
+    version: 5, id: randomUUID(),
     family: 'task-create', candidate: params.candidate,
   };
   return exchangeSandboxControl(request, { ...params, timeoutMs: params.timeoutMs ?? 120_000 });

package/lib/sandbox/control/executor.ts

@@ -33,8 +33,6 @@ import {
   type TaskControlOperation
 } from '../../task/control-authority.ts';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest, type BrokerOwner } from './lifecycle.ts';
-import { executeAgentClientOperation, validateAgentClientOperation } from './agent-operation.ts';
-import type { AgentClientSandboxControlOperation } from '../../agent-clients/adapter.ts';
 
 export type SandboxControlExecutionResult = {
   exitCode: number;
@@ -256,7 +254,6 @@ function taskCreateExecutionFailure(requestId: string, code: string, message: st
 
 type ExecuteRequestOptions = Readonly<{
   createTask?: typeof createTask;
-  agentClientOperation?: AgentClientSandboxControlOperation;
 }>;
 
 async function executeRequestInner(
@@ -279,10 +276,6 @@ async function executeRequestInner(
       return taskCreateExecutionFailure(request.id, code, detail);
     }
   }
-  if (request.family === 'agent-client') {
-    validateAgentClientOperation(request, manifest);
-    return executeAgentClientOperation(request, manifest, manifestPath, options.agentClientOperation);
-  }
   const boundArgs = bindSandboxControlTask(request, manifest.taskId!);
   let operation: TaskControlOperation;
   try {
@@ -346,9 +339,10 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   const gate = await waitForGate(nonce);
   const gateOwner = gate.owner;
   process.disconnect?.();
-  const manifestPath = process.env.AGENT_INFRA_EXECUTOR_MANIFEST;
-  if (!manifestPath) throw new Error('SANDBOX_CONTROL_EXECUTOR_MANIFEST_MISSING');
-  const manifest = readSandboxControlManifest(manifestPath);
+  const requestedManifestPath = process.env.AGENT_INFRA_EXECUTOR_MANIFEST;
+  if (!requestedManifestPath) throw new Error('SANDBOX_CONTROL_EXECUTOR_MANIFEST_MISSING');
+  const manifest = readSandboxControlManifest(requestedManifestPath);
+  const manifestPath = fs.realpathSync.native(requestedManifestPath);
   const identity = validateSandboxControlIdentity({
     publicStatusDir: manifest.publicStatusDir,
     root: path.dirname(path.resolve(manifestPath)),
@@ -390,17 +384,17 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
   let result: SandboxControlExecutionResult;
   try {
     assertSandboxControlExecutorAuthority(manifest, gateOwner);
-  const operation = request.family === 'task-lifecycle'
+    const operation = request.family === 'task-lifecycle'
       ? (() => {
         try { return parseTaskControlOperation(request.family, request.args); } catch { return null; }
       })()
-      : request.family === 'agent-client' ? request.operation : null;
+      : null;
     const context = createSandboxControlAuditContext(manifest, {
       requestId: request.id,
       family: request.family,
       operation: operation && typeof operation === 'object' && 'family' in operation && operation.family === 'task-lifecycle'
         ? operation.request.intent
-        : request.family === 'agent-client' ? request.operation : null,
+        : null,
       phase: 'started-committed',
       outcome: 'in-progress'
     });