@fitlab-ai/agent-infra 0.11.15 → 0.12.0

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

package/dist/lib/task/lifecycle.js

@@ -13,7 +13,7 @@ import { validateCurrentTaskContract } from './current-contract.js';
 import { isValidAgentInfraVersion } from '../version.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const lifecycleIntentCatalog = [
     'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
 ];
@@ -61,7 +61,7 @@ const DEFAULT_IO = {
 };
 function isVirtiofsMountPoint(directory, mountInfo) {
     const decodeMountInfoPath = (value) => value.replace(/\\([0-7]{3})/gu, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
-    const expected = path.resolve(directory);
+    const expected = fs.realpathSync.native(directory);
     return mountInfo.split('\n').some((line) => {
         if (!line)
             return false;
@@ -371,7 +371,7 @@ function validateRestoreStaging(request, repoRoot, taskId) {
     let workspace;
     let stagingDir;
     try {
-        workspace = fs.realpathSync.native(path.resolve(repoRoot, '.agents', 'workspace'));
+        workspace = fs.realpathSync.native(resolveProjectTaskWorkspaceRoot(repoRoot));
         stagingDir = fs.realpathSync.native(path.resolve(request.stagingDir));
     }
     catch (error) {
@@ -379,7 +379,7 @@ function validateRestoreStaging(request, repoRoot, taskId) {
     }
     const relative = path.relative(workspace, stagingDir);
     if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative) || path.basename(stagingDir) === taskId) {
-        return { code: 'LIFECYCLE_STAGING_INVALID', message: 'restore staging must be a non-final directory inside .agents/workspace' };
+        return { code: 'LIFECYCLE_STAGING_INVALID', message: 'restore staging must be a non-final directory inside the project task workspace' };
     }
     let entries;
     try {
@@ -594,7 +594,7 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
         return 'unknown';
     }
 }
-function applyTaskLifecycleUnlocked(requestInput, options = {}) {
+function applyTaskLifecycle(requestInput, options = {}) {
     if (requestInput.intent === 'recover-started') {
         return failed(requestInput, { code: 'LIFECYCLE_RECOVERY_REQUIRES_AUTHORITY', message: 'recover-started must be dispatched through task control authority' });
     }
@@ -649,7 +649,7 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
     else {
         return failed(request, { code: 'LIFECYCLE_TASK_NOT_FOUND', message: `task ${taskId} has no lifecycle source` }, { taskId });
     }
-    const targetPath = path.join(repoRoot, '.agents', 'workspace', spec.target, taskId);
+    const targetPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), spec.target, taskId);
     const requiredSteps = stepsForIntent(request.intent);
     const movingTaskDirectory = sourcePath !== targetPath;
     const currentTaskFile = path.join(sourcePath, 'task.md');
@@ -695,7 +695,7 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
             return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: contract.message }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     const registryRequest = executeShortIdCommand({
-        operation: 'list', activeDir: path.join(repoRoot, '.agents', 'workspace', 'active'),
+        operation: 'list', activeDir: path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active'),
         shortIdLength: configuredShortIdLength(repoRoot)
     });
     if (registryRequest.status === 'failed') {
@@ -905,7 +905,7 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
             }
         }
     }
-    const activeTaskPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const activeTaskPath = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId);
     if (request.intent === 'complete' && fs.existsSync(activeTaskPath)) {
         try {
             let sourceIsVirtiofsMount = false;
@@ -967,44 +967,5 @@ function applyTaskLifecycleUnlocked(requestInput, options = {}) {
         journalPath, completedSteps: [...completed], pendingSteps: []
     };
 }
-function applyTaskLifecycle(request, options = {}) {
-    const normalized = normalizedRequest(request);
-    if ('code' in normalized)
-        return applyTaskLifecycleUnlocked(request, options);
-    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
-    const taskId = normalized.intent === 'restore'
-        ? normalized.taskRef
-        : (() => {
-            const resolved = resolveTaskRef(normalized.taskRef, { repoRoot });
-            return resolved.ok ? resolved.taskId : null;
-        })();
-    if (!taskId)
-        return applyTaskLifecycleUnlocked(request, options);
-    try {
-        return withTaskExecutionLock(repoRoot, taskId, 'task-lifecycle.move', () => applyTaskLifecycleUnlocked(request, options));
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError) {
-            return failed(request, { code: error.code, message: error.message }, { taskId });
-        }
-        throw error;
-    }
-}
-function applyTaskLifecycleWithinTaskLock(request, options, lockedTaskId) {
-    const normalized = normalizedRequest(request);
-    if ('code' in normalized)
-        return failed(request, normalized);
-    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
-    const resolved = normalized.intent === 'restore'
-        ? { ok: true, taskId: normalized.taskRef }
-        : resolveTaskRef(normalized.taskRef, { repoRoot });
-    if (!resolved.ok || resolved.taskId !== lockedTaskId) {
-        return failed(request, {
-            code: 'LIFECYCLE_LOCK_SCOPE_MISMATCH',
-            message: 'task lifecycle request does not match the held task lock'
-        }, { taskId: resolved.ok ? resolved.taskId : resolved.taskId });
-    }
-    return applyTaskLifecycleUnlocked(request, options);
-}
-export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle, applyTaskLifecycleWithinTaskLock, previewTaskCompletion };
+export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle, previewTaskCompletion };
 //# sourceMappingURL=lifecycle.js.map

package/dist/lib/task/local-artifact-finalization.js

@@ -110,8 +110,7 @@ function prepareLocalArtifact(request, candidate) {
     return {
         result: validation.ok && !qualificationError ? { ...result, status: 'passed', error: null } : result,
         content,
-        repoRoot: resolved.repoRoot,
-        lockAlreadyHeld: request.lockAlreadyHeld
+        repoRoot: resolved.repoRoot
     };
 }
 function commitLocalArtifactProvenance(prepared) {