@fitlab-ai/agent-infra 0.11.15 → 0.12.1

package/dist/lib/platform/pull-requests.js

@@ -14,7 +14,6 @@ import { planPullRequestMetadata } from './pull-request-metadata.js';
 import { planInLabelUpdate, validateInLabelMapping } from './in-label-sync.js';
 import { platformResult } from './types.js';
 import { inspectCompletionArtifacts } from '../task/finalization-artifacts.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { resolveDeliveryTarget } from '../task/delivery-target.js';
 import { mergeOperationWarnings } from '../task/operation-outcome.js';
 import { buildBoundFact, buildSkippedFact, factFrontmatterMutation, readPrDeliveryFact } from '../task/pr-delivery-fact.js';
@@ -1007,16 +1006,9 @@ async function createPlatformPullRequestImpl(taskRef, options) {
         }), PRECONDITION_NOT_CREATED);
     }
     try {
-        return withTaskExecutionLock(base.resolved.repoRoot, base.resolved.taskId, 'platform-pr.create', () => createExternalPullRequest(taskRef, options, base));
+        return await createExternalPullRequest(taskRef, options, base);
     }
     catch (error) {
-        if (error instanceof TaskExecutionLockError) {
-            return withCreation(result('blocked', base.resolved.taskId, base.issueNumber, null, {
-                platform: base.context.platform,
-                capabilities: base.context.capabilities,
-                error: { code: error.code, message: error.message, retryable: true }
-            }), PRECONDITION_NOT_CREATED);
-        }
         return withCreation(result('failed', base.resolved.taskId, base.issueNumber, null, {
             platform: base.context.platform,
             capabilities: base.context.capabilities,
@@ -1456,7 +1448,7 @@ function readProjectPrFlow(repoRoot) {
         return undefined;
     }
 }
-function skipPlatformPullRequestFactUnlocked(resolved, options) {
+function applySkippedPullRequestFact(resolved, options) {
     let content;
     let frontmatter;
     try {
@@ -1533,13 +1525,9 @@ async function skipPlatformPullRequestFact(taskRef, options) {
             error: { code: 'TASK_STATE_INVALID', message: 'platform-pr skip requires an active task', retryable: false }
         });
     try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'platform-pr.skip', () => skipPlatformPullRequestFactUnlocked(resolved, options));
+        return await applySkippedPullRequestFact(resolved, options);
     }
     catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return result('blocked', resolved.taskId, null, null, {
-                error: { code: error.code, message: error.message, retryable: true }
-            });
         return result('failed', resolved.taskId, null, null, {
             error: { code: 'PR_SKIP_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false }
         });

package/dist/lib/platform/summary-content-pipeline.js

@@ -0,0 +1,18 @@
+function parse(value, parser) {
+    try {
+        return parser(value);
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+export function runSummaryContentPipeline(value, operations) {
+    try {
+        parse(value, operations.validate);
+    }
+    catch { /* Source correction gets a chance to repair invalid structure. */ }
+    const corrected = operations.correct(value);
+    const content = parse(corrected, operations.validate);
+    return { content, rendered: operations.render(content) };
+}
+//# sourceMappingURL=summary-content-pipeline.js.map

package/dist/lib/pr-review/evidence-grading.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.js';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.js';
 import { resourceIdentityEquals, resourceIdentityNumber } from '../platform/resource-identity.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
 export class HostResolutionError extends Error {
     code;
@@ -35,12 +36,12 @@ export function extractClosingIssueNumbers(body) {
     return result;
 }
 /**
- * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
+ * Scan active project task workspace task.md files for tasks bound to the
  * PR number or to one of the PR's closing issues. A task is emitted at most once;
  * a verified fact identity hit takes priority over the issue-identity reverse lookup.
  */
 export function collectHostCandidates(input) {
-    const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+    const activeRoot = path.join(resolveProjectTaskWorkspaceRoot(input.workspaceRoot), 'active');
     const candidates = [];
     let entries;
     try {

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

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { detectRepoRoot } from '../task/resolve-ref.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { acquireGitHubCheckpoint, commitGitHubCheckpoint, readGitHubCheckpoint, releaseGitHubCheckpoint } from './checkpoint.js';
 import { materializeJson, materializeSnapshot } from './materialize.js';
 import { normalizeResources } from './normalize.js';
@@ -60,14 +61,14 @@ function dataRoot(repoRoot, requested) {
         input = path.join(boundary, '.agent-infra', 'data-store', config.project);
     }
     const resolved = path.resolve(repoRoot, input);
-    const relative = path.relative(repoRoot, resolved);
-    if (requested !== undefined && (!relative || relative.startsWith('..') || path.isAbsolute(relative)))
-        throw new Error('data root must be inside the repository');
-    const workspace = path.resolve(repoRoot, '.agents', 'workspace');
+    const workspace = resolveProjectTaskWorkspaceRoot(repoRoot);
     const taskRoots = ['active', 'blocked', 'completed', 'archive'].map((state) => path.join(workspace, state));
     if (resolved === workspace || taskRoots.some((taskRoot) => resolved === taskRoot || resolved.startsWith(`${taskRoot}${path.sep}`))) {
         throw new Error('data root cannot be the workspace root or a task directory');
     }
+    const relative = path.relative(repoRoot, resolved);
+    if (requested !== undefined && (!relative || relative.startsWith('..') || path.isAbsolute(relative)))
+        throw new Error('data root must be inside the repository');
     let current = resolved;
     while (current !== boundary) {
         if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink())

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

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createGitHubClient } from '../platform/github-client.js';
 import { enumerateAllTaskDirs } from '../task/resolve-ref.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { captureText, inspectPrivacy, redactExcerpt } from './privacy.js';
 import { canonicalJsonBytes, sha256 } from './store.js';
 function endpointForPage(endpoint, page, perPage) {
@@ -103,6 +104,11 @@ function fetchRestCollection(options) {
     };
 }
 function relativeIdentity(repoRoot, filePath) {
+    const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
+    const taskRelative = path.relative(workspaceRoot, filePath);
+    if (taskRelative && !taskRelative.startsWith('..') && !path.isAbsolute(taskRelative)) {
+        return path.posix.join('task-workspace', taskRelative.split(path.sep).join('/'));
+    }
     const relative = path.relative(repoRoot, filePath);
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
         throw new Error(`path escapes repository: ${filePath}`);

package/dist/lib/run/index.js

@@ -4,6 +4,7 @@ import { loadServerConfig } from '../server/config.js';
 import { resolveSandboxTarget } from '../sandbox/workspace-identity.js';
 import { createRunId, runInSandbox } from '../sandbox/capture.js';
 import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.js';
 import { getSkillRunSpec } from './skills.js';
 import { runHostCommand } from './host.js';
@@ -133,7 +134,7 @@ function readShortIdLength(repoRoot) {
     return 2;
 }
 function readActiveShortIdRegistry(repoRoot) {
-    const registryPath = path.join(repoRoot, '.agents', 'workspace', 'active', '.short-ids.json');
+    const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', '.short-ids.json');
     try {
         const data = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
         return data && typeof data === 'object' && data.ids && typeof data.ids === 'object' ? data.ids : {};
@@ -157,7 +158,7 @@ function resolveActiveTaskIdentity(taskRef, repoRoot) {
     }
     if (!taskId)
         return null;
-    const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const taskDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId);
     if (!fs.existsSync(path.join(taskDir, 'task.md')))
         return null;
     return { taskId, taskDir, taskRef: resolvedTaskRef };

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

@@ -1040,7 +1040,7 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                             const completedTaskSource = target.workspace.mode === 'task-bound'
                                 ? prepareSandboxCompletedTaskMountSource(effectiveConfig.repoRoot, target.workspace.taskId)
                                 : null;
-                            prepareSandboxWorkspaceMountTargets(worktree, target.workspace.mode === 'task-bound' ? target.workspace.taskId : undefined);
+                            prepareSandboxWorkspaceMountTargets(effectiveConfig.repoRoot);
                             if (previousCutoverSnapshot) {
                                 assertSandboxControlCutoverSnapshot(previousCutoverSnapshot);
                                 if (previousManifest) {
@@ -1177,6 +1177,10 @@ export async function create(args, { runProjectInitCommand = true, workspace: wo
                                         : []),
                                     '--label',
                                     `${sandboxRuntimeCapabilityLabel(effectiveConfig)}=${capabilityPlan.runtimeSignature}`,
+                                    // Every task sandbox runs without seccomp and AppArmor filtering;
+                                    // capabilities and namespace isolation remain unchanged.
+                                    '--security-opt', 'seccomp=unconfined',
+                                    '--security-opt', 'apparmor=unconfined',
                                     ...coreVolumes,
                                     ...buildClipboardVolumeArgs(engine, effectiveConfig.home),
                                     ...dotfilesMount,

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

@@ -13,7 +13,7 @@ import { 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
-.agents/workspace/active/.short-ids.json. They resolve only via that
+the read-only task-workspace mount at /task-workspace/active/.short-ids.json. They resolve only via that
 registry — they do not reference a container's row position in
 'ai sandbox ls' output. --recreate rebuilds the matched container while
 preserving its task or branch identity. The same token after the target is

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

@@ -5,6 +5,7 @@ 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() {
     return '{{.Names}}\t{{.Status}}\t{{.Labels}}';
 }
@@ -111,7 +112,7 @@ function tryResolveFromRegistry(arg, repoRoot) {
         throw new Error(`Registry returned malformed task id for '${arg}': ${JSON.stringify(taskId)}`);
     }
     for (const sub of ['active', 'completed', 'blocked', 'archive']) {
-        const taskMdPath = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+        const taskMdPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), sub, taskId, 'task.md');
         if (!fs.existsSync(taskMdPath))
             continue;
         const content = fs.readFileSync(taskMdPath, 'utf8');

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

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.js';
+import { detectRepoRoot } from '../../task/resolve-ref.js';
 import { SANDBOX_CONTROL_MAX_BYTES, SANDBOX_CONTROL_STATUS_STALE_MS, isSandboxControlFamily } from './protocol.js';
 import { readSandboxControlPayload, readSandboxControlStatus } from './state.js';
 import { accessSandboxTaskView, taskViewFromStatus } from './task-view.js';
@@ -127,19 +129,12 @@ const CONTROL_TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const CONTROL_SHORT_ID_RE = /^\d+$/;
 // Use the current short-id contract for the first visible active registry.
 export function resolveVisibleActiveShortId(ref) {
-    let dir = process.cwd();
-    for (let depth = 0; depth < 64; depth += 1) {
-        const registryPath = path.join(dir, '.agents', 'workspace', 'active', '.short-ids.json');
-        if (fs.existsSync(registryPath)) {
-            const resolved = resolveShortIdReadOnly(ref, dir, { shortIdLength: configuredShortIdLength(dir) });
-            return resolved.ok ? resolved.taskId : null;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
+    const repoRoot = detectRepoRoot();
+    const registryPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', '.short-ids.json');
+    if (!fs.existsSync(registryPath))
+        return null;
+    const resolved = resolveShortIdReadOnly(ref, repoRoot, { shortIdLength: configuredShortIdLength(repoRoot) });
+    return resolved.ok ? resolved.taskId : null;
 }
 // A request's leading argument is only a task reference for some families and
 // may be a documented short id. Compare canonical ids so a bound sandbox keeps

package/dist/lib/sandbox/control/completed-reentry.js

@@ -4,6 +4,7 @@ import { resolveTaskWorkspace } from '../task-resolver.js';
 import { assertGitWorktreeBinding } from '../../git/worktree-identity.js';
 import { parseTypedTaskFrontmatter } from '../../task/frontmatter.js';
 import { readTaskFinalizationReceipt } from '../../task/finalization.js';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.js';
 import { inspectSandboxControlContainer } from './container-identity.js';
 import { atomicWriteJson, readSandboxControlStatus } from './state.js';
 import { taskViewForManifest } from './task-view.js';
@@ -40,7 +41,7 @@ export async function prepareCompletedReentry(manifest, inspect = inspectSandbox
         || previous.receipt.requestId !== view.receipt.requestId
         || previous.receipt.revision > view.receipt.revision)
         throw invalid();
-    const completedRoot = fs.realpathSync.native(path.join(manifest.repoRoot, '.agents', 'workspace', 'completed'));
+    const completedRoot = fs.realpathSync.native(path.join(resolveProjectTaskWorkspaceRoot(manifest.repoRoot), 'completed'));
     const source = fs.realpathSync.native(path.join(completedRoot, manifest.taskId));
     if (source !== path.join(completedRoot, manifest.taskId))
         throw invalid();

package/dist/lib/sandbox/control/task-view.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.js';
 export const SANDBOX_TASK_VIEW_STATES = ['not-applicable', 'current', 'finalized-stale', 'unknown'];
 export const SANDBOX_TASK_VIEW_SOURCES = ['active', 'completed', 'unknown'];
 function invalidView(message) {
@@ -71,8 +72,9 @@ export function taskViewForManifest(params) {
     if (params.mode !== 'task-bound' || !params.taskId) {
         return { state: 'not-applicable', taskId: null, observedSource: null, receipt: null, reasonCode: null };
     }
-    const active = path.join(params.repoRoot, '.agents', 'workspace', 'active', params.taskId, 'task.md');
-    const completed = path.join(params.repoRoot, '.agents', 'workspace', 'completed', params.taskId, 'task.md');
+    const taskRoot = resolveProjectTaskWorkspaceRoot(params.repoRoot);
+    const active = path.join(taskRoot, 'active', params.taskId, 'task.md');
+    const completed = path.join(taskRoot, 'completed', params.taskId, 'task.md');
     const activeExists = fs.existsSync(active);
     const completedExists = fs.existsSync(completed);
     if (activeExists === completedExists) {

package/dist/lib/sandbox/mounts.js

@@ -11,12 +11,12 @@ function workspaceStateMounts(workspaceViewRoot, taskBound) {
         .map(({ state, hostPath }) => taskBound && state === 'active'
         ? {
             hostPaths: [path.join(hostPath, '.short-ids.json')],
-            containerPath: '/workspace/.agents/workspace/active/.short-ids.json',
+            containerPath: '/task-workspace/active/.short-ids.json',
             readOnly: true
         }
         : {
             hostPaths: [hostPath],
-            containerPath: path.posix.join('/workspace/.agents/workspace', state),
+            containerPath: path.posix.join('/task-workspace', state),
             readOnly: true
         });
 }
@@ -37,13 +37,13 @@ function taskWorkspaceMounts(taskSources, taskBound, overrides) {
     const taskId = overrides.taskId;
     const mounts = [{
             hostPaths: taskSources,
-            containerPath: path.posix.join('/workspace/.agents/workspace/active', taskId),
+            containerPath: path.posix.join('/task-workspace/active', taskId),
             readOnly: false
         }];
     if (overrides.completedTaskSource)
         mounts.push({
             hostPaths: [overrides.completedTaskSource],
-            containerPath: path.posix.join('/workspace/.agents/workspace/completed', taskId),
+            containerPath: path.posix.join('/task-workspace/completed', taskId),
             readOnly: false
         });
     return mounts;

package/dist/lib/sandbox/recovery.js

@@ -11,6 +11,7 @@ import { sandboxCoreBindMounts } from './mounts.js';
 import { resolveSandboxGitMetadata } from './git-metadata.js';
 import { assertSandboxTaskSource, sandboxCompletedTaskMountSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
 import { resolveTaskWorkspace } from './task-resolver.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { inspectWorktree } from './worktree-safety.js';
 import { commandForEngine, runEngine, runOkEngine, runProbe, runVerboseEngine } from './shell.js';
@@ -277,11 +278,13 @@ export function classifySandboxRecovery(snapshot) {
         });
     }
     if (snapshot.workspaceTopology === 'legacy-parent') {
+        const legacyRoot = snapshot.mounts.some((mount) => mount.path === '/task-workspace')
+            ? '/task-workspace' : '/workspace/.agents/workspace';
         findings.push({
             repairKind: 'hard-failure',
             code: 'SANDBOX_WORKSPACE_TOPOLOGY_MISMATCH',
             message: 'Sandbox uses the legacy workspace parent-mount topology; recreate the container explicitly to migrate it.',
-            path: '/workspace/.agents/workspace'
+            path: legacyRoot
         });
     }
     if (snapshot.taskView && !snapshot.taskView.readable) {
@@ -302,7 +305,8 @@ export function classifySandboxRecovery(snapshot) {
     }
     for (const mount of snapshot.mounts) {
         if (snapshot.workspaceTopology === 'legacy-parent'
-            && mount.path.startsWith('/workspace/.agents/workspace'))
+            && (mount.path.startsWith('/workspace/.agents/workspace')
+                || mount.path.startsWith('/task-workspace')))
             continue;
         if (mount.actualType !== mount.expectedType
             || !mount.sourceMatches
@@ -386,14 +390,15 @@ function inspectContainer(engine, container, runFn) {
     return parsed[0];
 }
 function workspaceTopology(mountsByDestination) {
-    if (mountsByDestination.has('/workspace/.agents/workspace'))
+    if (mountsByDestination.has('/workspace/.agents/workspace')
+        || mountsByDestination.has('/task-workspace'))
         return 'legacy-parent';
     const perState = [
-        '/workspace/.agents/workspace/active',
-        '/workspace/.agents/workspace/active/.short-ids.json',
-        '/workspace/.agents/workspace/completed',
-        '/workspace/.agents/workspace/blocked',
-        '/workspace/.agents/workspace/archive'
+        '/task-workspace/active',
+        '/task-workspace/active/.short-ids.json',
+        '/task-workspace/completed',
+        '/task-workspace/blocked',
+        '/task-workspace/archive'
     ];
     return perState.some((destination) => mountsByDestination.has(destination))
         ? 'per-state'
@@ -421,8 +426,9 @@ function sourceCandidates(engine, hostPath) {
     return [...new Set(candidates.map((candidate) => normalizeMountSource(engine, candidate)))];
 }
 function recoveryTaskSources(repoRoot, taskId) {
-    const activePath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
-    const completedPath = path.join(repoRoot, '.agents', 'workspace', 'completed', taskId);
+    const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
+    const activePath = path.join(taskRoot, 'active', taskId);
+    const completedPath = path.join(taskRoot, 'completed', taskId);
     if (fs.existsSync(activePath) && !fs.existsSync(completedPath)) {
         const source = assertSandboxTaskSource(repoRoot, taskId);
         return { mountPaths: [source], accessiblePaths: [source] };
@@ -435,12 +441,12 @@ function recoveryTaskSources(repoRoot, taskId) {
     if (task.state !== 'completed') {
         throw new Error(`SANDBOX_TASK_SOURCE_STATE_UNSUPPORTED: task ${taskId} is ${task.state}`);
     }
-    const completedRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace', 'completed'));
+    const completedRoot = fs.realpathSync.native(path.join(taskRoot, 'completed'));
     const completedSource = fs.realpathSync.native(path.dirname(task.taskMd));
     if (path.dirname(completedSource) !== completedRoot) {
         throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${completedSource} is not under completed workspace`);
     }
-    const historicalActivePath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const historicalActivePath = path.join(taskRoot, 'active', taskId);
     const mountPaths = [completedSource, historicalActivePath];
     if (fs.existsSync(historicalActivePath)) {
         try {
@@ -456,7 +462,7 @@ function recoveryTaskSources(repoRoot, taskId) {
 export function startCompletedSandboxContainer(params) {
     const taskSources = recoveryTaskSources(params.config.repoRoot, params.taskId);
     const completedSource = taskSources.accessiblePaths[0];
-    const activeRoot = path.join(params.config.repoRoot, '.agents', 'workspace', 'active');
+    const activeRoot = path.join(resolveProjectTaskWorkspaceRoot(params.config.repoRoot), 'active');
     const historicalSource = path.join(activeRoot, params.taskId);
     fs.mkdirSync(activeRoot, { recursive: true });
     let replacedEmptyRoot = false;
@@ -559,11 +565,11 @@ function expectedMounts(params) {
         expectedType: 'bind',
         hostPaths: mount.hostPaths,
         ...(taskSources !== null && taskId !== null
-            && mount.containerPath === `/workspace/.agents/workspace/active/${taskId}`
+            && mount.containerPath === `/task-workspace/active/${taskId}`
             ? { sourceAccessiblePaths: taskSources.accessiblePaths }
             : {}),
         ...(completedTaskSource !== null && taskId !== null
-            && mount.containerPath === `/workspace/.agents/workspace/completed/${taskId}`
+            && mount.containerPath === `/task-workspace/completed/${taskId}`
             ? { sourceAccessiblePaths: [completedTaskSource] }
             : {}),
         expectedRW: !mount.readOnly
@@ -664,7 +670,7 @@ export function collectSandboxRecoverySnapshot(params) {
     const tools = [...capabilityPlan.tools];
     const topology = workspaceTopology(mountsByDestination);
     const taskViewPath = workspace.mode === 'task-bound'
-        ? `/workspace/.agents/workspace/active/${workspace.taskId}/task.md`
+        ? `/task-workspace/active/${workspace.taskId}/task.md`
         : null;
     const seeds = declaredTmpfsSeedEntries(tools).map((seed) => {
         const mounted = mountsByDestination.get(seed.stagingPath)?.Type === 'bind';
@@ -856,6 +862,10 @@ function canRetryFreshReadiness(findings) {
         && finding.code !== 'SANDBOX_WORKSPACE_TOPOLOGY_MISMATCH'
         && finding.path !== undefined
         && (finding.path.startsWith('/workspace/.agents/workspace')
+            || finding.path.startsWith('/task-workspace/active')
+            || finding.path.startsWith('/task-workspace/blocked')
+            || finding.path.startsWith('/task-workspace/completed')
+            || finding.path.startsWith('/task-workspace/archive')
             || finding.path === '/home/devuser/.host-shell-config'
             || finding.path === '/home/devuser/.bash_aliases'
             || finding.path === '/run/agent-infra/runtime'));

package/dist/lib/sandbox/removal.js

@@ -17,7 +17,6 @@ import { acquireSandboxResourceLock } from './control/native-file-lock.js';
 import { toolConfigDirCandidates, toolProjectDirCandidates } from './tools.js';
 import { getProcessStartTime } from '../server/process-state.js';
 import { releaseStaleShortIdRegistry } from '../task/short-id.js';
-import { withRepositoryMutationLock } from '../task/task-execution-lock.js';
 import { fetchSandboxRows } from './commands/list-running.js';
 import { createSandboxControlBindingEvidence } from './task-cleanup.js';
 import { createCleanPermit, createDiscardPermit, formatWorktreeSnapshot, inspectRecoveredWorktree, inspectWorktrees, verifyWorktreePermit } from './worktree-safety.js';
@@ -28,6 +27,40 @@ function isMissingPathError(error) {
     return Boolean(error && typeof error === 'object' && 'code' in error
         && error.code === 'ENOENT');
 }
+function removalErrorCode(error) {
+    return error && typeof error === 'object' && 'code' in error
+        && typeof error.code === 'string'
+        ? error.code
+        : null;
+}
+function removalErrorMessage(error) {
+    const code = removalErrorCode(error);
+    const message = error instanceof Error ? error.message : String(error);
+    return code ? `${code}: ${message}` : message;
+}
+function addOwnerWriteToDirectories(root) {
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        let stat;
+        try {
+            stat = fs.lstatSync(current);
+        }
+        catch (error) {
+            if (isMissingPathError(error))
+                continue;
+            throw error;
+        }
+        if (!stat.isDirectory())
+            continue;
+        fs.chmodSync(current, stat.mode | 0o200);
+        for (const entry of fs.readdirSync(current))
+            pending.push(path.join(current, entry));
+    }
+}
+function isPermissionRemovalError(error) {
+    return ['EACCES', 'EPERM', 'ENOTEMPTY'].includes(removalErrorCode(error) ?? '');
+}
 function canonicalPath(input) {
     try {
         return fs.realpathSync.native(input);
@@ -665,12 +698,12 @@ async function authorizeWorktrees(worktrees, { allowDirtyDiscard, assumeYes }, {
     }
     return permits;
 }
-async function runRmOneUnderRepositoryLock(config, tools, branch, options = {}) {
+async function runRmOne(config, tools, branch, options = {}) {
     const target = options.target ?? resolveRmTarget(config, tools, options.cleanupTarget ?? resolveSandboxCleanupTarget(branch, config.repoRoot));
     return rmOneCore(config, tools, branch, { ...options, target });
 }
 async function rmOne(config, tools, branch, options = {}) {
-    await withRepositoryMutationLock(config.repoRoot, () => runRmOneUnderRepositoryLock(config, tools, branch, options));
+    await runRmOne(config, tools, branch, options);
 }
 async function removeUncheckedSandbox(config, target, options) {
     const confirm = options.prompt?.confirm ?? p.confirm;
@@ -719,8 +752,28 @@ async function removeUncheckedSandbox(config, target, options) {
         fs.rmSync(root, { recursive: true, force: true });
         removeEmptyManagedParent(path.join(config.workspaceViewBase, config.project), root);
     }
-    for (const candidate of toolCandidates.flatMap(({ candidates }) => candidates))
-        fs.rmSync(candidate, { recursive: true, force: true });
+    const toolRemovalFailures = [];
+    for (const candidate of toolCandidates.flatMap(({ candidates }) => candidates)) {
+        try {
+            fs.rmSync(candidate, { recursive: true, force: true });
+            continue;
+        }
+        catch (initialError) {
+            if (isPermissionRemovalError(initialError)) {
+                try {
+                    addOwnerWriteToDirectories(candidate);
+                    fs.rmSync(candidate, { recursive: true, force: true });
+                    continue;
+                }
+                catch (retryError) {
+                    toolRemovalFailures.push(`${candidate}: ${removalErrorMessage(initialError)}; retry failed: ${removalErrorMessage(retryError)}`);
+                }
+            }
+            else {
+                toolRemovalFailures.push(`${candidate}: ${removalErrorMessage(initialError)}`);
+            }
+        }
+    }
     for (const shell of shellConfigDirCandidates(config, effectiveBranch))
         fs.rmSync(shell, { recursive: true, force: true });
     if (shouldRemoveShare)
@@ -737,6 +790,9 @@ async function removeUncheckedSandbox(config, target, options) {
         assertBranchRemovalIdentity(config, effectiveBranch, worktreePermits);
         runSafe('git', ['-C', config.repoRoot, 'branch', '-D', effectiveBranch]);
     }
+    if (toolRemovalFailures.length > 0) {
+        throw new Error(`SANDBOX_TOOL_CLEANUP_INCOMPLETE:\n${toolRemovalFailures.map((failure) => `  - ${failure}`).join('\n')}`);
+    }
     releaseTaskBoundSandboxIdentity(config.repoRoot, target.workspace);
     if (!options.quiet)
         p.outro('Sandbox removed');
@@ -751,9 +807,6 @@ async function rmOneCore(config, tools, branch, options = {}) {
     return removeUncheckedSandbox(config, target, options);
 }
 async function rmPurge(config, tools, prompt = {}) {
-    return withRepositoryMutationLock(config.repoRoot, () => rmPurgeCore(config, tools, prompt));
-}
-async function rmPurgeCore(config, tools, prompt = {}) {
     const engine = detectEngine(config);
     const confirm = prompt.confirm ?? p.confirm;
     const isCancel = prompt.isCancel ?? p.isCancel;
@@ -829,9 +882,6 @@ async function rmPurgeCore(config, tools, prompt = {}) {
     p.outro(pc.green('All project sandboxes removed'));
 }
 async function rmUnbound(config, tools, options) {
-    return withRepositoryMutationLock(config.repoRoot, () => rmUnboundCore(config, tools, options));
-}
-async function rmUnboundCore(config, tools, options) {
     const engine = detectEngine(config);
     const listed = fetchSandboxRows(engine, sandboxLabel(config), sandboxBranchLabel(config), { mode: sandboxWorkspaceModeLabel(config), taskId: sandboxTaskIdLabel(config) });
     const discovered = [...listed.running, ...listed.nonRunning];
@@ -892,7 +942,7 @@ async function rmUnboundCore(config, tools, options) {
         return;
     }
     for (const { row, cleanupTarget, target } of targets) {
-        await runRmOneUnderRepositoryLock(config, tools, cleanupTarget.branch, {
+        await runRmOne(config, tools, cleanupTarget.branch, {
             assumeYes: options.assumeYes,
             target,
             cleanupTarget

package/dist/lib/sandbox/task-resolver.js

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { isRemovedHashShortIdInput } from '../task/short-id.js';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const SHORT_ID_RE = /^\d+$/;
 export const TASK_WORKSPACE_STATES = ['active', 'completed', 'blocked', 'archive'];
@@ -20,10 +21,11 @@ function stripQuotes(value) {
     return value.replace(/^(["'])(.*)\1$/, '$2');
 }
 function readTaskContent(repoRoot, taskId) {
+    const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
     for (const state of TASK_WORKSPACE_STATES) {
         const taskPath = state === 'archive'
-            ? path.join(repoRoot, '.agents', 'workspace', state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
-            : path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
+            ? path.join(taskRoot, state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
+            : path.join(taskRoot, state, taskId, 'task.md');
         if (fs.existsSync(taskPath)) {
             return { content: fs.readFileSync(taskPath, 'utf8'), state, taskMd: taskPath };
         }
@@ -31,8 +33,9 @@ function readTaskContent(repoRoot, taskId) {
     throw new Error(`Task not found: ${taskId}`);
 }
 function taskWorkspaceCandidates(repoRoot, taskId) {
+    const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
     const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
-        const taskMd = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
+        const taskMd = path.join(taskRoot, state, taskId, 'task.md');
         if (!fs.existsSync(taskMd))
             return [];
         const content = fs.readFileSync(taskMd, 'utf8');
@@ -46,7 +49,7 @@ function taskWorkspaceCandidates(repoRoot, taskId) {
     const parts = findArchiveTaskParts(repoRoot, taskId);
     if (parts.length === 0)
         return hot;
-    const taskMd = path.join(repoRoot, '.agents', 'workspace', 'archive', ...parts, 'local', 'task.md');
+    const taskMd = path.join(taskRoot, 'archive', ...parts, 'local', 'task.md');
     if (!fs.existsSync(taskMd))
         return hot;
     const content = fs.readFileSync(taskMd, 'utf8');
@@ -58,7 +61,7 @@ function taskWorkspaceCandidates(repoRoot, taskId) {
         }];
 }
 function findArchiveTaskParts(repoRoot, taskId) {
-    const archiveRoot = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    const archiveRoot = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'archive');
     if (!fs.existsSync(archiveRoot))
         return [];
     for (const year of fs.readdirSync(archiveRoot).sort().reverse()) {
@@ -113,7 +116,7 @@ export function resolveTaskWorkspace(taskId, repoRoot) {
     return matches[0];
 }
 export function listTaskWorkspaces(repoRoot, state) {
-    const stateRoot = path.join(repoRoot, '.agents', 'workspace', state);
+    const stateRoot = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), state);
     if (state === 'archive') {
         if (!fs.existsSync(stateRoot))
             return [];