@fitlab-ai/agent-infra 0.9.9 → 0.9.11

package/dist/lib/merge.js

@@ -1,11 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { info, ok } from './log.js';
 import { removeDirRecursive } from './remove-dir.js';
+import { validateCurrentTaskContract } from './task/current-contract.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 const TITLE_RE = /^# (.+)$/m;
-const DATE_FROM_PATH_RE = /(?:^|[/\\])(\d{4})[/\\](\d{2})[/\\](\d{2})(?:[/\\]|$)/;
 const MUTABLE_SECTIONS = ['active', 'blocked', 'completed'];
 const ALL_SECTIONS = [...MUTABLE_SECTIONS, 'archive'];
 const SECTION_LABELS = {
@@ -64,36 +63,6 @@ function normalizeTaskRecord(taskDir, taskFile, dateParts) {
         completedAt: taskDate
     };
 }
-function fallbackDateParts(taskDir, content) {
-    const pathMatch = taskDir.match(DATE_FROM_PATH_RE);
-    if (pathMatch) {
-        const [, year, month, day] = pathMatch;
-        if (!year || !month || !day) {
-            return null;
-        }
-        return {
-            year,
-            month,
-            day
-        };
-    }
-    const completedAt = extractField(content, 'completed_at');
-    const updatedAt = extractField(content, 'updated_at');
-    const source = completedAt || updatedAt;
-    const dateMatch = source?.match(/^(\d{4})-(\d{2})-(\d{2})/);
-    if (dateMatch) {
-        const [, year, month, day] = dateMatch;
-        if (!year || !month || !day) {
-            return null;
-        }
-        return {
-            year,
-            month,
-            day
-        };
-    }
-    return null;
-}
 function scanSourceTasks(sourceDir) {
     const tasks = [];
     const years = fs.existsSync(sourceDir) ? fs.readdirSync(sourceDir, { withFileTypes: true }) : [];
@@ -130,37 +99,6 @@ function scanSourceTasks(sourceDir) {
             }
         }
     }
-    if (tasks.length > 0) {
-        return tasks;
-    }
-    // Fall back to a deeper scan if the source layout is unusual but still contains archived tasks.
-    const stack = [sourceDir];
-    while (stack.length > 0) {
-        const currentDir = stack.pop();
-        if (!currentDir || !fs.existsSync(currentDir)) {
-            continue;
-        }
-        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
-            const entryPath = path.join(currentDir, entry.name);
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            if (TASK_ID_RE.test(entry.name)) {
-                const taskFile = path.join(entryPath, 'task.md');
-                if (!fs.existsSync(taskFile)) {
-                    continue;
-                }
-                const content = fs.readFileSync(taskFile, 'utf8');
-                const dateParts = fallbackDateParts(entryPath, content);
-                if (!dateParts) {
-                    continue;
-                }
-                tasks.push(normalizeTaskRecord(entryPath, taskFile, dateParts));
-                continue;
-            }
-            stack.push(entryPath);
-        }
-    }
     return tasks.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 function findTaskDirById(rootDir, taskId) {
@@ -470,14 +408,200 @@ function copyTaskToSection(sourceTask, workspaceDir) {
     fs.cpSync(sourceTask.taskDir, destinationDir, { recursive: true });
     return destinationDir;
 }
+function invalidSource(message) {
+    throw new Error(`Invalid merge source: ${message}`);
+}
+function sourceRelativePath(sourceRoot, targetPath) {
+    return path.relative(sourceRoot, targetPath).split(path.sep).join('/') || '.';
+}
+function isMissingPathError(error) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT');
+}
+function assertSourcePathContained(sourceRoot, targetPath) {
+    let sourceRealPath;
+    let targetRealPath;
+    try {
+        sourceRealPath = fs.realpathSync(sourceRoot);
+        targetRealPath = fs.realpathSync(targetPath);
+    }
+    catch (error) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const relativePath = path.relative(sourceRealPath, targetRealPath);
+    if (relativePath === '..' || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} resolves outside the source workspace`);
+    }
+}
+function sourcePathStat(sourceRoot, targetPath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(targetPath);
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    if (stat.isSymbolicLink()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, targetPath)} must not be a symbolic link`);
+    }
+    assertSourcePathContained(sourceRoot, targetPath);
+    return stat;
+}
+function validateTaskTree(sourceRoot, taskDir) {
+    for (const entry of fs.readdirSync(taskDir, { withFileTypes: true })) {
+        const entryPath = path.join(taskDir, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        if (!entryStat) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} disappeared during validation`);
+        }
+        if (entryStat.isDirectory()) {
+            validateTaskTree(sourceRoot, entryPath);
+            continue;
+        }
+        if (!entryStat.isFile()) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} must be a regular file or directory`);
+        }
+    }
+}
+function validateSourceRoot(sourceRoot) {
+    const stat = sourcePathStat(sourceRoot, sourceRoot);
+    if (!stat || !stat.isDirectory()) {
+        invalidSource('source path must be a real directory');
+    }
+}
+function validateTaskDirectory(sourceRoot, taskDir, seenTaskIds) {
+    const taskId = path.basename(taskDir);
+    const taskFile = path.join(taskDir, 'task.md');
+    const taskDirStat = sourcePathStat(sourceRoot, taskDir);
+    if (!taskDirStat || !taskDirStat.isDirectory()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} must be a directory`);
+    }
+    const taskFileStat = sourcePathStat(sourceRoot, taskFile);
+    if (!taskFileStat || !taskFileStat.isFile()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} requires a regular task.md file`);
+    }
+    const content = fs.readFileSync(taskFile, 'utf8');
+    const contract = validateCurrentTaskContract(content);
+    if (!contract.ok) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} is not a valid current task: ${contract.message}`);
+    }
+    if (contract.metadata.id !== taskId) {
+        invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} id '${String(contract.metadata.id ?? 'missing')}' does not match directory '${taskId}'`);
+    }
+    validateTaskTree(sourceRoot, taskDir);
+    const previousPath = seenTaskIds.get(taskId);
+    if (previousPath) {
+        invalidSource(`duplicate task ID ${taskId} at ${previousPath} and ${sourceRelativePath(sourceRoot, taskDir)}`);
+    }
+    seenTaskIds.set(taskId, sourceRelativePath(sourceRoot, taskDir));
+}
+function validateMutableSection(sourceRoot, section, seenTaskIds) {
+    const sectionDir = path.join(sourceRoot, section);
+    const sectionStat = sourcePathStat(sourceRoot, sectionDir);
+    if (!sectionStat) {
+        return;
+    }
+    if (!sectionStat.isDirectory()) {
+        invalidSource(`${section} must be a directory`);
+    }
+    for (const entry of fs.readdirSync(sectionDir, { withFileTypes: true })) {
+        const entryPath = path.join(sectionDir, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        if (!entryStat) {
+            continue;
+        }
+        if (!entryStat.isDirectory()) {
+            if (TASK_ID_RE.test(entry.name)) {
+                invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} is not a directory`);
+            }
+            continue;
+        }
+        if (!TASK_ID_RE.test(entry.name)) {
+            invalidSource(`${sourceRelativePath(sourceRoot, entryPath)} is not a direct TASK-YYYYMMDD-HHMMSS directory`);
+        }
+        validateTaskDirectory(sourceRoot, entryPath, seenTaskIds);
+    }
+}
+function validateArchiveSection(sourceRoot, seenTaskIds) {
+    const archiveDir = path.join(sourceRoot, 'archive');
+    const archiveStat = sourcePathStat(sourceRoot, archiveDir);
+    if (!archiveStat) {
+        return;
+    }
+    if (!archiveStat.isDirectory()) {
+        invalidSource('archive must be a directory');
+    }
+    const allowManifest = (directory, entry) => {
+        const entryPath = path.join(directory, entry.name);
+        const entryStat = sourcePathStat(sourceRoot, entryPath);
+        return Boolean(entryStat?.isFile() && entry.name === 'manifest.md');
+    };
+    const years = fs.readdirSync(archiveDir, { withFileTypes: true });
+    for (const yearEntry of years) {
+        const yearPath = path.join(archiveDir, yearEntry.name);
+        if (allowManifest(archiveDir, yearEntry)) {
+            continue;
+        }
+        const yearStat = sourcePathStat(sourceRoot, yearPath);
+        if (!yearStat?.isDirectory() || !/^\d{4}$/.test(yearEntry.name)) {
+            invalidSource(`${sourceRelativePath(sourceRoot, yearPath)} is not a YYYY directory or manifest.md`);
+        }
+        const yearDir = yearPath;
+        for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
+            const monthPath = path.join(yearDir, monthEntry.name);
+            if (allowManifest(yearDir, monthEntry)) {
+                continue;
+            }
+            const monthStat = sourcePathStat(sourceRoot, monthPath);
+            if (!monthStat?.isDirectory() || !/^\d{2}$/.test(monthEntry.name)) {
+                invalidSource(`${sourceRelativePath(sourceRoot, monthPath)} is not a MM directory or manifest.md`);
+            }
+            const monthDir = monthPath;
+            for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
+                const dayPath = path.join(monthDir, dayEntry.name);
+                if (allowManifest(monthDir, dayEntry)) {
+                    continue;
+                }
+                const dayStat = sourcePathStat(sourceRoot, dayPath);
+                if (!dayStat?.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
+                    invalidSource(`${sourceRelativePath(sourceRoot, dayPath)} is not a DD directory or manifest.md`);
+                }
+                const dayDir = dayPath;
+                for (const taskEntry of fs.readdirSync(dayDir, { withFileTypes: true })) {
+                    const taskPath = path.join(dayDir, taskEntry.name);
+                    const taskStat = sourcePathStat(sourceRoot, taskPath);
+                    if (!taskStat?.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
+                        invalidSource(`${sourceRelativePath(sourceRoot, taskPath)} is not a TASK-YYYYMMDD-HHMMSS directory`);
+                    }
+                    validateTaskDirectory(sourceRoot, taskPath, seenTaskIds);
+                }
+            }
+        }
+    }
+}
+function validateSourceWorkspace(sourcePath) {
+    validateSourceRoot(sourcePath);
+    const seenTaskIds = new Map();
+    for (const section of MUTABLE_SECTIONS) {
+        validateMutableSection(sourcePath, section, seenTaskIds);
+    }
+    validateArchiveSection(sourcePath, seenTaskIds);
+}
 function detectSourceMode(sourcePath) {
+    validateSourceRoot(sourcePath);
     for (const section of ALL_SECTIONS) {
         const sectionDir = path.join(sourcePath, section);
-        if (fs.existsSync(sectionDir) && fs.statSync(sectionDir).isDirectory()) {
+        const sectionStat = sourcePathStat(sourcePath, sectionDir);
+        if (sectionStat?.isDirectory()) {
             return 'workspace';
         }
+        if (sectionStat) {
+            invalidSource(`${section} must be a directory`);
+        }
     }
-    return 'legacy-archive';
+    invalidSource('expected a current workspace containing active, blocked, completed, or archive sections');
 }
 function createReport(sourcePath, backupRoot) {
     return {
@@ -606,24 +730,6 @@ function mergeArchiveSection(sourceArchive, localArchive, report) {
     }
     return sourceTasks.length;
 }
-function printLegacyArchiveMessages(report, sourcePath) {
-    const merged = report.sections.archive.copied;
-    const skipped = report.sections.archive.skipped;
-    if (merged.length === 0 && skipped.length === 0) {
-        info(`No archived tasks found in ${sourcePath}`);
-    }
-    for (const task of merged) {
-        ok(`Merged ${task.taskId} -> ${task.relativePath}`);
-    }
-    for (const task of skipped) {
-        info(`Skipped ${task.taskId} (already exists at ${task.relativePath})`);
-    }
-    process.stdout.write('\n');
-    info('Merge summary');
-    info(`- Merged: ${merged.length}`);
-    info(`- Skipped: ${skipped.length}`);
-    process.stdout.write('\n');
-}
 function printSection(lines, name, counts) {
     const title = `${SECTION_LABELS[name].padEnd(9, ' ')} (.agents/workspace/${name}/):`;
     lines.push(title);
@@ -709,7 +815,10 @@ async function cmdMerge(args) {
     if (!fs.existsSync(resolvedSource)) {
         throw new Error(`Source path does not exist: ${sourcePath}`);
     }
-    if (!fs.statSync(resolvedSource).isDirectory()) {
+    if (fs.lstatSync(resolvedSource).isSymbolicLink()) {
+        throw new Error(`Invalid merge source: source path must be a real directory: ${sourcePath}`);
+    }
+    if (!fs.lstatSync(resolvedSource).isDirectory()) {
         throw new Error(`Source path is not a directory: ${sourcePath}`);
     }
     const workspaceDir = path.join(process.cwd(), '.agents', 'workspace');
@@ -718,30 +827,23 @@ async function cmdMerge(args) {
     const backupRootRelative = `.agents/workspace/.merge-backup/${backupStamp}/`;
     const backupRoot = path.join(workspaceDir, '.merge-backup', backupStamp);
     const report = createReport(resolvedSource, backupRootRelative);
-    const mode = detectSourceMode(resolvedSource);
+    detectSourceMode(resolvedSource);
+    validateSourceWorkspace(resolvedSource);
     for (const section of ALL_SECTIONS) {
         fs.mkdirSync(path.join(workspaceDir, section), { recursive: true });
     }
-    if (mode === 'legacy-archive') {
-        info('Detected legacy archive source; treating the input as archive-only for backward compatibility.');
-        mergeArchiveSection(resolvedSource, archiveDir, report);
-    }
-    else {
-        mergeMutableSections({
-            sourceWorkspace: resolvedSource,
-            localWorkspace: workspaceDir,
-            backupRoot,
-            report
-        });
-        const sourceArchive = path.join(resolvedSource, 'archive');
-        if (fs.existsSync(sourceArchive) && fs.statSync(sourceArchive).isDirectory()) {
-            mergeArchiveSection(sourceArchive, archiveDir, report);
-        }
+    mergeMutableSections({
+        sourceWorkspace: resolvedSource,
+        localWorkspace: workspaceDir,
+        backupRoot,
+        report
+    });
+    const sourceArchive = path.join(resolvedSource, 'archive');
+    const sourceArchiveStat = sourcePathStat(resolvedSource, sourceArchive);
+    if (sourceArchiveStat?.isDirectory()) {
+        mergeArchiveSection(sourceArchive, archiveDir, report);
     }
     rebuildManifests(archiveDir);
-    if (mode === 'legacy-archive') {
-        printLegacyArchiveMessages(report, sourcePath);
-    }
     printReport(report);
 }
 export { cmdMerge, compareTimestamps, detectSourceMode, extractField, extractTitle, formatBackupTimestamp, getTaskTimestamp, rebuildManifests, scanSourceTasks, scanWorkspaceSection, taskExistsInArchive };

package/dist/lib/process-data/normalize.js

@@ -1,4 +1,5 @@
 import { sha256 } from './store.js';
+import { normalizeAgentToken } from '../agent-clients/tokens.js';
 const TASK_ID_RE = /TASK-\d{8}-\d{6}/;
 const ACTIVITY_RE = /^- (\d{4}-\d{2}-\d{2} [^ ]+) — \*\*(.+?)\*\* by ([^ ]+) — (.+)$/gm;
 const LEDGER_RE = /^\|\s*((?:AN|PL|CD)-\d+)\s*\|\s*(analysis|plan|code)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|$/gm;
@@ -9,15 +10,7 @@ function recordId(kind, identity, suffix = '') {
 }
 function canonicalActor(raw) {
     const lowered = raw.toLowerCase();
-    const aliases = {
-        'claude-code': 'claude',
-        'antigravity-cli': 'antigravity',
-        'gemini-cli': 'gemini',
-        gemini: 'gemini'
-    };
-    if (['claude', 'codex', 'antigravity', 'opencode', 'cursor', 'human'].includes(lowered))
-        return lowered;
-    return aliases[lowered] ?? null;
+    return normalizeAgentToken(lowered);
 }
 function nextOccurrence(occurrences, identity) {
     const occurrence = (occurrences.get(identity) ?? 0) + 1;

package/dist/lib/run/host.js

@@ -1,26 +1,55 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-function resolveCommand(file) {
-    if (process.platform !== 'win32' || path.extname(file)) {
-        return file;
-    }
-    const pathValue = process.env.Path || process.env.PATH || '';
-    const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
-    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+function resolveCommandDetails(file, platform = process.platform, env = process.env) {
+    if (path.isAbsolute(file))
+        return { path: file, source: 'absolute' };
+    const pathValue = platform === 'win32'
+        ? env.Path || env.PATH || ''
+        : env.PATH || '';
+    const extensions = platform === 'win32'
+        ? (path.extname(file)
+            ? ['']
+            : (env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean))
+        : [''];
+    for (const dir of pathValue.split(path.delimiter)) {
         for (const extension of extensions) {
-            const lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
-            if (fs.existsSync(lowerCandidate))
-                return lowerCandidate;
-            const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
-            if (fs.existsSync(upperCandidate))
-                return upperCandidate;
+            const candidates = extension
+                ? [`${file}${extension.toLowerCase()}`, `${file}${extension.toUpperCase()}`]
+                : [file];
+            for (const candidateName of candidates) {
+                const candidate = path.resolve(dir || '.', candidateName);
+                try {
+                    const stat = fs.statSync(candidate);
+                    if (!stat.isFile())
+                        continue;
+                    if (platform !== 'win32' && (stat.mode & 0o111) === 0)
+                        continue;
+                    return {
+                        path: candidate,
+                        source: dir ? 'path' : 'current-directory',
+                        pathEntry: dir
+                    };
+                }
+                catch {
+                    // Keep searching the remaining PATH entries.
+                }
+            }
         }
     }
-    return file;
+    return { path: file, source: 'unresolved' };
+}
+function resolveCommand(file, platform = process.platform, env = process.env) {
+    return resolveCommandDetails(file, platform, env).path;
+}
+function resolveCommandFromAbsolutePath(file, platform = process.platform, env = process.env) {
+    const resolution = resolveCommandDetails(file, platform, env);
+    return resolution.source === 'path' && resolution.pathEntry && path.isAbsolute(resolution.pathEntry)
+        ? resolution.path
+        : null;
 }
-function needsShell(file) {
-    return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+function needsShell(file, platform = process.platform) {
+    return platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
 }
 export async function runHostCommand(command) {
     const [file, ...args] = command;
@@ -36,4 +65,5 @@ export async function runHostCommand(command) {
         child.on('close', (exitCode, signal) => resolve({ exitCode, signal }));
     });
 }
+export { needsShell, resolveCommand, resolveCommandFromAbsolutePath };
 //# sourceMappingURL=host.js.map

package/dist/lib/run/tui.js

@@ -1,11 +1,12 @@
 import { renderAgentClientInvocation } from '../agent-clients/invocation.js';
 import { getAgentClientAdapter } from '../agent-clients/registry.js';
-const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode']);
+const TUI_NAMES = new Set(['claude', 'codex', 'antigravity', 'opencode', 'traecli']);
 const TUI_AGENT_CLIENT_IDS = Object.freeze({
     claude: 'claude-code',
     codex: 'codex',
     antigravity: 'antigravity-cli',
-    opencode: 'opencode'
+    opencode: 'opencode',
+    traecli: 'traecli'
 });
 function isTuiName(value) {
     return typeof value === 'string' && TUI_NAMES.has(value);
@@ -33,6 +34,8 @@ export function buildTuiCommand(tui, prompt) {
         return ['agy', ['--dangerously-skip-permissions', '--print', prompt]];
     if (tui === 'opencode')
         return ['opencode', ['run', '--dangerously-skip-permissions', prompt]];
+    if (tui === 'traecli')
+        return ['traecli', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
     return ['codex', ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt]];
 }
 //# sourceMappingURL=tui.js.map

package/dist/lib/sandbox/agent-client-reconciler.js

@@ -15,15 +15,6 @@ function agentInfraTool(home) {
         setupHint: 'Provides the ai and agent-infra CLI commands inside the sandbox.'
     };
 }
-function compatAgentClientState(tools) {
-    return Object.fromEntries(listAgentClientAdapters().map((adapter) => [
-        adapter.id,
-        {
-            enabled: true,
-            installInSandbox: tools.includes(adapter.id)
-        }
-    ]));
-}
 function stableValue(value) {
     if (Array.isArray(value)) {
         return value.map(stableValue);
@@ -96,7 +87,7 @@ function hooksByPhase(adapters) {
     ])));
 }
 function createSandboxCapabilityPlan(config) {
-    const state = config.agentClientState ?? compatAgentClientState(config.tools);
+    const state = config.agentClientState;
     const selectedAgentClients = listInstalledAgentClientAdapters(state);
     const context = { home: config.home, project: config.project };
     const selectedTools = selectedAgentClients.map((adapter) => adapter.sandbox.createTool(context));
@@ -113,8 +104,9 @@ function createSandboxCapabilityPlan(config) {
     const nonClientTools = [];
     const selectedCustomTools = [];
     for (const id of config.tools) {
-        if (isAgentClientId(id))
-            continue;
+        if (isAgentClientId(id)) {
+            throw new Error(`Agent Client '${id}' must be provided by agentClientState`);
+        }
         if (id === 'agent-infra') {
             if (!nonClientTools.some((tool) => tool.id === id)) {
                 nonClientTools.push(agentInfraTool(config.home));

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

@@ -17,7 +17,7 @@ import { parseSandboxWorkspaceIdentity, resolveSandboxTarget, sameSandboxWorkspa
 import { createSandboxCapabilityPlan, runSandboxHooks, runBoundedSandboxHookCommand } from '../agent-client-reconciler.js';
 import { resolveTools, tmpfsSeedStagingPath, tmpfsSeedTargetPath, toolConfigDirCandidates } from '../tools.js';
 import { assertFreshSandboxReady, hydrateTmpfsSeedEntries, prepareTmpfsMounts, startSandboxControlBroker } from '../recovery.js';
-import { acquireSandboxControlReplacement, assertSandboxControlCutoverSnapshot, beginSandboxControlReplacement, captureSandboxControlCutoverSnapshot, commitSandboxControlReplacement, quiesceSandboxControlRoot, recoverSandboxControlReplacement, readSandboxControlManifestForTransition } from '../control/lifecycle.js';
+import { acquireSandboxControlReplacement, assertSandboxControlCutoverSnapshot, beginSandboxControlReplacement, captureSandboxControlCutoverSnapshot, commitSandboxControlReplacement, quiesceSandboxControlRoot, recoverSandboxControlReplacement, readSandboxControlManifest } from '../control/lifecycle.js';
 import { inspectSandboxControlContainer } from '../control/container-identity.js';
 import { hostJoin, toEnginePath, volumeArg } from '../engines/wsl2-paths.js';
 import { sandboxCoreBindMounts } from '../mounts.js';
@@ -879,7 +879,7 @@ export async function create(args) {
                         const recoveryResult = await recoverSandboxControlReplacement(controlPaths.root, replacementLease);
                         const hadExistingControlRoot = hadControlRootBeforeAcquire || recoveryResult === 'restored';
                         const previousManifest = fs.existsSync(controlPaths.manifestPath)
-                            ? readSandboxControlManifestForTransition(controlPaths.manifestPath)
+                            ? readSandboxControlManifest(controlPaths.manifestPath)
                             : null;
                         if (hadExistingControlRoot) {
                             await quiesceSandboxControlRoot(controlPaths.root);
@@ -1031,7 +1031,7 @@ export async function create(args) {
                                 ...(target.workspace.mode === 'task-bound' ? { runtimeDir: control.runtimeDir } : {}),
                                 ...(target.workspace.mode === 'task-bound'
                                     ? {
-                                        taskSource: assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId),
+                                        taskSources: [assertSandboxTaskSource(effectiveConfig.repoRoot, target.workspace.taskId)],
                                         taskId: target.workspace.taskId
                                     }
                                     : {})

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

@@ -1,5 +1,5 @@
 import { loadConfig } from '../config.js';
-import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel } from '../constants.js';
+import { assertValidBranchName, containerNameCandidates, sandboxBranchLabel, sandboxLabel, sandboxTaskIdLabel, sandboxWorkspaceModeLabel } from '../constants.js';
 import { detectEngine } from '../engine.js';
 import { ensureSandboxReady } from '../recovery.js';
 import { createSandboxCapabilityPlan, runBoundedSandboxHookCommand, runSandboxHooks } from '../agent-client-reconciler.js';
@@ -9,7 +9,7 @@ import { redactCommandError } from '../redaction.js';
 import { runInteractiveWithClipboardBridge } from '../clipboard/bridge.js';
 import { detectHostTimezone } from '../host-timezone.js';
 import { fetchSandboxRows, selectSandboxContainer, } from './list-running.js';
-import { resolveSandboxTarget } from '../workspace-identity.js';
+import { resolveSandboxReentryContext, resolveSandboxTarget } from '../workspace-identity.js';
 const USAGE = `Usage: ai sandbox exec [--recreate] <branch | TASK-id | N> [cmd...]
 
 N references an active task short id from
@@ -81,16 +81,30 @@ export async function enter(args) {
     const target = resolveSandboxTarget(parsed.target, config.repoRoot);
     const branch = target.branch;
     assertValidBranchName(branch);
-    const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config));
+    const { running, nonRunning } = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), {
+        mode: sandboxWorkspaceModeLabel(config),
+        taskId: sandboxTaskIdLabel(config)
+    });
     const found = selectSandboxContainer([...running, ...nonRunning], containerNameCandidates(config, branch));
     if (!found) {
         throw new Error(`No sandbox found for branch '${branch}'. Run 'ai sandbox create ${branch}' to create one.`);
     }
+    const containerWorkspace = found.workspaceMode === 'task-bound' && found.taskId
+        ? { mode: 'task-bound', taskId: found.taskId }
+        : found.workspaceMode === 'branch-only'
+            ? { mode: 'branch-only' }
+            : { mode: 'legacy-invalid' };
+    const reentry = resolveSandboxReentryContext({
+        target,
+        containerWorkspace,
+        repoRoot: config.repoRoot
+    });
     const ready = await ensureSandboxReady({
         config,
         engine,
         branch,
-        workspace: target.workspace,
+        workspace: reentry.workspace,
+        reentry: reentry.reentry,
         row: found,
         allowRecreate: parsed.recreate,
         recreate: async () => {

package/dist/lib/sandbox/config.js

@@ -4,7 +4,6 @@ import { homedir, platform } from 'node:os';
 import { execFileSync } from 'node:child_process';
 import pc from 'picocolors';
 import { normalizeAgentClients } from '../agent-clients/config.js';
-import { isAgentClientId } from '../agent-clients/types.js';
 import { validateSandboxEngine } from './engine.js';
 import { hostJoin } from './engines/wsl2-paths.js';
 import { findRuntimeEngineMismatches } from './runtime-engines.js';
@@ -48,15 +47,9 @@ function cloneDefaults() {
         vm: { ...DEFAULTS.vm }
     };
 }
-function resolveSandboxToolIds(sandbox, agentClients, defaults) {
+function resolveSandboxToolIds(sandbox, defaults) {
     if (Array.isArray(sandbox.tools)) {
-        const tools = sandbox.tools.filter((tool) => typeof tool === 'string');
-        return agentClients.source === 'canonical'
-            ? tools.filter((tool) => !isAgentClientId(tool))
-            : tools;
-    }
-    if (agentClients.remainingSandboxTools !== undefined) {
-        return [...agentClients.remainingSandboxTools];
+        return sandbox.tools.filter((tool) => typeof tool === 'string');
     }
     return [...defaults];
 }
@@ -71,7 +64,6 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         throw new Error('No .agents/.airc.json found. Run "ai init" first.');
     }
     const airc = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    const sandboxInput = airc.sandbox;
     const agentClients = normalizeAgentClients(airc);
     const defaults = cloneDefaults();
     const sandbox = airc.sandbox ?? {};
@@ -99,7 +91,7 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         }
     }
     const customTools = parseCustomTools(sandbox.customTools, { home });
-    const tools = resolveSandboxToolIds(sandbox, agentClients, defaults.tools);
+    const tools = resolveSandboxToolIds(sandbox, defaults.tools);
     return {
         repoRoot,
         configPath,
@@ -119,7 +111,6 @@ export function loadConfig({ platformFn = platform, writeStderr = (chunk) => pro
         tools,
         customTools,
         agentClientState: agentClients.state,
-        agentClientSource: agentClients.source,
         refreshIntervalDays: asNonNegativeIntegerOrDefault(sandbox.refreshIntervalDays, defaults.refreshIntervalDays),
         dockerfile,
         vm: {