@fitlab-ai/agent-infra 0.11.15 → 0.12.1

package/lib/task/control-authority.ts

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
@@ -29,8 +30,6 @@ import {
 } from './finalization.ts';
 import {
   applyTaskLifecycle,
-  applyTaskLifecycleWithinTaskLock,
-  taskLifecycleFailure,
   type TaskLifecycleRequest,
   type TaskLifecycleResult
 } from './lifecycle.ts';
@@ -39,8 +38,8 @@ import type {
   AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
 } from '../agent-clients/adapter.ts';
 import { resolveTaskContext, resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
+import { releaseStaleShortIdRegistry } from './short-id.ts';
 
 export type TaskControlExecutionContext =
   | Readonly<{
@@ -215,7 +214,7 @@ async function applyLifecycleWithAuthority(
 ): Promise<TaskLifecycleResult | LifecycleRecoveryResult> {
   const taskId = lifecycleTaskId(request, context.repoRoot);
   const controlRoot = taskId ? controlRootForTask(context, taskId) : undefined;
-  const execute = async (underTaskLock = false): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
+  const execute = async (): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
     if (request.intent === 'recover-started') {
       const adapter = isAgentClientId(request.agent)
         ? getAgentClientAdapter(request.agent).orchestrationAdapter
@@ -229,38 +228,13 @@ async function applyLifecycleWithAuthority(
       }
       return adapter.recoverStarted(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
     }
-    return underTaskLock
-      ? applyTaskLifecycleWithinTaskLock(request, {
-        repoRoot: context.repoRoot,
-        ...(controlRoot ? { controlRoot } : {}),
-        ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
-      }, taskId!)
-      : applyTaskLifecycle(request, {
-        repoRoot: context.repoRoot,
-        ...(controlRoot ? { controlRoot } : {}),
-        ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
-      });
+    return applyTaskLifecycle(request, {
+      repoRoot: context.repoRoot,
+      ...(controlRoot ? { controlRoot } : {}),
+      ...(context.source === 'direct-host' && context.project ? { controlProject: context.project } : {})
+    });
   };
-  if (!taskId) return await execute();
-  try {
-    return await withTaskExecutionLock(
-      context.repoRoot,
-      taskId,
-      `task-lifecycle.${request.intent}`,
-      () => execute(true)
-    );
-  } catch (error) {
-    if (!(error instanceof TaskExecutionLockError)) throw error;
-    if (request.intent === 'recover-started') {
-      return {
-        status: 'owner-unknown', changed: false, targetState: 'active',
-        requestRef: request.taskRef, intent: 'recover-started', taskId,
-        receiptId: null, childId: null,
-        error: { code: error.code, message: error.message }
-      };
-    }
-    return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
-  }
+  return await execute();
 }
 
 function controlRootForTask(context: TaskControlExecutionContext, taskId: string): string | undefined {
@@ -393,6 +367,26 @@ export function dispatchTaskControlOperation(
       preflight: (request, options) => verifyTaskEvent(
         { ...request, event: 'complete-task.hard-preflight' }, options
       )
+    }).then((result) => {
+      if (context.source !== 'direct-host' || !controlRoot || result.status !== 'completed' || !result.taskId) return result;
+      try {
+        if (fs.lstatSync(controlRoot, { throwIfNoEntry: false }) === undefined) {
+          const released = releaseStaleShortIdRegistry(context.repoRoot, result.taskId);
+          return { ...result, changed: result.changed || released.changed };
+        }
+        return result;
+      } catch (error) {
+        return {
+          ...result,
+          status: 'blocked',
+          result: 'blocked',
+          error: {
+            code: 'TASK_FINALIZATION_SHORT_ID_RELEASE_FAILED',
+            message: error instanceof Error ? error.message : String(error),
+            retryable: true
+          }
+        };
+      }
     });
   }
   try {

package/lib/task/create-service.ts

@@ -4,7 +4,6 @@ import type { PlatformResult } from '../platform/types.ts';
 import { VERSION } from '../version.ts';
 import { applyWorkflowWarningIntent } from './workflow-warning-intents.ts';
 import { createLocalTask, type TaskCreateCandidateV1 } from './create.ts';
-import { TaskExecutionLockError } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
 
 type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
@@ -201,9 +200,8 @@ async function createTask(value: unknown, options: CreateTaskOptions): Promise<T
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const lockBusy = error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY';
-    const code = lockBusy ? error.code : /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
-    return taskCreateFailure({ code, message, retryable: lockBusy || code === 'TASK_CREATE_LOCK_TIMEOUT' });
+    const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
+    return taskCreateFailure({ code, message, retryable: false });
   }
 
   const operations: TaskCreateOperation[] = [{

package/lib/task/create.ts

@@ -5,13 +5,13 @@ import path from 'node:path';
 
 import { isValidAgentInfraVersion, VERSION } from '../version.ts';
 import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.ts';
-import { TaskExecutionLockError, withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.ts';
 import { enumerateAllTaskDirs } from './resolve-ref.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { AGENT_TOKEN_VALUES, type AgentToken } from '../agent-clients/tokens.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'] as const;
 const PRIORITIES = ['Urgent', 'High', 'Medium', 'Low'] as const;
@@ -348,42 +348,6 @@ function ensureRealDirectory(directory: string, code: string): void {
   fs.mkdirSync(directory, { mode: 0o700 });
 }
 
-function createLockRoot(project: string): string {
-  const root = path.join(os.homedir(), '.agent-infra');
-  const directories = [root, path.join(root, 'run'), path.join(root, 'run', project), path.join(root, 'run', project, 'task-create-locks')];
-  for (const directory of directories) {
-    if (fs.existsSync(directory)) {
-      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
-      continue;
-    }
-    try {
-      fs.mkdirSync(directory, { mode: 0o700 });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-      assertRealDirectory(directory, 'TASK_CREATE_LOCK_FAILED');
-    }
-  }
-  return directories.at(-1)!;
-}
-
-function withCreateLock<T>(repoRoot: string, project: string, operation: () => T): T {
-  const lockRoot = createLockRoot(project);
-  let callbackError: unknown;
-  try {
-    return withTaskExecutionLock(repoRoot, 'task-create', 'task-create', () => {
-      try { return operation(); }
-      catch (error) { callbackError = error; throw error; }
-    }, { lockRoot, identityScope: `task-create\0${project}` });
-  } catch (error) {
-    if (callbackError !== undefined) throw callbackError;
-    if (error instanceof TaskExecutionLockError && error.code === 'ORCHESTRATION_LOCK_BUSY') {
-      throw new Error('TASK_CREATE_LOCK_TIMEOUT');
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`TASK_CREATE_LOCK_FAILED: ${message}`);
-  }
-}
-
 function recoverPublishedTask(repoRoot: string, keyDigest: string, candidateDigest: string): { taskId: string; shortId: string | null; state: 'active' | 'blocked' | 'completed' | 'archive' } | null {
   for (const task of enumerateAllTaskDirs(repoRoot)) {
     const taskMd = path.join(task.taskDir, 'task.md');
@@ -410,16 +374,22 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     throw new Error('TASK_CREATE_VERSION_INVALID: agentInfraVersion must be a valid v-prefixed semver');
   }
   const repoRoot = fs.realpathSync.native(options.repoRoot);
-  const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
+  const workspaceRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
   const activeRoot = path.join(workspaceRoot, 'active');
   ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+  const home = path.resolve(process.env.HOME || os.homedir());
+  const managedRoots = [path.join(home, '.agent-infra'), path.join(home, '.agent-infra', 'task-workspaces')];
+  for (const root of managedRoots) {
+    if (fs.existsSync(root)) assertRealDirectory(root, 'TASK_CREATE_WORKSPACE_INVALID');
+    else fs.mkdirSync(root, { mode: 0o700 });
+  }
   ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   const projectConfig = readProject(repoRoot);
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);
   const keyDigest = sha256(candidate.idempotencyKey);
-  function createUnderRepositoryLock(): LocalTaskCreateResult {
+  function createOnce(): LocalTaskCreateResult {
     const recovered = recoverPublishedTask(repoRoot, keyDigest, candidateDigest);
     if (recovered) {
       return { status: 'no-op', changed: false, task: { id: recovered.taskId, shortId: recovered.shortId, state: recovered.state } };
@@ -451,18 +421,7 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
     return { status: 'applied', changed: true, task: { id: taskId, shortId: allocated.shortId, state: 'active' } };
   }
 
-  return withCreateLock(repoRoot, projectConfig.project, () => {
-    let callbackError: unknown;
-    try {
-      return withRepositoryMutationLock(repoRoot, () => {
-        try { return createUnderRepositoryLock(); }
-        catch (error) { callbackError = error; throw error; }
-      });
-    } catch (error) {
-      if (callbackError !== undefined) throw callbackError;
-      throw error;
-    }
-  });
+  return createOnce();
 
 }
 

package/lib/task/delegation-receipts.ts

@@ -263,7 +263,7 @@ function validateSealRequest(
 
 function validateReviewerSealPaths(receipt: DelegationReceipt, changedPaths: readonly string[]): ReceiptFailure | null {
   if (receipt.role !== 'reviewer') return null;
-  const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
+  const taskRoot = `task-workspace/active/${receipt.taskId}/`;
   const allowed = new Set([
     `${taskRoot}${receipt.artifact}`,
     `${taskRoot}task.md`,

package/lib/task/delivery.ts

@@ -6,7 +6,6 @@ import { parseTaskFrontmatter } from './frontmatter.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
-import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 
 export type DeliveryState = 'absent' | 'same' | 'known-old' | 'unknown-drift';
 
@@ -50,7 +49,7 @@ function failure(taskId: string | null, code: string, message: string, retryable
   return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
 
-function deliverUnlocked(
+function deliverTaskBranchCore(
   taskId: string,
   taskDir: string,
   repoRoot: string,
@@ -108,14 +107,7 @@ function deliverUnlocked(
 function deliverTaskBranch(taskRef: string, options: { repoRoot?: string; agent: string; remote?: string; baseRef?: string; dryRun?: boolean }): TaskBranchDeliveryResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failure(resolved.taskId, resolved.code, resolved.message);
-  try {
-    return withRepositoryMutationLock(resolved.repoRoot, () => withTaskExecutionLock(
-      resolved.repoRoot, resolved.taskId, 'task-delivery',
-      () => deliverUnlocked(resolved.taskId, resolved.taskDir, resolved.repoRoot, options)
-    ));
-  } catch (error) {
-    return failure(resolved.taskId, 'DELIVERY_LOCK_FAILED', error instanceof Error ? error.message : String(error), true, 'blocked');
-  }
+  return deliverTaskBranchCore(resolved.taskId, resolved.taskDir, resolved.repoRoot, options);
 }
 
 export { classifyDeliveryState, deliverTaskBranch };

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';
@@ -35,6 +33,7 @@ import {
 } from './operation-outcome.ts';
 import { readSandboxControlManifest } from '../sandbox/control/lifecycle.ts';
 import { validateSandboxControlIdentity } from '../sandbox/control/identity-sentinel.ts';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent } from '../platform/issue-summary-content.ts';
 
 const RECEIPT_VERSION = 4 as const;
 const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'] as const;
@@ -586,7 +585,7 @@ function mutationPatch(current: TaskFinalizationReceipt, mutation: FinalizationM
     : { warningProjection: 'pending', lastError: mutation.error };
 }
 
-function applyFinalizationReceiptMutationUnderLock(
+function mutateFinalizationReceipt(
   repoRoot: string,
   receipt: TaskFinalizationReceipt,
   capability: FinalizationCapability,
@@ -615,9 +614,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 +637,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 +689,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 +705,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 +714,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);
@@ -734,16 +731,20 @@ function readDeliverySummary(taskDir: string, taskId: string): { body: string; s
   } catch {
     throw Object.assign(new Error('delivery summary staging record is unavailable'), { code: 'SUMMARY_STAGING_INVALID' });
   }
-  if (value.taskId !== taskId || typeof value.body !== 'string' || typeof value.sha256 !== 'string') {
+  if (value.taskId !== taskId || !value.content || typeof value.contentSha256 !== 'string') {
     throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
   }
-  const canonical = canonicalizeSummaryBody(value.body);
-  if (!canonical.ok || canonical.value !== value.body) {
-    throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+  let content;
+  try { content = parseDeliverySummaryContent(value.content); }
+  catch { throw Object.assign(new Error('delivery summary staging payload is invalid'), { code: 'SUMMARY_STAGING_INVALID' }); }
+  if (content.taskId !== taskId || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== value.contentSha256) {
+    throw Object.assign(new Error('delivery summary staging digest does not match payload'), { code: 'SUMMARY_STAGING_INVALID' });
   }
+  const body = renderDeliverySummaryContent(content);
+  const canonical = canonicalizeSummaryBody(body);
+  if (!canonical.ok) throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
   const digest = createHash('sha256').update(canonical.value).digest('hex');
-  if (digest !== value.sha256) throw Object.assign(new Error('delivery summary staging digest does not match body'), { code: 'SUMMARY_STAGING_INVALID' });
-  return { body: canonical.value, sha256: value.sha256 };
+  return { body: canonical.value, sha256: digest };
 }
 
 async function syncPendingSummary(input: {
@@ -863,14 +864,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 +1143,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 +1158,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 +1222,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 +1304,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);
   }
 }