@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/task/platform-operation-recovery.js

@@ -2,13 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { inspectPlatformCommentOperation, normalizeCommentContent, syncPlatformComment } from '../platform/issue-comments.js';
+import { inspectPlatformCommentOperation, syncPlatformComment } from '../platform/issue-comments.js';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent, parseCancelSummaryContent, renderCancelSummaryContent } from '../platform/issue-summary-content.js';
+import { enumerateArtifacts } from './artifacts.js';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
-import { resolvePlatformProviderContext } from '../platform/context.js';
-import { providerOperationContext, providerError, unsupportedProviderOperation } from '../platform/provider-bridge.js';
+import '../platform/context.js';
+import '../platform/provider-bridge.js';
 import { inLabelMappingDigest } from '../platform/in-label-sync.js';
-import { bindPlatformPullRequest, inspectPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
-import { syncPullRequestSummary } from '../platform/pr-summary.js';
+import { bindPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { replayPullRequestSummary } from '../platform/pr-summary.js';
 import { publishPrReview, readReviewBodyFile } from '../platform/pr-review.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
@@ -16,9 +18,10 @@ import { parseResourceIdentity, resourceIdentityEquals } from '../platform/resou
 import { operationId } from './platform-operation-journal.js';
 import { canonicalizeSummaryBody } from '../platform/comment-safety.js';
 import { platformResult } from '../platform/types.js';
+import { mergeOperationWarnings } from './operation-outcome.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { readPlatformOperationJournal, recordPlatformOperation } from './platform-operation-journal.js';
-import { providerErrorRetryable } from '../platform/provider-validation.js';
+import '../platform/provider-validation.js';
 const DEFAULT_RECOVERY_ATTEMPTS = 3;
 function labelsMatchOwnedPrefix(actual, expected, prefix) {
     return actual.filter((label) => label.startsWith(prefix)).sort().join('\0')
@@ -27,40 +30,78 @@ function labelsMatchOwnedPrefix(actual, expected, prefix) {
 function fieldsMatchExpected(actual, expected) {
     return Object.entries(expected).every(([name, value]) => actual[name] === value);
 }
-function result(status, recovered, pending, error = null) {
-    return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null };
+function result(status, recovered, pending, error = null, warnings = []) {
+    return { status, changed: recovered.length > 0, recovered, pending, error: error ? { code: error.code, message: error.message } : null, ...(warnings.length ? { warnings } : {}) };
 }
 function summaryPayload(taskDir, taskId) {
     const file = path.join(taskDir, '.delivery-summary.json');
     if (!fs.existsSync(file))
         return null;
     const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    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) {
+    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, taskId) {
+    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, taskDir, operation, agent, cwd, client) {
     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);
+        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('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
-        });
+            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;
+        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 } });
 }
@@ -130,7 +171,8 @@ async function replayIssueMetadata(taskId, operation, agent, cwd, client) {
     }
     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',
@@ -164,7 +206,7 @@ async function replayIssueMetadata(taskId, operation, agent, cwd, client) {
                 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, operation, cwd, client) {
     if (!operation.issueCreate)
@@ -185,64 +227,6 @@ async function verifyIssueCreate(taskId, operation, cwd, client) {
             } });
     return platformResult('no-op');
 }
-async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
-    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, agent, cwd, client) {
     const intent = operation.pullRequestReview;
     if (!intent)
@@ -301,6 +285,20 @@ async function replayPullRequest(taskId, operation, agent, cwd) {
     }
     return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
+function isRecoveryEligible(operation, excludeId) {
+    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, options) {
+    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, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -313,9 +311,14 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
         const value = error;
         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;
+        return result('blocked', [], [], value);
+    }
     if (!candidates.length)
         return result('no-op', [], []);
     const head = candidates[0];
@@ -329,8 +332,9 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
     const limit = options.limit === undefined ? candidates.length : Math.max(1, options.limit);
     const recovered = [];
     const pending = [];
+    let warnings = [];
     const selected = candidates.slice(0, limit);
-    for (const [index, operation] of selected.entries()) {
+    for (const operation of selected) {
         {
             try {
                 recordPlatformOperation({
@@ -382,9 +386,22 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 : operation.kind === 'artifact-comment'
                     ? { kind: 'artifact', 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', body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
-                    })() : { kind: 'cancel', agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency };
+                        try {
+                            const summary = summaryPayload(resolved.taskDir, resolved.taskId);
+                            return summary ? { kind: 'summary', 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', 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);
@@ -407,20 +424,21 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
             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;
             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,
@@ -435,7 +453,7 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 ...(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) {
@@ -446,11 +464,12 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
             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(taskRef, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
@@ -464,10 +483,14 @@ async function recoverPlatformOperations(taskRef, selection, options) {
         const value = error;
         return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
     }
-    const eligible = (operation) => 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;
+        return result('blocked', [], [], value);
+    }
     if (!first.length)
         return result('no-op', [], []);
     const operationLimit = options.limit === undefined ? first.length : Math.max(1, options.limit);
@@ -476,6 +499,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
         return result('failed', [], [], { code: 'PLATFORM_OPERATION_RECOVERY_PAYLOAD_INVALID', message: 'Recovery attempts must be a positive safe integer', retryable: false });
     }
     const recovered = [];
+    let warnings = [];
     for (let operationIndex = 0; operationIndex < operationLimit; operationIndex += 1) {
         let latest;
         try {
@@ -483,23 +507,32 @@ async function recoverPlatformOperations(taskRef, selection, options) {
         }
         catch (error) {
             const value = error;
-            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);
+        }
+        let candidates;
+        try {
+            candidates = recoveryCandidates(latest, options);
+        }
+        catch (error) {
+            const value = error;
+            return result('blocked', recovered, [], value, warnings);
         }
-        const head = latest.operations.find(eligible);
+        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 = 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;
         }
@@ -509,24 +542,34 @@ async function recoverPlatformOperations(taskRef, selection, options) {
                 current = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot);
             }
             catch {
-                return result('blocked', recovered, [head.id], last?.error ?? null);
+                return result('blocked', recovered, [head.id], last?.error ?? null, warnings);
+            }
+            let pending;
+            try {
+                pending = recoveryCandidates(current, options).map((operation) => operation.id);
+            }
+            catch (error) {
+                const value = error;
+                return result('blocked', recovered, [], value, warnings);
             }
-            const pending = current.operations.filter(eligible).map((operation) => operation.id);
             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;
     try {
-        remaining = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.filter(eligible).map((operation) => operation.id);
+        remaining = recoveryCandidates(readPlatformOperationJournal(resolved.taskId, resolved.repoRoot), options).map((operation) => operation.id);
     }
-    catch {
-        remaining = [];
+    catch (error) {
+        const value = error;
+        return result('blocked', recovered, [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || 'Unable to read platform operations' }, warnings);
     }
-    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);
+    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 };
 //# sourceMappingURL=platform-operation-recovery.js.map

package/dist/lib/task/pr-delivery-fact.js

@@ -1,4 +1,4 @@
-import { isResourceIdentity, parseResourceIdentity, resourceIdentityNumber, serializeResourceIdentity } from '../platform/resource-identity.js';
+import { parseResourceIdentity, serializeResourceIdentity } from '../platform/resource-identity.js';
 const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
 function factError(message) {
     return Object.assign(new Error(`PR_DELIVERY_FACT_INVALID: ${message}`), { code: 'PR_DELIVERY_FACT_INVALID' });
@@ -132,8 +132,5 @@ function buildBoundFact(input) {
         }, provenance: { establishedBy: provenanceForSource(input.source) } });
 }
 function factFrontmatterMutation(fact) { return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } }; }
-function identityFromPullRequest(pullRequest) {
-    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 };
 //# sourceMappingURL=pr-delivery-fact.js.map

package/dist/lib/task/qualification-confirmation.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { CONFIRMATION_COLUMNS, CONFIRMATION_HEADINGS, constraintDigest, parseQualificationConfirmations, parseTaskQualification } from './qualification-audit.js';
 import { findSectionHeading } from './sections.js';
 import { resolveTaskRef } from './resolve-ref.js';
@@ -58,13 +58,13 @@ function applyQualificationConfirmation(request, options = {}) {
     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);
@@ -90,20 +90,18 @@ function applyQualificationConfirmation(request, options = {}) {
     } : 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 = [
         {
             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', 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', 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 };
 //# sourceMappingURL=qualification-confirmation.js.map

package/dist/lib/task/resolve-ref.js

@@ -70,30 +70,6 @@ function findTaskMd(workspaceRoot, taskId) {
     const archived = findInArchive(workspaceRoot, taskId);
     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) {
-    const out = [];
-    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;
@@ -316,5 +292,5 @@ function resolveTaskContext(taskRef, options = {}) {
     const match = matches[0];
     return { ok: true, repoRoot, ...match, state: 'active' };
 }
-export { resolveTaskRef, resolveTaskContext, detectRepoRoot, enumerateTaskDirs, enumerateAllTaskDirs, locateHotTaskDirs, TASK_ID_RE };
+export { resolveTaskRef, resolveTaskContext, detectRepoRoot, enumerateAllTaskDirs, locateHotTaskDirs, TASK_ID_RE };
 //# sourceMappingURL=resolve-ref.js.map

package/dist/lib/task/review-command.js

@@ -3,7 +3,7 @@ export function parseReviewCommand(args) {
         throw new Error('task ref and a supported review operation are required');
     const values = {};
     const flags = {
-        '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
+        '--stage': 'stage', '--artifact': 'artifact', '--dry-run': 'dryRun'
     };
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
@@ -12,7 +12,7 @@ export function parseReviewCommand(args) {
         const key = flags[flag];
         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/dist/lib/task/review-finalization.js

@@ -7,7 +7,6 @@ import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedge
 import { finalizeReviewSummaryContent } from './review-artifacts.js';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { validateQualificationAudit } from './qualification-audit.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
@@ -74,13 +73,6 @@ function preflightReviewSummary(request, options = {}) {
     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);
@@ -140,15 +132,6 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     }
     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)
@@ -194,9 +177,6 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
         },
     };
 }
-function commitReviewSummaryProvenance(prepared, repoRoot, options = {}) {
-    return prepared.result;
-}
 function replaceCurrentArtifactAtomically(file, content) {
     const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
     try {
@@ -250,5 +230,5 @@ function finalizeReviewSummary(request, options = {}) {
         return failed(request, 'REVIEW_RECOVERY_COMMIT_FAILED', `cannot update current review artifact: ${error instanceof Error ? error.message : String(error)}`, resolved.taskId);
     }
 }
-export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate, commitReviewSummaryProvenance };
+export { finalizeReviewSummary, preflightReviewSummary, prepareReviewSummaryCandidate };
 //# sourceMappingURL=review-finalization.js.map

package/dist/lib/task/review-fingerprint.js

@@ -1,10 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import { inspectArtifactDirectory } from "./artifact-lifecycle.js";
-const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
-export function parseReviewedGitTree(value) {
-    return REVIEWED_TREE_RE.test(value) ? value : null;
-}
 // Paths excluded from the post-review coverage gate. Fail-closed: the gate
 // covers ALL tracked changes by default. This default denylist is EMPTY —
 // projects opt into exclusions explicitly via review.post_review_exclude_globs.