@fitlab-ai/agent-infra 0.11.14 → 0.12.0

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'
 ];
@@ -54,8 +54,24 @@ const DEFAULT_IO = {
     renameSync: (source, target) => fs.renameSync(source, target),
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
     writeFileSync: (file, content, flag) => fs.writeFileSync(file, content, { encoding: 'utf8', flag: flag ?? 'w' }),
-    unlinkSync: (file) => fs.unlinkSync(file)
+    unlinkSync: (file) => fs.unlinkSync(file),
+    rmdirSync: (directory) => fs.rmdirSync(directory),
+    readdirSync: (directory) => fs.readdirSync(directory),
+    readMountInfoSync: () => fs.readFileSync('/proc/self/mountinfo', 'utf8')
 };
+function isVirtiofsMountPoint(directory, mountInfo) {
+    const decodeMountInfoPath = (value) => value.replace(/\\([0-7]{3})/gu, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
+    const expected = fs.realpathSync.native(directory);
+    return mountInfo.split('\n').some((line) => {
+        if (!line)
+            return false;
+        const fields = line.split(' ');
+        const separator = fields.indexOf('-');
+        return separator >= 0
+            && fields[separator + 1] === 'virtiofs'
+            && path.resolve(decodeMountInfoPath(fields[4] ?? '')) === expected;
+    });
+}
 function failed(request, error, extra = {}) {
     return {
         status: 'failed', changed: false, requestRef: request.taskRef, taskId: null,
@@ -355,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) {
@@ -363,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 {
@@ -578,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' });
     }
@@ -633,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');
@@ -679,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') {
@@ -889,10 +905,22 @@ 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 {
-            fs.rmdirSync(activeTaskPath);
+            let sourceIsVirtiofsMount = false;
+            try {
+                sourceIsVirtiofsMount = isVirtiofsMountPoint(activeTaskPath, io.readMountInfoSync());
+            }
+            catch { /* Platforms without mountinfo retain the ordinary directory cleanup path. */ }
+            if (sourceIsVirtiofsMount) {
+                if (io.readdirSync(activeTaskPath).length > 0) {
+                    throw new Error('virtiofs source directory is not empty after task contents were transferred');
+                }
+            }
+            else {
+                io.rmdirSync(activeTaskPath);
+            }
         }
         catch (error) {
             return failed(request, { code: 'LIFECYCLE_SOURCE_DIRECTORY_CLEANUP_FAILED', message: String(error) }, {
@@ -939,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) {

package/dist/lib/task/orchestration.js

@@ -7,19 +7,19 @@ import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 import { activateDelegation, abortActivatedDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
 import { getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.js';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { resolveArtifactContext } from './artifact-lifecycle.js';
+import { resolveArtifactContextForResolvedTask } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -274,15 +274,9 @@ function mutateDelegationAdapterEvidence(taskRef, receiptId, adapterId, mutate,
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         throw new Error(`${resolved.code}: ${resolved.message}`);
-    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, false);
+    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options);
 }
-function mutateDelegationAdapterEvidenceWithinTaskLock(taskRef, receiptId, adapterId, mutate, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, true);
-}
-function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, taskLockHeld) {
+function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options) {
     const update = () => {
         try {
             const run = readRun(resolved.taskDir, options);
@@ -316,9 +310,7 @@ function mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterI
         }
     };
     let mutationError;
-    const result = taskLockHeld
-        ? update()
-        : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+    const result = update();
     if (mutationError)
         throw mutationError;
     return result;
@@ -542,10 +534,7 @@ function routeFromFacts(facts) {
     const role = action.startsWith('review-') ? 'reviewer' : 'executor';
     return { action: command, role, stage: action };
 }
-function routeOrchestration(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
+function routeResolvedTask(taskRef, resolved, options) {
     let gitRoot;
     try {
         gitRoot = gitRootFor(resolved.repoRoot, options);
@@ -584,7 +573,7 @@ function routeOrchestration(taskRef, options = {}) {
     catch (error) {
         return failed('ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
-    const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation));
+    const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation), resolved.repoRoot);
     if (!facts.ok)
         return failed('ORCHESTRATION_CAPABILITY_FACTS_INVALID', facts.message, resolved.taskId);
     const routed = routeFromFacts(facts.facts);
@@ -674,7 +663,7 @@ function routeOrchestration(taskRef, options = {}) {
     }
     const action = routed.stage;
     const family = action === 'analysis' ? 'analysis' : action;
-    const artifactContext = resolveArtifactContext(taskRef, family, {
+    const artifactContext = resolveArtifactContextForResolvedTask(resolved, family, {
         repoRoot: resolved.repoRoot
     });
     if (artifactContext.status !== 'ready' || !artifactContext.selection) {
@@ -700,6 +689,12 @@ function routeOrchestration(taskRef, options = {}) {
     };
     return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
+function routeOrchestration(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failed(resolved.code, resolved.message, resolved.taskId);
+    return routeResolvedTask(taskRef, resolved, options);
+}
 function statusOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -743,7 +738,7 @@ function validateDelegationRun(taskRef, taskId, run, options) {
     }
     return null;
 }
-function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
+function prepareOrchestrationDelegation(taskRef, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -763,7 +758,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     if (runFailure)
         return runFailure;
     const activeRun = run;
-    const routed = routeOrchestration(taskRef, options);
+    const routed = routeResolvedTask(taskRef, resolved, options);
     if (!routed.next)
         return routed;
     const next = routed.next;
@@ -797,20 +792,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
 }
-function prepareOrchestrationDelegation(taskRef, input, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.prepare.task', () => prepareOrchestrationDelegationUnlocked(taskRef, input, options));
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
-        throw error;
-    }
-}
-function dispatchOrchestrationDelegationUnlocked(taskRef, options = {}) {
+function dispatchOrchestrationDelegation(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -830,19 +812,6 @@ function dispatchOrchestrationDelegationUnlocked(taskRef, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-function dispatchOrchestrationDelegation(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failed(resolved.code, resolved.message, resolved.taskId);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.dispatch.task', () => dispatchOrchestrationDelegationUnlocked(taskRef, options));
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
-        throw error;
-    }
-}
 function matchingDelegations(predicate, options) {
     const taskId = options.taskId;
     if (taskId === undefined || taskId === '') {
@@ -852,7 +821,7 @@ function matchingDelegations(predicate, options) {
         return { ok: false, error: failed('ORCHESTRATION_TASK_ID_INVALID', 'taskId must be a canonical TASK-id') };
     }
     const repoRoot = options.repoRoot ?? process.cwd();
-    const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    const taskDir = path.join(resolveProjectTaskWorkspaceRoot(repoRoot), 'active', taskId);
     const run = readRun(taskDir, options);
     const matches = run && run.status === 'running' && run.pendingDelegation && predicate(run.pendingDelegation)
         ? [{ taskId, run }]
@@ -1033,7 +1002,7 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
     try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.recover-prepared', () => {
+        return (() => {
             const run = readRun(resolved.taskDir, options);
             const receipt = run?.pendingDelegation;
             if (!run || !receipt) {
@@ -1073,11 +1042,9 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
             }, options.now);
             saveRun(resolved.taskDir, updated);
             return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
-        });
+        })();
     }
     catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            return failed(error.code, error.message, resolved.taskId);
         return failed('ORCHESTRATION_PREPARED_RECOVERY_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
 }
@@ -1088,7 +1055,7 @@ function recoveryReceiptMatches(receipt, event) {
         && receipt.childId === event.childId
         && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
 }
-function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, options = {}) {
+function recoverActivatedOrchestrationDelegation(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
@@ -1204,7 +1171,7 @@ function sealOrchestrationDelegation(taskRef, event, expected, options = {}, bef
     const resolved = resolveTaskRef(taskRef, { repoRoot: orchestrationOptions.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
-    return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.seal', () => {
+    return (() => {
         const run = readRun(resolved.taskDir, orchestrationOptions);
         if (!run?.pendingDelegation)
             return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
@@ -1226,7 +1193,7 @@ function sealOrchestrationDelegation(taskRef, event, expected, options = {}, bef
         const updated = withUpdatedRun(current, { pendingDelegation: result.receipt });
         saveRun(resolved.taskDir, updated);
         return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
-    });
+    })();
 }
 function advanceOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -1262,5 +1229,5 @@ function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, readDelegationAdapterEvidence, mutateDelegationAdapterEvidence, mutateDelegationAdapterEvidenceWithinTaskLock, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegationUnderLock, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, readDelegationAdapterEvidence, mutateDelegationAdapterEvidence, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, };
 //# sourceMappingURL=orchestration.js.map

package/dist/lib/task/platform-operation-recovery.js

@@ -234,8 +234,7 @@ async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
         ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
         primaryResult: 'no_op',
         strict: true,
-        skipQueue: true,
-        lockAlreadyHeld: true
+        skipQueue: true
     });
     if ((replayed.status === 'applied' || replayed.status === 'no-op') && !replayed.error && replayed.warnings.length === 0) {
         return platformResult(replayed.status, { changed: replayed.changed });

package/dist/lib/task/resolve-ref.js

@@ -3,10 +3,12 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { normalizeShortIdInput, resolveShortIdReadOnly } from './short-id.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 // Flat-structured workspace dirs that hold tasks under `{dir}/{taskId}/task.md`.
 // Note: `archive` uses a three-level YYYY/MM/DD layout and is handled separately.
 const FLAT_WORKSPACE_DIRS = ['active', 'blocked', 'completed'];
+function taskRoot(repoRoot) { return resolveProjectTaskWorkspaceRoot(repoRoot); }
 function detectRepoRoot() {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -40,12 +42,12 @@ function listSortedNumeric(dir, width) {
         .sort()
         .reverse();
 }
-function findInArchive(repoRoot, taskId) {
-    // archive-tasks stores local material at .agents/workspace/archive/YYYY/MM/DD/{taskId}/local/task.md
+function findInArchive(workspaceRoot, taskId) {
+    // archive-tasks stores local material at the project task workspace archive/YYYY/MM/DD/{taskId}/local/task.md
     // where YYYY/MM/DD comes from completed_at (or updated_at fallback) — NOT from
     // the task id's creation date. So we cannot derive the path from taskId alone;
     // walk the bounded YYYY/MM/DD tree instead. Newest-first to favor recent archives.
-    const archiveDir = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    const archiveDir = path.join(workspaceRoot, 'archive');
     for (const year of listSortedNumeric(archiveDir, 4)) {
         const yearDir = path.join(archiveDir, year);
         for (const month of listSortedNumeric(yearDir, 2)) {
@@ -59,13 +61,13 @@ function findInArchive(repoRoot, taskId) {
     }
     return null;
 }
-function findTaskMd(repoRoot, taskId) {
+function findTaskMd(workspaceRoot, taskId) {
     for (const sub of FLAT_WORKSPACE_DIRS) {
-        const candidate = path.join(repoRoot, '.agents', 'workspace', sub, taskId, 'task.md');
+        const candidate = path.join(workspaceRoot, sub, taskId, 'task.md');
         if (fs.existsSync(candidate))
             return { taskMdPath: candidate, state: sub };
     }
-    const archived = findInArchive(repoRoot, taskId);
+    const archived = findInArchive(workspaceRoot, taskId);
     return archived ? { taskMdPath: archived, state: 'archive' } : null;
 }
 /**
@@ -76,8 +78,9 @@ function findTaskMd(repoRoot, taskId) {
  */
 function enumerateTaskDirs(repoRoot) {
     const out = [];
+    const workspaceRoot = taskRoot(repoRoot);
     for (const sub of FLAT_WORKSPACE_DIRS) {
-        const base = path.join(repoRoot, '.agents', 'workspace', sub);
+        const base = path.join(workspaceRoot, sub);
         if (!fs.existsSync(base))
             continue;
         for (const entry of fs.readdirSync(base).sort()) {
@@ -98,6 +101,7 @@ function enumerateTaskDirs(repoRoot) {
  */
 function enumerateAllTaskDirs(repoRoot) {
     const out = [];
+    const workspaceRoot = taskRoot(repoRoot);
     const seen = new Map();
     const add = (taskId, taskDir, state) => {
         if (!TASK_ID_RE.test(taskId))
@@ -116,13 +120,13 @@ function enumerateAllTaskDirs(repoRoot) {
         out.push({ taskId, taskDir, state });
     };
     for (const state of FLAT_WORKSPACE_DIRS) {
-        const base = path.join(repoRoot, '.agents', 'workspace', state);
+        const base = path.join(workspaceRoot, state);
         if (!fs.existsSync(base))
             continue;
         for (const taskId of fs.readdirSync(base).sort())
             add(taskId, path.join(base, taskId), state);
     }
-    const archive = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    const archive = path.join(workspaceRoot, 'archive');
     for (const year of listSortedNumeric(archive, 4).reverse()) {
         const yearDir = path.join(archive, year);
         for (const month of listSortedNumeric(yearDir, 2).reverse()) {
@@ -137,8 +141,9 @@ function enumerateAllTaskDirs(repoRoot) {
     return out;
 }
 function locateHotTaskDirs(repoRoot, taskId) {
+    const workspaceRoot = taskRoot(repoRoot);
     return FLAT_WORKSPACE_DIRS.flatMap((state) => {
-        const taskDir = path.join(repoRoot, '.agents', 'workspace', state, taskId);
+        const taskDir = path.join(workspaceRoot, state, taskId);
         const taskMdPath = path.join(taskDir, 'task.md');
         return fs.existsSync(taskMdPath) ? [{ taskId, taskDir, taskMdPath, state }] : [];
     });
@@ -203,7 +208,7 @@ function resolveTaskRef(arg, options = {}) {
         }
         taskId = shortResult.taskId;
     }
-    const located = findTaskMd(repoRoot, taskId);
+    const located = findTaskMd(taskRoot(repoRoot), taskId);
     if (!located) {
         return {
             ok: false,
@@ -255,7 +260,7 @@ function resolveTaskContext(taskRef, options = {}) {
             taskId: null
         };
     }
-    const activeDir = path.join(repoRoot, '.agents', 'workspace', 'active');
+    const activeDir = path.join(taskRoot(repoRoot), 'active');
     const matches = [];
     if (fs.existsSync(activeDir)) {
         for (const entry of fs.readdirSync(activeDir).sort()) {

package/dist/lib/task/review-finalization.js

@@ -8,7 +8,6 @@ import { finalizeReviewSummaryContent } from './review-artifacts.js';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { validateQualificationAudit } from './qualification-audit.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
@@ -47,7 +46,7 @@ function preflightFailed(request, code, message, taskId = null, extra = {}) {
     };
 }
 /** Validate the current review draft before any finding-ledger write. */
-function preflightReviewSummaryUnlocked(request, options = {}) {
+function preflightReviewSummary(request, options = {}) {
     const stage = request.stage;
     const spec = STAGES[stage];
     if (!spec)
@@ -106,21 +105,6 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
         status: 'passed', changed: false, error: null
     };
 }
-function preflightReviewSummary(request, options = {}) {
-    if (request.dryRun || options.lockAlreadyHeld)
-        return preflightReviewSummaryUnlocked(request, options);
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return preflightReviewSummaryUnlocked(request, options);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.preflight', () => preflightReviewSummaryUnlocked(request, { ...options, lockAlreadyHeld: true }));
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `${error.code}: ${error.message}`, resolved.taskId);
-    }
-}
 /** Prepare domain validation, summary bytes and provenance before any publication. */
 function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     let taskId = null;
@@ -208,7 +192,6 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
             operations: transformed.changed ? [{ kind: 'artifact', artifact: request.artifact, operation: 'update' }] : [],
             error: null
         },
-        lockAlreadyHeld: options.lockAlreadyHeld
     };
 }
 function commitReviewSummaryProvenance(prepared, repoRoot, options = {}) {
@@ -230,7 +213,7 @@ function replaceCurrentArtifactAtomically(file, content) {
         }
     }
 }
-function finalizeReviewSummaryUnlocked(request, options = {}) {
+function finalizeReviewSummary(request, options = {}) {
     const spec = STAGES[request.stage];
     if (!spec || !request.taskRef || !request.artifact)
         return prepareReviewSummaryCandidate(request, '', options).result;
@@ -267,21 +250,5 @@ function finalizeReviewSummaryUnlocked(request, options = {}) {
         return failed(request, 'REVIEW_RECOVERY_COMMIT_FAILED', `cannot update current review artifact: ${error instanceof Error ? error.message : String(error)}`, resolved.taskId);
     }
 }
-function finalizeReviewSummary(request, options = {}) {
-    const effectiveOptions = options;
-    if (request.dryRun || options.lockAlreadyHeld)
-        return finalizeReviewSummaryUnlocked(request, effectiveOptions);
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return finalizeReviewSummaryUnlocked(request, effectiveOptions);
-    try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', () => finalizeReviewSummaryUnlocked(request, { ...effectiveOptions, lockAlreadyHeld: true }));
-    }
-    catch (error) {
-        if (!(error instanceof TaskExecutionLockError))
-            throw error;
-        return failed(request, 'REVIEW_PROVENANCE_INVALID', `${error.code}: ${error.message}`, resolved.taskId);
-    }
-}
 export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate, commitReviewSummaryProvenance };
 //# sourceMappingURL=review-finalization.js.map

package/dist/lib/task/review-identity.js

@@ -23,7 +23,9 @@ export function inspectReviewIdentity(taskDir, reportContent, repositoryRoot) {
     }
     try {
         const metadata = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
-        const taskRepositoryRoot = git(taskDir, ['rev-parse', '--show-toplevel']);
+        const taskRepositoryRoot = repositoryRoot
+            ? fs.realpathSync.native(repositoryRoot)
+            : git(taskDir, ['rev-parse', '--show-toplevel']);
         const branch = String(metadata.branch ?? '').trim();
         const gitRoot = branch ? resolveBranchWorktree(taskRepositoryRoot, branch) : taskRepositoryRoot;
         if (!gitRoot)