@fitlab-ai/agent-infra 0.11.14 → 0.12.0

package/dist/lib/task/commit-operation.js

@@ -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.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
@@ -6,7 +7,6 @@ import { checkpointCommitMatches } from './commit-identity.js';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.js';
 import { commitPushDecision } from './commit-policy.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 import { appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { checkpointIntentDigest, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent } from './commit-intent.js';
@@ -58,6 +58,8 @@ function resolveBoundTask(input) {
             };
         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);
@@ -181,7 +183,7 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
-function executeUnlocked(input, task, mode) {
+function executeCommitOperationCore(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
         return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
@@ -432,12 +434,10 @@ function executeCommitOperation(input) {
     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/dist/lib/task/control-authority.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { isAgentClientId } from '../agent-clients/types.js';
@@ -5,10 +6,10 @@ import { sandboxControlPaths } from '../sandbox/workspace-view.js';
 import { getAgentClientAdapter } from '../agent-clients/registry.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
-import { applyTaskLifecycle, applyTaskLifecycleWithinTaskLock, taskLifecycleFailure } from './lifecycle.js';
+import { applyTaskLifecycle } from './lifecycle.js';
 import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
+import { releaseStaleShortIdRegistry } from './short-id.js';
 export function taskControlOperationKey(operation) {
     if (operation.family === 'task-finalization')
         return 'complete';
@@ -112,7 +113,7 @@ function lifecycleTaskId(request, repoRoot) {
 async function applyLifecycleWithAuthority(context, request) {
     const taskId = lifecycleTaskId(request, context.repoRoot);
     const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
-    const execute = async (underTaskLock = false) => {
+    const execute = async () => {
         if (request.intent === 'recover-started') {
             const adapter = isAgentClientId(request.agent)
                 ? getAgentClientAdapter(request.agent).orchestrationAdapter
@@ -126,36 +127,13 @@ async function applyLifecycleWithAuthority(context, request) {
             }
             return adapter.recoverStarted(request, { 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, taskId) {
     if (context.source === 'sandbox-executor')
@@ -251,6 +229,28 @@ export function dispatchTaskControlOperation(context, operation) {
             ...(controlRoot ? { controlRoot } : {}),
             ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {}),
             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/dist/lib/task/create-service.js

@@ -3,7 +3,6 @@ import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { VERSION } from '../version.js';
 import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
 import { createLocalTask } from './create.js';
-import { TaskExecutionLockError } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 const DEFAULT_DEPENDENCIES = {
     createIssue: createPlatformIssue,
@@ -152,9 +151,8 @@ async function createTask(value, options) {
     }
     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 = [{
             name: 'task:local', status: local.status, reasonCode: null

package/dist/lib/task/create.js

@@ -4,13 +4,13 @@ import os from 'node:os';
 import path from 'node:path';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
-import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.js';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.js';
 import { enumerateAllTaskDirs } from './resolve-ref.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { AGENT_TOKEN_VALUES } from '../agent-clients/tokens.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'];
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'];
 const EFFORTS = ['High', 'Medium', 'Low'];
@@ -295,49 +295,6 @@ function ensureRealDirectory(directory, code) {
     }
     fs.mkdirSync(directory, { mode: 0o700 });
 }
-function createLockRoot(project) {
-    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.code !== 'EEXIST')
-                throw error;
-            assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
-        }
-    }
-    return directories.at(-1);
-}
-function withCreateLock(repoRoot, project, operation) {
-    const lockRoot = createLockRoot(project);
-    let callbackError;
-    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, keyDigest, candidateDigest) {
     for (const task of enumerateAllTaskDirs(repoRoot)) {
         const taskMd = path.join(task.taskDir, 'task.md');
@@ -366,16 +323,24 @@ function createLocalTask(value, options) {
         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() {
+    function createOnce() {
         const recovered = recoverPublishedTask(repoRoot, keyDigest, candidateDigest);
         if (recovered) {
             return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId, state: recovered.state } };
@@ -407,25 +372,7 @@ function createLocalTask(value, options) {
             throw new Error('TASK_CREATE_SHORT_ID_FAILED');
         return { status: 'applied', changed: true, task: { id: taskId, shortId: allocated.shortId, state: 'active' } };
     }
-    return withCreateLock(repoRoot, projectConfig.project, () => {
-        let callbackError;
-        try {
-            return withRepositoryMutationLock(repoRoot, () => {
-                try {
-                    return createUnderRepositoryLock();
-                }
-                catch (error) {
-                    callbackError = error;
-                    throw error;
-                }
-            });
-        }
-        catch (error) {
-            if (callbackError !== undefined)
-                throw callbackError;
-            throw error;
-        }
-    });
+    return createOnce();
 }
 export { canonicalTaskCreateCandidate, createLocalTask, validateTaskCreateCandidate };
 //# sourceMappingURL=create.js.map

package/dist/lib/task/delegation-receipts.js

@@ -195,7 +195,7 @@ function validateSealRequest(receipt, event) {
 function validateReviewerSealPaths(receipt, changedPaths) {
     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/dist/lib/task/delivery.js

@@ -5,7 +5,6 @@ import { parseTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 function classifyDeliveryState(localHead, remoteHead, lastDelivered) {
     if (remoteHead === null)
         return { state: 'absent', shouldPush: true };
@@ -29,7 +28,7 @@ function validateBranch(cwd, branch) {
 function failure(taskId, code, message, retryable = false, status = retryable ? 'blocked' : 'failed') {
     return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
-function deliverUnlocked(taskId, taskDir, repoRoot, options) {
+function deliverTaskBranchCore(taskId, taskDir, repoRoot, options) {
     let frontmatter;
     try {
         frontmatter = parseTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
@@ -100,12 +99,7 @@ function deliverTaskBranch(taskRef, options) {
     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 };
 //# sourceMappingURL=delivery.js.map

package/dist/lib/task/events.js

@@ -15,7 +15,6 @@ import { resolveTaskRef } from './resolve-ref.js';
 import { findSectionHeading } from './sections.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { commitOrchestrationStageCompletion } from './orchestration.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.js';
@@ -456,11 +455,11 @@ function reworkIntentMutationForCompletion(content, taskDir, family, artifact, t
     }
     return { mutation: JSON.stringify(next) === JSON.stringify(parsed.intents) ? null : reworkIntentMutation(content, next) };
 }
-function buildCompletionReceipt(content, taskDir, family, artifact, completedAt, frontmatter, request) {
+function buildCompletionReceipt(content, taskDir, repositoryRoot, family, artifact, completedAt, frontmatter, request) {
     if (!['analyze', 'plan', 'code'].includes(family) && !family.startsWith('review-'))
         return null;
     if (family === 'review-code') {
-        const identity = inspectReviewIdentity(taskDir, fs.readFileSync(artifact.path, 'utf8'));
+        const identity = inspectReviewIdentity(taskDir, fs.readFileSync(artifact.path, 'utf8'), repositoryRoot);
         if (identity.status !== 'matched')
             return { ok: false, message: `review-code identity is ${identity.status}: ${identity.message}` };
     }
@@ -566,7 +565,7 @@ function sameCompletionFact(left, right) {
 function replaceCompletionFact(facts, next) {
     return [...facts.filter((fact) => !(fact.event === next.event && fact.output === next.output)), next];
 }
-function applyTaskEventUnlocked(request, options = {}) {
+function applyTaskEvent(request, options = {}) {
     const invalid = validateTaskEventRequest(request);
     if (invalid)
         return failed(request, invalid);
@@ -718,7 +717,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     }
     if (eventIdentity.phase === 'started') {
         const trigger = eventTrigger(normalized, eventIdentity.family);
-        const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state);
+        const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, false, resolved.repoRoot);
         if (!facts.ok)
             return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${facts.code}: ${facts.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
@@ -766,7 +765,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     let currentFact = null;
     let completionRework = null;
     if (eventIdentity.phase === 'completed' && completedArtifact) {
-        const receipt = buildCompletionReceipt(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter, normalized);
+        const receipt = buildCompletionReceipt(content, resolved.taskDir, resolved.repoRoot, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter, normalized);
         if (receipt && !receipt.ok) {
             return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: receipt.message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
@@ -938,31 +937,6 @@ function applyTaskEventUnlocked(request, options = {}) {
         agentInfraVersion: result.agentInfraVersion, operations: result.operations, error: null
     };
 }
-function applyTaskEvent(request, options = {}) {
-    const invalid = validateTaskEventRequest(request);
-    if (invalid)
-        return failed(request, invalid);
-    const parts = eventParts(request.event);
-    if (options.lockAlreadyHeld)
-        return applyTaskEventUnlocked(request, options);
-    if (request.dryRun || !['started', 'completed'].includes(parts.phase)) {
-        return applyTaskEventUnlocked(request, options);
-    }
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return applyTaskEventUnlocked(request, options);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, () => applyTaskEventUnlocked(request, { ...options, lockAlreadyHeld: true }));
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        return failed(request, {
-            code: 'EVENT_TRANSITION_INVALID',
-            message: `${error.code}: ${error.message}`
-        }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-    }
-}
 function successNoOp(request, taskId, taskMdPath, currentStep, eventIdentity, timestamp, frontmatter, artifactContext) {
     return {
         ...failed(request, { code: 'EVENT_LOG_CONFLICT', message: '' }), status: 'no-op', error: null,

package/dist/lib/task/finalization.js

@@ -9,10 +9,9 @@ import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { recoverPlatformOperations } from './platform-operation-recovery.js';
-import { applyTaskLifecycle, applyTaskLifecycleWithinTaskLock, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
+import { applyTaskLifecycle, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
 import { enumerateAllTaskDirs, resolveTaskRef } from './resolve-ref.js';
 import { inspectShortIdRegistry } from './short-id.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
@@ -442,7 +441,7 @@ function mutationPatch(current, mutation) {
         ? { warningProjection: 'done', lastError: null }
         : { warningProjection: 'pending', lastError: mutation.error };
 }
-function applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, mutation, consumed) {
+function mutateFinalizationReceipt(repoRoot, receipt, capability, mutation, consumed) {
     if (!hasFinalizationTaskDocument(repoRoot, receipt.taskId)) {
         throw capabilityError('FINALIZATION_SCOPE_INVALID', 'finalization capability requires an active task or a completed task');
     }
@@ -459,7 +458,7 @@ function applyFinalizationReceiptMutation(repoRoot, receipt, capability, mutatio
     if (!hasFinalizationTaskDocument(repoRoot, receipt.taskId)) {
         throw capabilityError('FINALIZATION_SCOPE_INVALID', 'finalization capability requires an active task or a completed task');
     }
-    return withTaskExecutionLock(repoRoot, receipt.taskId, 'task-finalization.receipt-mutation', () => applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, mutation, new Set()));
+    return mutateFinalizationReceipt(repoRoot, receipt, capability, mutation, new Set());
 }
 function warningKey(warning) {
     return `${warning.step}\0${warning.code}\0${warning.target}`;
@@ -479,14 +478,14 @@ function reconcileWarningProjection(repoRoot, taskId, receipt, consumed) {
                     retryable: true
                 };
                 const capability = issueCapability(receipt, 'warning-projection');
-                return applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'failed', error: detail }, consumed);
+                return mutateFinalizationReceipt(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'failed', error: detail }, consumed);
             }
         }
         catch (error) {
             const detail = errorOf(error, 'FINALIZATION_WARNING_PROJECTION_FAILED', true);
             try {
                 const capability = issueCapability(receipt, 'warning-projection');
-                return applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'failed', error: detail }, consumed);
+                return mutateFinalizationReceipt(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'failed', error: detail }, consumed);
             }
             catch {
                 return receipt;
@@ -495,7 +494,7 @@ function reconcileWarningProjection(repoRoot, taskId, receipt, consumed) {
     }
     try {
         const capability = issueCapability(receipt, 'warning-projection');
-        return applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'succeeded' }, consumed);
+        return mutateFinalizationReceipt(repoRoot, receipt, capability, { scope: 'warning-projection', operation: 'succeeded' }, consumed);
     }
     catch {
         return receipt;
@@ -526,7 +525,7 @@ async function syncPendingTaskComment(input) {
         if (result.status === 'applied' || result.status === 'no-op') {
             const skipped = result.error?.code === 'ISSUE_NOT_LINKED';
             const capability = issueCapability(receipt, 'task-comment');
-            receipt = applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, {
+            receipt = mutateFinalizationReceipt(repoRoot, receipt, capability, {
                 scope: 'task-comment', operation: 'succeeded', state: skipped ? 'skipped' : 'done'
             }, consumedCapabilities);
             receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
@@ -542,7 +541,7 @@ async function syncPendingTaskComment(input) {
         }
         const detail = step.error ?? { code: 'COMMENT_SYNC_FAILED', message: 'task comment synchronization failed', retryable: true };
         const capability = issueCapability(receipt, 'task-comment');
-        receipt = applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, {
+        receipt = mutateFinalizationReceipt(repoRoot, receipt, capability, {
             scope: 'task-comment', operation: 'failed', error: detail
         }, consumedCapabilities);
         receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
@@ -552,7 +551,7 @@ async function syncPendingTaskComment(input) {
         const detail = errorOf(error, 'COMMENT_SYNC_FAILED', true);
         try {
             const capability = issueCapability(receipt, 'task-comment');
-            receipt = applyFinalizationReceiptMutationUnderLock(repoRoot, receipt, capability, {
+            receipt = mutateFinalizationReceipt(repoRoot, receipt, capability, {
                 scope: 'task-comment', operation: 'failed', error: detail
             }, consumedCapabilities);
             receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
@@ -682,9 +681,9 @@ function preparedResult(taskId, receipt, steps, changed) {
         result: 'prepared', warnings: openWarnings(receipt), error: null
     };
 }
-async function prepareUnderLock(request, taskId, options) {
+async function prepareTaskFinalizationCore(request, taskId, options) {
     const repoRoot = path.resolve(options.repoRoot);
-    const lifecycle = options.lifecycle ?? ((lifecycleRequest, lifecycleOptions) => (applyTaskLifecycleWithinTaskLock(lifecycleRequest, lifecycleOptions ?? { repoRoot }, taskId)));
+    const lifecycle = options.lifecycle ?? ((lifecycleRequest, lifecycleOptions) => (applyTaskLifecycle(lifecycleRequest, lifecycleOptions ?? { repoRoot })));
     const backfill = options.backfill ?? backfillCompletionComments;
     const commentSync = options.commentSync ?? syncPlatformComment;
     const issueSync = options.issueSync ?? syncPlatformIssue;
@@ -966,12 +965,10 @@ async function prepareTaskFinalization(request, options) {
     if (!resolved.ok)
         return failed(resolved.taskId, { code: resolved.code, message: resolved.message, retryable: false });
     try {
-        return await withTaskExecutionLock(repoRoot, resolved.taskId, 'task-finalization.prepare', () => prepareUnderLock(request, resolved.taskId, options));
+        return await prepareTaskFinalizationCore(request, resolved.taskId, options);
     }
     catch (error) {
-        const detail = error instanceof TaskExecutionLockError
-            ? { code: error.code, message: error.message, retryable: error.code === 'ORCHESTRATION_LOCK_BUSY' }
-            : errorOf(error, 'TASK_FINALIZATION_FAILED');
+        const detail = errorOf(error, 'TASK_FINALIZATION_FAILED');
         return failed(resolved.taskId, detail);
     }
 }
@@ -984,7 +981,7 @@ async function commitPreparedTaskFinalization(request, options) {
     if (!resolved.ok)
         return failed(resolved.taskId, { code: resolved.code, message: resolved.message, retryable: false });
     try {
-        return await withTaskExecutionLock(repoRoot, resolved.taskId, 'task-finalization.commit', async () => {
+        return await (async () => {
             if (options.controlBinding && options.manifestPath) {
                 try {
                     const manifest = readSandboxControlManifest(options.manifestPath);
@@ -1051,7 +1048,7 @@ async function commitPreparedTaskFinalization(request, options) {
             };
             const result = options.lifecycle
                 ? options.lifecycle(lifecycleRequest, lifecycleOptions)
-                : applyTaskLifecycleWithinTaskLock(lifecycleRequest, lifecycleOptions, resolved.taskId);
+                : applyTaskLifecycle(lifecycleRequest, lifecycleOptions);
             const step = lifecycleStep(result);
             if (result.status !== 'applied' && result.status !== 'no-op') {
                 const updated = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: step.error });
@@ -1131,12 +1128,10 @@ async function commitPreparedTaskFinalization(request, options) {
                 });
             }
             return terminalResult(resolved.taskId, updated, { lifecycle: step, verification }, result.changed, detail);
-        });
+        })();
     }
     catch (error) {
-        const detail = error instanceof TaskExecutionLockError
-            ? { code: error.code, message: error.message, retryable: error.code === 'ORCHESTRATION_LOCK_BUSY' }
-            : errorOf(error, 'TASK_FINALIZATION_FAILED');
+        const detail = errorOf(error, 'TASK_FINALIZATION_FAILED');
         return failed(resolved.taskId, detail);
     }
 }