@fitlab-ai/agent-infra 0.11.15 → 0.12.1

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'
@@ -138,7 +138,7 @@ const DEFAULT_IO: LifecycleFileSystem = {
 
 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 = path.resolve(directory);
+  const expected = fs.realpathSync.native(directory);
   return mountInfo.split('\n').some((line) => {
     if (!line) return false;
     const fields = line.split(' ');
@@ -437,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 }); }
@@ -629,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' });
   }
@@ -671,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');
@@ -709,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') {
@@ -880,7 +880,7 @@ 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 {
       let sourceIsVirtiofsMount = false;
@@ -925,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
   };
 
 }

package/lib/task/orchestration.ts

@@ -9,6 +9,7 @@ import { parseReviewSummary } from './review-artifacts.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import type { LedgerDocument } from './ledger.ts';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
+import { resolveProjectTaskWorkspaceRoot } from './workspace-root.ts';
 import {
   activateDelegation,
   abortActivatedDelegation,
@@ -48,14 +49,13 @@ import {
 import type { RepositorySnapshot } from './workspace-snapshot.ts';
 import type { WorkspaceSnapshotContext } from './workspace-snapshot.ts';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.ts';
-import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.ts';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.ts';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.ts';
 import { hasOpenLifecycleExecution } from './activity-log.ts';
 import type { LifecycleAction, LifecycleFacts } from './capabilities.ts';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
-import { resolveArtifactContext } from './artifact-lifecycle.ts';
+import { resolveArtifactContextForResolvedTask } from './artifact-lifecycle.ts';
 
 type OrchestrationStatus = 'running' | 'paused' | 'completed';
 type ModelPolicySource = Readonly<{
@@ -441,19 +441,7 @@ function mutateDelegationAdapterEvidence(
 ): unknown {
   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);
-}
-
-function mutateDelegationAdapterEvidenceWithinTaskLock(
-  taskRef: string,
-  receiptId: string,
-  adapterId: AgentClientId,
-  mutate: (current: unknown) => unknown,
-  options: OrchestrationOptions = {}
-): unknown {
-  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);
+  return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options);
 }
 
 function mutateDelegationAdapterEvidenceAtResolved(
@@ -461,8 +449,7 @@ function mutateDelegationAdapterEvidenceAtResolved(
   receiptId: string,
   adapterId: AgentClientId,
   mutate: (current: unknown) => unknown,
-  options: OrchestrationOptions,
-  taskLockHeld: boolean
+  options: OrchestrationOptions
 ): unknown {
   const update = () => {
     try {
@@ -494,9 +481,7 @@ function mutateDelegationAdapterEvidenceAtResolved(
     }
   };
   let mutationError: unknown;
-  const result = taskLockHeld
-    ? update()
-    : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+  const result = update();
   if (mutationError) throw mutationError;
   return result;
 }
@@ -733,9 +718,13 @@ function routeFromFacts(facts: LifecycleFacts): Omit<OrchestrationNext, 'request
   return { action: command, role, stage: action };
 }
 
-function routeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-  if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
+type ResolvedTaskRef = Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>;
+
+function routeResolvedTask(
+  taskRef: string,
+  resolved: ResolvedTaskRef,
+  options: OrchestrationOptions
+): OrchestrationResult {
   let gitRoot: string;
   try {
     gitRoot = gitRootFor(resolved.repoRoot, options);
@@ -772,7 +761,8 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
     resolved.taskDir,
     content,
     resolved.state,
-    hasOpenLifecycleExecution(content) || Boolean(run?.pendingDelegation)
+    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);
@@ -864,7 +854,7 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
   }
   const action = routed.stage as LifecycleAction;
   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) {
@@ -898,6 +888,12 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
   return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
 
+function routeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
+  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: string, options: OrchestrationOptions = {}): OrchestrationResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
@@ -952,7 +948,7 @@ function validateDelegationRun(
   return null;
 }
 
-function prepareOrchestrationDelegationUnlocked(
+function prepareOrchestrationDelegation(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
@@ -978,7 +974,7 @@ function prepareOrchestrationDelegationUnlocked(
   const runFailure = validateDelegationRun(taskRef, resolved.taskId, run, 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;
   const policyFailure = validatePreparedModelPolicy(resolved.taskId, activeRun, next, input);
@@ -1010,31 +1006,7 @@ function prepareOrchestrationDelegationUnlocked(
   return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
 }
 
-function prepareOrchestrationDelegation(
-  taskRef: string,
-  input: Readonly<{
-    client: AgentClientId;
-    requestedModel?: string;
-    requestedReasoningEffort?: string;
-  }>,
-  options: OrchestrationOptions = {}
-): OrchestrationResult {
-  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(
+function dispatchOrchestrationDelegation(
   taskRef: string,
   options: OrchestrationOptions = {}
 ): OrchestrationResult {
@@ -1055,25 +1027,6 @@ function dispatchOrchestrationDelegationUnlocked(
   return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
 
-function dispatchOrchestrationDelegation(
-  taskRef: string,
-  options: OrchestrationOptions = {}
-): OrchestrationResult {
-  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;
-  }
-}
-
 type MatchingDelegationsResult =
   | Readonly<{ ok: true; matches: readonly { taskId: string; run: OrchestrationRun }[] }>
   | Readonly<{ ok: false; error: OrchestrationResult }>;
@@ -1090,7 +1043,7 @@ function matchingDelegations(
     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 }]
@@ -1385,7 +1338,7 @@ function recoverPreparedOrchestrationDelegation(
   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.recover-prepared', () => {
+    return (() => {
       const run = readRun(resolved.taskDir, options);
       const receipt = run?.pendingDelegation;
       if (!run || !receipt) {
@@ -1430,9 +1383,8 @@ function recoverPreparedOrchestrationDelegation(
       }, 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),
@@ -1462,7 +1414,7 @@ function recoveryReceiptMatches(
     && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
 }
 
-function recoverActivatedOrchestrationDelegationUnderLock(
+function recoverActivatedOrchestrationDelegation(
   taskRef: string,
   event: ActivatedRecoveryEvent,
   options: OrchestrationOptions = {}
@@ -1598,7 +1550,7 @@ function sealOrchestrationDelegation(
   const orchestrationOptions = options;
   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);
     if (expected && (run.runId !== expected.runId || run.pendingDelegation.id !== expected.receiptId)) {
@@ -1616,7 +1568,7 @@ function sealOrchestrationDelegation(
     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: string, options: OrchestrationOptions = {}): OrchestrationResult {
@@ -1672,7 +1624,6 @@ export {
   orchestrationPath,
   readDelegationAdapterEvidence,
   mutateDelegationAdapterEvidence,
-  mutateDelegationAdapterEvidenceWithinTaskLock,
   pauseMatchingOrchestrationDelegation,
   pauseOrchestration,
   planOrchestrationStageCompletion,
@@ -1680,7 +1631,7 @@ export {
   readRun,
   reconcileMatchingOrchestrationDelegation,
   recoverPreparedOrchestrationDelegation,
-  recoverActivatedOrchestrationDelegationUnderLock,
+  recoverActivatedOrchestrationDelegation,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealOrchestrationDelegation,

package/lib/task/platform-operation-recovery.ts

@@ -3,13 +3,15 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 
-import { inspectPlatformCommentOperation, normalizeCommentContent, syncPlatformComment } from '../platform/issue-comments.ts';
+import { inspectPlatformCommentOperation, syncPlatformComment } from '../platform/issue-comments.ts';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent, parseCancelSummaryContent, renderCancelSummaryContent } from '../platform/issue-summary-content.ts';
+import { enumerateArtifacts } from './artifacts.ts';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.ts';
 import { resolvePlatformProviderContext } from '../platform/context.ts';
 import { providerOperationContext, providerError, unsupportedProviderOperation } from '../platform/provider-bridge.ts';
 import { inLabelMappingDigest } from '../platform/in-label-sync.ts';
-import { bindPlatformPullRequest, inspectPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.ts';
-import { syncPullRequestSummary } from '../platform/pr-summary.ts';
+import { bindPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.ts';
+import { replayPullRequestSummary } from '../platform/pr-summary.ts';
 import { publishPrReview, readReviewBodyFile } from '../platform/pr-review.ts';
 import type { PlatformClient } from '../platform/context.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
@@ -53,33 +55,57 @@ function result(status: RecoveryResult['status'], recovered: string[], pending:
 function summaryPayload(taskDir: string, taskId: string): { body: string; sha256: string } | null {
   const file = path.join(taskDir, '.delivery-summary.json');
   if (!fs.existsSync(file)) return null;
-  const data = JSON.parse(fs.readFileSync(file, 'utf8')) as { taskId?: unknown; body?: unknown; sha256?: unknown };
-  const canonical = typeof data.body === 'string' ? canonicalizeSummaryBody(data.body) : null;
-  if (data.taskId !== taskId || typeof data.body !== 'string' || typeof data.sha256 !== 'string'
-    || !canonical?.ok || canonical.value !== data.body
-    || createHash('sha256').update(data.body).digest('hex') !== data.sha256) {
+  const data = JSON.parse(fs.readFileSync(file, 'utf8')) as { taskId?: unknown; content?: unknown; contentSha256?: unknown };
+  let content;
+  try { content = parseDeliverySummaryContent(data.content); }
+  catch { content = null; }
+  if (data.taskId !== taskId || !content || content.taskId !== taskId || typeof data.contentSha256 !== 'string'
+    || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== data.contentSha256) {
     throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
   }
-  return { body: data.body, sha256: data.sha256 };
+  const canonical = canonicalizeSummaryBody(renderDeliverySummaryContent(content));
+  if (!canonical?.ok) throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+  return { body: canonical.value, sha256: createHash('sha256').update(canonical.value).digest('hex') };
+}
+
+function cancellationPayload(taskDir: string, taskId: string): string | null {
+  const taskPath = path.join(taskDir, 'task.md');
+  if (!fs.existsSync(taskPath)) return null;
+  const taskContent = fs.readFileSync(taskPath, 'utf8');
+  const frontmatter = parseTaskFrontmatter(taskContent);
+  const title = /^#\s+(.+)$/mu.exec(taskContent)?.[1]?.trim() || taskId;
+  const artifacts = enumerateArtifacts(taskDir).filter((artifact) => artifact.name !== 'task.md').map((artifact) => artifact.name);
+  const content = parseCancelSummaryContent({
+    taskId,
+    title,
+    outcome: 'cancelled',
+    reason: frontmatter.cancel_reason,
+    cancelledAt: frontmatter.cancelled_at,
+    lastCompletedArtifact: artifacts.at(-1) ?? null
+  });
+  return renderCancelSummaryContent(content);
 }
 
 async function replayComment(taskId: string, taskDir: string, operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], agent: string, cwd: string, client?: PlatformClient): Promise<PlatformResult> {
   if (operation.kind === 'task-comment') {
-    return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+    return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
   }
   if (operation.kind === 'artifact-comment') {
-    return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+    return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
   }
   if (operation.kind === 'summary-comment') {
-    const summary = summaryPayload(taskDir, taskId);
-    if (!summary) return platformResult('failed', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: false } });
-    return syncPlatformComment(taskId, {
-      kind: 'summary', body: summary.body, agent, cwd,
-      summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, client, skipQueue: true
-    });
+    let summary;
+    try { summary = summaryPayload(taskDir, taskId); }
+    catch (error) { return platformResult('failed', { error: { code: 'SUMMARY_STAGING_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } }); }
+    if (!summary) return platformResult('blocked', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: true } });
+    return syncPlatformComment(taskId, { kind: 'summary', body: summary.body, agent, cwd, client, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, queuedOperation: operation });
   }
   if (operation.kind === 'cancel-comment') {
-    return syncPlatformComment(taskId, { kind: 'cancel', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+    let body: string | null;
+    try { body = cancellationPayload(taskDir, taskId); }
+    catch (error) { return platformResult('failed', { error: { code: 'CANCEL_SUMMARY_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } }); }
+    if (!body) return platformResult('blocked', { error: { code: 'CANCEL_SUMMARY_INVALID', message: 'Cancellation facts are unavailable for recovery', retryable: true } });
+    return syncPlatformComment(taskId, { kind: 'cancel', body, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
   }
   return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_UNSUPPORTED', message: `operation kind '${operation.kind}' has no registered recovery handler`, retryable: false } });
 }
@@ -183,56 +209,6 @@ async function verifyIssueCreate(taskId: string, operation: ReturnType<typeof re
   return platformResult('no-op');
 }
 
-async function replayPullRequestSummary(taskId: string, operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], agent: string, cwd: string, client?: PlatformClient): Promise<PlatformResult> {
-  let identity;
-  try { identity = parseResourceIdentity(JSON.parse(operation.target), 'queued pull-request summary identity'); }
-  catch { return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Queued pull-request summary identity is invalid', retryable: false } }); }
-  const summary = operation.pullRequestSummary;
-  if (!summary) return platformResult('blocked', { error: {
-    code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
-  } });
-  const manualValidationHeading = /^###\s+(?:⏳\s+(?:Manual Validation Pending|人工验证待收尾)|✅\s+(?:Manual Validation Passed|人工验证已通过))\s*$/mu.test(summary.body);
-  if (manualValidationHeading && !summary.manualValidation) return platformResult('blocked', { error: {
-    code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'Queued manual-validation summary has no persisted transaction context', retryable: false
-  } });
-  const resolved = await resolvePlatformProviderContext({ cwd, client });
-  if (!resolved.ok) return resolved.context;
-  const listed = resolved.value.provider.comments?.list
-    ? await resolved.value.provider.comments.list({ context: providerOperationContext(resolved.value), parent: identity })
-    : unsupportedProviderOperation(resolved.value.provider, 'comments.list');
-  if (!listed.ok) return platformResult(providerErrorRetryable(listed.error.code) ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
-  const marker = `<!-- sync-pr:${taskId}:summary -->`;
-  const summaries = listed.value.filter((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === marker);
-  if (summaries.length > 1) return platformResult('blocked', { error: {
-    code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple pull-request comments contain the queued summary marker', retryable: false
-  } });
-  if (!summary.manualValidation && summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0]!.body)).digest('hex') === operation.expectedDigest) {
-    return platformResult('no-op');
-  }
-  const bound = await inspectPlatformPullRequest(taskId, { cwd, client });
-  if (!bound.pullRequest || !resourceIdentityEquals(bound.pullRequest.identity, identity)) return platformResult('blocked', { error: bound.error ?? {
-    code: 'PLATFORM_OPERATION_IDENTITY_MISMATCH', message: 'Bound pull request differs from the queued summary target', retryable: false
-  } });
-  const replayed = await syncPullRequestSummary(taskId, {
-    agent,
-    cwd,
-    client,
-    body: summary.body,
-    changeReportFile: summary.changeReportFile,
-    ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
-    primaryResult: 'no_op',
-    strict: true,
-    skipQueue: true,
-    lockAlreadyHeld: true
-  });
-  if ((replayed.status === 'applied' || replayed.status === 'no-op') && !replayed.error && replayed.warnings.length === 0) {
-    return platformResult(replayed.status, { changed: replayed.changed });
-  }
-  return platformResult('blocked', { error: replayed.error ?? {
-    code: 'PR_SUMMARY_RECOVERY_UNCONFIRMED', message: 'Pull-request summary replay did not confirm the requested remote state', retryable: true
-  } });
-}
-
 async function replayPullRequestReview(operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], agent: string, cwd: string, client?: PlatformClient): Promise<PlatformResult> {
   const intent = operation.pullRequestReview;
   if (!intent) return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request review recovery parameters are missing', retryable: false } });
@@ -281,6 +257,14 @@ async function replayPullRequest(taskId: string, operation: ReturnType<typeof re
   return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
 
+function isRecoveryEligible(operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], excludeId?: string): boolean {
+  if (operation.id === excludeId) return false;
+  if (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown') return true;
+  return operation.state === 'failed'
+    && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED'
+;
+}
+
 async function recoverPlatformOperationsOnce(
   taskRef: string,
   selection: 'required' | 'deferred' | 'all',
@@ -294,9 +278,7 @@ async function recoverPlatformOperationsOnce(
     const value = error as { code?: string; message?: string };
     return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
   }
-  const candidates = journal.operations.filter((operation) => operation.id !== options.excludeId
-    && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-      || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')));
+  const candidates = journal.operations.filter((operation) => isRecoveryEligible(operation, options.excludeId));
   if (!candidates.length) return result('no-op', [], []);
   const head = candidates[0]!;
   if (selection !== 'all' && head.dependency !== selection) {
@@ -358,11 +340,18 @@ async function recoverPlatformOperationsOnce(
       const commentOptions = operation.kind === 'task-comment'
         ? { kind: 'task' as const, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency }
           : operation.kind === 'artifact-comment'
-          ? { kind: 'artifact' as const, artifact: operation.target, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency }
-          : operation.kind === 'summary-comment' ? (() => {
-            const summary = summaryPayload(resolved.taskDir, resolved.taskId);
-            return summary ? { kind: 'summary' as const, body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
-          })() : { kind: 'cancel' as const, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency };
+            ? { kind: 'artifact' as const, artifact: operation.target, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency }
+            : operation.kind === 'summary-comment' ? (() => {
+              try {
+                const summary = summaryPayload(resolved.taskDir, resolved.taskId);
+                return summary ? { kind: 'summary' as const, body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
+              } catch { return null; }
+            })() : (() => {
+              try {
+                const body = cancellationPayload(resolved.taskDir, resolved.taskId);
+                return body ? { kind: 'cancel' as const, body, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency } : null;
+              } catch { return null; }
+            })();
       const current = commentOptions ? inspectPlatformCommentOperation(resolved.taskId, commentOptions) : null;
       if (!current) {
         pending.push(operation.id);
@@ -384,20 +373,21 @@ async function recoverPlatformOperationsOnce(
       remote = operation.kind === 'issue-create'
         ? await verifyIssueCreate(resolved.taskId, operation, resolved.repoRoot)
         : operation.kind === 'pull-request-summary'
-        ? await replayPullRequestSummary(resolved.taskId, operation, options.agent, resolved.repoRoot, options.client)
+        ? await replayPullRequestSummary(resolved.taskId, targetOperation, { agent: options.agent, cwd: resolved.repoRoot, client: options.client })
         : operation.kind === 'pull-request-review'
         ? await replayPullRequestReview(operation, options.agent, resolved.repoRoot, options.client)
         : operation.kind === 'issue-metadata'
         ? await replayIssueMetadata(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
         : operation.kind === 'pull-request'
           ? await replayPullRequest(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
-          : await replayComment(resolved.taskId, resolved.taskDir, operation, options.agent, resolved.repoRoot);
+          : await replayComment(resolved.taskId, resolved.taskDir, targetOperation, options.agent, resolved.repoRoot, options.client);
     }
     catch (error) {
       const value = error as { code?: string; message?: string };
       remote = platformResult('blocked', { error: { code: value.code || 'PLATFORM_OPERATION_RECOVERY_FAILED', message: value.message || String(error), retryable: true } });
     }
     const succeeded = (remote.status === 'applied' || remote.status === 'no-op') && !remote.error;
+    const latestOperation = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.find((item) => item.id === operation.id);
     try {
       recordPlatformOperation({
         taskRef: resolved.taskId,
@@ -412,7 +402,7 @@ async function recoverPlatformOperationsOnce(
         ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
         dependency: operation.dependency,
         state: succeeded ? 'succeeded' : 'unknown',
-        lastCode: remote.error?.code ?? null
+        lastCode: remote.error?.code ?? latestOperation?.lastCode ?? null
       });
     } catch (error) {
       const value = error as { code?: string; message?: string };
@@ -442,9 +432,7 @@ async function recoverPlatformOperations(
     const value = error as { code?: string; message?: string };
     return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
   }
-  const eligible = (operation: typeof initial.operations[number]) => operation.id !== options.excludeId
-    && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-      || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED'));
+  const eligible = (operation: typeof initial.operations[number]) => isRecoveryEligible(operation, options.excludeId);
   const first = initial.operations.filter(eligible);
   if (!first.length) return result('no-op', [], []);
   const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);