@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/dist/lib/task/lifecycle.js

@@ -13,12 +13,13 @@ 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';
 const lifecycleIntentCatalog = [
     'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
 ];
 const lifecycleFailureCatalog = [
+    'LIFECYCLE_DIRECTORY_TRANSFER_FAILED',
     'LIFECYCLE_DIRECTORY_RENAME_FAILED',
-    'LIFECYCLE_DIRECTORY_COPY_FAILED',
     'LIFECYCLE_DOCUMENT_INVALID',
     'LIFECYCLE_FINAL_STATE_INVALID',
     'LIFECYCLE_IDENTITY_CONFLICT',
@@ -32,6 +33,7 @@ const lifecycleFailureCatalog = [
     'LIFECYCLE_PAYLOAD_INVALID',
     'LIFECYCLE_SHORT_ID_FAILED',
     'LIFECYCLE_SHORT_ID_PRECONDITION',
+    'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
     'LIFECYCLE_SOURCE_INVALID',
     'LIFECYCLE_STAGING_IDENTITY_INVALID',
     'LIFECYCLE_STAGING_INVALID',
@@ -45,6 +47,9 @@ const lifecycleProducerCatalog = lifecycleFailureCatalog.map((code) => ({
     code
 }));
 const STEPS = ['task-written', 'directory-moved', 'registry-committed'];
+function stepsForIntent(intent) {
+    return intent === 'complete' ? ['task-written', 'directory-moved'] : STEPS;
+}
 const DEFAULT_IO = {
     renameSync: (source, target) => fs.renameSync(source, target),
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
@@ -57,7 +62,7 @@ function failed(request, error, extra = {}) {
         intent: request.intent, sourceState: null, targetState: null, sourcePath: null,
         targetPath: null, task: { operations: [] }, directory: { effect: 'unchanged', changed: false },
         shortId: { effect: 'unchanged', shortId: null, changed: false }, timestamp: null,
-        agentInfraVersion: null, journalPath: null, completedSteps: [], pendingSteps: STEPS,
+        agentInfraVersion: null, journalPath: null, completedSteps: [], pendingSteps: stepsForIntent(request.intent),
         error, ...extra
     };
 }
@@ -133,8 +138,105 @@ function transition(request) {
         return { sources: ['active', 'blocked'], target: 'completed', registry: 'release' };
     if (request.intent === 'restore')
         return { sources: ['staging'], target: 'active', registry: 'alloc' };
+    if (request.intent === 'complete')
+        return { sources: ['active'], target: 'completed', registry: 'none' };
     return { sources: ['active'], target: 'completed', registry: 'release' };
 }
+function sameTaskEntry(source, target) {
+    const sourceStat = fs.lstatSync(source);
+    let targetStat;
+    try {
+        targetStat = fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+    if (sourceStat.isSymbolicLink() || targetStat.isSymbolicLink()) {
+        return sourceStat.isSymbolicLink() && targetStat.isSymbolicLink()
+            && fs.readlinkSync(source) === fs.readlinkSync(target);
+    }
+    if (sourceStat.isDirectory() && targetStat.isDirectory()) {
+        const sourceNames = fs.readdirSync(source).sort();
+        const targetNames = fs.readdirSync(target).sort();
+        return sourceNames.join('\0') === targetNames.join('\0')
+            && sourceNames.every((name) => sameTaskEntry(path.join(source, name), path.join(target, name)))
+            && (sourceStat.mode & 0o777) === (targetStat.mode & 0o777);
+    }
+    return sourceStat.isFile() && targetStat.isFile()
+        && (sourceStat.mode & 0o777) === (targetStat.mode & 0o777)
+        && fs.readFileSync(source).equals(fs.readFileSync(target));
+}
+function copyTaskEntry(source, target) {
+    const sourceStat = fs.lstatSync(source);
+    if (fs.existsSync(target)) {
+        const targetStat = fs.lstatSync(target);
+        if (sourceStat.isDirectory() && targetStat.isDirectory() && !targetStat.isSymbolicLink()) {
+            for (const name of fs.readdirSync(source).sort())
+                copyTaskEntry(path.join(source, name), path.join(target, name));
+            fs.chmodSync(target, sourceStat.mode & 0o777);
+            return;
+        }
+        if (sameTaskEntry(source, target))
+            return;
+        throw new Error(`task content conflict at ${path.relative(path.dirname(source), source)}`);
+    }
+    if (sourceStat.isSymbolicLink()) {
+        fs.symlinkSync(fs.readlinkSync(source), target);
+        return;
+    }
+    if (sourceStat.isDirectory()) {
+        fs.mkdirSync(target, { mode: sourceStat.mode & 0o777 });
+        for (const name of fs.readdirSync(source).sort())
+            copyTaskEntry(path.join(source, name), path.join(target, name));
+        fs.chmodSync(target, sourceStat.mode & 0o777);
+        return;
+    }
+    if (!sourceStat.isFile())
+        throw new Error(`unsupported task entry: ${source}`);
+    fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL);
+    fs.chmodSync(target, sourceStat.mode & 0o777);
+}
+function transferTaskContents(sourcePath, targetPath) {
+    const sourceRoot = fs.lstatSync(sourcePath);
+    if (!sourceRoot.isDirectory() || sourceRoot.isSymbolicLink())
+        throw new Error('task source is not a real directory');
+    const targetRoot = fs.lstatSync(targetPath);
+    if (!targetRoot.isDirectory() || targetRoot.isSymbolicLink())
+        throw new Error('completed target is not a real directory');
+    for (const name of fs.readdirSync(sourcePath).sort()) {
+        copyTaskEntry(path.join(sourcePath, name), path.join(targetPath, name));
+    }
+    const sourceNames = fs.readdirSync(sourcePath).sort();
+    const targetNames = fs.readdirSync(targetPath).sort();
+    if (sourceNames.join('\0') !== targetNames.join('\0')
+        || !sourceNames.every((name) => sameTaskEntry(path.join(sourcePath, name), path.join(targetPath, name)))) {
+        throw new Error('completed target does not match task source after copy');
+    }
+}
+function targetContainsTask(targetPath, taskId, request) {
+    try {
+        const stat = fs.lstatSync(targetPath);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return false;
+        const entries = fs.readdirSync(targetPath);
+        if (entries.length === 0)
+            return true;
+        const taskPath = path.join(targetPath, 'task.md');
+        const journalPath = path.join(targetPath, '.task-lifecycle.json');
+        if (!fs.existsSync(taskPath) || !fs.existsSync(journalPath))
+            return false;
+        const frontmatter = parseTypedTaskFrontmatter(fs.readFileSync(taskPath, 'utf8'));
+        const journal = parseJournal(fs.readFileSync(journalPath, 'utf8'));
+        return frontmatter.id === taskId && frontmatter.status === 'completed'
+            && journal.taskId === taskId && journal.intent === request.intent
+            && journal.intentDigest === intentIdentity(request, taskId);
+    }
+    catch {
+        return false;
+    }
+}
 function actionAndNote(request, restoredFiles = 0) {
     if (request.intent === 'block')
         return { action: 'Block Task', note: request.reason };
@@ -366,7 +468,7 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
             || journal.intentDigest !== intentIdentity(request, taskId)
             || journal.sourceState !== 'active' || journal.targetState !== 'completed')
             return 'unknown';
-        if (journal.completedSteps.some((step, index) => STEPS[index] !== step))
+        if (journal.completedSteps.some((step, index) => stepsForIntent(journal.intent)[index] !== step))
             return 'unknown';
         const directoryMoved = journal.completedSteps.includes('directory-moved');
         const registryCommitted = journal.completedSteps.includes('registry-committed');
@@ -374,7 +476,7 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
         if (state === 'active' && (directoryMoved || !hasShortId))
             return 'unknown';
         if (state === 'completed' && (!journal.completedSteps.includes('task-written')
-            || !matchingCompletion(content, request) || (registryCommitted && hasShortId)))
+            || !matchingCompletion(content, request) || registryCommitted || !hasShortId))
             return 'unknown';
         if (frontmatter.status !== state
             && !(state === 'active' && frontmatter.status === 'completed' && matchingCompletion(content, request))) {
@@ -386,66 +488,7 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
         return 'unknown';
     }
 }
-function directoryManifest(root) {
-    const entries = [];
-    const visit = (current, relative = '') => {
-        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
-            const relativePath = relative ? path.join(relative, entry.name) : entry.name;
-            const absolute = path.join(current, entry.name);
-            const stat = fs.lstatSync(absolute);
-            if (stat.isSymbolicLink())
-                throw new Error(`symbolic link is not allowed in lifecycle directory: ${relativePath}`);
-            if (entry.isDirectory()) {
-                entries.push({ relativePath, kind: 'directory', size: 0, digest: '' });
-                visit(absolute, relativePath);
-            }
-            else if (entry.isFile()) {
-                const digest = createHash('sha256').update(fs.readFileSync(absolute)).digest('hex');
-                entries.push({ relativePath, kind: 'file', size: stat.size, digest });
-            }
-            else {
-                throw new Error(`unsupported lifecycle directory entry: ${relativePath}`);
-            }
-        }
-    };
-    visit(root);
-    return entries;
-}
-function copyDirectoryVerified(source, target) {
-    if (fs.existsSync(target))
-        throw new Error(`target directory already exists: ${target}`);
-    const copy = (currentSource, currentTarget) => {
-        fs.mkdirSync(currentTarget);
-        for (const entry of fs.readdirSync(currentSource, { withFileTypes: true })) {
-            const sourcePath = path.join(currentSource, entry.name);
-            const targetPath = path.join(currentTarget, entry.name);
-            const stat = fs.lstatSync(sourcePath);
-            if (stat.isSymbolicLink())
-                throw new Error(`symbolic link is not allowed in lifecycle directory: ${entry.name}`);
-            if (entry.isDirectory())
-                copy(sourcePath, targetPath);
-            else if (entry.isFile())
-                fs.copyFileSync(sourcePath, targetPath);
-            else
-                throw new Error(`unsupported lifecycle directory entry: ${entry.name}`);
-        }
-    };
-    copy(source, target);
-    const sourceManifest = directoryManifest(source);
-    const targetManifest = directoryManifest(target);
-    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
-        throw new Error('copied lifecycle directory failed manifest verification');
-    }
-}
-function removeCopiedSource(source, target) {
-    const sourceManifest = directoryManifest(source);
-    const targetManifest = directoryManifest(target);
-    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
-        throw new Error('lifecycle source and target diverged before source cleanup');
-    }
-    fs.rmSync(source, { recursive: true, force: false });
-}
-function applyTaskLifecycle(requestInput, options = {}) {
+function applyTaskLifecycleUnlocked(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' });
     }
@@ -469,7 +512,12 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     const spec = transition(request);
     const hot = locateHotTaskDirs(repoRoot, taskId);
-    if (hot.length > 1)
+    const activeSource = hot.find((candidate) => candidate.state === 'active');
+    const completedTarget = hot.find((candidate) => candidate.state === 'completed');
+    const transferInProgress = request.intent === 'complete' && Boolean(activeSource && completedTarget)
+        && targetContainsTask(completedTarget.taskDir, taskId, request)
+        && fs.existsSync(path.join(activeSource.taskDir, '.task-lifecycle.json'));
+    if (hot.length > 1 && !transferInProgress)
         return failed(request, { code: 'LIFECYCLE_IDENTITY_CONFLICT', message: `task ${taskId} exists in multiple hot states` }, { taskId });
     let sourceState;
     let sourcePath;
@@ -482,6 +530,11 @@ function applyTaskLifecycle(requestInput, options = {}) {
         sourcePath = validation.stagingDir;
         restoredFiles = validation.fileCount;
     }
+    else if (activeSource && request.intent === 'complete') {
+        sourceState = activeSource.state;
+        sourcePath = activeSource.taskDir;
+        restoredFiles = fs.readdirSync(sourcePath).filter((name) => !name.startsWith('.')).length;
+    }
     else if (hot[0]) {
         sourceState = hot[0].state;
         sourcePath = hot[0].taskDir;
@@ -491,6 +544,39 @@ function applyTaskLifecycle(requestInput, options = {}) {
         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 requiredSteps = stepsForIntent(request.intent);
+    const movingTaskDirectory = sourcePath !== targetPath;
+    const assertRuntimeMoveSafe = () => {
+        if (!movingTaskDirectory)
+            return null;
+        const controlManifest = path.join(sourcePath, '.runtime', 'sandbox-control', 'manifest.json');
+        const controlLease = path.join(sourcePath, '.runtime', 'sandbox-control', 'lease.json');
+        if (request.intent !== 'complete' && (fs.existsSync(controlManifest) || fs.existsSync(controlLease))) {
+            return {
+                code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
+                message: 'task-bound sandbox control state exists; stop and remove the verified sandbox before moving the task directory'
+            };
+        }
+        const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
+        if (fs.existsSync(orchestrationPath)) {
+            try {
+                const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8'));
+                if (run.status === 'running' || run.pendingDelegation !== null && run.pendingDelegation !== undefined) {
+                    return {
+                        code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
+                        message: 'task orchestration has an active or pending delegation; settle it before moving the task directory'
+                    };
+                }
+            }
+            catch {
+                return {
+                    code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE',
+                    message: 'task orchestration state is unreadable; refusing to move the task directory'
+                };
+            }
+        }
+        return null;
+    };
     const currentTaskFile = path.join(sourcePath, 'task.md');
     const existingJournal = fs.existsSync(path.join(sourcePath, '.task-lifecycle.json'));
     if (sourceState === spec.target && !existingJournal) {
@@ -500,7 +586,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
             return {
                 ...failed(request, { code: '', message: '' }), status: 'no-op', error: null, taskId,
                 sourceState, targetState: spec.target, sourcePath, targetPath, pendingSteps: [],
-                completedSteps: STEPS, timestamp: typeof frontmatter.updated_at === 'string' ? frontmatter.updated_at : null,
+                completedSteps: requiredSteps, timestamp: typeof frontmatter.updated_at === 'string' ? frontmatter.updated_at : null,
                 agentInfraVersion: typeof frontmatter.agent_infra_version === 'string' ? frontmatter.agent_infra_version : null
             };
         }
@@ -509,9 +595,13 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (!spec.sources.includes(sourceState) && !existingJournal) {
         return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal) {
+    if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal
+        && !(request.intent === 'complete' && targetContainsTask(targetPath, taskId, request))) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
+    const moveSafety = assertRuntimeMoveSafe();
+    if (moveSafety)
+        return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     const content = io.readFileSync(currentTaskFile);
     let frontmatter;
     try {
@@ -538,7 +628,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     const registry = JSON.parse(registryRequest.output || '{"version":1,"ids":{}}');
     const registeredKey = Object.entries(registry.ids).find(([, candidate]) => candidate === taskId)?.[0];
-    if (spec.registry === 'release' && sourceState === 'active' && !registeredKey) {
+    if ((spec.registry === 'release' || request.intent === 'complete') && sourceState === 'active' && !registeredKey) {
         return failed(request, { code: 'LIFECYCLE_SHORT_ID_PRECONDITION', message: 'active source has no short-id registry entry' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1) {
@@ -563,7 +653,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         if (request.dryRun) {
             if (!journal.failure)
                 return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
-            return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: STEPS.filter((step) => !journal.completedSteps.includes(step)) });
+            return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: requiredSteps.filter((step) => !journal.completedSteps.includes(step)) });
         }
         if (journal.intentDigest !== digest)
             return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
@@ -614,7 +704,8 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (sourceState === spec.target && journal.sourceState !== spec.target)
         completed.add('directory-moved');
     const currentMappings = loadShortIdByTaskId(repoRoot);
-    if ((spec.target === 'active' && currentMappings.has(taskId)) || (spec.target !== 'active' && !currentMappings.has(taskId))) {
+    if (requiredSteps.includes('registry-committed')
+        && ((spec.target === 'active' && currentMappings.has(taskId)) || (spec.target !== 'active' && !currentMappings.has(taskId)))) {
         if (completed.has('directory-moved'))
             completed.add('registry-committed');
     }
@@ -626,7 +717,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
             task: { operations: [] }, directory: { effect: 'unchanged', changed: false },
             shortId: { effect: 'unchanged', shortId: null, changed: false },
             timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion,
-            journalPath, completedSteps: [...completed], pendingSteps: STEPS.filter((step) => !completed.has(step))
+            journalPath, completedSteps: [...completed], pendingSteps: requiredSteps.filter((step) => !completed.has(step))
         };
     }
     if (matchingCompletion(io.readFileSync(path.join(sourcePath, 'task.md')), request, restoredFiles))
@@ -660,48 +751,42 @@ function applyTaskLifecycle(requestInput, options = {}) {
             task: { operations: taskOperations }, directory: { effect: 'unchanged', changed: false },
             shortId: { effect: 'unchanged', shortId: null, changed: false },
             timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion,
-            journalPath, completedSteps: [...completed], pendingSteps: STEPS.filter((step) => !completed.has(step))
+            journalPath, completedSteps: [...completed], pendingSteps: requiredSteps.filter((step) => !completed.has(step))
         };
     }
-    if (fs.existsSync(targetPath) && !fs.existsSync(sourcePath))
+    if (fs.existsSync(targetPath) && !fs.existsSync(path.join(sourcePath, 'task.md')))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {
+        const moveSafety = assertRuntimeMoveSafe();
+        if (moveSafety)
+            return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0, timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-        if (fs.existsSync(targetPath))
-            return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
-        try {
-            (options.directoryRenameSync ?? io.renameSync)(sourcePath, targetPath);
-        }
-        catch (error) {
-            if (error.code === 'EXDEV') {
-                try {
-                    copyDirectoryVerified(sourcePath, targetPath);
-                    completed.add('directory-moved');
-                    journal.completedSteps = [...completed];
-                    const copiedJournalPath = path.join(targetPath, '.task-lifecycle.json');
-                    writeJournal(initialJournalPath, journal, io);
-                    writeJournal(copiedJournalPath, journal, io);
-                    removeCopiedSource(sourcePath, targetPath);
-                    journalPath = copiedJournalPath;
+        if (request.intent === 'complete') {
+            try {
+                if (!fs.existsSync(targetPath))
+                    fs.mkdirSync(targetPath, { recursive: false, mode: 0o700 });
+                if (!targetContainsTask(targetPath, taskId, request)) {
+                    throw new Error('completed target has no matching task identity');
                 }
-                catch (copyError) {
-                    if (fs.existsSync(targetPath))
-                        fs.rmSync(targetPath, { recursive: true, force: false });
-                    const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(copyError) };
-                    rememberJournalFailure(initialJournalPath, journal, io, failure);
-                    return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+                transferTaskContents(sourcePath, targetPath);
+                for (const name of fs.readdirSync(sourcePath).filter((entry) => entry !== '.task-lifecycle.json' && entry !== 'task.md').sort()) {
+                    fs.rmSync(path.join(sourcePath, name), { recursive: true, force: false });
                 }
+                fs.rmSync(path.join(sourcePath, 'task.md'), { force: false });
+                fs.rmSync(path.join(sourcePath, '.task-lifecycle.json'), { force: false });
             }
-            else {
-                const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
-                rememberJournalFailure(journalPath, journal, io, failure);
-                return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            catch (error) {
+                const failure = { code: 'LIFECYCLE_DIRECTORY_TRANSFER_FAILED', message: String(error) };
+                const sourceJournalPath = path.join(sourcePath, '.task-lifecycle.json');
+                rememberJournalFailure(sourceJournalPath, journal, io, failure);
+                return failed(request, failure, {
+                    taskId, sourceState, targetState: spec.target, sourcePath, targetPath,
+                    journalPath: sourceJournalPath, task: { operations: taskOperations },
+                    changed: true, completedSteps: [...completed].filter((step) => step !== 'directory-moved'),
+                    pendingSteps: requiredSteps.filter((step) => !completed.has(step) || step === 'directory-moved'),
+                    timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion
+                });
             }
-        }
-        if (completed.has('directory-moved') && !fs.existsSync(sourcePath)) {
-            journalPath = path.join(targetPath, '.task-lifecycle.json');
-        }
-        else if (!completed.has('directory-moved')) {
             completed.add('directory-moved');
             journal.completedSteps = [...completed];
             journalPath = path.join(targetPath, '.task-lifecycle.json');
@@ -709,23 +794,58 @@ function applyTaskLifecycle(requestInput, options = {}) {
                 writeJournal(journalPath, journal, io);
             }
             catch (error) {
-                return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+                return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, {
+                    taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath,
+                    task: { operations: taskOperations }, directory: { effect: 'move', changed: true },
+                    changed: true, completedSteps: [...completed].filter((step) => step !== 'directory-moved'),
+                    pendingSteps: requiredSteps.filter((step) => step !== 'task-written'),
+                    timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion
+                });
+            }
+        }
+        else {
+            if (fs.existsSync(targetPath))
+                return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            try {
+                (options.directoryRenameSync ?? io.renameSync)(sourcePath, targetPath);
+            }
+            catch (error) {
+                const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
+                rememberJournalFailure(journalPath, journal, io, failure);
+                return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            }
+            if (completed.has('directory-moved') && !fs.existsSync(sourcePath)) {
+                journalPath = path.join(targetPath, '.task-lifecycle.json');
+            }
+            else if (!completed.has('directory-moved')) {
+                completed.add('directory-moved');
+                journal.completedSteps = [...completed];
+                journalPath = path.join(targetPath, '.task-lifecycle.json');
+                try {
+                    writeJournal(journalPath, journal, io);
+                }
+                catch (error) {
+                    return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+                }
             }
         }
     }
-    if (completed.has('directory-moved') && sourcePath !== targetPath && fs.existsSync(sourcePath) && fs.existsSync(targetPath)) {
+    const activeTaskPath = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+    if (request.intent === 'complete' && fs.existsSync(activeTaskPath)) {
         try {
-            removeCopiedSource(sourcePath, targetPath);
-            journalPath = path.join(targetPath, '.task-lifecycle.json');
+            fs.rmdirSync(activeTaskPath);
         }
         catch (error) {
-            const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(error) };
-            rememberJournalFailure(journalPath, journal, io, failure);
-            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            return failed(request, { code: 'LIFECYCLE_SOURCE_DIRECTORY_CLEANUP_FAILED', message: String(error) }, {
+                taskId, sourceState, targetState: spec.target, sourcePath: activeTaskPath, targetPath, journalPath,
+                task: { operations: taskOperations }, directory: { effect: 'move', changed: true },
+                changed: true, completedSteps: [...completed], pendingSteps: [],
+                timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion
+            });
         }
     }
-    let shortId = { effect: 'unchanged', shortId: null, changed: false };
-    if (!completed.has('registry-committed')) {
+    let shortId = { effect: 'unchanged', shortId: request.intent === 'complete' ? registeredKey ?? null : null, changed: false };
+    if (requiredSteps.includes('registry-committed') && !completed.has('registry-committed')) {
         try {
             shortId = mutateShortIdRegistry(repoRoot, taskId, spec.registry);
         }
@@ -744,7 +864,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     const mappings = loadShortIdByTaskId(repoRoot);
     if (spec.target === 'active' && !mappings.has(taskId))
         return failed(request, { code: 'LIFECYCLE_FINAL_STATE_INVALID', message: 'active lifecycle target has no short id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, changed: true, completedSteps: [...completed], pendingSteps: [], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
-    if (spec.target !== 'active' && mappings.has(taskId))
+    if (request.intent !== 'complete' && spec.target !== 'active' && mappings.has(taskId))
         return failed(request, { code: 'LIFECYCLE_FINAL_STATE_INVALID', message: 'non-active lifecycle target retained a short id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, changed: true, completedSteps: [...completed], pendingSteps: [], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
     try {
         io.unlinkSync(journalPath);
@@ -760,5 +880,44 @@ function applyTaskLifecycle(requestInput, options = {}) {
         journalPath, completedSteps: [...completed], pendingSteps: []
     };
 }
-export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle, previewTaskCompletion };
+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 };
 //# sourceMappingURL=lifecycle.js.map