@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/dist/lib/sandbox/recovery.js

@@ -9,7 +9,7 @@ import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
 import { toEnginePath } from './engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from './mounts.js';
 import { resolveSandboxGitMetadata } from './git-metadata.js';
-import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
+import { assertSandboxTaskSource, sandboxCompletedTaskMountSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
 import { resolveTaskWorkspace } from './task-resolver.js';
 import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { inspectWorktree } from './worktree-safety.js';
@@ -174,6 +174,7 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
 async function ensureSandboxControlBroker(params) {
     const control = sandboxControlPaths({
         base: params.config.controlBase ?? path.join(params.config.home, '.agent-infra', 'sandbox-control'),
+        repoRoot: params.config.repoRoot,
         project: params.config.project,
         container: params.container,
         identity: params.workspace
@@ -459,25 +460,38 @@ export function startCompletedSandboxContainer(params) {
     const activeRoot = path.join(params.config.repoRoot, '.agents', 'workspace', 'active');
     const historicalSource = path.join(activeRoot, params.taskId);
     fs.mkdirSync(activeRoot, { recursive: true });
+    let replacedEmptyRoot = false;
+    let emptyRootMode = 0o700;
     try {
-        fs.lstatSync(historicalSource);
-        throw new Error(`SANDBOX_COMPLETED_SOURCE_CONFLICT: historical task source already exists at ${historicalSource}`);
+        const existing = fs.lstatSync(historicalSource);
+        if (existing.isSymbolicLink() || !existing.isDirectory() || fs.readdirSync(historicalSource).length > 0) {
+            throw new Error(`SANDBOX_COMPLETED_SOURCE_CONFLICT: historical task source already exists at ${historicalSource}`);
+        }
+        emptyRootMode = existing.mode & 0o777;
+        fs.rmdirSync(historicalSource);
+        replacedEmptyRoot = true;
     }
     catch (error) {
         if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT'))
             throw error;
     }
-    fs.symlinkSync(completedSource, historicalSource, process.platform === 'win32' ? 'junction' : 'dir');
+    let temporaryLink = false;
     try {
+        fs.symlinkSync(completedSource, historicalSource, process.platform === 'win32' ? 'junction' : 'dir');
+        temporaryLink = true;
         params.start(params.engine, params.container);
     }
     finally {
-        const temporarySource = fs.lstatSync(historicalSource);
-        const resolvedSource = fs.realpathSync.native(historicalSource);
-        if (!temporarySource.isSymbolicLink() || resolvedSource !== completedSource) {
-            throw new Error(`SANDBOX_COMPLETED_SOURCE_CHANGED: refusing to remove unexpected path at ${historicalSource}`);
+        if (temporaryLink) {
+            const temporarySource = fs.lstatSync(historicalSource);
+            const resolvedSource = fs.realpathSync.native(historicalSource);
+            if (!temporarySource.isSymbolicLink() || resolvedSource !== completedSource) {
+                throw new Error(`SANDBOX_COMPLETED_SOURCE_CHANGED: refusing to remove unexpected path at ${historicalSource}`);
+            }
+            fs.unlinkSync(historicalSource);
         }
-        fs.unlinkSync(historicalSource);
+        if (replacedEmptyRoot)
+            fs.mkdirSync(historicalSource, { mode: emptyRootMode });
     }
 }
 function sameHostSource(left, right) {
@@ -509,6 +523,7 @@ function expectedMounts(params) {
     });
     const control = sandboxControlPaths({
         base: config.controlBase ?? path.join(config.home, '.agent-infra', 'sandbox-control'),
+        repoRoot: config.repoRoot,
         project: config.project,
         container: params.container,
         identity: params.workspace
@@ -517,6 +532,7 @@ function expectedMounts(params) {
         ? recoveryTaskSources(config.repoRoot, params.workspace.taskId)
         : null;
     const taskId = params.workspace.mode === 'task-bound' ? params.workspace.taskId : null;
+    const completedTaskSource = taskId ? sandboxCompletedTaskMountSource(config.repoRoot, taskId) : null;
     const worktrees = worktreeDirCandidates(config, branch).filter((candidate) => fs.existsSync(path.join(candidate, '.git')));
     const gitMetadata = worktrees.length === 1
         ? resolveSandboxGitMetadata(worktrees[0], control.channelDir)
@@ -536,6 +552,7 @@ function expectedMounts(params) {
             : {
                 runtimeDir: control.runtimeDir,
                 taskSources: taskSources.accessiblePaths,
+                completedTaskSource: completedTaskSource,
                 taskId: taskId
             })
     }).map((mount) => ({
@@ -546,6 +563,10 @@ function expectedMounts(params) {
             && mount.containerPath === `/workspace/.agents/workspace/active/${taskId}`
             ? { sourceAccessiblePaths: taskSources.accessiblePaths }
             : {}),
+        ...(completedTaskSource !== null && taskId !== null
+            && mount.containerPath === `/workspace/.agents/workspace/completed/${taskId}`
+            ? { sourceAccessiblePaths: [completedTaskSource] }
+            : {}),
         expectedRW: !mount.readOnly
     }));
     const live = tools.flatMap((tool) => (tool.hostLiveMounts ?? []).flatMap(({ hostPath, containerSubpath }) => {
@@ -905,7 +926,7 @@ export async function ensureSandboxReady(params) {
             let completedReentry = null;
             if (params.reentry === 'completed' && params.workspace?.mode === 'task-bound') {
                 const control = sandboxControlPaths({
-                    base: params.config.controlBase, project: params.config.project,
+                    base: params.config.controlBase, repoRoot: params.config.repoRoot, project: params.config.project,
                     container: params.row.name, identity: params.workspace
                 });
                 const manifest = readSandboxControlManifest(control.manifestPath);

package/dist/lib/sandbox/removal.js

@@ -568,7 +568,7 @@ function resolveRmTarget(config, tools, cleanupTarget, options = {}) {
         ? matchedContainers
         : [...new Set([...containerNameCandidates(config, effectiveBranch), ...matchedContainers])];
     const controlRoots = containers.flatMap((container) => identities.map((identity) => sandboxControlPaths({
-        base: config.controlBase, project: config.project, container, identity
+        base: config.controlBase, repoRoot: config.repoRoot, project: config.project, container, identity
     }).root));
     const workspaceViewRoots = containers.flatMap((container) => identities.map((identity) => sandboxWorkspaceViewPaths({
         base: config.workspaceViewBase, project: config.project, container, identity
@@ -711,7 +711,9 @@ async function removeUncheckedSandbox(config, target, options) {
     }
     for (const root of controlRoots) {
         fs.rmSync(root, { recursive: true, force: true });
-        removeEmptyManagedParent(path.join(config.controlBase, config.project), root);
+        if (target.workspace.mode !== 'task-bound') {
+            removeEmptyManagedParent(path.join(config.controlBase, config.project), root);
+        }
     }
     for (const root of workspaceViewRoots) {
         fs.rmSync(root, { recursive: true, force: true });
@@ -735,13 +737,15 @@ async function removeUncheckedSandbox(config, target, options) {
         assertBranchRemovalIdentity(config, effectiveBranch, worktreePermits);
         runSafe('git', ['-C', config.repoRoot, 'branch', '-D', effectiveBranch]);
     }
-    if (target.workspace.mode === 'task-bound') {
-        releaseStaleShortIdRegistry(config.repoRoot, target.workspace.taskId);
-    }
+    releaseTaskBoundSandboxIdentity(config.repoRoot, target.workspace);
     if (!options.quiet)
         p.outro('Sandbox removed');
     return null;
 }
+function releaseTaskBoundSandboxIdentity(repoRoot, workspace) {
+    if (workspace.mode === 'task-bound')
+        releaseStaleShortIdRegistry(repoRoot, workspace.taskId);
+}
 async function rmOneCore(config, tools, branch, options = {}) {
     const target = options.target ?? resolveRmTarget(config, tools, options.cleanupTarget ?? resolveSandboxCleanupTarget(branch, config.repoRoot));
     return removeUncheckedSandbox(config, target, options);
@@ -754,11 +758,20 @@ async function rmPurgeCore(config, tools, prompt = {}) {
     const confirm = prompt.confirm ?? p.confirm;
     const isCancel = prompt.isCancel ?? p.isCancel;
     p.intro(pc.cyan(`Removing all sandboxes for ${config.project}`));
+    const listed = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) });
+    const rows = [...listed.running, ...listed.nonRunning];
     const containers = runEngine(engine, 'docker', [
         'ps', '-a', '--filter', `label=${sandboxLabel(config)}`, '--format', '{{.Names}}'
     ]).split('\n').filter(Boolean);
+    const completedTaskIds = [...new Set(rows
+            .filter((row) => row.workspaceMode === 'task-bound' && row.taskId)
+            .map((row) => row.taskId))];
     for (const name of containers)
         runSafeEngine(engine, 'docker', ['rm', '-f', name]);
+    if (!sandboxContainersRemoved(engine, containers)) {
+        throw new Error(`SANDBOX_REMOVAL_CONTAINER_STILL_PRESENT: ${containers.join(', ')}`);
+    }
+    let cleanupCompleted = true;
     const worktrees = fs.existsSync(config.worktreeBase)
         ? fs.readdirSync(config.worktreeBase).map((entry) => path.join(config.worktreeBase, entry))
         : [];
@@ -769,6 +782,8 @@ async function rmPurgeCore(config, tools, prompt = {}) {
                 fs.rmSync(worktree, { recursive: true, force: true });
             runSafe('git', ['-C', config.repoRoot, 'worktree', 'prune']);
         }
+        else
+            cleanupCompleted = false;
     }
     for (const dir of projectToolDirs(config, tools))
         fs.rmSync(dir, { recursive: true, force: true });
@@ -776,15 +791,23 @@ async function rmPurgeCore(config, tools, prompt = {}) {
         const selected = await confirm({ message: `Remove all shell config dirs in ${config.shellConfigBase}?`, initialValue: true });
         if (!isCancel(selected) && selected)
             fs.rmSync(config.shellConfigBase, { recursive: true, force: true });
+        else
+            cleanupCompleted = false;
     }
     if (fs.existsSync(config.shareBase)) {
         const selected = await confirm({ message: `Remove all share dirs for project (${config.shareBase})?`, initialValue: true });
         if (!isCancel(selected) && selected)
             fs.rmSync(config.shareBase, { recursive: true, force: true });
+        else
+            cleanupCompleted = false;
     }
     for (const base of [config.workspaceViewBase, config.controlBase]) {
         fs.rmSync(path.join(base, config.project), { recursive: true, force: true });
     }
+    if (cleanupCompleted) {
+        for (const taskId of completedTaskIds)
+            releaseStaleShortIdRegistry(config.repoRoot, taskId);
+    }
     const removeImage = await confirm({ message: `Remove image ${config.imageName}?`, initialValue: false });
     if (!isCancel(removeImage) && removeImage)
         runSafeEngine(engine, 'docker', ['rmi', config.imageName]);

package/dist/lib/sandbox/workspace-identity.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { isRemovedHashShortIdInput } from '../task/short-id.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
 import { resolveTaskWorkspace } from './task-resolver.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const SHORT_ID_RE = /^\d+$/;
@@ -38,6 +39,16 @@ function taskIdentity(repoRoot, taskId, registry) {
     }
     return { mode: 'task-bound', taskId, shortId: shortIds[0] };
 }
+function cleanupTaskId(requestedRef, repoRoot) {
+    if (TASK_ID_RE.test(requestedRef))
+        return requestedRef;
+    if (!SHORT_ID_RE.test(requestedRef))
+        return null;
+    const task = resolveTaskRef(requestedRef, { repoRoot });
+    if (!task.ok)
+        throw new Error(task.message);
+    return task.taskId;
+}
 export function resolveSandboxTarget(requestedRef, repoRoot) {
     if (isRemovedHashShortIdInput(requestedRef)) {
         throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);
@@ -83,26 +94,27 @@ export function resolveSandboxCleanupTarget(requestedRef, repoRoot, options = {}
     if (isRemovedHashShortIdInput(requestedRef)) {
         throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);
     }
-    if (TASK_ID_RE.test(requestedRef)) {
+    const taskId = cleanupTaskId(requestedRef, repoRoot);
+    if (taskId) {
         let task;
         try {
-            task = resolveTaskWorkspace(requestedRef, repoRoot);
+            task = resolveTaskWorkspace(taskId, repoRoot);
         }
         catch (error) {
-            if (!(error instanceof Error && error.message === `Task not found: ${requestedRef}`))
+            if (!(error instanceof Error && error.message === `Task not found: ${taskId}`))
                 throw error;
-            const branch = options.resolveMissingTask?.(requestedRef);
+            const branch = options.resolveMissingTask?.(taskId);
             if (!branch)
                 throw error;
             return {
                 requestedRef,
                 branch,
-                workspace: { mode: 'task-bound', taskId: requestedRef },
+                workspace: { mode: 'task-bound', taskId },
                 taskState: 'unknown'
             };
         }
         if (!options.allowProtected && (task.state === 'blocked' || task.state === 'archive')) {
-            throw new Error(`SANDBOX_CLEANUP_STATE_UNSUPPORTED: task ${requestedRef} is ${task.state}`);
+            throw new Error(`SANDBOX_CLEANUP_STATE_UNSUPPORTED: task ${taskId} is ${task.state}`);
         }
         return {
             requestedRef,

package/dist/lib/sandbox/workspace-view.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolveTaskWorkspace } from './task-resolver.js';
+import { resolveTaskRuntimeRoot } from '../task/runtime-paths.js';
 import { createSandboxControlIdentitySentinel, writeSandboxControlIdentitySentinel } from './control/identity-sentinel.js';
 export const SANDBOX_WORKSPACE_VIEW_STATES = Object.freeze([
     'active',
@@ -25,11 +26,12 @@ export function sandboxWorkspaceViewPaths(params) {
     return { root };
 }
 export function sandboxControlPaths(params) {
-    const identityKey = params.identity.mode === 'task-bound'
-        ? `task-bound:${params.identity.taskId}`
-        : 'branch-only';
-    const digest = createHash('sha256').update(identityKey).digest('hex').slice(0, 16);
-    const root = path.resolve(params.base, params.project, params.container, digest);
+    const root = params.identity.mode === 'task-bound'
+        ? path.join(resolveTaskRuntimeRoot(params.identity.taskId, { repoRoot: params.repoRoot }), 'sandbox-control')
+        : (() => {
+            const digest = createHash('sha256').update('branch-only').digest('hex').slice(0, 16);
+            return path.resolve(params.base, params.project, params.container, digest);
+        })();
     return {
         root,
         channelDir: path.join(root, 'channel'),
@@ -109,13 +111,16 @@ export function assertSandboxTaskSource(repoRoot, taskId) {
     }
     return canonical;
 }
-export function prepareSandboxWorkspaceMountTargets(worktreeRoot) {
+export function prepareSandboxWorkspaceMountTargets(worktreeRoot, taskId) {
     const resolvedWorktreeRoot = path.resolve(worktreeRoot);
     const canonicalWorktreeRoot = fs.realpathSync.native(resolvedWorktreeRoot);
     const workspaceRoot = path.resolve(resolvedWorktreeRoot, '.agents', 'workspace');
     const statePaths = sandboxWorkspaceViewStatePaths(workspaceRoot);
     const registryTarget = path.join(workspaceRoot, 'active', '.short-ids.json');
-    for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget]) {
+    const completedTaskTarget = taskId ? path.join(workspaceRoot, 'completed', taskId) : null;
+    if (taskId && !/^TASK-\d{8}-\d{6}$/.test(taskId))
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget, ...(completedTaskTarget ? [completedTaskTarget] : [])]) {
         assertSafeMountTargetPath(target, resolvedWorktreeRoot, canonicalWorktreeRoot);
     }
     fs.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
@@ -123,9 +128,52 @@ export function prepareSandboxWorkspaceMountTargets(worktreeRoot) {
         fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
         fs.chmodSync(hostPath, 0o700);
     }
+    if (completedTaskTarget)
+        fs.mkdirSync(completedTaskTarget, { recursive: true, mode: 0o700 });
     fs.chmodSync(workspaceRoot, 0o700);
     fs.closeSync(fs.openSync(registryTarget, 'a', 0o600));
 }
+export function prepareSandboxCompletedTaskMountSource(repoRoot, taskId) {
+    if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    const workspaceRoot = path.resolve(repoRoot, '.agents', 'workspace');
+    fs.mkdirSync(path.join(workspaceRoot, 'completed'), { recursive: true, mode: 0o700 });
+    const completedRoot = path.join(workspaceRoot, 'completed');
+    const completedStat = fs.lstatSync(completedRoot);
+    if (!completedStat.isDirectory() || completedStat.isSymbolicLink())
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    const target = path.join(completedRoot, taskId);
+    try {
+        const stat = fs.lstatSync(target);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || fs.readdirSync(target).length > 0) {
+            throw new Error(`SANDBOX_COMPLETED_MOUNT_CONFLICT: ${target}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        fs.mkdirSync(target, { mode: 0o700 });
+    }
+    return sandboxCompletedTaskMountSource(repoRoot, taskId);
+}
+export function sandboxCompletedTaskMountSource(repoRoot, taskId) {
+    if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    const source = path.resolve(repoRoot, '.agents', 'workspace', 'completed', taskId);
+    const stat = fs.lstatSync(source);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    const canonicalWorkspace = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+    const canonicalSource = fs.realpathSync.native(source);
+    const canonicalRepoRoot = fs.realpathSync.native(repoRoot);
+    const workspaceRelative = path.relative(canonicalRepoRoot, canonicalWorkspace);
+    const relative = path.relative(canonicalWorkspace, canonicalSource);
+    if (workspaceRelative.startsWith('..') || path.isAbsolute(workspaceRelative)
+        || path.dirname(canonicalSource) !== fs.realpathSync.native(path.dirname(source))
+        || relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error('SANDBOX_TASK_SOURCE_INVALID');
+    return canonicalSource;
+}
 export function materializeSandboxWorkspaceView(params) {
     const projectRoot = path.resolve(params.base, params.project);
     const { root } = sandboxWorkspaceViewPaths(params);
@@ -155,7 +203,7 @@ export function materializeSandboxWorkspaceView(params) {
 }
 export function materializeSandboxControl(params) {
     const { root, channelDir, statusDir, processingDir, runtimeDir, manifestPath } = sandboxControlPaths(params);
-    assertSafeDirectory(root, path.resolve(params.base));
+    assertSafeDirectory(root, params.identity.mode === 'task-bound' ? path.dirname(root) : path.resolve(params.base));
     if (fs.existsSync(root)) {
         if (!params.replacementLease || path.resolve(params.replacementLease.root) !== root) {
             throw new Error('SANDBOX_CONTROL_REPLACEMENT_REQUIRED');
@@ -168,18 +216,7 @@ export function materializeSandboxControl(params) {
     fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
     for (const directory of [statusDir, processingDir, runtimeDir]) {
         assertSafeDirectory(directory, root);
-        if (directory === runtimeDir)
-            fs.rmSync(directory, { recursive: true, force: true });
-        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-    }
-    for (const directory of [
-        path.join(runtimeDir, 'clients'),
-        path.join(runtimeDir, 'clients', 'codex', 'capabilities'),
-        path.join(runtimeDir, 'clients', 'codex', 'lifecycle')
-    ]) {
-        assertSafeDirectory(directory, runtimeDir);
         fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
-        fs.chmodSync(directory, 0o700);
     }
     for (const queue of ['requests', 'responses']) {
         const directory = path.join(channelDir, queue);

package/dist/lib/task/commands/ls.js

@@ -58,9 +58,9 @@ function collectTasks(repoRoot, state) {
     const dir = path.join(repoRoot, '.agents', 'workspace', state);
     if (!fs.existsSync(dir))
         return [];
-    // Short ids live only in the registry and only for active tasks; archived
-    // (blocked/completed) tasks have released their short id and render '-'.
-    const shortIdByTaskId = state === 'active' ? loadShortIdByTaskId(repoRoot) : new Map();
+    const shortIdByTaskId = state === 'active' || state === 'completed'
+        ? loadShortIdByTaskId(repoRoot)
+        : new Map();
     const rows = [];
     for (const entry of fs.readdirSync(dir).sort()) {
         if (!TASK_ID_RE.test(entry))