@fitlab-ai/agent-infra 0.11.15 → 0.12.0

package/lib/internal/task-workspace.ts

@@ -0,0 +1,39 @@
+import { detectRepoRoot } from '../task/resolve-ref.ts';
+import { resolveProjectTaskWorkspaceLayout, type ExecutionBoundary } from '../task/workspace-root.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
+
+const USAGE = `Usage: agent-infra-internal task-workspace resolve [--boundary host|container]\n`;
+
+function fail(code: string, message: string): void {
+  process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code, message } })}\n`);
+  process.exitCode = 1;
+}
+
+function taskWorkspace(args: string[] = []): void {
+  if (!ensureInternalHandlerRoute('task-workspace', args)) return;
+  const operation = args[0] ?? '';
+  if (operation === '--help' || operation === '-h') { process.stdout.write(USAGE); return; }
+  if (!internalHandlerRoute('task-workspace', 'resolve', operation)) {
+    fail('TASK_WORKSPACE_PAYLOAD_INVALID', "operation must be 'resolve'");
+    return;
+  }
+  let boundary: ExecutionBoundary = 'host';
+  const options = args.slice(1);
+  if (options.length !== 0) {
+    if (options.length !== 2 || options[0] !== '--boundary') {
+      fail('TASK_WORKSPACE_PAYLOAD_INVALID', 'invalid or duplicate task-workspace option');
+      return;
+    }
+    boundary = options[1] as ExecutionBoundary;
+  }
+  if (boundary !== 'host' && boundary !== 'container') {
+    fail('TASK_WORKSPACE_PAYLOAD_INVALID', 'resolve accepts only --boundary host|container');
+    return;
+  }
+  try {
+    const layout = resolveProjectTaskWorkspaceLayout(detectRepoRoot(), boundary);
+    process.stdout.write(`${JSON.stringify({ status: 'resolved', changed: false, projectKey: layout.projectKey, boundary: layout.boundary, root: layout.root, error: null })}\n`);
+  } catch (error) { fail('TASK_WORKSPACE_OPERATION_FAILED', error instanceof Error ? error.message : String(error)); }
+}
+
+export { taskWorkspace };

package/lib/merge.ts

@@ -4,6 +4,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { removeDirRecursive } from './remove-dir.ts';
 import { validateCurrentTaskContract } from './task/current-contract.ts';
+import { resolveProjectTaskWorkspaceRoot } from './task/workspace-root.ts';
 
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
@@ -988,7 +989,7 @@ function mergeArchiveSection(sourceArchive: string, localArchive: string, report
 }
 
 function printSection(lines: string[], name: MutableSection, counts: MutableCounts): void {
-  const title = `${SECTION_LABELS[name].padEnd(9, ' ')} (.agents/workspace/${name}/):`;
+  const title = `${SECTION_LABELS[name].padEnd(9, ' ')} (task workspace/${name}/):`;
   lines.push(title);
 
   const allEntries: Array<[MutableAction, string]> = [
@@ -1013,7 +1014,7 @@ function printSection(lines: string[], name: MutableSection, counts: MutableCoun
 }
 
 function printArchiveSection(lines: string[], counts: ArchiveCounts): void {
-  const title = `${SECTION_LABELS.archive.padEnd(9, ' ')} (.agents/workspace/archive/):`;
+  const title = `${SECTION_LABELS.archive.padEnd(9, ' ')} (task workspace/archive/):`;
   lines.push(title);
 
   if (counts.copied.length === 0 && counts.skipped.length === 0) {
@@ -1105,7 +1106,7 @@ async function cmdMerge(args: string[]): Promise<void> {
   }
 
   const repoRoot = process.cwd();
-  const workspaceDir = path.join(repoRoot, '.agents', 'workspace');
+  const workspaceDir = resolveProjectTaskWorkspaceRoot(repoRoot);
   const archiveDir = path.join(workspaceDir, 'archive');
   const backupStamp = formatBackupTimestamp(new Date());
   const projectKey = resolveRecoveryProjectKey(repoRoot);

package/lib/platform/pr-summary.ts

@@ -5,7 +5,6 @@ import { createHash } from 'node:crypto';
 import { enumerateArtifacts } from '../task/artifacts.ts';
 import { parseTypedTaskFrontmatter } from '../task/frontmatter.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.ts';
 import type { PrDeliveryFact } from '../task/pr-delivery-fact.ts';
 import { resolvePlatformProviderContext } from './context.ts';
@@ -433,7 +432,7 @@ async function reportWrite(taskRef: string, options: ReportWriteOptions): Promis
   if (!loaded.ok || !context.platform.repository || !['no-op', 'degraded'].includes(context.status)) return { ...context, report: null };
   let knownPrNumber: number | null = null;
   try {
-    return await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, options.agent, async () => {
+    return await (async () => {
       const { taskContent, boundFact, factError } = readBoundTaskSnapshot(resolved.taskMdPath);
       if (factError) return {
         ...basePlatformResult('failed', context, resolved.taskId, null, { code: factError.code, message: factError.message, retryable: false }),
@@ -502,18 +501,15 @@ async function reportWrite(taskRef: string, options: ReportWriteOptions): Promis
         operations: [{ name: 'change-report:write', status: 'applied', reasonCode: null }],
         report: { ...reportInfo, status: 'written' }
       };
-    });
+    })();
   } catch (error) {
-    const lockError = error instanceof TaskExecutionLockError
-      ? { code: error.code, message: error.message, retryable: error.code === 'ORCHESTRATION_LOCK_BUSY' }
-      : { code: 'PR_CHANGE_REPORT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
-    return { ...basePlatformResult(lockError.retryable ? 'blocked' : 'failed', context, resolved.taskId, knownPrNumber, lockError), report: null };
+    return { ...basePlatformResult('failed', context, resolved.taskId, knownPrNumber, { code: 'PR_CHANGE_REPORT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false }), report: null };
   }
 }
 
 async function syncPullRequestSummary(
   taskRef: string,
-  options: { agent: string; body: string; changeReportFile?: string; cwd?: string; client?: PlatformClient; dryRun?: boolean; strict?: boolean; primaryResult: PullRequestPrimaryResult; runtimeVersion?: string; manualValidation?: ManualValidationSummaryOptions; lockAlreadyHeld?: boolean; skipQueue?: boolean }
+  options: { agent: string; body: string; changeReportFile?: string; cwd?: string; client?: PlatformClient; dryRun?: boolean; strict?: boolean; primaryResult: PullRequestPrimaryResult; runtimeVersion?: string; manualValidation?: ManualValidationSummaryOptions; skipQueue?: boolean }
 ): Promise<PullRequestSummaryResult> {
   const warningResult = warningResultForPrimary(options.primaryResult);
   let knownPrNumber: number | null = null;
@@ -561,7 +557,7 @@ async function syncPullRequestSummary(
   const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
   const context = loaded.ok ? loaded.value.context : loaded.context;
   if (!loaded.ok || !context.platform.repository || !['no-op', 'degraded'].includes(context.status)) {
-    // This diagnostic-only read preserves the known PR target when context resolution fails before the execution lock.
+    // Preserve the known PR target for diagnostics when provider context resolution fails.
     knownPrNumber = boundPrNumberForWarning(resolved.taskMdPath);
     return preserveFailure(context);
   }
@@ -780,14 +776,9 @@ async function syncPullRequestSummary(
         persistenceFailure: (error) => fail('failed', context, error, prNumber)
       });
     };
-    return await (options.lockAlreadyHeld
-      ? execute()
-      : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, options.agent, execute));
+    return await execute();
   } catch (error) {
-    const lockError = error instanceof TaskExecutionLockError
-      ? { code: error.code, message: error.message, retryable: error.code === 'ORCHESTRATION_LOCK_BUSY' }
-      : { code: 'PR_SUMMARY_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
-    return fail(lockError.retryable ? 'blocked' : 'failed', context, lockError);
+    return fail('failed', context, { code: 'PR_SUMMARY_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false });
   }
 }
 

package/lib/platform/pull-requests.ts

@@ -21,7 +21,6 @@ import {
 import { platformResult } from './types.ts';
 import type { PlatformOperation, PlatformResult } from './types.ts';
 import { inspectCompletionArtifacts } from '../task/finalization-artifacts.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { resolveDeliveryTarget } from '../task/delivery-target.ts';
 import { mergeOperationWarnings, type OperationWarning } from '../task/operation-outcome.ts';
 import {
@@ -1174,20 +1173,8 @@ async function createPlatformPullRequestImpl(taskRef: string, options: CreateOpt
     }), 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,
@@ -1602,7 +1589,7 @@ function readProjectPrFlow(repoRoot: string): 'required' | 'disabled' | undefine
   }
 }
 
-function skipPlatformPullRequestFactUnlocked(
+function applySkippedPullRequestFact(
   resolved: Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>,
   options: SkipFactOptions
 ): PullRequestResult {
@@ -1674,16 +1661,8 @@ async function skipPlatformPullRequestFact(taskRef: string, options: SkipFactOpt
     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/lib/pr-review/evidence-grading.ts

@@ -5,6 +5,7 @@ import { parseTypedTaskFrontmatter } from '../task/frontmatter.ts';
 import { readPrDeliveryFact } from '../task/pr-delivery-fact.ts';
 import { resourceIdentityEquals, resourceIdentityNumber } from '../platform/resource-identity.ts';
 import type { ResourceIdentity } from '../platform/resource-identity.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { taskIssueIdentity } from '../platform/task-identities.ts';
 
 // ---------------------------------------------------------------------------
@@ -61,7 +62,7 @@ export function extractClosingIssueNumbers(body: string): number[] {
 }
 
 /**
- * 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.
  */
@@ -71,7 +72,7 @@ export function collectHostCandidates(input: {
   closingIssues: number[];
   workspaceRoot: string;
 }): HostCandidate[] {
-  const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+  const activeRoot = path.join(resolveProjectTaskWorkspaceRoot(input.workspaceRoot), 'active');
   const candidates: HostCandidate[] = [];
   let entries: fs.Dirent[];
   try {

package/lib/process-data/index.ts

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { detectRepoRoot } from '../task/resolve-ref.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { acquireGitHubCheckpoint, commitGitHubCheckpoint, readGitHubCheckpoint, releaseGitHubCheckpoint } from './checkpoint.ts';
 import { materializeJson, materializeSnapshot } from './materialize.ts';
 import { normalizeResources } from './normalize.ts';
@@ -64,13 +65,13 @@ function dataRoot(repoRoot: string, requested?: string): string {
     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()) throw new Error('data root cannot traverse a symlink');

package/lib/process-data/sources.ts

@@ -3,6 +3,7 @@ import path from 'node:path';
 
 import { createGitHubClient } from '../platform/github-client.ts';
 import { enumerateAllTaskDirs } from '../task/resolve-ref.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { captureText, inspectPrivacy, redactExcerpt } from './privacy.ts';
 import { canonicalJsonBytes, sha256 } from './store.ts';
 
@@ -157,6 +158,11 @@ function fetchRestCollection<T>(options: FetchRestCollectionOptions<T>): Process
 }
 
 function relativeIdentity(repoRoot: string, filePath: string): string {
+  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}`);
   return relative.split(path.sep).join('/');

package/lib/run/index.ts

@@ -4,6 +4,7 @@ import { loadServerConfig } from '../server/config.ts';
 import { resolveSandboxTarget, type SandboxWorkspaceIdentity } from '../sandbox/workspace-identity.ts';
 import { createRunId, runInSandbox, type SandboxRunMetadata } from '../sandbox/capture.ts';
 import { loadShortIdByTaskId, normalizeShortIdInput } from '../task/short-id.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { buildTuiCommand, renderPrompt, selectTui } from './tui.ts';
 import { getSkillRunSpec } from './skills.ts';
 import { runHostCommand, type RunProcessResult } from './host.ts';
@@ -157,7 +158,7 @@ function readShortIdLength(repoRoot: string): number {
 }
 
 function readActiveShortIdRegistry(repoRoot: string): Record<string, string> {
-  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 : {};
@@ -186,7 +187,7 @@ function resolveActiveTaskIdentity(taskRef: string, repoRoot: string): ActiveTas
   }
 
   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/lib/sandbox/commands/create.ts

@@ -1454,7 +1454,7 @@ export async function create(
             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) {
@@ -1603,6 +1603,10 @@ export async function create(
                 : []),
               '--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/lib/sandbox/commands/enter.ts

@@ -31,7 +31,7 @@ import {
 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/lib/sandbox/commands/list-running.ts

@@ -5,6 +5,7 @@ import { runSafeEngine, runVerboseEngine } from '../shell.ts';
 import { resolveTaskBranch } from '../task-resolver.ts';
 import { isRemovedHashShortIdInput } from '../../task/short-id.ts';
 import { parseSandboxWorkspaceIdentity } from '../workspace-identity.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.ts';
 
 export type SandboxRow = {
   name: string;
@@ -143,7 +144,7 @@ function tryResolveFromRegistry(arg: string, repoRoot: string): RegistryLookup {
     );
   }
   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');
     const fm = content.match(/^branch:\s*(.+)$/m);

package/lib/sandbox/control/client.ts

@@ -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.ts';
+import { detectRepoRoot } from '../../task/resolve-ref.ts';
 import {
   SANDBOX_CONTROL_MAX_BYTES,
   SANDBOX_CONTROL_STATUS_STALE_MS,
@@ -158,18 +160,11 @@ type CanonicalRequestTask =
 
 // Use the current short-id contract for the first visible active registry.
 export function resolveVisibleActiveShortId(ref: string): string | null {
-  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

package/lib/sandbox/control/completed-reentry.ts

@@ -4,6 +4,7 @@ import { resolveTaskWorkspace } from '../task-resolver.ts';
 import { assertGitWorktreeBinding } from '../../git/worktree-identity.ts';
 import { parseTypedTaskFrontmatter } from '../../task/frontmatter.ts';
 import { readTaskFinalizationReceipt } from '../../task/finalization.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.ts';
 import { inspectSandboxControlContainer } from './container-identity.ts';
 import type { SandboxControlManifest } from './protocol.ts';
 import { atomicWriteJson, readSandboxControlStatus } from './state.ts';
@@ -53,7 +54,7 @@ export async function prepareCompletedReentry(
     || previous.receipt.generation !== view.receipt.generation
     || 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();
   const stat = fs.statSync(source, { bigint: true });

package/lib/sandbox/control/task-view.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveProjectTaskWorkspaceRoot } from '../../task/workspace-root.ts';
 
 export const SANDBOX_TASK_VIEW_STATES = ['not-applicable', 'current', 'finalized-stale', 'unknown'] as const;
 export const SANDBOX_TASK_VIEW_SOURCES = ['active', 'completed', 'unknown'] as const;
@@ -119,8 +120,9 @@ export function taskViewForManifest(params: Readonly<{
   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/lib/sandbox/mounts.ts

@@ -24,12 +24,12 @@ function workspaceStateMounts(workspaceViewRoot: string, taskBound: boolean): Sa
     .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
         }
     );
@@ -60,12 +60,12 @@ function taskWorkspaceMounts(taskSources: string[], taskBound: boolean, override
   const taskId = overrides.taskId!;
   const mounts: SandboxBindMountDeclaration[] = [{
     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/lib/sandbox/recovery.ts

@@ -30,6 +30,7 @@ import {
   sandboxWorkspaceViewPaths
 } from './workspace-view.ts';
 import { resolveTaskWorkspace } from './task-resolver.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import {
   parseSandboxWorkspaceIdentity,
   sameSandboxWorkspaceIdentity,
@@ -450,11 +451,13 @@ export function classifySandboxRecovery(snapshot: SandboxRecoverySnapshot): Sand
     });
   }
   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) {
@@ -476,7 +479,8 @@ export function classifySandboxRecovery(snapshot: SandboxRecoverySnapshot): Sand
   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
@@ -571,13 +575,14 @@ function inspectContainer(
 }
 
 function workspaceTopology(mountsByDestination: ReadonlyMap<string, DockerMount>): SandboxRecoverySnapshot['workspaceTopology'] {
-  if (mountsByDestination.has('/workspace/.agents/workspace')) return 'legacy-parent';
+  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'
@@ -618,8 +623,9 @@ function recoveryTaskSources(repoRoot: string, taskId: string): {
   mountPaths: string[];
   accessiblePaths: string[];
 } {
-  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] };
@@ -635,7 +641,7 @@ function recoveryTaskSources(repoRoot: string, taskId: string): {
   }
 
   const completedRoot = fs.realpathSync.native(
-    path.join(repoRoot, '.agents', 'workspace', 'completed')
+    path.join(taskRoot, 'completed')
   );
   const completedSource = fs.realpathSync.native(path.dirname(task.taskMd));
   if (path.dirname(completedSource) !== completedRoot) {
@@ -643,9 +649,7 @@ function recoveryTaskSources(repoRoot: string, taskId: string): {
   }
 
   const historicalActivePath = path.join(
-    repoRoot,
-    '.agents',
-    'workspace',
+    taskRoot,
     'active',
     taskId
   );
@@ -670,7 +674,7 @@ export function startCompletedSandboxContainer(params: {
 }): void {
   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;
@@ -791,11 +795,11 @@ function expectedMounts(params: {
     expectedType: 'bind' as const,
     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
@@ -929,7 +933,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';
@@ -1215,6 +1219,10 @@ function canRetryFreshReadiness(findings: SandboxRecoveryFinding[]): boolean {
     && 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/lib/sandbox/removal.ts

@@ -48,7 +48,6 @@ import { toolConfigDirCandidates, toolProjectDirCandidates } from './tools.ts';
 import type { SandboxTool } from './tools.ts';
 import { getProcessStartTime } from '../server/process-state.ts';
 import { releaseStaleShortIdRegistry } from '../task/short-id.ts';
-import { withRepositoryMutationLock } from '../task/task-execution-lock.ts';
 import { fetchSandboxRows, type SandboxRow } from './commands/list-running.ts';
 import { createSandboxControlBindingEvidence } from './task-cleanup.ts';
 import {
@@ -933,7 +932,7 @@ async function authorizeWorktrees(
   return permits;
 }
 
-async function runRmOneUnderRepositoryLock(
+async function runRmOne(
   config: SandboxConfig,
   tools: SandboxTool[],
   branch: string,
@@ -953,10 +952,7 @@ async function rmOne(
   branch: string,
   options: RmOneOptions = {}
 ): Promise<void> {
-  await withRepositoryMutationLock(
-    config.repoRoot,
-    () => runRmOneUnderRepositoryLock(config, tools, branch, options)
-  );
+  await runRmOne(config, tools, branch, options);
 }
 
 async function removeUncheckedSandbox(
@@ -1060,14 +1056,6 @@ async function rmPurge(
   config: SandboxConfig,
   tools: SandboxTool[],
   prompt: PromptDependencies = {}
-): Promise<void> {
-  return withRepositoryMutationLock(config.repoRoot, () => rmPurgeCore(config, tools, prompt));
-}
-
-async function rmPurgeCore(
-  config: SandboxConfig,
-  tools: SandboxTool[],
-  prompt: PromptDependencies = {}
 ): Promise<void> {
   const engine = detectEngine(config);
   const confirm = prompt.confirm ?? p.confirm;
@@ -1142,17 +1130,6 @@ async function rmUnbound(
   config: SandboxConfig,
   tools: SandboxTool[],
   options: { dryRun: boolean; assumeYes: boolean }
-): Promise<void> {
-  return withRepositoryMutationLock(
-    config.repoRoot,
-    () => rmUnboundCore(config, tools, options)
-  );
-}
-
-async function rmUnboundCore(
-  config: SandboxConfig,
-  tools: SandboxTool[],
-  options: { dryRun: boolean; assumeYes: boolean }
 ): Promise<void> {
   const engine = detectEngine(config);
   const listed = fetchSandboxRows(
@@ -1215,7 +1192,7 @@ async function rmUnboundCore(
     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