@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/lib/sandbox/commands/create.ts

@@ -57,12 +57,7 @@ import {
   runSandboxHooks,
   runBoundedSandboxHookCommand
 } from '../agent-client-reconciler.ts';
-import {
-  resolveTools,
-  tmpfsSeedStagingPath,
-  tmpfsSeedTargetPath,
-  toolConfigDirCandidates
-} from '../tools.ts';
+import { tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.ts';
 import type { SandboxTool, TmpfsSeedEntry } from '../tools.ts';
 import {
   assertFreshSandboxReady,
@@ -96,12 +91,6 @@ import {
 } from '../workspace-view.ts';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.ts';
 import { validateSelinuxDisableEnv } from '../engines/selinux.ts';
-import {
-  captureSandboxAuthority,
-  commandForSandboxAuthority,
-  verifySandboxAuthority,
-  type SandboxAuthorityEvidenceV1
-} from '../engines/authority.ts';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.ts';
 import { ensureSandboxDiscoveryReadmes } from '../readme-scaffold.ts';
 import { removeDirRecursive } from '../../remove-dir.ts';
@@ -155,7 +144,6 @@ const MANAGED_GITHUB_GIT_CONFIG = [
 ];
 
 type SandboxCreateConfig = ReturnType<typeof loadConfig>;
-type PreparedDockerfile = ReturnType<typeof prepareDockerfile>;
 type ResolvedTool = { tool: SandboxTool; dir: string };
 type TmpfsSeedPlanEntry = TmpfsSeedEntry & {
   volumeArgs: string[];
@@ -175,7 +163,6 @@ type EngineRunSafeFn = EngineRunFn;
 type EngineRunVerboseFn = (engine: string, cmd: string, args: string[], opts?: { cwd?: string; env?: NodeJS.ProcessEnv }) => void;
 type DirectRunFn = (cmd: string, args: string[], opts?: { cwd?: string }) => string;
 type DirectRunSafeFn = DirectRunFn;
-type DirectRunVerboseFn = (cmd: string, args: string[], opts?: { cwd?: string }) => void;
 type HostShellConfig = {
   hostDir: string;
   mounts: Array<{ hostPath: string; containerPath: string }>;
@@ -933,24 +920,6 @@ function runEngineTaskCommand(engine: string, cmd: string, args: string[], opts:
   return runTaskCommand(command.cmd, command.args, opts);
 }
 
-function runSandboxAuthorityTaskCommand(
-  authority: SandboxAuthorityEvidenceV1,
-  cmd: string,
-  args: string[],
-  opts: { cwd?: string } = {}
-): string {
-  const command = commandForSandboxAuthority(authority, cmd, args);
-  return runTaskCommand(command.cmd, command.args, opts);
-}
-
-function runSandboxAuthoritySafeCommand(
-  authority: SandboxAuthorityEvidenceV1,
-  args: string[]
-): string {
-  const command = commandForSandboxAuthority(authority, 'docker', args);
-  return runSafe(command.cmd, command.args);
-}
-
 // `docker run` args for mounting a tool's containerMount as an in-container
 // tmpfs. containerMount is an in-container path, so it is NOT engine-converted.
 export function buildTmpfsRunArgs(containerMount: string, tmpfs: { size?: string; exec?: boolean }): string[] {
@@ -1317,18 +1286,29 @@ export async function create(
             const previousManifest = fs.existsSync(controlPaths.manifestPath)
               ? readSandboxControlManifest(controlPaths.manifestPath)
               : null;
-            if (hadExistingControlRoot) {
-              await quiesceSandboxControlRoot(controlPaths.root);
-            }
-            const previousCutoverSnapshot = hadExistingControlRoot
-              ? captureSandboxControlCutoverSnapshot(controlPaths.root)
-              : null;
           const existing = runSafeEngine(engine, 'docker', ['ps', '-a', '--format', '{{.Names}}']).split('\n').filter(Boolean);
           const matchedContainers = containerNameCandidates(effectiveConfig, branch)
             .filter((name) => existing.includes(name));
 
+          const oldContainer = previousManifest ? await inspectSandboxControlContainer(previousManifest) : null;
+          if (oldContainer?.state === 'unknown') {
+            throw new Error(`SANDBOX_CONTROL_CONTAINER_UNKNOWN: ${oldContainer.reason}`);
+          }
+          if (previousManifest && (previousManifest.branch !== branch
+            || previousManifest.mode !== target.workspace.mode
+            || previousManifest.taskId !== (target.workspace.mode === 'task-bound' ? target.workspace.taskId : null)
+            || fs.realpathSync.native(previousManifest.worktreeRoot) !== fs.realpathSync.native(worktree))) {
+            throw new Error('SANDBOX_WORKSPACE_IDENTITY_CONFLICT: recorded sandbox binding does not match the requested worktree');
+          }
+          const removalIds: string[] = [];
           if (matchedContainers.length > 0) {
             for (const name of matchedContainers) {
+              const id = runSafeEngine(engine, 'docker', ['inspect', '--format', '{{.Id}}', name]).trim();
+              if (!/^[a-f0-9]{64}$/u.test(id)
+                || (previousManifest && id !== previousManifest.containerIdentity.id)) {
+                throw new Error('SANDBOX_CONTROL_CONTAINER_IDENTITY_MISMATCH');
+              }
+              removalIds.push(id);
               const rawLabels = runSafeEngine(engine, 'docker', [
                 'inspect', '--format', '{{json .Config.Labels}}', name
               ]).trim();
@@ -1359,19 +1339,9 @@ export async function create(
                 );
               }
             }
-            message('Removing old container instance...');
-            for (const name of matchedContainers) {
-              runSafeEngine(engine, 'docker', ['stop', name]);
-              runSafeEngine(engine, 'docker', ['rm', name]);
-            }
           }
-          if (previousManifest) {
-            const oldContainer = await inspectSandboxControlContainer(previousManifest);
-            if (oldContainer.state !== 'absent') {
-              throw new Error(oldContainer.state === 'unknown'
-                ? `SANDBOX_CONTROL_CONTAINER_UNKNOWN: ${oldContainer.reason}`
-                : 'SANDBOX_CONTROL_CONTAINER_STILL_EXISTS');
-            }
+          if (oldContainer?.state === 'found' && !removalIds.includes(oldContainer.id)) {
+            throw new Error('SANDBOX_CONTROL_CONTAINER_IDENTITY_MISMATCH');
           }
           const aliasesFile = ensureSandboxAliasesFile(
             effectiveConfig.home,
@@ -1455,8 +1425,17 @@ export async function create(
               ? prepareSandboxCompletedTaskMountSource(effectiveConfig.repoRoot, target.workspace.taskId)
               : null;
             prepareSandboxWorkspaceMountTargets(effectiveConfig.repoRoot);
+            if (hadExistingControlRoot) await quiesceSandboxControlRoot(controlPaths.root);
+            const previousCutoverSnapshot = hadExistingControlRoot
+              ? captureSandboxControlCutoverSnapshot(controlPaths.root)
+              : null;
+            if (previousCutoverSnapshot) assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
+            if (removalIds.length > 0) message('Removing old container instance...');
+            for (const id of removalIds) {
+              runEngineTaskCommand(engine, 'docker', ['stop', id]);
+              runEngineTaskCommand(engine, 'docker', ['rm', id]);
+            }
             if (previousCutoverSnapshot) {
-              assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
               if (previousManifest) {
                 const finalOldContainer = await inspectSandboxControlContainer(previousManifest);
                 if (finalOldContainer.state !== 'absent') {
@@ -1559,11 +1538,8 @@ export async function create(
             const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
 
             let createdContainerRef: string | null = null;
-            let creationAuthority: SandboxAuthorityEvidenceV1 | null = null;
             try {
-              creationAuthority = captureSandboxAuthority(engine);
-              commandForSandboxAuthority(creationAuthority, 'docker');
-              const dockerRunId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+              const dockerRunId = runEngineTaskCommand(engine, 'docker', [
               'run',
               '-d',
               '--init',
@@ -1622,11 +1598,11 @@ export async function create(
               effectiveConfig.imageName
               ]);
               createdContainerRef = dockerRunId.trim();
-              const containerId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+              const containerId = runEngineTaskCommand(engine, 'docker', [
                 'inspect', '--format', '{{.Id}}', dockerRunId.trim()
               ]).trim();
-              if (!containerId) throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
-              const rawContainerLabels = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+              if (!/^[a-f0-9]{64}$/u.test(containerId)) throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
+              const rawContainerLabels = runEngineTaskCommand(engine, 'docker', [
                 'inspect', '--format', '{{json .Config.Labels}}', containerId
               ]).trim();
               let inspectedLabels: unknown;
@@ -1651,18 +1627,10 @@ export async function create(
               for (const [key, expected] of Object.entries(expectedLabels)) {
                 if (labels[key] !== expected) throw new Error('SANDBOX_CONTROL_CONTAINER_IDENTITY_MISMATCH');
               }
-              const authorityEvidence = captureSandboxAuthority(engine, {
-                route: creationAuthority,
-                lockDomain: creationAuthority.lockDomain
-              });
-              if (verifySandboxAuthority(creationAuthority, authorityEvidence).state !== 'verified') {
-                throw new Error('SANDBOX_AUTHORITY_DRIFT_DURING_CREATE');
-              }
               finalizeSandboxControlManifest(control, {
                 engine,
                 id: containerId,
-                labels: expectedLabels,
-                authorityEvidence
+                labels: expectedLabels
               });
               replacementLease.clearQuiescing();
               await startSandboxControlBroker(effectiveConfig.repoRoot, control.manifestPath);
@@ -1673,13 +1641,8 @@ export async function create(
               createdTmpfsSeedPlan = tmpfsSeedPlan;
             } catch (error) {
               if (createdContainerRef) {
-                if (creationAuthority) {
-                  runSandboxAuthoritySafeCommand(creationAuthority, ['stop', createdContainerRef]);
-                  runSandboxAuthoritySafeCommand(creationAuthority, ['rm', createdContainerRef]);
-                } else {
-                  runSafeEngine(engine, 'docker', ['stop', createdContainerRef]);
-                  runSafeEngine(engine, 'docker', ['rm', createdContainerRef]);
-                }
+                runSafeEngine(engine, 'docker', ['stop', createdContainerRef]);
+                runSafeEngine(engine, 'docker', ['rm', createdContainerRef]);
               }
               if (!hadExistingControlRoot) removeDirRecursive(control.root);
               if (replacementCutover) {

package/lib/sandbox/commands/list-running.ts

@@ -2,8 +2,6 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { runSafeEngine, runVerboseEngine } from '../shell.ts';
-import { resolveTaskBranch } from '../task-resolver.ts';
-import { isRemovedHashShortIdInput } from '../../task/short-id.ts';
 import { parseSandboxWorkspaceIdentity } from '../workspace-identity.ts';
 import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.ts';
 
@@ -191,23 +189,6 @@ export function resolveTaskShortRef(
   );
 }
 
-/**
- * Resolve a sandbox command argument (`<branch | TASK-id | N>`) to a
- * branch name, mirroring `ai sandbox exec` so that `start` and `exec` share one
- * input contract. Short refs go through the registry-only resolver (which throws
- * an actionable error on a miss); everything else flows through resolveTaskBranch
- * (plain branch names pass through unchanged, TASK-ids resolve via task.md).
- * Callers still run assertValidBranchName on the result.
- */
-export function resolveBranchArg(arg: string, ctx: { repoRoot: string }): string {
-  if (isRemovedHashShortIdInput(arg)) {
-    throw new Error(`Invalid task short id '${arg}': task short ids must use bare digits`);
-  }
-  return isTaskShortRef(arg)
-    ? resolveTaskShortRef(arg, ctx)
-    : resolveTaskBranch(arg, ctx.repoRoot);
-}
-
 /**
  * Pick the sandbox container row whose name matches one of the candidate
  * container names (covers both the '..' and legacy '-' branch sanitizations).

package/lib/sandbox/commands/start.ts

@@ -15,11 +15,10 @@ import { resolveSandboxTarget } from '../workspace-identity.ts';
 
 const USAGE = `Usage: ai sandbox start [--recreate] <branch | TASK-id | N>
 
-Start an existing sandbox container that has stopped (for example after the
-Docker daemon was restarted or replaced). The container must already exist:
-if none is found, run 'ai sandbox create <branch>' first. Without --recreate, a
-container that is already running is checked without modifying healthy runtime
-state. --recreate replaces the existing container even when it is healthy.`;
+Start or check an existing sandbox without replacing it. A missing container
+leaves its task and control data intact. --recreate explicitly restores a missing
+container from its existing worktree or replaces an existing container, preserving
+the worktree and host-managed data.`;
 
 export function parseStartArgs(args: string[]): { target: string; recreate: boolean; help: boolean } {
   let recreate = false;
@@ -70,10 +69,8 @@ export async function start(args: string[]): Promise<void> {
     containerNameCandidates(config, branch)
   );
 
-  if (!found) {
-    throw new Error(
-      `No sandbox container for branch '${branch}'. Run 'ai sandbox create ${branch}' to create one.`
-    );
+  if (!found && !parsed.recreate) {
+    throw new Error(`No sandbox container for branch '${branch}'. Existing task and control data were preserved; use --recreate to explicitly restore the container.`);
   }
 
   const ready = await ensureSandboxReady({
@@ -81,7 +78,7 @@ export async function start(args: string[]): Promise<void> {
     engine,
     branch,
     workspace: target.workspace,
-    row: found,
+    row: found ?? null,
     allowRecreate: parsed.recreate,
     forceRecreate: parsed.recreate,
     recreate: async () => {

package/lib/sandbox/constants.ts

@@ -67,18 +67,10 @@ export function containerNameCandidates(config: Pick<SandboxPathConfig, 'contain
   return safeNameCandidates(branch).map((name) => `${config.containerPrefix}-${name}`);
 }
 
-export function worktreeDir(config: Pick<SandboxPathConfig, 'worktreeBase'>, branch: string): string {
-  return hostJoin(config.worktreeBase, sanitizeBranchName(branch));
-}
-
 export function worktreeDirCandidates(config: Pick<SandboxPathConfig, 'worktreeBase'>, branch: string): string[] {
   return safeNameCandidates(branch).map((name) => hostJoin(config.worktreeBase, name));
 }
 
-export function shareDir(config: Pick<SandboxPathConfig, 'shareBase'>): string {
-  return config.shareBase;
-}
-
 export function shareCommonDir(config: Pick<SandboxPathConfig, 'shareBase'>): string {
   return hostJoin(config.shareBase, 'common');
 }

package/lib/sandbox/control/client.ts

@@ -188,7 +188,6 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
   const statusDir = params.statusDir ?? process.env.AGENT_INFRA_CONTROL_STATUS_DIR ?? '/run/agent-infra/control-status';
   const taskViewEffect = taskViewEffectForRequest(request);
   const hostGeneration = preflight(statusDir, taskViewEffect);
-  const identityPath = path.join(statusDir, 'identity.json');
   if (fs.existsSync(statusDir)) {
     const identity = readSandboxControlIdentitySentinel(statusDir);
     const requestTask = canonicalRequestTask(request);

package/lib/sandbox/control/container-identity.ts

@@ -1,6 +1,5 @@
 import type { SandboxControlManifest } from './protocol.ts';
 import { runProbe } from '../shell.ts';
-import { captureSandboxAuthority, isSandboxAuthorityEvidence, verifySandboxAuthority } from '../engines/authority.ts';
 import { discoverExactContainer } from '../engines/docker-exact-discovery.ts';
 
 export type ContainerObservation =
@@ -46,24 +45,10 @@ export async function inspectSandboxControlContainer(
   manifest: SandboxControlManifest,
   options: { probe?: typeof runProbe; timeoutMs?: number } = {}
 ): Promise<ContainerObservation> {
-  if (!isSandboxAuthorityEvidence(manifest.authorityEvidence)) {
-    return { state: 'unknown', reason: 'SANDBOX_AUTHORITY_EVIDENCE_MISSING' };
-  }
   try {
-    const authority = captureSandboxAuthority(manifest.engine, {
-      probe: options.probe,
-      timeoutMs: options.timeoutMs,
-      lockDomain: manifest.authorityEvidence.lockDomain,
-      route: manifest.authorityEvidence
-    });
-    const authorityState = verifySandboxAuthority(manifest.authorityEvidence, authority);
-    if (authorityState.state !== 'verified') {
-      return { state: 'unknown', reason: authorityState.reason ?? 'SANDBOX_AUTHORITY_UNAVAILABLE' };
-    }
     const discovered = discoverExactContainer(manifest.engine, manifest.containerIdentity.id, {
       probe: options.probe,
-      timeoutMs: options.timeoutMs,
-      authority: manifest.authorityEvidence
+      timeoutMs: options.timeoutMs
     });
     if (discovered.state === 'absent') return { state: 'absent', id: discovered.id };
     if (discovered.state === 'conflict') {

package/lib/sandbox/control/executor.ts

@@ -1,4 +1,4 @@
-import { spawn, type ChildProcess } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -424,7 +424,3 @@ function readJsonExecution(filePath: string): SandboxControlExecution {
   if (!value || value.requestId.length === 0) throw new Error('SANDBOX_CONTROL_EXECUTION_INVALID');
   return value;
 }
-
-export function disconnectExecutor(child: ChildProcess): void {
-  if (child.connected) child.disconnect();
-}

package/lib/sandbox/control/identity-sentinel.ts

@@ -127,11 +127,3 @@ export function validateSandboxControlIdentity(params: Readonly<{
   }
   return { state: 'valid', sentinel };
 }
-
-export function assertSandboxControlIdentity(params: Parameters<typeof validateSandboxControlIdentity>[0]): SandboxControlIdentitySentinel {
-  const result = validateSandboxControlIdentity(params);
-  if (result.state !== 'valid' || !result.sentinel) {
-    throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
-  }
-  return result.sentinel;
-}

package/lib/sandbox/control/lifecycle.ts

@@ -22,7 +22,6 @@ import {
   resolveSandboxLockNamespace,
   type SandboxResourceLock
 } from './native-file-lock.ts';
-import { isSandboxAuthorityEvidence } from '../engines/authority.ts';
 import { validateSandboxControlIdentity } from './identity-sentinel.ts';
 import {
   parseSandboxControlStatus,
@@ -97,7 +96,6 @@ export type SandboxRemovalJournal = Readonly<{
   engine: string;
   containerId: string;
   generation: string;
-  authorityFingerprint: string;
   carrierIdentityDigest: string;
   lockDomain: string;
   owner: ProcessIdentity & Readonly<{ leaseNonce: string }>;
@@ -144,10 +142,14 @@ function removalJournalDomain(lockDomain: string, create = true): string {
 }
 
 function removalJournalPath(manifest: SandboxControlManifest): string {
-  return path.join(
-    removalJournalDomain(manifest.authorityEvidence.lockDomain),
-    `${removalCarrierDigest(manifest.engine, manifest.containerIdentity.id, manifest.generation)}.json`
-  );
+  const digest = removalCarrierDigest(manifest.engine, manifest.containerIdentity.id, manifest.generation);
+  // Existing interrupted removals retain their original native lock namespace.
+  const existing = listSandboxRemovalJournals({ project: manifest.project, branch: manifest.branch })
+    .filter((record) => record.carrierIdentityDigest === digest);
+  if (existing.length > 1) throw new Error('SANDBOX_CONTROL_REMOVAL_JOURNAL_IDENTITY_MISMATCH');
+  if (existing[0]) return removalJournalPathForRecord(existing[0]);
+  const namespace = resolveSandboxLockNamespace('sandbox-removal-journal');
+  return path.join(removalJournalDomain(namespace.lockDomain), `${digest}.json`);
 }
 
 function removalJournalPathForRecord(record: SandboxRemovalJournal): string {
@@ -195,8 +197,10 @@ function parseRemovalJournal(raw: string): SandboxRemovalJournal {
   } catch {
     throw new Error('SANDBOX_CONTROL_REMOVAL_JOURNAL_INVALID');
   }
+  // TODO(compat): Remove obsolete-field normalization after pre-simplification removal journals drain.
+  if (isRecord(value)) delete value.authorityFingerprint;
   if (!isRecord(value) || !hasExactKeys(value, [
-    'authorityFingerprint', 'carrierIdentityDigest', 'containerId', 'engine', 'expectedOldJournalRevision',
+    'carrierIdentityDigest', 'containerId', 'engine', 'expectedOldJournalRevision',
     'generation', 'handoffId', 'lockDomain', 'newOperation', 'oldOperation', 'operation', 'owner', 'phase',
     'recordedAt', 'revision', 'target', 'transitionId', 'version'
   ]) || !isRecord(value.owner) || !hasExactKeys(value.owner, ['leaseNonce', 'pid', 'startTime'])
@@ -211,7 +215,6 @@ function parseRemovalJournal(raw: string): SandboxRemovalJournal {
     || typeof value.engine !== 'string' || value.engine.length === 0
     || typeof value.containerId !== 'string' || value.containerId.length === 0
     || typeof value.generation !== 'string' || value.generation.length === 0
-    || typeof value.authorityFingerprint !== 'string' || !/^[a-f0-9]{64}$/u.test(value.authorityFingerprint)
     || typeof value.carrierIdentityDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(value.carrierIdentityDigest)
     || typeof value.lockDomain !== 'string' || !/^[a-f0-9]{64}$/u.test(value.lockDomain)
     || !Number.isSafeInteger(value.owner.pid) || (value.owner.pid as number) <= 0
@@ -254,7 +257,6 @@ function parseRemovalJournal(raw: string): SandboxRemovalJournal {
     engine: value.engine as string,
     containerId: value.containerId as string,
     generation: value.generation as string,
-    authorityFingerprint: value.authorityFingerprint as string,
     carrierIdentityDigest: value.carrierIdentityDigest as string,
     lockDomain: value.lockDomain as string,
     owner: {
@@ -470,9 +472,7 @@ function startRemovalJournal(
   const target = removalJournalPath(manifest);
   const existing = readRemovalJournalAt(target);
   if (existing && (existing.engine !== manifest.engine || existing.containerId !== manifest.containerIdentity.id
-    || existing.generation !== manifest.generation
-    || existing.authorityFingerprint !== manifest.authorityEvidence.authorityFingerprint
-    || existing.lockDomain !== manifest.authorityEvidence.lockDomain)) {
+    || existing.generation !== manifest.generation)) {
     throw new Error('SANDBOX_CONTROL_REMOVAL_JOURNAL_IDENTITY_MISMATCH');
   }
   const targetCommit = options.target ?? existing?.target ?? defaultRemovalTarget(manifest);
@@ -496,9 +496,8 @@ function startRemovalJournal(
     engine: manifest.engine,
     containerId: manifest.containerIdentity.id,
     generation: manifest.generation,
-    authorityFingerprint: manifest.authorityEvidence.authorityFingerprint,
     carrierIdentityDigest: removalCarrierDigest(manifest.engine, manifest.containerIdentity.id, manifest.generation),
-    lockDomain: manifest.authorityEvidence.lockDomain,
+    lockDomain: existing?.lockDomain ?? resolveSandboxLockNamespace('sandbox-removal-journal').lockDomain,
     owner: { pid: process.pid, startTime, leaseNonce: randomUUID() },
     target: targetCommit
   };
@@ -574,21 +573,6 @@ export function advanceSandboxRemovalJournalPhase(
   }
 }
 
-export function advanceSandboxRemovalJournalToPhase(
-  journal: SandboxRemovalJournal,
-  phase: SandboxRemovalJournalPhase,
-  resourceLock: SandboxResourceLock
-): SandboxRemovalJournal {
-  let current = journal;
-  while (phaseIndex(current.phase) < phaseIndex(phase)) {
-    const next = current.phase === 'target-committed' && phase === 'container-absent'
-      ? phase : SANDBOX_REMOVAL_JOURNAL_PHASES[phaseIndex(current.phase) + 1];
-    if (!next) throw new Error('SANDBOX_CONTROL_REMOVAL_PHASE_TRANSITION_INVALID');
-    current = advanceSandboxRemovalJournalPhase(current, next, { resourceLock });
-  }
-  return current;
-}
-
 async function awaitWithDeadline<T>(
   operation: () => Promise<T>,
   deadlineAt: number,
@@ -682,7 +666,6 @@ function recordSandboxRemovalPending(
       phase,
       containerId: manifest.containerIdentity.id,
       generation: manifest.generation,
-      authorityFingerprint: manifest.authorityEvidence.authorityFingerprint,
       recordedAt: Date.now()
     })}\n`, { mode: 0o600, flag: 'wx' });
     fs.renameSync(temporary, pendingPath);
@@ -1104,11 +1087,13 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
   } catch {
     throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
+  // TODO(compat): Remove obsolete-field normalization after existing sandbox manifests are rewritten by their lifecycle.
+  delete manifest.authorityEvidence;
   const candidate = manifest as Partial<SandboxControlManifest>;
   const expectedKeys = [
     'branch', 'channelDir', 'container', 'containerIdentity', 'engine', 'generation',
     'mode', 'processingDir', 'project', 'publicStatusDir', 'repoRoot', 'runtimeDir',
-    'taskId', 'token', 'worktreeRoot', 'authorityEvidence', 'controlRootId',
+    'taskId', 'token', 'worktreeRoot', 'controlRootId',
   ];
   const actualKeys = Object.keys(manifest).sort().join(',');
   if (actualKeys !== expectedKeys.sort().join(',')) {
@@ -1134,8 +1119,7 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
     || typeof candidate.generation !== 'string'
     || typeof candidate.controlRootId !== 'string' || !/^[a-f0-9]{64,128}$/u.test(candidate.controlRootId)
     || (candidate.mode === 'task-bound' && (typeof candidate.taskId !== 'string' || candidate.taskId.length === 0))
-    || (candidate.mode === 'branch-only' && candidate.taskId !== null)
-    || !isSandboxAuthorityEvidence(candidate.authorityEvidence)) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
+    || (candidate.mode === 'branch-only' && candidate.taskId !== null)) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   const root = path.dirname(path.resolve(manifestPath));
   const canonicalRoot = fs.realpathSync.native(root);
   const resolveControlChildPath = (candidatePath: string, name: string): string | null => {
@@ -1174,7 +1158,6 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
       id: containerIdentity.id as string,
       labels: { ...(containerIdentity.labels as Record<string, string>) }
     },
-    authorityEvidence: candidate.authorityEvidence,
     branch: candidate.branch,
     mode: candidate.mode,
     taskId: candidate.taskId,
@@ -1489,7 +1472,7 @@ async function removeSandboxControlRootAttempt(
   const manifest = readSandboxControlManifest(manifestPath);
   const resourceLock = options.resourceLock ?? acquireSandboxResourceLock(
     `${manifest.engine}:${manifest.containerIdentity.id}`,
-    { lockDomain: manifest.authorityEvidence.lockDomain }
+    { lockDomain: readSandboxRemovalJournal(manifest)?.lockDomain }
   );
   try {
   if (fs.readFileSync(manifestPath, 'utf8') !== manifestRawBeforeLock) {
@@ -1603,7 +1586,6 @@ async function removeSandboxControlRootAttempt(
   if (currentManifestRaw !== manifestRawBeforeLock
     || currentManifest.engine !== manifest.engine
     || currentManifest.containerIdentity.id !== manifest.containerIdentity.id
-    || currentManifest.authorityEvidence.lockDomain !== manifest.authorityEvidence.lockDomain
     || currentManifest.token !== manifest.token || currentManifest.generation !== manifest.generation
     || !isSandboxControlRootQuiescing(resolvedRoot)) {
     throw new Error('SANDBOX_CONTROL_MANIFEST_CHANGED');
@@ -1683,18 +1665,3 @@ async function removeSandboxControlRootAttempt(
     if (!options.resourceLock) resourceLock.release();
   }
 }
-
-export type GarbageCollectSandboxControlOptions = Omit<RemoveSandboxControlOptions, 'removeContainer' | 'requireAbsent'>;
-
-export async function garbageCollectSandboxControlRoot(
-  root: string,
-  options: GarbageCollectSandboxControlOptions = {}
-): Promise<void> {
-  await removeSandboxControlRoot(path.resolve(root), {
-    ...options,
-    requireAbsent: true,
-    removeContainer: async () => {
-      throw new Error('SANDBOX_CONTROL_CONTAINER_REAPPEARED');
-    }
-  });
-}

package/lib/sandbox/control/native-file-lock.ts

@@ -86,14 +86,6 @@ export function resolveSandboxLockNamespace(
   };
 }
 
-export function stableSandboxLockPath(
-  carrierIdentity: string,
-  lockDomain?: string,
-  options: Readonly<{ home?: string }> = {}
-): string {
-  return resolveSandboxLockNamespace(carrierIdentity, { lockDomain, home: options.home }).lockPath;
-}
-
 export function acquireSandboxResourceLock(
   carrierIdentity: string,
   options: Readonly<{ lockDomain?: string; home?: string }> = {}

package/lib/sandbox/control/protocol.ts

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate, type TaskCreateCandidateV1 } from '../../task/create.ts';
 import type { ProcessIdentity } from '../../server/process-state.ts';
-import type { SandboxAuthorityEvidenceV1 } from '../engines/authority.ts';
 import type { SandboxTaskView } from './task-view.ts';
 
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
@@ -36,7 +35,6 @@ export type SandboxControlContainerIdentity = Readonly<{
 export type SandboxControlManifestBase = Readonly<{
   engine: string; repoRoot: string; worktreeRoot: string; project: string; container: string;
   containerIdentity: SandboxControlContainerIdentity;
-  authorityEvidence: SandboxAuthorityEvidenceV1;
   branch: string; mode: 'task-bound' | 'branch-only'; taskId: string | null; token: string;
   generation: string; controlRootId: string; channelDir: string; publicStatusDir: string; processingDir: string;
 }>;