@fitlab-ai/agent-infra 0.11.14 → 0.12.0

package/lib/task/events.ts

@@ -31,7 +31,6 @@ import { findSectionHeading } from './sections.ts';
 import { validateLifecycleExecution } from './lifecycle-execution.ts';
 import { commitOrchestrationStageCompletion } from './orchestration.ts';
 import type { OrchestrationStageCompletion } from './orchestration.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from './write.ts';
 import { validateLocalArtifact } from './local-artifact-finalization.ts';
@@ -86,7 +85,6 @@ type TaskEventRequest = {
 type TaskEventError = { code: TaskEventErrorCode; message: string };
 type TaskEventOptions = TaskWriteOptions & {
   commitOrchestrationCompletion?: (plan: OrchestrationStageCompletion) => void;
-  lockAlreadyHeld?: boolean;
 };
 type TaskEventResult = {
   status: 'planned' | 'applied' | 'no-op' | 'failed'; changed: boolean;
@@ -519,6 +517,7 @@ function reworkIntentMutationForCompletion(
 function buildCompletionReceipt(
   content: string,
   taskDir: string,
+  repositoryRoot: string | undefined,
   family: EventFamily,
   artifact: ArtifactIdentity,
   completedAt: string,
@@ -527,7 +526,7 @@ function buildCompletionReceipt(
 ): { ok: true; receipts: readonly ArtifactReceipt[] } | { ok: false; message: string } | null {
   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}` };
   }
   const event = family === 'analyze' ? 'analysis.completed'
@@ -627,7 +626,7 @@ function replaceCompletionFact(facts: readonly CompletionFact[], next: Completio
   return [...facts.filter((fact) => !(fact.event === next.event && fact.output === next.output)), next];
 }
 
-function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOptions = {}): TaskEventResult {
+function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {}): TaskEventResult {
   const invalid = validateTaskEventRequest(request);
   if (invalid) return failed(request, invalid);
   const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
@@ -757,7 +756,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   }
   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);
     const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
@@ -804,7 +803,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   let currentFact: CompletionFact | null = null;
   let completionRework: ReturnType<typeof reworkIntentMutation> | null = 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 });
     }
@@ -978,32 +977,6 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   };
 }
 
-function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {}): TaskEventResult {
-  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: TaskEventRequest, taskId: string, taskMdPath: string, currentStep: string,
   eventIdentity: ReturnType<typeof identity>, timestamp: string,

package/lib/task/finalization.ts

@@ -14,7 +14,6 @@ import { parseTaskFrontmatter } from './frontmatter.ts';
 import { recoverPlatformOperations } from './platform-operation-recovery.ts';
 import {
   applyTaskLifecycle,
-  applyTaskLifecycleWithinTaskLock,
   inspectTaskLifecycleProgress,
   type TaskLifecycleOptions,
   type TaskLifecycleRequest,
@@ -24,7 +23,6 @@ import {
 } from './lifecycle.ts';
 import { enumerateAllTaskDirs, resolveTaskRef } from './resolve-ref.ts';
 import { inspectShortIdRegistry } from './short-id.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
 import type { TaskVerificationResult } from './verification.ts';
 import { projectFinalizationWarning } from './workflow-warning-intents.ts';
@@ -586,7 +584,7 @@ function mutationPatch(current: TaskFinalizationReceipt, mutation: FinalizationM
     : { warningProjection: 'pending', lastError: mutation.error };
 }
 
-function applyFinalizationReceiptMutationUnderLock(
+function mutateFinalizationReceipt(
   repoRoot: string,
   receipt: TaskFinalizationReceipt,
   capability: FinalizationCapability,
@@ -615,9 +613,7 @@ function applyFinalizationReceiptMutation(
   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<string>())
-  );
+  return mutateFinalizationReceipt(repoRoot, receipt, capability, mutation, new Set<string>());
 }
 
 function warningKey(warning: Pick<FinalizationWarning, 'step' | 'code' | 'target'>): string {
@@ -640,20 +636,20 @@ function reconcileWarningProjection(repoRoot: string, taskId: string, receipt: T
           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; }
     }
   }
   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; }
 }
@@ -692,7 +688,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);
@@ -708,7 +704,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);
@@ -717,7 +713,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);
@@ -863,14 +859,14 @@ function preparedResult(
   };
 }
 
-async function prepareUnderLock(
+async function prepareTaskFinalizationCore(
   request: TaskFinalizationRequest,
   taskId: string,
   options: TaskFinalizationOptions
 ): Promise<TaskFinalizationResult> {
   const repoRoot = path.resolve(options.repoRoot);
   const lifecycle = options.lifecycle ?? ((lifecycleRequest, lifecycleOptions) => (
-    applyTaskLifecycleWithinTaskLock(lifecycleRequest, lifecycleOptions ?? { repoRoot }, taskId)
+    applyTaskLifecycle(lifecycleRequest, lifecycleOptions ?? { repoRoot })
   ));
   const backfill = options.backfill ?? backfillCompletionComments;
   const commentSync = options.commentSync ?? syncPlatformComment;
@@ -1142,11 +1138,9 @@ async function prepareTaskFinalization(request: TaskFinalizationRequest, options
   const resolved = resolveTaskRef(request.taskRef, { repoRoot });
   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);
   }
 }
@@ -1159,7 +1153,7 @@ async function commitPreparedTaskFinalization(request: TaskFinalizationRequest,
   const resolved = resolveTaskRef(request.taskRef, { repoRoot });
   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);
@@ -1223,7 +1217,7 @@ async function commitPreparedTaskFinalization(request: TaskFinalizationRequest,
       };
       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 });
@@ -1305,11 +1299,9 @@ async function commitPreparedTaskFinalization(request: TaskFinalizationRequest,
         });
       }
       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/lib/task/lifecycle.ts

@@ -18,7 +18,7 @@ import { validateCurrentTaskContract } from './current-contract.ts';
 import { isValidAgentInfraVersion } from '../version.ts';
 import { taskIssueIdentity } from '../platform/task-identities.ts';
 import { resourceIdentityEquals } from '../platform/resource-identity.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 const lifecycleIntentCatalog = [
   'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
@@ -103,6 +103,9 @@ type LifecycleFileSystem = {
   readFileSync: (file: string) => string;
   writeFileSync: (file: string, content: string, flag?: string) => void;
   unlinkSync: (file: string) => void;
+  rmdirSync: (directory: string) => void;
+  readdirSync: (directory: string) => string[];
+  readMountInfoSync: () => string;
 };
 type TaskLifecycleOptions = {
   repoRoot?: string;
@@ -127,9 +130,25 @@ const DEFAULT_IO: LifecycleFileSystem = {
   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: string, mountInfo: string): boolean {
+  const decodeMountInfoPath = (value: string): string => value.replace(/\\([0-7]{3})/gu, (_match, octal: string) => 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: Pick<TaskLifecycleRequest, 'taskRef' | 'intent'>, error: LifecycleError, extra: Partial<TaskLifecycleResult> = {}): TaskLifecycleResult {
   return {
     status: 'failed', changed: false, requestRef: request.taskRef, taskId: null,
@@ -418,14 +437,14 @@ function validateRestoreStaging(request: Extract<TaskLifecycleRequest, { intent:
   let workspace: string;
   let stagingDir: string;
   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) {
     return { code: 'LIFECYCLE_STAGING_INVALID', message: String(error) };
   }
   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: fs.Dirent[];
   try { entries = fs.readdirSync(stagingDir, { withFileTypes: true }); }
@@ -610,7 +629,7 @@ export function inspectTaskLifecycleProgress(
   }
 }
 
-function applyTaskLifecycleUnlocked(requestInput: TaskLifecycleRequest, options: TaskLifecycleOptions = {}): TaskLifecycleResult {
+function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLifecycleOptions = {}): TaskLifecycleResult {
   if (requestInput.intent === 'recover-started') {
     return failed(requestInput, { code: 'LIFECYCLE_RECOVERY_REQUIRES_AUTHORITY', message: 'recover-started must be dispatched through task control authority' });
   }
@@ -652,7 +671,7 @@ function applyTaskLifecycleUnlocked(requestInput: TaskLifecycleRequest, 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');
@@ -690,7 +709,7 @@ function applyTaskLifecycleUnlocked(requestInput: TaskLifecycleRequest, options:
     if (!contract.ok) 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') {
@@ -861,9 +880,20 @@ function applyTaskLifecycleUnlocked(requestInput: TaskLifecycleRequest, 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); }
+    try {
+      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) }, {
         taskId, sourceState, targetState: spec.target, sourcePath: activeTaskPath, targetPath, journalPath,
@@ -895,50 +925,9 @@ function applyTaskLifecycleUnlocked(requestInput: TaskLifecycleRequest, options:
   };
 }
 
-function applyTaskLifecycle(request: TaskLifecycleRequest, options: TaskLifecycleOptions = {}): TaskLifecycleResult {
-  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: TaskLifecycleRequest,
-  options: TaskLifecycleOptions,
-  lockedTaskId: string
-): TaskLifecycleResult {
-  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 as const, 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
+  applyTaskLifecycle, previewTaskCompletion
 };
 export type {
   TaskLifecycleIntent, TaskLifecycleRequest, TaskLifecycleResult, TaskLifecycleOptions,

package/lib/task/local-artifact-finalization.ts

@@ -52,7 +52,6 @@ type LocalArtifactFinalizationRequest = {
   artifact: string;
   repoRoot?: string;
   requiredSections?: readonly string[];
-  lockAlreadyHeld?: boolean;
 };
 
 type LocalArtifactFinalizationResult = {
@@ -129,7 +128,6 @@ type LocalArtifactPreparation = Readonly<{
   result: LocalArtifactFinalizationResult;
   content: string;
   repoRoot?: string;
-  lockAlreadyHeld?: boolean;
 }>;
 
 function prepareLocalArtifact(
@@ -180,8 +178,7 @@ function prepareLocalArtifact(
   return {
     result: validation.ok && !qualificationError ? { ...result, status: 'passed', error: null } : result,
     content,
-    repoRoot: resolved.repoRoot,
-    lockAlreadyHeld: request.lockAlreadyHeld
+    repoRoot: resolved.repoRoot
   };
 
 }