@fitlab-ai/agent-infra 0.11.14 → 0.12.0

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');
   }
 }

package/lib/task/control-authority.ts

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
@@ -29,8 +30,6 @@ import {
 } from './finalization.ts';
 import {
   applyTaskLifecycle,
-  applyTaskLifecycleWithinTaskLock,
-  taskLifecycleFailure,
   type TaskLifecycleRequest,
   type TaskLifecycleResult
 } from './lifecycle.ts';
@@ -39,8 +38,8 @@ import type {
   AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
 } from '../agent-clients/adapter.ts';
 import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
+import { releaseStaleShortIdRegistry } from './short-id.ts';
 
 export type TaskControlExecutionContext =
   | Readonly<{
@@ -215,7 +214,7 @@ async function applyLifecycleWithAuthority(
 ): Promise<TaskLifecycleResult | LifecycleRecoveryResult> {
   const taskId = lifecycleTaskId(request, context.repoRoot);
   const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
-  const execute = async (underTaskLock = false): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
+  const execute = async (): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
     if (request.intent === 'recover-started') {
       const adapter = isAgentClientId(request.agent)
         ? getAgentClientAdapter(request.agent).orchestrationAdapter
@@ -229,38 +228,13 @@ async function applyLifecycleWithAuthority(
       }
       return adapter.recoverStarted(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
     }
-    return underTaskLock
-      ? applyTaskLifecycleWithinTaskLock(request, {
-        repoRoot: context.repoRoot,
-        ...(controlRoot ? { controlRoot } : {}),
-        ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
-      }, taskId!)
-      : applyTaskLifecycle(request, {
-        repoRoot: context.repoRoot,
-        ...(controlRoot ? { controlRoot } : {}),
-        ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
-      });
+    return applyTaskLifecycle(request, {
+      repoRoot: context.repoRoot,
+      ...(controlRoot ? { controlRoot } : {}),
+      ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
+    });
   };
-  if (!taskId) return await execute();
-  try {
-    return await withTaskExecutionLock(
-      context.repoRoot,
-      taskId,
-      `task-lifecycle.${request.intent}`,
-      () => execute(true)
-    );
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    if (request.intent === 'recover-started') {
-      return {
-        status: 'owner-unknown', changed: false, targetState: 'active',
-        requestRef: request.taskRef, intent: 'recover-started', taskId,
-        receiptId: null, childId: null,
-        error: { code: error.code, message: error.message }
-      };
-    }
-    return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
-  }
+  return await execute();
 }
 
 function controlRootForTask(context: TaskControlExecutionContext, taskId: string): string | undefined {
@@ -393,6 +367,26 @@ export function dispatchTaskControlOperation(
       preflight: (request, options) => verifyTaskEvent(
         { ...request, event: 'complete-task.hard-preflight' }, options
       )
+    }).then((result) => {
+      if (context.source !== 'direct-host' || !controlRoot || result.status !== 'completed' || !result.taskId) return result;
+      try {
+        if (fs.lstatSync(controlRoot, { throwIfNoEntry: false }) === undefined) {
+          const released = releaseStaleShortIdRegistry(context.repoRoot, result.taskId);
+          return { ...result, changed: result.changed || released.changed };
+        }
+        return result;
+      } catch (error) {
+        return {
+          ...result,
+          status: 'blocked',
+          result: 'blocked',
+          error: {
+            code: 'TASK_FINALIZATION_SHORT_ID_RELEASE_FAILED',
+            message: error instanceof Error ? error.message : String(error),
+            retryable: true
+          }
+        };
+      }
     });
   }
   try {

package/lib/task/create-service.ts

@@ -4,7 +4,6 @@ import type { PlatformResult } from '../platform/types.ts';
 import { VERSION } from '../version.ts';
 import { applyWorkflowWarningIntent } from './workflow-warning-intents.ts';
 import { createLocalTask, type TaskCreateCandidateV1 } from './create.ts';
-import { TaskExecutionLockError } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
 
 type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
@@ -201,9 +200,8 @@ async function createTask(value: unknown, options: CreateTaskOptions): Promise<T
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const lockBusy = error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY';
-    const code = lockBusy ? error.code : /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
-    return taskCreateFailure({ code, message, retryable: lockBusy || code === 'TASK_CREATE_LOCK_TIMEOUT' });
+    const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+    return taskCreateFailure({ code, message, retryable: false });
   }
 
   const operations: TaskCreateOperation[] = [{

package/lib/task/create.ts

@@ -5,13 +5,13 @@ import path from 'node:path';
 
 import { isValidAgentInfraVersion, VERSION } from '../version.ts';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.ts';
-import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.ts';
 import { enumerateAllTaskDirs } from './resolve-ref.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { AGENT_TOKEN_VALUES, type AgentToken } from '../agent-clients/tokens.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'] as const;
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'] as const;
@@ -348,42 +348,6 @@ function ensureRealDirectory(directory: string, code: string): void {
   fs.mkdirSync(directory, { mode: 0o700 });
 }
 
-function createLockRoot(project: string): string {
-  const root = path.join(os.homedir(), '.agent-infra');
-  const directories = [root, path.join(root, 'run'), path.join(root, 'run', project), path.join(root, 'run', project, 'task-create-locks')];
-  for (const directory of directories) {
-    if (fs.existsSync(directory)) {
-      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
-      continue;
-    }
-    try {
-      fs.mkdirSync(directory, { mode: 0o700 });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
-    }
-  }
-  return directories.at(-1)!;
-}
-
-function withCreateLock<T>(repoRoot: string, project: string, operation: () => T): T {
-  const lockRoot = createLockRoot(project);
-  let callbackError: unknown;
-  try {
-    return withTaskExecutionLock(repoRoot, 'task-create', 'task-create', () => {
-      try { return operation(); }
-      catch (error) { callbackError = error; throw error; }
-    }, { lockRoot, identityScope: `task-create\0${project}` });
-  } catch (error) {
-    if (callbackError !== undefined) throw callbackError;
-    if (error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY') {
-      throw new Error('TASK_CREATE_LOCK_TIMEOUT');
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`TASK_CREATE_LOCK_FAILED: ${message}`);
-  }
-}
-
 function recoverPublishedTask(repoRoot: string, keyDigest: string, candidateDigest: string): { taskId: string; shortId: string | null; state: 'active' | 'blocked' | 'completed' | 'archive' } | null {
   for (const task of enumerateAllTaskDirs(repoRoot)) {
     const taskMd = path.join(task.taskDir, 'task.md');
@@ -410,16 +374,22 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     throw new Error('TASK_CREATE_VERSION_INVALID: agentInfraVersion must be a valid v-prefixed semver');
   }
   const repoRoot = fs.realpathSync.native(options.repoRoot);
-  const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
+  const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
   const activeRoot = path.join(workspaceRoot, 'active');
   ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+  const home = path.resolve(process.env.HOME || os.homedir());
+  const managedRoots = [path.join(home, '.agent-infra'), path.join(home, '.agent-infra', 'task-workspaces')];
+  for (const root of managedRoots) {
+    if (fs.existsSync(root)) assertRealDirectory(root, 'TASK_CREATE_WORKSPACE_INVALID');
+    else fs.mkdirSync(root, { mode: 0o700 });
+  }
   ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   const projectConfig = readProject(repoRoot);
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);
   const keyDigest = sha256(candidate.idempotencyKey);
-  function createUnderRepositoryLock(): LocalTaskCreateResult {
+  function createOnce(): LocalTaskCreateResult {
     const recovered = recoverPublishedTask(repoRoot, keyDigest, candidateDigest);
     if (recovered) {
       return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId, state: recovered.state } };
@@ -451,18 +421,7 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     return { status: 'applied', changed: true, task: { id: taskId, shortId: allocated.shortId, state: 'active' } };
   }
 
-  return withCreateLock(repoRoot, projectConfig.project, () => {
-    let callbackError: unknown;
-    try {
-      return withRepositoryMutationLock(repoRoot, () => {
-        try { return createUnderRepositoryLock(); }
-        catch (error) { callbackError = error; throw error; }
-      });
-    } catch (error) {
-      if (callbackError !== undefined) throw callbackError;
-      throw error;
-    }
-  });
+  return createOnce();
 
 }
 

package/lib/task/delegation-receipts.ts

@@ -263,7 +263,7 @@ function validateSealRequest(
 
 function validateReviewerSealPaths(receipt: DelegationReceipt, changedPaths: readonly string[]): ReceiptFailure | null {
   if (receipt.role !== 'reviewer') return null;
-  const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
+  const taskRoot = `task-workspace/active/${receipt.taskId}/`;
   const allowed = new Set([
     `${taskRoot}${receipt.artifact}`,
     `${taskRoot}task.md`,

package/lib/task/delivery.ts

@@ -6,7 +6,6 @@ import { parseTaskFrontmatter } from './frontmatter.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
-import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 
 export type DeliveryState = 'absent' | 'same' | 'known-old' | 'unknown-drift';
 
@@ -50,7 +49,7 @@ function failure(taskId: string | null, code: string, message: string, retryable
   return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
 
-function deliverUnlocked(
+function deliverTaskBranchCore(
   taskId: string,
   taskDir: string,
   repoRoot: string,
@@ -108,14 +107,7 @@ function deliverUnlocked(
 function deliverTaskBranch(taskRef: string, options: { repoRoot?: string; agent: string; remote?: string; baseRef?: string; dryRun?: boolean }): TaskBranchDeliveryResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failure(resolved.taskId, resolved.code, resolved.message);
-  try {
-    return withRepositoryMutationLock(resolved.repoRoot, () => withTaskExecutionLock(
-      resolved.repoRoot, resolved.taskId, 'task-delivery',
-      () => deliverUnlocked(resolved.taskId, resolved.taskDir, resolved.repoRoot, options)
-    ));
-  } catch (error) {
-    return failure(resolved.taskId, 'DELIVERY_LOCK_FAILED', error instanceof Error ? error.message : String(error), true, 'blocked');
-  }
+  return deliverTaskBranchCore(resolved.taskId, resolved.taskDir, resolved.repoRoot, options);
 }
 
 export { classifyDeliveryState, deliverTaskBranch };