@fitlab-ai/agent-infra 0.11.12 → 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';
@@ -460,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) {
@@ -519,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)
@@ -538,6 +552,7 @@ function expectedMounts(params) {
             : {
                 runtimeDir: control.runtimeDir,
                 taskSources: taskSources.accessiblePaths,
+                completedTaskSource: completedTaskSource,
                 taskId: taskId
             })
     }).map((mount) => ({
@@ -548,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 }) => {

package/dist/lib/sandbox/removal.js

@@ -758,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))
         : [];
@@ -773,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 });
@@ -780,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

@@ -111,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 });
@@ -125,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);

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))

package/dist/lib/task/control-authority.js

@@ -320,6 +320,8 @@ export function parseTaskControlOperation(family, args) {
     const taskRef = args[0];
     const intent = args[1];
     if (family === 'task-lifecycle') {
+        if (intent === 'complete')
+            operationInvalid('complete must use task-finalization');
         const values = parseValues(args, 2, LIFECYCLE_FLAGS);
         const agent = normalizeAgentToken(value(values, '--agent') ?? '');
         if (!agent)

package/dist/lib/task/control-recovery.js

@@ -16,10 +16,9 @@ export function parseControlOutput(output) {
 export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
-const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
+const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS = Object.freeze([
     ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle', intent, class: 'lifecycle-mutation' })),
-    { family: 'task-finalization', intent: 'complete', class: 'finalization' },
     { family: 'task-create', intent: 'create', class: 'task-create' },
     ...['controller.close', 'controller.verify'].map((intent) => ({ family: 'agent-client', intent, class: 'agent-client-operation' }))
 ]);

package/dist/lib/task/finalization.js

@@ -1133,6 +1133,20 @@ async function applyTaskFinalization(request, options) {
     const prepared = await prepareTaskFinalization(request, options);
     if (prepared.status !== 'prepared')
         return prepared;
+    if (options.beforeLifecycle) {
+        try {
+            await options.beforeLifecycle(prepared.taskId);
+        }
+        catch (error) {
+            const detail = errorOf(error, 'TASK_FINALIZATION_PRE_LIFECYCLE_FAILED', true);
+            return failed(prepared.taskId, detail, {
+                changed: prepared.changed,
+                completedSteps: prepared.completedSteps,
+                pendingSteps: prepared.pendingSteps,
+                warnings: prepared.warnings
+            });
+        }
+    }
     return commitPreparedTaskFinalization(request, options);
 }
 export { applyFinalizationReceiptMutation, commitPreparedTaskFinalization, applyTaskFinalization, prepareTaskFinalization, issueCapability as createFinalizationCapability, readTaskFinalizationReceipt, terminalResult };