@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/sandbox/commands/create.js

@@ -15,7 +15,7 @@ import { detectEngine, ensureDocker } from '../engine.js';
 import { commandForEngine, execEngine, run, runEngine, runOk, runOkEngine, runSafe, runSafeEngine, runVerboseEngine } from '../shell.js';
 import { parseSandboxWorkspaceIdentity, resolveSandboxTarget, sameSandboxWorkspaceIdentity } from '../workspace-identity.js';
 import { createSandboxCapabilityPlan, runSandboxHooks, runBoundedSandboxHookCommand } from '../agent-client-reconciler.js';
-import { resolveTools, tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.js';
+import { tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.js';
 import { assertFreshSandboxReady, hydrateTmpfsSeedEntries, prepareTmpfsMounts, startSandboxControlBroker } from '../recovery.js';
 import { acquireSandboxControlReplacement, assertSandboxControlCutoverSnapshot, beginSandboxControlReplacement, captureSandboxControlCutoverSnapshot, commitSandboxControlReplacement, quiesceSandboxControlRoot, recoverSandboxControlReplacement, readSandboxControlManifest } from '../control/lifecycle.js';
 import { atomicWriteJson } from '../control/state.js';
@@ -26,7 +26,6 @@ import { materializeSandboxGitMetadata } from '../git-metadata.js';
 import { assertSandboxTaskSource, finalizeSandboxControlManifest, materializeSandboxControl, materializeSandboxWorkspaceView, prepareSandboxWorkspaceMountTargets, prepareSandboxCompletedTaskMountSource, sandboxControlPaths, } from '../workspace-view.js';
 import { clipboardHostDir, CONTAINER_CLIPBOARD_MOUNT } from '../clipboard/paths.js';
 import { validateSelinuxDisableEnv } from '../engines/selinux.js';
-import { captureSandboxAuthority, commandForSandboxAuthority, verifySandboxAuthority } from '../engines/authority.js';
 import { dotfilesCacheDir, materializeDotfiles } from '../dotfiles.js';
 import { ensureSandboxDiscoveryReadmes } from '../readme-scaffold.js';
 import { removeDirRecursive } from '../../remove-dir.js';
@@ -619,14 +618,6 @@ function runEngineTaskCommand(engine, cmd, args, opts = {}) {
     const command = commandForEngine(engine, cmd, args);
     return runTaskCommand(command.cmd, command.args, opts);
 }
-function runSandboxAuthorityTaskCommand(authority, cmd, args, opts = {}) {
-    const command = commandForSandboxAuthority(authority, cmd, args);
-    return runTaskCommand(command.cmd, command.args, opts);
-}
-function runSandboxAuthoritySafeCommand(authority, args) {
-    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, tmpfs) {
@@ -923,17 +914,28 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                         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 = [];
                         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();
@@ -963,19 +965,9 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                         + `Run 'ai sandbox start --recreate ${recoveryTarget}' on the host, then retry.`);
                                 }
                             }
-                            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, capabilityPlan.aliases);
                         if (aliasesFile.created) {
@@ -1041,8 +1033,20 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                 ? prepareSandboxCompletedTaskMountSource(effectiveConfig.repoRoot, target.workspace.taskId)
                                 : null;
                             prepareSandboxWorkspaceMountTargets(effectiveConfig.repoRoot);
-                            if (previousCutoverSnapshot) {
+                            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) {
                                 if (previousManifest) {
                                     const finalOldContainer = await inspectSandboxControlContainer(previousManifest);
                                     if (finalOldContainer.state !== 'absent') {
@@ -1133,11 +1137,8 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                             const hostTz = detectHostTimezone();
                             const tzFlags = hostTz ? ['-e', `TZ=${hostTz}`] : [];
                             let createdContainerRef = null;
-                            let creationAuthority = null;
                             try {
-                                creationAuthority = captureSandboxAuthority(engine);
-                                commandForSandboxAuthority(creationAuthority, 'docker');
-                                const dockerRunId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+                                const dockerRunId = runEngineTaskCommand(engine, 'docker', [
                                     'run',
                                     '-d',
                                     '--init',
@@ -1196,12 +1197,12 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                     effectiveConfig.imageName
                                 ]);
                                 createdContainerRef = dockerRunId.trim();
-                                const containerId = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+                                const containerId = runEngineTaskCommand(engine, 'docker', [
                                     'inspect', '--format', '{{.Id}}', dockerRunId.trim()
                                 ]).trim();
-                                if (!containerId)
+                                if (!/^[a-f0-9]{64}$/u.test(containerId))
                                     throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
-                                const rawContainerLabels = runSandboxAuthorityTaskCommand(creationAuthority, 'docker', [
+                                const rawContainerLabels = runEngineTaskCommand(engine, 'docker', [
                                     'inspect', '--format', '{{json .Config.Labels}}', containerId
                                 ]).trim();
                                 let inspectedLabels;
@@ -1228,18 +1229,10 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                     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);
@@ -1251,14 +1244,8 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                             }
                             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);

package/dist/lib/sandbox/commands/list-running.js

@@ -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.js';
-import { resolveTaskBranch } from '../task-resolver.js';
-import { isRemovedHashShortIdInput } from '../../task/short-id.js';
 import { parseSandboxWorkspaceIdentity } from '../workspace-identity.js';
 import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.js';
 export function containerListFormat() {
@@ -150,22 +148,6 @@ export function resolveTaskShortRef(arg, ctx) {
         `bare N resolves only via the registry (not by row position in 'ai sandbox ls'); ` +
         `use a task short id (e.g. 'ai sandbox exec 11'), a TASK-id, or a branch name.`);
 }
-/**
- * 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, ctx) {
-    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/dist/lib/sandbox/commands/start.js

@@ -6,11 +6,10 @@ import { fetchSandboxRows, selectSandboxContainer, } from './list-running.js';
 import { resolveSandboxTarget } from '../workspace-identity.js';
 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) {
     let recreate = false;
     let help = false;
@@ -52,15 +51,15 @@ export async function start(args) {
     assertValidBranchName(branch);
     const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
     const found = selectSandboxContainer([...running, ...nonRunning], 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({
         config,
         engine,
         branch,
         workspace: target.workspace,
-        row: found,
+        row: found ?? null,
         allowRecreate: parsed.recreate,
         forceRecreate: parsed.recreate,
         recreate: async () => {

package/dist/lib/sandbox/constants.js

@@ -42,15 +42,9 @@ export function containerName(config, branch) {
 export function containerNameCandidates(config, branch) {
     return safeNameCandidates(branch).map((name) => `${config.containerPrefix}-${name}`);
 }
-export function worktreeDir(config, branch) {
-    return hostJoin(config.worktreeBase, sanitizeBranchName(branch));
-}
 export function worktreeDirCandidates(config, branch) {
     return safeNameCandidates(branch).map((name) => hostJoin(config.worktreeBase, name));
 }
-export function shareDir(config) {
-    return config.shareBase;
-}
 export function shareCommonDir(config) {
     return hostJoin(config.shareBase, 'common');
 }

package/dist/lib/sandbox/control/client.js

@@ -155,7 +155,6 @@ function exchangeSandboxControl(request, params) {
     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/dist/lib/sandbox/control/container-identity.js

@@ -1,5 +1,4 @@
 import { runProbe } from '../shell.js';
-import { captureSandboxAuthority, isSandboxAuthorityEvidence, verifySandboxAuthority } from '../engines/authority.js';
 import { discoverExactContainer } from '../engines/docker-exact-discovery.js';
 export function classifySandboxContainerInspection(expected, inspection) {
     if ('notFound' in inspection)
@@ -26,24 +25,10 @@ export function classifySandboxContainerInspection(expected, inspection) {
     };
 }
 export async function inspectSandboxControlContainer(manifest, options = {}) {
-    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 };

package/dist/lib/sandbox/control/executor.js

@@ -357,8 +357,4 @@ function readJsonExecution(filePath) {
         throw new Error('SANDBOX_CONTROL_EXECUTION_INVALID');
     return value;
 }
-export function disconnectExecutor(child) {
-    if (child.connected)
-        child.disconnect();
-}
 //# sourceMappingURL=executor.js.map

package/dist/lib/sandbox/control/identity-sentinel.js

@@ -97,11 +97,4 @@ export function validateSandboxControlIdentity(params) {
     }
     return { state: 'valid', sentinel };
 }
-export function assertSandboxControlIdentity(params) {
-    const result = validateSandboxControlIdentity(params);
-    if (result.state !== 'valid' || !result.sentinel) {
-        throw new Error(`SANDBOX_CONTROL_IDENTITY_${result.state.replaceAll('-', '_').toUpperCase()}`);
-    }
-    return result.sentinel;
-}
 //# sourceMappingURL=identity-sentinel.js.map

package/dist/lib/sandbox/control/lifecycle.js

@@ -8,7 +8,6 @@ import { getProcessIdentityState, getProcessStartTime } from '../../server/proce
 import { DEFAULT_SANDBOX_CONTROL_TIMING } from './protocol.js';
 import { inspectSandboxControlContainer } from './container-identity.js';
 import { acquireSandboxResourceLock, resolveSandboxLockNamespace } from './native-file-lock.js';
-import { isSandboxAuthorityEvidence } from '../engines/authority.js';
 import { validateSandboxControlIdentity } from './identity-sentinel.js';
 import { parseSandboxControlStatus, readExecution, terminateSandboxControlExecution } from './state.js';
 const DEFAULT_QUIESCE_TIMEOUT_MS = DEFAULT_SANDBOX_CONTROL_TIMING.quiesceDeadlineMs;
@@ -58,7 +57,16 @@ function removalJournalDomain(lockDomain, create = true) {
     return domain;
 }
 function removalJournalPath(manifest) {
-    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) {
     return path.join(removalJournalDomain(record.lockDomain, false), `${record.carrierIdentityDigest}.json`);
@@ -101,8 +109,11 @@ function parseRemovalJournal(raw) {
     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'])
@@ -117,7 +128,6 @@ function parseRemovalJournal(raw) {
         || 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 <= 0
@@ -160,7 +170,6 @@ function parseRemovalJournal(raw) {
         engine: value.engine,
         containerId: value.containerId,
         generation: value.generation,
-        authorityFingerprint: value.authorityFingerprint,
         carrierIdentityDigest: value.carrierIdentityDigest,
         lockDomain: value.lockDomain,
         owner: {
@@ -342,9 +351,7 @@ function startRemovalJournal(manifest, options) {
     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);
@@ -371,9 +378,8 @@ function startRemovalJournal(manifest, options) {
         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
     };
@@ -440,17 +446,6 @@ export function advanceSandboxRemovalJournalPhase(journal, phase, options = {})
         ownedLock?.release();
     }
 }
-export function advanceSandboxRemovalJournalToPhase(journal, phase, resourceLock) {
-    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(operation, deadlineAt, errorCode) {
     const remaining = deadlineAt - Date.now();
     if (remaining <= 0)
@@ -530,7 +525,6 @@ function recordSandboxRemovalPending(root, manifest, phase, journal) {
             phase,
             containerId: manifest.containerIdentity.id,
             generation: manifest.generation,
-            authorityFingerprint: manifest.authorityEvidence.authorityFingerprint,
             recordedAt: Date.now()
         })}\n`, { mode: 0o600, flag: 'wx' });
         fs.renameSync(temporary, pendingPath);
@@ -920,11 +914,13 @@ function readSandboxControlManifestValue(manifestPath) {
     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;
     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(',')) {
@@ -951,8 +947,7 @@ function readSandboxControlManifestValue(manifestPath) {
         || 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))
+        || (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);
@@ -999,7 +994,6 @@ function readSandboxControlManifestValue(manifestPath) {
             id: containerIdentity.id,
             labels: { ...containerIdentity.labels }
         },
-        authorityEvidence: candidate.authorityEvidence,
         branch: candidate.branch,
         mode: candidate.mode,
         taskId: candidate.taskId,
@@ -1287,7 +1281,7 @@ async function removeSandboxControlRootAttempt(root, options) {
     const manifestPath = path.join(resolvedRoot, 'manifest.json');
     const manifestRawBeforeLock = fs.readFileSync(manifestPath, 'utf8');
     const manifest = readSandboxControlManifest(manifestPath);
-    const resourceLock = options.resourceLock ?? acquireSandboxResourceLock(`${manifest.engine}:${manifest.containerIdentity.id}`, { lockDomain: manifest.authorityEvidence.lockDomain });
+    const resourceLock = options.resourceLock ?? acquireSandboxResourceLock(`${manifest.engine}:${manifest.containerIdentity.id}`, { lockDomain: readSandboxRemovalJournal(manifest)?.lockDomain });
     try {
         if (fs.readFileSync(manifestPath, 'utf8') !== manifestRawBeforeLock) {
             throw new Error('SANDBOX_CONTROL_MANIFEST_CHANGED');
@@ -1394,7 +1388,6 @@ async function removeSandboxControlRootAttempt(root, options) {
         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');
@@ -1478,13 +1471,4 @@ async function removeSandboxControlRootAttempt(root, options) {
             resourceLock.release();
     }
 }
-export async function garbageCollectSandboxControlRoot(root, options = {}) {
-    await removeSandboxControlRoot(path.resolve(root), {
-        ...options,
-        requireAbsent: true,
-        removeContainer: async () => {
-            throw new Error('SANDBOX_CONTROL_CONTAINER_REAPPEARED');
-        }
-    });
-}
 //# sourceMappingURL=lifecycle.js.map

package/dist/lib/sandbox/control/native-file-lock.js

@@ -69,9 +69,6 @@ export function resolveSandboxLockNamespace(carrierIdentity, options = {}) {
         lockPath: path.join(domainDirectory, `${carrierIdentityDigest}.lock`)
     };
 }
-export function stableSandboxLockPath(carrierIdentity, lockDomain, options = {}) {
-    return resolveSandboxLockNamespace(carrierIdentity, { lockDomain, home: options.home }).lockPath;
-}
 export function acquireSandboxResourceLock(carrierIdentity, options = {}) {
     const namespace = resolveSandboxLockNamespace(carrierIdentity, options);
     try {