@fitlab-ai/agent-infra 0.11.14 → 0.12.0

package/lib/internal/task-activity.ts

@@ -7,7 +7,6 @@ import type {
   PrReviewInspectIntent
 } from '../task/activity-intent.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-activity <task-ref> pr-review-inspect
@@ -95,15 +94,7 @@ async function taskActivity(args: string[] = []): Promise<void> {
   }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { usageFailure(resolved.message); return; }
-  let result;
-  try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true }));
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-    process.exitCode = 1;
-    return;
-  }
+  const result = await applyPrReviewActivityIntent(values as PrReviewActivityIntent);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/internal/task-event.ts

@@ -2,7 +2,6 @@ import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.t
 import { applyTaskEvent, eventCatalog } from '../task/events.ts';
 import type { TaskEventRequest, Verdict } from '../task/events.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
@@ -73,15 +72,7 @@ async function taskEvent(args: string[] = []): Promise<void> {
     process.exitCode = 1;
     return;
   }
-  let result;
-  try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => applyTaskEvent(request, { lockAlreadyHeld: true }));
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-    process.exitCode = 1;
-    return;
-  }
+  const result = await applyTaskEvent(request);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/internal/task-finalization.ts

@@ -7,7 +7,7 @@ import {
 import { applyTaskFinalization } from '../task/finalization.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import { resolveSandboxControlTransport } from './task-operation-registry.ts';
-import { quiesceSandboxControlForTaskCompletion } from '../sandbox/control/lifecycle.ts';
+import { validateSandboxControlTaskIdentity } from '../sandbox/control/lifecycle.ts';
 import { loadSandboxControlLocation } from '../sandbox/config.ts';
 import { serializeTaskFinalizationEnvelope } from '../task/finalization-envelope.ts';
 import { verifyTaskEvent } from '../task/verification.ts';
@@ -97,7 +97,7 @@ async function taskFinalization(args: string[] = []): Promise<void> {
       repoRoot,
       beforeLifecycle: async (currentTaskId) => {
         if (currentTaskId !== taskId) throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
-        await quiesceSandboxControlForTaskCompletion(
+        validateSandboxControlTaskIdentity(
           controlRoot,
           { taskId, generation, controlRootId, statusDir }
         );

package/lib/internal/task-ledger.ts

@@ -4,7 +4,6 @@ import { applyLedgerIntent } from '../task/ledger-intents.ts';
 import type { LedgerIntent } from '../task/ledger-intents.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, rework-intent-rebuild, stage-status\n`;
@@ -116,15 +115,7 @@ async function taskLedger(args: string[] = []): Promise<void> {
   }
   const lockResolved = resolveTaskRef(taskRef);
   if (!lockResolved.ok) { usageFailure(lockResolved.message); return; }
-  let result;
-  try {
-    result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => applyLedgerIntent(values as LedgerIntent));
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-    process.exitCode = 1;
-    return;
-  }
+  const result = await applyLedgerIntent(values as LedgerIntent);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/internal/task-operation-registry.ts

@@ -112,6 +112,7 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'platform-checks', 'resolve-run', 'conditional', 'diagnostic'),
     descriptor('internal', 'platform-checks', 'logs', 'conditional', 'diagnostic'),
     descriptor('internal', 'task-context', 'resolve', 'task-bound', 'diagnostic'),
+    descriptor('internal', 'task-workspace', 'resolve', 'non-task', 'diagnostic', 'none'),
     descriptor('internal', 'task-ledger', 'decision-next-id', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-ledger', 'stage-status', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-ledger', 'finding-upsert', 'task-bound', 'progress'),
@@ -214,7 +215,7 @@ export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
   'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle',
   'git-workflow', 'task-delivery', 'release-workflow', 'platform-release-notes', 'platform-security', 'platform-metadata', 'platform-context',
   'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
-  'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
+  'platform-checks', 'task-context', 'task-workspace', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
   'task-orchestration', 'task-review', 'task-event', 'task-lifecycle',
   'task-finalization', 'task-platform-recovery', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);

package/lib/internal/task-qualification.ts

@@ -5,7 +5,6 @@ import type { QualificationConfirmationRequest } from '../task/qualification-con
 import { applyQualificationProposal } from '../task/qualification-intents.ts';
 import type { QualificationProposalRequest } from '../task/qualification-intents.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-qualification <task-ref> <proposal|confirm|supersede|revoke> --input <json-file> [--dry-run]\n`;
@@ -46,16 +45,11 @@ async function taskQualification(args: string[] = []): Promise<void> {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) { fail('qualification input must be an object'); return; }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { fail(resolved.message, resolved.code); return; }
-  try {
-    const result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-qualification.${operation}`, () => operation === 'proposal'
-      ? applyQualificationProposal({ ...(payload as Record<string, unknown>), taskRef: resolved.taskId, dryRun } as QualificationProposalRequest, { repoRoot: resolved.repoRoot })
-      : applyQualificationConfirmation({ ...(payload as Record<string, unknown>), taskRef: resolved.taskId, operation, dryRun } as QualificationConfirmationRequest, { repoRoot: resolved.repoRoot }));
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed') process.exitCode = 1;
-  } catch (error) {
-    if (error instanceof TaskExecutionLockError) fail(`${error.code}: ${error.message}`, error.code);
-    else throw error;
-  }
+  const result = await (operation === 'proposal'
+    ? applyQualificationProposal({ ...(payload as Record<string, unknown>), taskRef: resolved.taskId, dryRun } as QualificationProposalRequest, { repoRoot: resolved.repoRoot })
+    : applyQualificationConfirmation({ ...(payload as Record<string, unknown>), taskRef: resolved.taskId, operation, dryRun } as QualificationConfirmationRequest, { repoRoot: resolved.repoRoot }));
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskQualification };

package/lib/internal/task-review.ts

@@ -1,7 +1,6 @@
 import { parseReviewCommand } from '../task/review-command.ts';
 import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
@@ -30,19 +29,9 @@ async function taskReview(args: string[] = []): Promise<void> {
   const operation = args[1]!;
   const resolved = resolveTaskRef(args[0]!);
   if (!resolved.ok) { failUsage(resolved.message); return; }
-  let result;
-  try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-review.${operation}`, async () => {
-      return operation === 'preflight'
-        ? preflightReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true })
-        : finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
-    });
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-    process.exitCode = 1;
-    return;
-  }
+  const result = operation === 'preflight'
+    ? preflightReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun })
+    : finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun });
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/internal/task-short-id.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 
 import { detectRepoRoot } from '../task/resolve-ref.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import { configuredShortIdLength, executeShortIdCommand } from '../task/short-id.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
@@ -50,7 +51,7 @@ function taskShortId(args: string[] = []): void {
   if (positional.length > (operation === 'list' ? 0 : 1)) { failure('too many positional arguments'); return; }
   let repoRoot: string | null = null;
   try { repoRoot = detectRepoRoot(); } catch { /* custom active-dir mode */ }
-  const resolvedActiveDir = activeDir ?? (repoRoot ? path.join(repoRoot, '.agents', 'workspace', 'active') : null);
+  const resolvedActiveDir = activeDir ?? (repoRoot ? path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active') : null);
   if (!resolvedActiveDir) { failure('cannot determine active task directory'); return; }
   const width = shortIdLength ?? (repoRoot ? configuredShortIdLength(repoRoot) : 2);
   const result = executeShortIdCommand({

package/lib/internal/task-verify.ts

@@ -1,6 +1,5 @@
 import { renderTaskVerification, verifyTaskEvent } from '../task/verification.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text]\n';
@@ -34,14 +33,7 @@ async function taskVerify(args: string[] = []): Promise<void> {
   }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { fail(resolved.message); return; }
-  let result;
-  try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, async () => verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }));
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    fail(`${error.code}: ${error.message}`);
-    return;
-  }
+  const result = await verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) });
   process.stdout.write(format === 'text' ? renderTaskVerification(result) : `${JSON.stringify(result)}\n`);
   process.exitCode = result.status === 'pass' ? 0 : result.status === 'blocked' ? 2 : 1;
 }

package/lib/internal/task-warning.ts

@@ -1,7 +1,6 @@
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
 import type { WorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
@@ -52,15 +51,7 @@ async function taskWarning(args: string[] = []): Promise<void> {
   if (missing) { usageFailure(`${kind} requires '${missing}'`); return; }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { usageFailure(resolved.message); return; }
-  let result;
-  try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, async () => applyWorkflowWarningIntent(values as WorkflowWarningIntent));
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
-    process.exitCode = 1;
-    return;
-  }
+  const result = await applyWorkflowWarningIntent(values as WorkflowWarningIntent);
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

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-change-report.ts

@@ -429,12 +429,15 @@ function runMechanicalChangeReport(repoRoot: string, baseSha: string, headSha: s
   return validated.value;
 }
 
+const DOCUMENTATION_CATEGORY = { label: '文档', prefixes: ['docs/'] } as const;
+
 const CHANGE_CATEGORIES = [
   { label: '运行时代码', prefixes: ['bin/', 'lib/', 'src/', 'scripts/'] },
   { label: '测试与校验', prefixes: ['test/', 'tests/'] },
   { label: '模板与生成内容', prefixes: ['templates/'] },
   { label: '技能与协作配置', prefixes: ['.agents/'] },
-  { label: '文档与其他', prefixes: [] }
+  DOCUMENTATION_CATEGORY,
+  { label: '其他', prefixes: [] }
 ] as const;
 
 function emptyChangeTotals(): ChangeTotals {
@@ -443,7 +446,10 @@ function emptyChangeTotals(): ChangeTotals {
 
 function categoryForChangeFile(file: ChangeFile): (typeof CHANGE_CATEGORIES)[number] {
   const filePath = file.newPath || file.oldPath || '';
-  return CHANGE_CATEGORIES.find((category) => category.prefixes.some((prefix) => filePath.startsWith(prefix))) || CHANGE_CATEGORIES[CHANGE_CATEGORIES.length - 1]!;
+  const category = CHANGE_CATEGORIES.find((entry) => entry.prefixes.some((prefix) => prefix && filePath.startsWith(prefix)));
+  if (category) return category;
+  if (/\.(?:md|mdx|markdown|rst)$/i.test(filePath)) return DOCUMENTATION_CATEGORY;
+  return CHANGE_CATEGORIES[CHANGE_CATEGORIES.length - 1]!;
 }
 
 function summarizeChangeCategories(files: ChangeFile[]): Array<{ label: string; totals: ChangeTotals }> {
@@ -553,7 +559,7 @@ function renderEvidence(evidence: Evidence): string {
 function renderPrechecks(checks: Precheck[]): string[] {
   return checks.flatMap((check) => [
     `- **${PRECHECK_LABELS[check.id]}（${check.id}）**：${check.verdict === 'pass' ? '通过' : '需复核'}。${escapeReportText(check.rationale)}`,
-    ...check.evidence.slice(0, 1).map(renderEvidence)
+    ...check.evidence.map(renderEvidence)
   ]);
 }
 

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

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
+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';
@@ -52,16 +54,26 @@ function parseArgs(args: string[], valueOptions: Set<string>, booleanOptions: Se
 }
 
 function dataRoot(repoRoot: string, requested?: string): string {
-  const workspace = path.resolve(repoRoot, '.agents', 'workspace');
-  const resolved = path.resolve(repoRoot, requested ?? path.join('.agents', 'workspace', 'process-data'));
-  const relative = path.relative(repoRoot, resolved);
-  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('data root must be inside the repository');
+  let boundary = repoRoot;
+  let input = requested;
+  if (input === undefined) {
+    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { project?: unknown };
+    if (typeof config.project !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(config.project)) {
+      throw new Error('.agents/.airc.json must contain a valid project name in its project field');
+    }
+    boundary = path.resolve(os.homedir());
+    input = path.join(boundary, '.agent-infra', 'data-store', config.project);
+  }
+  const resolved = path.resolve(repoRoot, input);
+  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 !== repoRoot) {
+  while (current !== boundary) {
     if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) throw new Error('data root cannot traverse a symlink');
     current = path.dirname(current);
   }

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