@fitlab-ai/agent-infra 0.12.0 → 0.12.2

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 '../platform/context.ts';
+import '../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';
@@ -19,11 +21,12 @@ import { operationId } from './platform-operation-journal.ts';
 import { canonicalizeSummaryBody } from '../platform/comment-safety.ts';
 import { platformResult } from '../platform/types.ts';
 import type { PlatformResult } from '../platform/types.ts';
+import { mergeOperationWarnings, type OperationWarning } from './operation-outcome.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { readPlatformOperationJournal, recordPlatformOperation } from './platform-operation-journal.ts';
-import { providerErrorRetryable } from '../platform/provider-validation.ts';
+import '../platform/provider-validation.ts';
 
-type RecoveryOptions = Readonly<{ agent: string; client?: PlatformClient; cwd?: string; limit?: number; attempts?: number; excludeId?: string }>;
+type RecoveryOptions = Readonly<{ agent: string; client?: PlatformClient; cwd?: string; limit?: number; attempts?: number; excludeId?: string; beforeId?: string }>;
 const DEFAULT_RECOVERY_ATTEMPTS = 3;
 type RecoveryResult = Readonly<{
   status: 'applied' | 'no-op' | 'blocked' | 'failed';
@@ -31,6 +34,8 @@ type RecoveryResult = Readonly<{
   recovered: readonly string[];
   pending: readonly string[];
   error: { code: string; message: string } | null;
+  degraded?: readonly { id: string; reasonCode: string }[];
+  warnings?: readonly OperationWarning[];
 }>;
 type RecoveryError = { code: string; message: string; retryable?: boolean };
 
@@ -46,40 +51,64 @@ function fieldsMatchExpected(
   return Object.entries(expected).every(([name, value]) => actual[name] === value);
 }
 
-function result(status: RecoveryResult['status'], recovered: string[], pending: string[], error: RecoveryError | null = null): RecoveryResult {
-  return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null };
+function result(status: RecoveryResult['status'], recovered: string[], pending: string[], error: RecoveryError | null = null, warnings: readonly OperationWarning[] = []): RecoveryResult {
+  return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null, ...(warnings.length ? { warnings } : {}) };
 }
 
 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 } });
 }
@@ -138,7 +167,8 @@ async function replayIssueMetadata(taskId: string, operation: ReturnType<typeof
   }
   const issue = after.issue;
   const metadata = operation.issueMetadata;
-  const failedOperation = sync.operations.find((item) => item.status === 'failed' || item.status === 'skipped');
+  const failedOperation = sync.operations.find((item) => item.status === 'failed' || (item.status === 'skipped'
+    && !(sync.capabilities.push === false && ['fields', 'issue-type'].includes(item.name) && item.reasonCode === 'PUSH_REQUIRED')));
   if (failedOperation) return platformResult('blocked', { error: {
     code: failedOperation.reasonCode || 'PLATFORM_OPERATION_METADATA_UNCONFIRMED',
     message: `Issue metadata recovery did not confirm operation '${failedOperation.name}'`, retryable: true
@@ -163,7 +193,7 @@ async function replayIssueMetadata(taskId: string, operation: ReturnType<typeof
     code: 'PLATFORM_OPERATION_METADATA_UNCONFIRMED',
     message: 'Issue metadata differs from the requested recovery target after reread', retryable: true
   } });
-  return platformResult('no-op', { changed: sync.changed || after.changed });
+  return platformResult('no-op', { changed: sync.changed || after.changed, operations: sync.operations });
 }
 
 async function verifyIssueCreate(taskId: string, operation: ReturnType<typeof readPlatformOperationJournal>['operations'][number], cwd: string, client?: PlatformClient): Promise<PlatformResult> {
@@ -183,55 +213,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
-  });
-  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 } });
@@ -280,6 +261,20 @@ 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'
+;
+}
+
+function recoveryCandidates(journal: ReturnType<typeof readPlatformOperationJournal>, options: RecoveryOptions) {
+  const boundary = options.beforeId ? journal.operations.findIndex((item) => item.id === options.beforeId) : journal.operations.length;
+  if (boundary < 0) throw Object.assign(new Error('Current platform operation boundary is unavailable'), { code: 'PLATFORM_OPERATION_BOUNDARY_MISSING' });
+  return journal.operations.slice(0, boundary).filter((item) => isRecoveryEligible(item, options.excludeId));
+}
+
 async function recoverPlatformOperationsOnce(
   taskRef: string,
   selection: 'required' | 'deferred' | 'all',
@@ -293,9 +288,9 @@ 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')));
+  let candidates;
+  try { candidates = recoveryCandidates(journal, options); }
+  catch (error) { const value = error as { code: string; message: string }; return result('blocked', [], [], value); }
   if (!candidates.length) return result('no-op', [], []);
   const head = candidates[0]!;
   if (selection !== 'all' && head.dependency !== selection) {
@@ -308,8 +303,9 @@ async function recoverPlatformOperationsOnce(
   const limit = options.limit === undefined ? candidates.length : Math.max(1, options.limit);
   const recovered: string[] = [];
   const pending: string[] = [];
+  let warnings: readonly OperationWarning[] = [];
   const selected = candidates.slice(0, limit);
-  for (const [index, operation] of selected.entries()) {
+  for (const operation of selected) {
     {
       try {
         recordPlatformOperation({
@@ -357,11 +353,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);
@@ -378,25 +381,26 @@ async function recoverPlatformOperationsOnce(
         }
       }
     }
-    let remote: PlatformResult;
+    let remote: PlatformResult & { warnings?: readonly OperationWarning[] };
     try {
       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,
@@ -411,7 +415,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 ?? remote.operations.find((item) => item.status === 'skipped' && item.reasonCode === 'PUSH_REQUIRED')?.reasonCode ?? (succeeded ? null : latestOperation?.lastCode) ?? null
       });
     } catch (error) {
       const value = error as { code?: string; message?: string };
@@ -421,11 +425,12 @@ async function recoverPlatformOperationsOnce(
       pending.push(targetOperation.id);
       return result(remote.status === 'failed' ? 'failed' : 'blocked', recovered, pending, remote.error ?? { code: 'PLATFORM_OPERATION_RECOVERY_UNKNOWN', message: 'Platform operation outcome remains unknown', retryable: true });
     }
+      warnings = mergeOperationWarnings(warnings, remote.warnings ?? []);
       recovered.push(targetOperation.id);
   }
   const remaining = candidates.slice(limit).map((operation) => operation.id);
   pending.push(...remaining);
-  return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null);
+  return result(pending.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, pending, pending.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain pending after the recovery budget', retryable: true } : null, warnings);
 }
 
 async function recoverPlatformOperations(
@@ -441,10 +446,9 @@ 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 first = initial.operations.filter(eligible);
+  let first;
+  try { first = recoveryCandidates(initial, options); }
+  catch (error) { const value = error as { code: string; message: string }; return result('blocked', [], [], value); }
   if (!first.length) return result('no-op', [], []);
   const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);
   const attemptLimit = options.attempts ?? DEFAULT_RECOVERY_ATTEMPTS;
@@ -452,47 +456,56 @@ async function recoverPlatformOperations(
     return result('failed', [], [], { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'Recovery attempts must be a positive safe integer', retryable: false });
   }
   const recovered: string[] = [];
+  let warnings: readonly OperationWarning[] = [];
 
   for (let operationIndex = 0; operationIndex < operationLimit; operationIndex += 1) {
     let latest;
     try { latest = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot); }
     catch (error) {
       const value = error as { code?: string; message?: string };
-      return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
+      return result('failed', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false }, warnings);
     }
-    const head = latest.operations.find(eligible);
+    let candidates;
+    try { candidates = recoveryCandidates(latest, options); }
+    catch (error) { const value = error as { code: string; message: string }; return result('blocked', recovered, [], value, warnings); }
+    const head = candidates[0];
     if (!head) break;
     if (selection !== 'all' && head.dependency !== selection) {
-      const pending = latest.operations.filter(eligible).map((operation) => operation.id);
+      const pending = candidates.map((operation) => operation.id);
       return result('blocked', recovered, pending, {
         code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
         message: 'The first unresolved platform operation belongs to another recovery selection',
         retryable: true
-      });
+      }, warnings);
     }
     let last: RecoveryResult | null = null;
     for (let attempt = 0; attempt < attemptLimit; attempt += 1) {
       last = await recoverPlatformOperationsOnce(taskRef, selection, { ...options, limit: 1 });
       recovered.push(...last.recovered.filter((id) => !recovered.includes(id)));
+      warnings = mergeOperationWarnings(warnings, last.warnings ?? []);
       if (last.recovered.length > 0 || last.status === 'applied' || last.status === 'no-op') break;
     }
     if (!last || (last.recovered.length === 0 && last.status !== 'applied' && last.status !== 'no-op')) {
       let current;
       try { current = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot); }
-      catch { return result('blocked', recovered, [head.id], last?.error ?? null); }
-      const pending = current.operations.filter(eligible).map((operation) => operation.id);
+      catch { return result('blocked', recovered, [head.id], last?.error ?? null, warnings); }
+      let pending: string[];
+      try { pending = recoveryCandidates(current, options).map((operation) => operation.id); }
+      catch (error) { const value = error as { code: string; message: string }; return result('blocked', recovered, [], value, warnings); }
       return result(last?.status === 'failed' ? 'failed' : 'blocked', recovered, pending, last?.error ?? {
         code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
         message: 'The first queued platform operation remains unresolved after this recovery run',
         retryable: true
-      });
+      }, warnings);
     }
   }
   let remaining: string[];
-  try { remaining = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter(eligible).map((operation) => operation.id); }
-  catch { remaining = []; }
-  return result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining,
-    remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null);
+  try { remaining = recoveryCandidates(readPlatformOperationJournal(resolved.taskId, resolved.repoRoot), options).map((operation) => operation.id); }
+  catch (error) { const value = error as { code?: string; message?: string }; return result('blocked', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || 'Unable to read platform operations' }, warnings); }
+  const output = result(remaining.length ? 'blocked' : recovered.length ? 'applied' : 'no-op', recovered, remaining,
+    remaining.length ? { code: 'PLATFORM_OPERATION_RECOVERY_PENDING', message: 'Platform operations remain queued after this recovery run', retryable: true } : null, warnings);
+  const degraded = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter((item) => recovered.includes(item.id) && item.lastCode === 'PUSH_REQUIRED').map((item) => ({ id: item.id, reasonCode: item.lastCode! }));
+  return degraded.length ? { ...output, degraded } : output;
 }
 
 export { fieldsMatchExpected, labelsMatchOwnedPrefix, recoverPlatformOperations };

package/lib/task/pr-delivery-fact.ts

@@ -1,10 +1,5 @@
 import type { ResourceIdentity } from '../platform/resource-identity.ts';
-import {
-  isResourceIdentity,
-  parseResourceIdentity,
-  resourceIdentityNumber,
-  serializeResourceIdentity
-} from '../platform/resource-identity.ts';
+import { parseResourceIdentity, serializeResourceIdentity } from '../platform/resource-identity.ts';
 
 const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
 
@@ -182,9 +177,5 @@ function buildBoundFact(input: {
   }, provenance: { establishedBy: provenanceForSource(input.source) } });
 }
 function factFrontmatterMutation(fact: PrDeliveryFact): { set: { [PR_DELIVERY_FACT_KEY]: string } } { return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } }; }
-function identityFromPullRequest(pullRequest: PrDeliveryIdentityInput): PrDeliveryIdentity {
-  return canonicalIdentity(pullRequest);
-}
-
-export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact, serializeResourceIdentity };
+export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, readPrDeliveryFact, serializeResourceIdentity };
 export type { CreationOutcome, PrDeliveryBindingSource, PrDeliveryFact, PrDeliveryFactError, PrDeliveryFactReadResult, PrDeliveryIdentity, PrDeliveryIdentityInput, PrDeliveryProvenance };

package/lib/task/qualification-confirmation.ts

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 
-import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { CONFIRMATION_COLUMNS, CONFIRMATION_HEADINGS, constraintDigest, parseQualificationConfirmations, parseTaskQualification } from './qualification-audit.ts';
 import type { QualificationConfirmation } from './qualification-audit.ts';
 import { findSectionHeading } from './sections.ts';
@@ -25,6 +25,7 @@ type QualificationConfirmationResult = {
   requestId: string | null;
   operations: readonly TaskOperationSummary[];
   error: { code: string; message: string } | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 
 function failed(code: string, message: string, taskId: string | null = null): QualificationConfirmationResult {
@@ -73,13 +74,13 @@ function applyQualificationConfirmation(request: QualificationConfirmationReques
   const previous = existing.confirmations.find((row) => row.qcrId === constraint.approvalEvidence);
   if (operation === 'confirm' && constraint.status === 'confirmed') {
     if (previous?.constraintId === constraint.constraintId && previous.approvedDigest === constraint.digest && previous.rationale === request.rationale.trim()) {
-      return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: previous.qcrId, requestId: previous.requestId, operations: [], error: null };
+      return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: previous.qcrId, requestId: previous.requestId, operations: [], error: null, warnings: activityWarnings(content) };
     }
     return failed('QUALIFICATION_CONFIRMATION_CONFLICT', `constraint '${request.constraintId}' is already confirmed with different evidence`, resolved.taskId);
   }
   const transitionStatus = operation === 'supersede' ? 'superseded' : 'open';
   if (operation !== 'confirm' && constraint.status === transitionStatus && !constraint.approvalEvidence) {
-    return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: null, requestId: null, operations: [], error: null };
+    return { status: 'no-op', changed: false, taskId: resolved.taskId, qcrId: null, requestId: null, operations: [], error: null, warnings: activityWarnings(content) };
   }
   if (operation !== 'confirm' && constraint.status !== 'confirmed') return failed('QUALIFICATION_CONFIRMATION_REQUIRED', `constraint '${request.constraintId}' is not confirmed`, resolved.taskId);
   if (parsed.qualification.constraintDigest !== request.expectedDigest) return failed('QUALIFICATION_DIGEST_CONFLICT', 'constraint digest changed before human confirmation', resolved.taskId);
@@ -99,18 +100,17 @@ function applyQualificationConfirmation(request: QualificationConfirmationReques
   } : null;
   const confirmations = confirmation ? [...existing.confirmations, confirmation] : existing.confirmations;
   const activity = locateActivityLog(content);
-  if (!activity) return failed('QUALIFICATION_ACTIVITY_MISSING', 'task has no unique Activity Log section', resolved.taskId);
   const mutations: Parameters<typeof writeTask>[0]['mutations'][number][] = [
     {
       kind: 'table-row', action: 'upsert', sectionAliases: ['约束', 'Constraints'], columns: ['constraint_id', 'statement', 'status', 'authority', 'source', 'evidence', 'derived_from', 'approval_evidence'], keyColumn: 'constraint_id', key: constraint.constraintId,
       values: { statement: constraint.statement, status: operation === 'confirm' ? 'confirmed' : transitionStatus, authority: operation === 'confirm' ? 'human-declared' : constraint.authority, source: constraint.source, evidence: constraint.evidence, derived_from: constraint.derivedFrom.join(','), approval_evidence: qcrId ?? '' }
     },
     ...(operation === 'confirm' ? [{ kind: 'section' as const, aliases: CONFIRMATION_HEADINGS, heading: findSectionHeading(content, [...CONFIRMATION_HEADINGS]), body: renderConfirmations(confirmations) }] : []),
-    { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: activity.heading, body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Qualification Confirmation', agent: 'human', note: operation === 'confirm' ? `${request.constraintId} confirmed → ${qcrId}` : `${request.constraintId} ${operation}d` }) }
+    ...(activity ? [{ kind: 'section' as const, aliases: ['活动日志', 'Activity Log'], heading: activity.heading, body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Qualification Confirmation', agent: 'human', note: operation === 'confirm' ? `${request.constraintId} confirmed → ${qcrId}` : `${request.constraintId} ${operation}d` }) }] : [])
   ];
   const result = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state }, metadataProvider: () => metadata });
   if (result.status === 'failed') return failed(result.error.code, result.error.message, result.taskId);
-  return { status: result.status, changed: result.changed, taskId: result.taskId, qcrId, requestId, operations: result.operations, error: null };
+  return { status: result.status, changed: result.changed, taskId: result.taskId, qcrId, requestId, operations: result.operations, error: null, warnings: activityWarnings(content) };
 }
 
 export { applyQualificationConfirmation };

package/lib/task/resolve-ref.ts

@@ -114,28 +114,6 @@ function findTaskMd(
   return archived ? { taskMdPath: archived, state: 'archive' } : null;
 }
 
-/**
- * Enumerate every task directory under the flat workspace states
- * (active / blocked / completed) — archive is intentionally excluded so a
- * full-tree scan never pulls in cold data. Ordered by state, then task id
- * ascending, giving callers a deterministic traversal.
- */
-function enumerateTaskDirs(repoRoot: string): { taskId: string; taskDir: string }[] {
-  const out: { taskId: string; taskDir: string }[] = [];
-  const workspaceRoot = taskRoot(repoRoot);
-  for (const sub of FLAT_WORKSPACE_DIRS) {
-    const base = path.join(workspaceRoot, sub);
-    if (!fs.existsSync(base)) continue;
-    for (const entry of fs.readdirSync(base).sort()) {
-      if (!TASK_ID_RE.test(entry)) continue;
-      const taskDir = path.join(base, entry);
-      if (!fs.existsSync(path.join(taskDir, 'task.md'))) continue;
-      out.push({ taskId: entry, taskDir });
-    }
-  }
-  return out;
-}
-
 /**
  * Enumerate every task directory, including the cold YYYY/MM/DD archive.
  * Invalid directory names, symlinks and entries without task.md are ignored;
@@ -364,7 +342,6 @@ export {
   resolveTaskRef,
   resolveTaskContext,
   detectRepoRoot,
-  enumerateTaskDirs,
   enumerateAllTaskDirs,
   locateHotTaskDirs,
   TASK_ID_RE

package/lib/task/review-command.ts

@@ -4,14 +4,14 @@ export function parseReviewCommand(args: readonly string[]): ReviewFinalizationR
   if (!args[0] || !['preflight', 'finalize-summary'].includes(args[1] ?? '')) throw new Error('task ref and a supported review operation are required');
   const values: Record<string, string | boolean> = {};
   const flags = {
-    '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
+    '--stage': 'stage', '--artifact': 'artifact', '--dry-run': 'dryRun'
   } as const;
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
     if (!Object.hasOwn(flags, flag)) throw new Error(`unknown option '${flag}'`);
     const key = flags[flag as keyof typeof flags];
     if (Object.hasOwn(values, key)) throw new Error(`duplicate option '${flag}'`);
-    const value = flag === '--orchestrated' || flag === '--dry-run' ? true : args[++index];
+    const value = flag === '--dry-run' ? true : args[++index];
     if (!value || typeof value === 'string' && value.startsWith('--')) throw new Error(`option '${flag}' requires a value`);
     values[key] = value;
   }

package/lib/task/review-finalization.ts

@@ -9,7 +9,6 @@ import type { LedgerStageStatus, ReviewStage } from './ledger.ts';
 import { finalizeReviewSummaryContent } from './review-artifacts.ts';
 import { inspectDecisionDetailDuplicates } from './decision-details.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { validateLifecycleExecution } from './lifecycle-execution.ts';
 import type { ResolveTaskRefErrorCode } from './resolve-ref.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { validateQualificationAudit } from './qualification-audit.ts';
@@ -36,7 +35,6 @@ type ReviewFinalizationRequest = {
   taskRef: string;
   stage: string;
   artifact: string;
-  orchestrated?: boolean;
   dryRun?: boolean;
 };
 type ReviewFinalizationResult = {
@@ -144,13 +142,6 @@ function preflightReviewSummary(
     content = fs.readFileSync(validated.artifact.path, 'utf8');
   } catch (error) { return preflightFailed(request, 'REVIEW_ARTIFACT_NOT_REGULAR', String(error), resolved.taskId); }
 
-  const execution = validateLifecycleExecution(request.taskRef, {
-    mode: request.orchestrated ? 'orchestrated' : 'standalone',
-    identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
-    dryRun: request.dryRun
-  }, { repoRoot: options.repoRoot });
-  if (!execution.ok) return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`, resolved.taskId);
-
   const artifactSha256 = sha256Content(content);
   const semanticDigest = canonicalSemanticDigest(content);
   const detail = inspectDecisionDetailDuplicates(content);
@@ -211,15 +202,6 @@ function prepareReviewSummaryCandidate(
   catch (error) { return reject('REVIEW_ARTIFACT_NOT_REGULAR', String(error)); }
   const artifactSha256 = sha256Content(artifactContent);
   const semanticDigest = canonicalSemanticDigest(artifactContent);
-  const digests = { artifactSha256, semanticDigest };
-  const execution = validateLifecycleExecution(request.taskRef, {
-    mode: request.orchestrated ? 'orchestrated' : 'standalone',
-    identity: { stage: spec.family, round: parsed.round, artifact: request.artifact, role: 'reviewer' },
-    dryRun: request.dryRun
-  }, { repoRoot: options.repoRoot });
-  if (!execution.ok) {
-    return reject('REVIEW_PROVENANCE_INVALID', `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`);
-  }
   try {
     const ledger = parseLedgerDocument(taskContent);
     if (!ledger.present) return reject('REVIEW_LEDGER_INVALID', `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`);
@@ -259,14 +241,6 @@ function prepareReviewSummaryCandidate(
   };
 }
 
-function commitReviewSummaryProvenance(
-  prepared: ReviewSummaryCandidatePreparation,
-  repoRoot: string,
-  options: Readonly<{ afterPublish?: () => void }> = {}
-): ReviewFinalizationResult {
-  return prepared.result;
-}
-
 function replaceCurrentArtifactAtomically(file: string, content: string): void {
   const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
   try {
@@ -316,7 +290,7 @@ function finalizeReviewSummary(
   }
 }
 
-export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate, commitReviewSummaryProvenance };
+export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate };
 export type {
   ReviewFinalizationError,
   ReviewFinalizationErrorCode,