@fitlab-ai/agent-infra 0.11.15 → 0.12.0

package/lib/sandbox/task-resolver.ts

@@ -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.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const SHORT_ID_RE = /^\d+$/;
@@ -35,10 +36,11 @@ function stripQuotes(value: string): string {
 }
 
 function readTaskContent(repoRoot: string, taskId: string): { content: string; state: TaskWorkspaceState; taskMd: string } {
+  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 };
     }
@@ -47,8 +49,9 @@ function readTaskContent(repoRoot: string, taskId: string): { content: string; s
 }
 
 function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspace[] {
+  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');
     return [{
@@ -60,7 +63,7 @@ function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspac
   });
   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');
   return [...hot, {
@@ -72,7 +75,7 @@ function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspac
 }
 
 function findArchiveTaskParts(repoRoot: string, taskId: string): string[] {
-  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()) {
     if (!/^\d{4}$/.test(year)) continue;
@@ -129,7 +132,7 @@ export function resolveTaskWorkspace(taskId: string, repoRoot: string): TaskWork
 }
 
 export function listTaskWorkspaces(repoRoot: string, state: TaskWorkspaceState): TaskWorkspace[] {
-  const stateRoot = path.join(repoRoot, '.agents', 'workspace', state);
+  const stateRoot = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), state);
   if (state === 'archive') {
     if (!fs.existsSync(stateRoot)) return [];
     const rows: TaskWorkspace[] = [];

package/lib/sandbox/workspace-identity.ts

@@ -6,6 +6,7 @@ import {
   isRemovedHashShortIdInput,
   normalizeShortIdInput
 } from '../task/short-id.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import {
   TASK_WORKSPACE_STATES,
   listTaskWorkspaces,
@@ -57,7 +58,7 @@ function taskBranch(taskMd: string, taskId: string): string {
 }
 
 function activeRegistry(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');
   if (!fs.existsSync(registryPath)) return {};
   const value = JSON.parse(fs.readFileSync(registryPath, 'utf8')) as unknown;
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -74,7 +75,7 @@ function activeRegistry(repoRoot: string): Record<string, string> {
 }
 
 function taskIdentity(repoRoot: string, taskId: string, registry: Record<string, string>): SandboxWorkspaceIdentity {
-  const taskMd = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+  const taskMd = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId, 'task.md');
   if (!fs.existsSync(taskMd)) throw new Error(`Active task not found: ${taskId}`);
   const shortIds = Object.entries(registry).filter(([, id]) => id === taskId).map(([shortId]) => shortId);
   if (shortIds.length !== 1) {
@@ -126,14 +127,14 @@ export function resolveSandboxTarget(requestedRef: string, repoRoot: string): Sa
     const taskId = canonicalShortId ? registry[canonicalShortId] : undefined;
     if (!taskId) throw new Error(`Short id '${requestedRef}' not found in active task registry`);
     const workspace = taskIdentity(repoRoot, taskId, registry);
-    return { requestedRef, branch: taskBranch(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), taskId), workspace };
+    return { requestedRef, branch: taskBranch(path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId, 'task.md'), taskId), workspace };
   }
   if (TASK_ID_RE.test(requestedRef)) {
     const workspace = taskIdentity(repoRoot, requestedRef, registry);
-    return { requestedRef, branch: taskBranch(path.join(repoRoot, '.agents', 'workspace', 'active', requestedRef, 'task.md'), requestedRef), workspace };
+    return { requestedRef, branch: taskBranch(path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', requestedRef, 'task.md'), requestedRef), workspace };
   }
 
-  const activeRoot = path.join(repoRoot, '.agents', 'workspace', 'active');
+  const activeRoot = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active');
   const matches = fs.existsSync(activeRoot)
     ? fs.readdirSync(activeRoot, { withFileTypes: true }).flatMap((entry) => {
       if (!entry.isDirectory() || !TASK_ID_RE.test(entry.name)) return [];

package/lib/sandbox/workspace-view.ts

@@ -1,6 +1,8 @@
 import { createHash, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 import type { SandboxWorkspaceIdentity, SandboxWorkspaceKey } from './workspace-identity.ts';
 import { resolveTaskWorkspace } from './task-resolver.ts';
 import type { SandboxControlManifest } from './control/protocol.ts';
@@ -147,7 +149,8 @@ function assertSafeMountTargetPath(
 
 export function assertSandboxTaskSource(repoRoot: string, taskId: string): string {
   if (!/^TASK-\d{8}-\d{6}$/.test(taskId)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-  const activeSource = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+  const workspaceRootPath = resolveProjectTaskWorkspaceRoot(repoRoot);
+  const activeSource = path.join(workspaceRootPath, 'active', taskId);
   try {
     const stat = fs.lstatSync(activeSource);
     if (!stat.isDirectory() || stat.isSymbolicLink()) {
@@ -155,7 +158,7 @@ export function assertSandboxTaskSource(repoRoot: string, taskId: string): strin
     }
     const canonical = fs.realpathSync.native(activeSource);
     const activeRoot = fs.realpathSync.native(path.dirname(activeSource));
-    const workspaceRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+    const workspaceRoot = fs.realpathSync.native(workspaceRootPath);
     const relative = path.relative(workspaceRoot, canonical);
     if (path.dirname(canonical) !== activeRoot || relative.startsWith('..') || path.isAbsolute(relative)) {
       throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${activeSource} escapes the task workspace`);
@@ -173,7 +176,7 @@ export function assertSandboxTaskSource(repoRoot: string, taskId: string): strin
     throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} must be a real directory`);
   }
   const canonical = fs.realpathSync.native(source);
-  const workspaceRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+  const workspaceRoot = fs.realpathSync.native(workspaceRootPath);
   const relative = path.relative(workspaceRoot, canonical);
   if (path.basename(canonical) !== taskId || relative.startsWith('..') || path.isAbsolute(relative)) {
     throw new Error(`SANDBOX_TASK_SOURCE_INVALID: ${source} escapes the task workspace`);
@@ -181,30 +184,38 @@ export function assertSandboxTaskSource(repoRoot: string, taskId: string): strin
   return canonical;
 }
 
-export function prepareSandboxWorkspaceMountTargets(worktreeRoot: string, taskId?: string): void {
-  const resolvedWorktreeRoot = path.resolve(worktreeRoot);
-  const canonicalWorktreeRoot = fs.realpathSync.native(resolvedWorktreeRoot);
-  const workspaceRoot = path.resolve(resolvedWorktreeRoot, '.agents', 'workspace');
+export function prepareSandboxWorkspaceMountTargets(repoRoot: string): void {
+  const resolvedHome = path.resolve(process.env.HOME || os.homedir());
+  const canonicalHome = fs.realpathSync.native(resolvedHome);
+  const workspaceRoot = path.resolve(resolveProjectTaskWorkspaceRoot(repoRoot));
+  const relativeRoot = path.relative(resolvedHome, workspaceRoot);
+  if (relativeRoot.startsWith('..') || path.isAbsolute(relativeRoot)) {
+    throw new Error(`Sandbox workspace mount target escapes the host home: ${workspaceRoot}`);
+  }
   const statePaths = sandboxWorkspaceViewStatePaths(workspaceRoot);
   const registryTarget = path.join(workspaceRoot, 'active', '.short-ids.json');
-  const completedTaskTarget = taskId ? path.join(workspaceRoot, 'completed', taskId) : null;
-  if (taskId && !/^TASK-\d{8}-\d{6}$/.test(taskId)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-  for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget, ...(completedTaskTarget ? [completedTaskTarget] : [])]) {
-    assertSafeMountTargetPath(target, resolvedWorktreeRoot, canonicalWorktreeRoot);
+  for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget]) {
+    assertSafeMountTargetPath(target, resolvedHome, canonicalHome);
   }
   fs.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
   for (const { hostPath } of statePaths) {
     fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
     fs.chmodSync(hostPath, 0o700);
   }
-  if (completedTaskTarget) fs.mkdirSync(completedTaskTarget, { recursive: true, mode: 0o700 });
   fs.chmodSync(workspaceRoot, 0o700);
-  fs.closeSync(fs.openSync(registryTarget, 'a', 0o600));
+  const registryFd = fs.openSync(registryTarget, 'a', 0o600);
+  try {
+    if (fs.fstatSync(registryFd).size === 0) {
+      fs.writeFileSync(registryFd, `${JSON.stringify({ version: 1, ids: {} })}\n`);
+    }
+  } finally {
+    fs.closeSync(registryFd);
+  }
 }
 
 export function prepareSandboxCompletedTaskMountSource(repoRoot: string, taskId: string): string {
   if (!/^TASK-\d{8}-\d{6}$/.test(taskId)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-  const workspaceRoot = path.resolve(repoRoot, '.agents', 'workspace');
+  const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
   fs.mkdirSync(path.join(workspaceRoot, 'completed'), { recursive: true, mode: 0o700 });
   const completedRoot = path.join(workspaceRoot, 'completed');
   const completedStat = fs.lstatSync(completedRoot);
@@ -224,16 +235,13 @@ export function prepareSandboxCompletedTaskMountSource(repoRoot: string, taskId:
 
 export function sandboxCompletedTaskMountSource(repoRoot: string, taskId: string): string {
   if (!/^TASK-\d{8}-\d{6}$/.test(taskId)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-  const source = path.resolve(repoRoot, '.agents', 'workspace', 'completed', taskId);
+  const source = path.resolve(resolveProjectTaskWorkspaceRoot(repoRoot), 'completed', taskId);
   const stat = fs.lstatSync(source);
   if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
-  const canonicalWorkspace = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace'));
+  const canonicalWorkspace = fs.realpathSync.native(resolveProjectTaskWorkspaceRoot(repoRoot));
   const canonicalSource = fs.realpathSync.native(source);
-  const canonicalRepoRoot = fs.realpathSync.native(repoRoot);
-  const workspaceRelative = path.relative(canonicalRepoRoot, canonicalWorkspace);
   const relative = path.relative(canonicalWorkspace, canonicalSource);
-  if (workspaceRelative.startsWith('..') || path.isAbsolute(workspaceRelative)
-    || path.dirname(canonicalSource) !== fs.realpathSync.native(path.dirname(source))
+  if (path.dirname(canonicalSource) !== fs.realpathSync.native(path.dirname(source))
     || relative.startsWith('..') || path.isAbsolute(relative)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
   return canonicalSource;
 }

package/lib/task/activity-intent.ts

@@ -10,8 +10,6 @@ import {
 } from './artifact-lifecycle.ts';
 import { parseArtifactName } from './artifact-name.ts';
 import type { ArtifactIdentity } from './artifact-lifecycle.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
-import type { TaskExecutionLockOptions } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
 
@@ -95,7 +93,7 @@ export type PrReviewInspectionResult = {
   error: { code: string; message: string } | null;
 };
 
-type ActivityIntentOptions = TaskWriteOptions & { lockOptions?: TaskExecutionLockOptions; lockAlreadyHeld?: boolean };
+type ActivityIntentOptions = TaskWriteOptions;
 type ArtifactRecord = { identity: ArtifactIdentity; head: string; status: PrReviewArtifactStatus };
 type RoundState = ArtifactRecord & {
   startedAgent: string | null;
@@ -299,7 +297,7 @@ function terminalNote(intent: PrReviewCompleteIntent | PrReviewTerminateIntent):
   return `Outcome: ${outcomeLabel(intent.outcome)}, reason: ${intent.reason} → ${intent.artifact}`;
 }
 
-function applyLocked(intent: PrReviewActivityIntent, normalizedAgent: string, options: ActivityIntentOptions): PrReviewActivityResult {
+function applyActivityIntent(intent: PrReviewActivityIntent, normalizedAgent: string, options: ActivityIntentOptions): PrReviewActivityResult {
   const state = readSnapshot(intent.taskRef, options.repoRoot);
   if (!state.ok) return failed(intent, state.code, state.message, state.taskId);
   const parsed = parseArtifactName(intent.artifact)!;
@@ -401,19 +399,7 @@ export function applyPrReviewActivityIntent(intent: PrReviewActivityIntent, opti
   if (resolved.state !== 'active') {
     return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   }
-  if (options.lockAlreadyHeld) return applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
-  try {
-    return withTaskExecutionLock(
-      resolved.repoRoot,
-      resolved.taskId,
-      `task-activity:${intent.kind}`,
-      () => applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot }),
-      options.lockOptions
-    );
-  } catch (error) {
-    if (error instanceof TaskExecutionLockError) return failed(intent, error.code, error.message, resolved.taskId);
-    return failed(intent, 'ACTIVITY_LOCK_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
-  }
+  return applyActivityIntent(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
 }
 
 export type { ActivityIntentOptions };

package/lib/task/artifact-lifecycle.ts

@@ -134,6 +134,8 @@ type InspectOptions = {
   sourceSha256?: string;
 };
 
+type ResolvedTaskRef = Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>;
+
 const BLOCKING_DIAGNOSTICS = new Set<ArtifactDiagnosticCode>([
   'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
   'DUPLICATE_LOGICAL_ROUND', 'NON_REGULAR_FILE', 'SYMBOLIC_LINK',
@@ -160,10 +162,15 @@ function diagnostic(code: ArtifactDiagnosticCode, family: ArtifactFamily, name:
   return { code, family, name, message };
 }
 
-function inspectTaskArtifacts(taskRef: string, family: string, options: InspectOptions = {}): ArtifactInventoryResult {
+function inspectTaskArtifacts(
+  taskRef: string,
+  family: string,
+  options: InspectOptions = {},
+  resolvedTask?: ResolvedTaskRef
+): ArtifactInventoryResult {
   const spec = familySpec(family);
   if (!spec) return failure(taskRef, family, { code: 'ARTIFACT_FAMILY_UNKNOWN', message: `unknown artifact family '${family}'` });
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  const resolved = resolvedTask ?? resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failure(taskRef, family, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
   return inspectArtifactDirectory(resolved.taskDir, spec.family, {
     requestRef: taskRef, taskId: resolved.taskId, taskState: resolved.state
@@ -452,8 +459,13 @@ function attachArtifactSelection(
   }
 }
 
-function resolveArtifactContext(taskRef: string, family: string, options: InspectOptions = {}): ArtifactContextResult {
-  const inventory = inspectTaskArtifacts(taskRef, family, options);
+function resolveArtifactContextFromTask(
+  taskRef: string,
+  family: string,
+  options: InspectOptions,
+  resolvedTask?: ResolvedTaskRef
+): ArtifactContextResult {
+  const inventory = inspectTaskArtifacts(taskRef, family, options, resolvedTask);
   if (inventory.status === 'failed') return { ...inventory, inputs: [], codeMode: null };
   const writableError = assertWritableInventory(inventory);
   if (writableError) return { ...inventory, status: 'failed', inputs: [], codeMode: null, error: writableError };
@@ -462,7 +474,7 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
     return contextFailure(inventory, 'LIFECYCLE_PATH_INVALID', pathState.message);
   }
   if (inventory.family === 'code') {
-    const code = resolveCodeContext(inventory, options);
+    const code = resolveCodeContext(inventory, options, resolvedTask);
     const selected = attachArtifactSelection(code, pathState, options);
     if (selected.status !== 'ready' || !selected.selection) return selected;
     if (selected.selection.disposition === 'reuse') return selected;
@@ -496,7 +508,7 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
   const required = REQUIRED_INPUT[inventory.family as ArtifactFamily];
   const inputs: ArtifactIdentity[] = [];
   if (required) {
-    const input = inspectTaskArtifacts(taskRef, required, options);
+    const input = inspectTaskArtifacts(taskRef, required, options, resolvedTask);
     if (input.status === 'failed' || !input.latest) {
       return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_INPUT_MISSING', message: `latest ${required} artifact is required` } };
     }
@@ -505,7 +517,7 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
   const optional = OPTIONAL_CONTEXT[inventory.family as ArtifactFamily];
   if (optional) {
     for (const family of optional) {
-      const context = inspectTaskArtifacts(taskRef, family, options);
+      const context = inspectTaskArtifacts(taskRef, family, options, resolvedTask);
       if (context.status === 'ready' && context.latest) inputs.push(context.latest);
     }
   }
@@ -515,14 +527,30 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
   return attachArtifactSelection({ ...inventory, inputs, codeMode: null }, pathState, options);
 }
 
-function resolveCodeContext(inventory: ArtifactInventoryResult, options: InspectOptions): ArtifactContextResult {
+function resolveArtifactContext(taskRef: string, family: string, options: InspectOptions = {}): ArtifactContextResult {
+  return resolveArtifactContextFromTask(taskRef, family, options);
+}
+
+export function resolveArtifactContextForResolvedTask(
+  resolvedTask: ResolvedTaskRef,
+  family: string,
+  options: InspectOptions = {}
+): ArtifactContextResult {
+  return resolveArtifactContextFromTask(resolvedTask.taskId, family, options, resolvedTask);
+}
+
+function resolveCodeContext(
+  inventory: ArtifactInventoryResult,
+  options: InspectOptions,
+  resolvedTask?: ResolvedTaskRef
+): ArtifactContextResult {
   const taskRef = inventory.requestRef;
   const pathState = lifecyclePathState(inventory.taskDir!);
   if (pathState.status !== 'valid') return contextFailure(inventory, 'LIFECYCLE_PATH_INVALID', pathState.message);
   const inputFamily = pathState.decision.path === 'streamlined' ? 'analysis' : 'plan';
-  const source = inspectTaskArtifacts(taskRef, inputFamily, options);
+  const source = inspectTaskArtifacts(taskRef, inputFamily, options, resolvedTask);
   if (source.status === 'failed' || !source.latest) return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `latest ${inputFamily} artifact is required`);
-  const reviewCode = inspectTaskArtifacts(taskRef, 'review-code', options);
+  const reviewCode = inspectTaskArtifacts(taskRef, 'review-code', options, resolvedTask);
   try {
     const taskContent = fs.readFileSync(path.join(inventory.taskDir!, 'task.md'), 'utf8');
     const hasPendingImplementation = parseImplementationInputs(taskContent).rows.some((input) => input.needsImplementation && input.status === 'pending');
@@ -538,7 +566,7 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
   const reviewMax = reviewCode.latest?.round ?? 0;
   const inputs = [source.latest];
   const sourceReviewFamily = inputFamily === 'analysis' ? 'review-analysis' : 'review-plan';
-  const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options);
+  const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options, resolvedTask);
   if (sourceReview.status === 'ready' && sourceReview.latest && sourceReview.reviewedInput?.name === source.latest.name) inputs.push(sourceReview.latest);
   if (inventory.openRounds.length > 0) {
     try {

package/lib/task/artifact-operations.ts

@@ -9,7 +9,6 @@ import {
   getArtifactSchema,
   renderArtifactSkeleton
 } from './artifact-schema.ts';
-import { withTaskExecutionLock } from './task-execution-lock.ts';
 import type {
   ArtifactSchema,
   ArtifactSchemaFamily,
@@ -352,42 +351,36 @@ function initializeArtifactSkeleton(request: ArtifactInitRequest): ArtifactFileR
   const target = path.join(request.taskDir, request.artifact);
   if (path.dirname(path.resolve(target)) !== path.resolve(request.taskDir)) return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact must be inside the current task directory');
   try {
-    return withTaskExecutionLock(request.repoRoot, request.taskId, 'task-artifact.init', () => {
-      try {
-        const existing = fs.lstatSync(target);
-        if (existing.isSymbolicLink() || !existing.isFile()) return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact target is not a regular file');
-        return resultNoOp(readStableFileSync(target, { maxBytes: 1024 * 1024 }).bytes.toString('utf8'));
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return resultFailure('ARTIFACT_INIT_TARGET_INVALID', String(error));
-      }
-      const skeleton = renderArtifactSkeleton({
-        taskId: request.taskId,
-        family: request.family,
-        artifact: request.artifact,
-        ...(request.locale ? { locale: request.locale } : {})
-      });
-      const content = skeleton.trimEnd();
-      const tempPath = path.join(request.taskDir, `.${request.artifact}.init-${process.pid}-${Date.now()}.tmp`);
-      try {
-        fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
-        try { fs.lstatSync(target); fs.unlinkSync(tempPath); return resultFailure('ARTIFACT_INIT_TARGET_EXISTS', 'artifact was created concurrently'); }
-        catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
-        fs.renameSync(tempPath, target);
-      } catch (error) {
-        try { fs.unlinkSync(tempPath); } catch { /* preserve primary error */ }
-        return resultFailure('ARTIFACT_INIT_WRITE_FAILED', String(error));
-      }
-      return {
-        status: 'applied',
-        changed: true,
-        artifactSha256: sha256Content(content),
-        semanticDigest: canonicalSemanticDigest(content),
-        error: null
-      };
-    });
+    const existing = fs.lstatSync(target);
+    if (existing.isSymbolicLink() || !existing.isFile()) return resultFailure('ARTIFACT_INIT_TARGET_INVALID', 'artifact target is not a regular file');
+    return resultNoOp(readStableFileSync(target, { maxBytes: 1024 * 1024 }).bytes.toString('utf8'));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return resultFailure('ARTIFACT_INIT_TARGET_INVALID', String(error));
+  }
+  const skeleton = renderArtifactSkeleton({
+    taskId: request.taskId,
+    family: request.family,
+    artifact: request.artifact,
+    ...(request.locale ? { locale: request.locale } : {})
+  });
+  const content = skeleton.trimEnd();
+  const tempPath = path.join(request.taskDir, `.${request.artifact}.init-${process.pid}-${Date.now()}.tmp`);
+  try {
+    fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    try { fs.lstatSync(target); fs.unlinkSync(tempPath); return resultFailure('ARTIFACT_INIT_TARGET_EXISTS', 'artifact was created concurrently'); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    fs.renameSync(tempPath, target);
   } catch (error) {
-    return resultFailure('ARTIFACT_INIT_LOCK_FAILED', String(error));
+    try { fs.unlinkSync(tempPath); } catch { /* preserve primary error */ }
+    return resultFailure('ARTIFACT_INIT_WRITE_FAILED', String(error));
   }
+  return {
+    status: 'applied',
+    changed: true,
+    artifactSha256: sha256Content(content),
+    semanticDigest: canonicalSemanticDigest(content),
+    error: null
+  };
 }
 
 export {

package/lib/task/capabilities.ts

@@ -302,7 +302,7 @@ function recommendNext(facts: LifecycleFacts): LifecycleRecommendation {
   return { action: null, reasonCode: 'LIFECYCLE_REVIEWED', evidence: ['latest code review is approved'] };
 }
 
-function buildLifecycleFacts(taskDir: string, content: string, taskState = 'active', executionBusy = false): LifecycleFactsResult {
+function buildLifecycleFacts(taskDir: string, content: string, taskState = 'active', executionBusy = false, repositoryRoot?: string): LifecycleFactsResult {
   try {
     const metadata = parseTypedTaskFrontmatter(content);
     const rework = parseReworkIntentDocument(content);
@@ -393,7 +393,7 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
         && artifactHashes[input] === receipt.inputSha256
       ) reviewedInputs[family] = input;
       if (family === 'review-code') {
-        const identity = inspectReviewIdentity(taskDir, reviewContent);
+        const identity = inspectReviewIdentity(taskDir, reviewContent, repositoryRoot);
         reviewCodeIdentityValid = identity.status === 'matched'
           && hasArtifactCompletionFact(content, path.join(taskDir, latest), 'review-code.completed')
           && hasArtifactCompletionLog(content, latest, 'review-code.completed');

package/lib/task/commands/ls.ts

@@ -4,10 +4,11 @@ import { execFileSync } from 'node:child_process';
 import { formatTable } from '../../table.ts';
 import { parseTaskFrontmatter, extractTitle } from '../frontmatter.ts';
 import { loadShortIdByTaskId } from '../short-id.ts';
+import { resolveProjectTaskWorkspaceRoot } from '../workspace-root.ts';
 
 const USAGE = `Usage: ai task ls [--all | --blocked | --completed]
 
-Lists tasks under .agents/workspace/. Defaults to active tasks only.
+Lists tasks under the project task workspace. Defaults to active tasks only.
   --all         Include active + blocked + completed (excludes archive)
   --blocked     Only blocked tasks
   --completed   Only completed tasks
@@ -73,7 +74,7 @@ type TaskRow = {
 };
 
 function collectTasks(repoRoot: string, state: 'active' | 'blocked' | 'completed'): TaskRow[] {
-  const dir = path.join(repoRoot, '.agents', 'workspace', state);
+  const dir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), state);
   if (!fs.existsSync(dir)) return [];
   const shortIdByTaskId = state === 'active' || state === 'completed'
     ? loadShortIdByTaskId(repoRoot)
@@ -117,7 +118,7 @@ function ls(args: string[] = []): void {
     rows.push(...collectTasks(repoRoot, state));
   }
   if (rows.length === 0) {
-    process.stdout.write(`No tasks under .agents/workspace/${selection.join('|')}\n`);
+    process.stdout.write(`No tasks under project task workspace state ${selection.join('|')}\n`);
     return;
   }
   const tableRows = rows.map((r, i) => [

package/lib/task/commands/status.ts

@@ -521,7 +521,7 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
   const run = input.run ?? makeRunner(input.repoRoot);
   const artifacts = enumerateArtifacts(input.taskDir);
   const workflow = collectWorkflow(content, input.now);
-  const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
+  const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active', false, input.repoRoot);
   const next = facts.ok ? recommendNext(facts.facts) : null;
   const recommendation = next?.action ?? DASH;
 

package/lib/task/commit-operation.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 
 import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/workflow.ts';
@@ -7,7 +8,6 @@ import { checkpointCommitMatches } from './commit-identity.ts';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.ts';
 import { commitPushDecision } from './commit-policy.ts';
 import { mergeOperationWarnings, type OperationWarning } from './operation-outcome.ts';
-import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation } from './write.ts';
@@ -135,6 +135,7 @@ function resolveBoundTask(input: CommitOperationInput):
     };
     return boundTask(input, resolved.taskId, resolved.taskDir, resolved.taskMdPath, resolved.repoRoot, resolved.state);
   }
+  if (!fs.existsSync(path.join(input.cwd, '.agents', '.airc.json'))) return { kind: 'none' };
   const context = resolveTaskContext(undefined, { repoRoot: input.cwd });
   if (context.ok) return boundTask(input, context.taskId, context.taskDir, context.taskMdPath, context.repoRoot, context.state);
   if (context.code === 'TASK_CONTEXT_NOT_FOUND') return { kind: 'none' };
@@ -280,7 +281,7 @@ function checkpointTimestamp(): string {
   return new Date().toISOString();
 }
 
-function executeUnlocked(input: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode): CommitOperationResult {
+function executeCommitOperationCore(input: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode): CommitOperationResult {
   const inspected = inspectGitWorkflow(input.cwd);
   if (!inspected.snapshot) return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
   if (mode === 'orchestrated') return failure(
@@ -516,11 +517,9 @@ function executeCommitOperation(input: CommitOperationInput): CommitOperationRes
   const task = resolved.kind === 'bound' ? resolved.task : null;
   if (mode === 'orchestrated' && !task) return failure(normalizedInput, mode, null, 'ORCHESTRATION_TASK_REQUIRED', 'orchestrated commit requires a task context', 'blocked');
   try {
-    return task
-      ? withRepositoryMutationLock(normalizedInput.cwd, () => withTaskExecutionLock(normalizedInput.cwd, task.taskId, 'commit-operation', () => executeUnlocked(normalizedInput, task, mode)))
-      : withRepositoryMutationLock(normalizedInput.cwd, () => executeUnlocked(normalizedInput, null, mode));
+    return executeCommitOperationCore(normalizedInput, task, mode);
   } catch (error) {
-    const code = error instanceof TaskExecutionLockError ? error.code : 'COMMIT_OPERATION_FAILED';
+    const code = 'COMMIT_OPERATION_FAILED';
     return failure(normalizedInput, mode, task?.taskId ?? null, code, error instanceof Error ? error.message : String(error), 'blocked');
   }
 }