@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/task/lifecycle-execution.js

@@ -1,37 +1,42 @@
-import { inspectOrchestrationStage, pauseOrchestration, planOrchestrationStageCompletion } from './orchestration.js';
-import { resolveTaskRef } from './resolve-ref.js';
-function failure(mode, code, message) {
-    return { ok: false, mode, completionPlan: null, error: { code, message } };
-}
-function inspectLifecycleExecution(taskRef, request, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failure(request.mode, resolved.code, resolved.message);
-    if (request.mode === 'standalone') {
-        return { ok: true, mode: request.mode, completionPlan: null, error: null };
-    }
-    if (request.agent) {
-        const planned = planOrchestrationStageCompletion(taskRef, {
-            ...request.identity,
-            agent: request.agent
-        }, options);
-        if (planned.plan) {
-            return { ok: true, mode: request.mode, completionPlan: planned.plan, error: null };
-        }
-        return failure(request.mode, planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', planned.result.error?.message ?? 'orchestration provenance validation failed');
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+const labels = {
+    'Analyze Task': 'analyze', 'Review Analysis': 'review-analysis', 'Plan Task': 'plan',
+    'Review Plan': 'review-plan', 'Code Task': 'code', 'Review Code': 'review-code',
+    'Run Manual Validation': 'validation-run'
+};
+export function lifecycleExecutions(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+    if (value !== undefined) {
+        if (typeof value !== 'string')
+            throw new Error('invalid lifecycle execution state');
+        const state = JSON.parse(value);
+        if (!state || typeof state !== 'object' || !('version' in state) || state.version !== 1 || !('open' in state) || !Array.isArray(state.open))
+            throw new Error('invalid lifecycle execution state');
+        return state.open.map((item) => {
+            if (!item || typeof item !== 'object' || !('family' in item) || typeof item.family !== 'string' || ![...Object.values(labels), 'manual-validation', 'other'].includes(item.family) || !('agent' in item) || typeof item.agent !== 'string' || !('startedAt' in item) || typeof item.startedAt !== 'string')
+                throw new Error('invalid lifecycle execution identity');
+            return item;
+        });
     }
-    const inspected = inspectOrchestrationStage(taskRef, request.identity, options);
-    if (inspected.status !== 'failed') {
-        return { ok: true, mode: request.mode, completionPlan: null, error: null };
-    }
-    return failure(request.mode, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed');
+    return [];
+}
+export function prReviewExecution(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+    if (value === undefined)
+        return { open: null, terminals: [] };
+    if (typeof value !== 'string')
+        throw new Error('invalid lifecycle execution state');
+    const state = JSON.parse(value);
+    if (state.version !== 1 || !Array.isArray(state.open))
+        throw new Error('invalid lifecycle execution state');
+    const pr = state.prReview ?? { open: null, terminals: [] };
+    const valid = (item) => item && typeof item.artifact === 'string' && typeof item.head === 'string' && typeof item.agent === 'string';
+    if (!Array.isArray(pr.terminals) || (pr.open !== null && (!valid(pr.open) || typeof pr.open.startedAt !== 'string')) || !pr.terminals.every((item) => valid(item) && typeof item.note === 'string'))
+        throw new Error('invalid PR review execution state');
+    return pr;
 }
-function validateLifecycleExecution(taskRef, request, options = {}) {
-    const inspected = inspectLifecycleExecution(taskRef, request, options);
-    if (inspected.ok || request.mode === 'standalone' || request.dryRun)
-        return inspected;
-    const paused = pauseOrchestration(taskRef, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed', true, options);
-    return failure(request.mode, paused.run?.pause?.code ?? inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', paused.run?.pause?.message ?? inspected.error?.message ?? 'orchestration provenance validation failed');
+export function serializeLifecycleExecution(open, content, prReview) {
+    const pr = prReview ?? (content ? prReviewExecution(content) : { open: null, terminals: [] });
+    return JSON.stringify({ version: 1, open, prReview: pr });
 }
-export { inspectLifecycleExecution, validateLifecycleExecution };
 //# sourceMappingURL=lifecycle-execution.js.map

package/dist/lib/task/lifecycle.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { artifactFamilyCatalog, inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
@@ -15,7 +15,7 @@ import { taskIssueIdentity } from '../platform/task-identities.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
 const lifecycleIntentCatalog = [
-    'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'
+    'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ];
 const lifecycleFailureCatalog = [
     'LIFECYCLE_DIRECTORY_TRANSFER_FAILED',
@@ -82,9 +82,6 @@ function failed(request, error, extra = {}) {
         error, ...extra
     };
 }
-export function taskLifecycleFailure(request, error, taskId = null) {
-    return failed(request, error, { taskId });
-}
 function normalizedRequest(request) {
     if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent)) {
         return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -300,26 +297,11 @@ function taskBoundControlMoveSafety(request, controlRoot, options, taskId, repoR
     }
     return null;
 }
-function orchestrationMoveSafety(sourcePath) {
-    const orchestrationPath = path.join(sourcePath, '.runtime', 'orchestration.json');
-    if (!pathExists(orchestrationPath))
-        return null;
-    try {
-        const run = JSON.parse(fs.readFileSync(orchestrationPath, 'utf8'));
-        if (run.status === 'running' || run.pendingDelegation !== null && run.pendingDelegation !== undefined) {
-            return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration has an active or pending delegation; settle it before moving the task directory' };
-        }
-    }
-    catch {
-        return { code: 'LIFECYCLE_RUNTIME_MOVE_UNSAFE', message: 'task orchestration state is unreadable; refusing to move the task directory' };
-    }
-    return null;
-}
-function runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, validateControlManifestIdentity) {
+function runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, validateControlManifestIdentity) {
     if (!movingTaskDirectory)
         return null;
     const controlSafety = taskBoundControlMoveSafety(request, options.controlRoot, options, taskId, repoRoot, validateControlManifestIdentity);
-    return controlSafety ?? orchestrationMoveSafety(sourcePath);
+    return controlSafety;
 }
 function targetContainsTask(targetPath, taskId, request) {
     try {
@@ -356,16 +338,26 @@ function actionAndNote(request, restoredFiles = 0) {
         return { action: 'Close Codescan', note: `Code Scanning alert #${request.alertNumber} dismissed: ${request.reason}` };
     if (request.intent === 'close-dependabot')
         return { action: 'Close Dependabot', note: `Dependabot alert #${request.alertNumber} dismissed: ${request.reason}` };
-    if (request.intent === 'recover-started')
-        return { action: 'Recover Started', note: 'automatic recovery' };
     return { action: 'Restore Task', note: `Restored ${restoredFiles} files from Issue #${request.issueNumber}` };
 }
+function completionKeys(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_transition;
+    if (value === undefined)
+        return [];
+    if (typeof value !== 'string')
+        throw new Error('invalid lifecycle transition');
+    const state = JSON.parse(value);
+    if (!state || typeof state !== 'object' || !('completedKeys' in state) || !Array.isArray(state.completedKeys))
+        throw new Error('invalid lifecycle transition');
+    return state.completedKeys.map((key) => {
+        if (!key || typeof key !== 'object' || !('action' in key) || typeof key.action !== 'string' || !('agent' in key) || typeof key.agent !== 'string' || !('note' in key) || typeof key.note !== 'string')
+            throw new Error('invalid lifecycle completion identity');
+        return key;
+    });
+}
 function matchingCompletion(content, request, restoredFiles = 0) {
-    const section = locateActivityLog(content);
-    if (!section)
-        return false;
     const identity = actionAndNote(request, restoredFiles);
-    return section.entries.some((entry) => entry.step === identity.action && entry.agent === request.agent && entry.note === identity.note);
+    return completionKeys(content).some((entry) => entry.action === identity.action && entry.agent === request.agent && entry.note === identity.note);
 }
 function validateRestoreStaging(request, repoRoot, taskId) {
     let workspace;
@@ -424,13 +416,17 @@ function validateRestoreStaging(request, repoRoot, taskId) {
     }
     return { stagingDir, fileCount: entries.filter((entry) => !entry.name.startsWith('.')).length };
 }
-function mutationsFor(request, content, metadata, restoredFiles, allowMissingActivityLog = false) {
-    const section = locateActivityLog(content) ?? (allowMissingActivityLog ? { heading: 'Activity Log', body: '', entries: [] } : null);
+function lifecycleActivityMutation(content, request, metadata, identity, allowMissing) {
+    const section = locateActivityLog(content) ?? (allowMissing ? { heading: 'Activity Log', body: '', entries: [] } : null);
     if (!section)
-        return { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' };
-    const identity = actionAndNote(request, restoredFiles);
+        return [];
     let body = appendActivityEntry(section, { time: metadata.timestamp, step: `${identity.action} [started]`, agent: request.agent, note: 'started' });
     body = appendActivityEntry({ ...section, body }, { time: metadata.timestamp, step: identity.action, agent: request.agent, note: identity.note });
+    return [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }];
+}
+function mutationsFor(request, content, metadata, restoredFiles, allowMissingActivityLog = false) {
+    const identity = actionAndNote(request, restoredFiles);
+    const activityMutation = lifecycleActivityMutation(content, request, metadata, identity, allowMissingActivityLog);
     const set = {};
     const remove = [];
     if (request.intent === 'block') {
@@ -458,9 +454,13 @@ function mutationsFor(request, content, metadata, restoredFiles, allowMissingAct
         if (frontmatter.target_date === '')
             set.target_date = metadata.timestamp.slice(0, 10);
     }
+    const completedKeys = completionKeys(content);
+    if (!matchingCompletion(content, request, restoredFiles))
+        completedKeys.push({ ...identity, agent: request.agent });
+    set.lifecycle_transition = JSON.stringify({ completedKeys });
     const mutations = [
         { kind: 'frontmatter', set, remove: [...new Set(remove)] },
-        { kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }
+        ...activityMutation
     ];
     if (request.intent === 'block') {
         mutations.splice(1, 0, {
@@ -595,9 +595,6 @@ export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
     }
 }
 function applyTaskLifecycle(requestInput, options = {}) {
-    if (requestInput.intent === 'recover-started') {
-        return failed(requestInput, { code: 'LIFECYCLE_RECOVERY_REQUIRES_AUTHORITY', message: 'recover-started must be dispatched through task control authority' });
-    }
     const normalized = normalizedRequest(requestInput);
     if ('code' in normalized)
         return failed(requestInput, normalized);
@@ -674,7 +671,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         && !(request.intent === 'complete' && targetContainsTask(targetPath, taskId, request))) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, true);
+    const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, true);
     if (moveSafety)
         return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     const content = io.readFileSync(currentTaskFile);
@@ -687,8 +684,6 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     if (frontmatter.id !== taskId)
         return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
-    if (!locateActivityLog(content))
-        return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     if (spec.target === 'active') {
         const contract = validateCurrentTaskContract(content);
         if (!contract.ok)
@@ -832,7 +827,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (fs.existsSync(targetPath) && !fs.existsSync(path.join(sourcePath, 'task.md')))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {
-        const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, sourcePath, false);
+        const moveSafety = runtimeMoveSafety(request, movingTaskDirectory, options, taskId, repoRoot, false);
         if (moveSafety)
             return failed(request, moveSafety, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0, timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -967,5 +962,18 @@ function applyTaskLifecycle(requestInput, options = {}) {
         journalPath, completedSteps: [...completed], pendingSteps: []
     };
 }
-export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycle, previewTaskCompletion };
+function applyTaskLifecycleWithWarnings(request, options = {}) {
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    const taskFile = resolved.ok ? resolved.taskMdPath : request.intent === 'restore' ? path.join(request.stagingDir, 'task.md') : null;
+    let warnings = [];
+    if (taskFile) {
+        try {
+            warnings = activityWarnings(fs.readFileSync(taskFile, 'utf8'));
+        }
+        catch { /* The lifecycle operation reports its own read failure. */ }
+    }
+    const result = applyTaskLifecycle(request, options);
+    return result.status === 'failed' || !warnings.length ? result : { ...result, warnings };
+}
+export { lifecycleIntentCatalog, lifecycleFailureCatalog, lifecycleProducerCatalog, applyTaskLifecycleWithWarnings as applyTaskLifecycle, previewTaskCompletion };
 //# sourceMappingURL=lifecycle.js.map

package/dist/lib/task/local-artifact-finalization.js

@@ -113,9 +113,6 @@ function prepareLocalArtifact(request, candidate) {
         repoRoot: resolved.repoRoot
     };
 }
-function commitLocalArtifactProvenance(prepared) {
-    return prepared.result;
-}
 function finalizeLocalArtifact(request) {
     return prepareLocalArtifact(request).result;
 }
@@ -124,5 +121,5 @@ function preflightLocalArtifact(request) {
     const prepared = prepareLocalArtifact(request);
     return prepared.result;
 }
-export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, finalizeLocalArtifact, preflightLocalArtifact, prepareLocalArtifact, commitLocalArtifactProvenance, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
+export { LOCAL_ARTIFACT_REQUIRED_SECTIONS, finalizeLocalArtifact, preflightLocalArtifact, prepareLocalArtifact, canonicalSemanticDigest as semanticDigest, sha256Content, validateLocalArtifact };
 //# sourceMappingURL=local-artifact-finalization.js.map

package/dist/lib/task/manual-validation-evidence.js

@@ -1,5 +1,3 @@
-import fs from 'node:fs';
-import { createHash } from 'node:crypto';
 import { MANUAL_VALIDATION_SHA40 as SHA40, MANUAL_VALIDATION_TASK_ID as TASK_ID, exactKeys, isRecord, validTimestamp } from './manual-validation-shared.js';
 const MANUAL_VALIDATION_EVIDENCE_SCHEMA = 'agent-infra/branch-only-validation-evidence';
 const MANUAL_VALIDATION_EVIDENCE_VERSION = 1;
@@ -92,39 +90,5 @@ function manualValidationEvidenceSummary(evidence) {
         cleanup: evidence.result.cleanup
     };
 }
-function validateManualValidationEvidence(value, expected) {
-    const shape = validateShape(value);
-    if (!shape.ok)
-        return shape;
-    const evidence = shape.value;
-    if (evidence.result.exitCode !== 0 || evidence.result.signal !== null || evidence.result.cleanup !== 'completed') {
-        return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_UNSUCCESSFUL', message: 'validation must exit 0 without a signal and complete cleanup' } };
-    }
-    if (expected) {
-        if (evidence.taskId !== expected.taskId || evidence.branch !== expected.branch) {
-            return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_IDENTITY_MISMATCH', message: 'evidence task or branch does not match the expected identity' } };
-        }
-        if (expected.commit !== undefined && evidence.commit !== expected.commit) {
-            return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_STALE', message: 'evidence commit does not match the current head' } };
-        }
-    }
-    return shape;
-}
-function readManualValidationEvidence(file, expected) {
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch (error) {
-        const code = error.code === 'ENOENT'
-            ? 'MANUAL_VALIDATION_EVIDENCE_MISSING'
-            : 'MANUAL_VALIDATION_EVIDENCE_INVALID';
-        return { ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } };
-    }
-    return validateManualValidationEvidence(parsed, expected);
-}
-function manualValidationEvidenceDigest(evidence) {
-    return createHash('sha256').update(JSON.stringify(evidence), 'utf8').digest('hex');
-}
-export { MANUAL_VALIDATION_EVIDENCE_SCHEMA, MANUAL_VALIDATION_EVIDENCE_VERSION, createManualValidationEvidence, manualValidationEvidenceSummary, manualValidationEvidenceDigest, readManualValidationEvidence, validateManualValidationEvidence };
+export { MANUAL_VALIDATION_EVIDENCE_SCHEMA, MANUAL_VALIDATION_EVIDENCE_VERSION, createManualValidationEvidence, manualValidationEvidenceSummary };
 //# sourceMappingURL=manual-validation-evidence.js.map

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

@@ -6,8 +6,8 @@ import { inspectPlatformCommentOperation, syncPlatformComment } from '../platfor
 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, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
 import { replayPullRequestSummary } from '../platform/pr-summary.js';
@@ -18,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')
@@ -29,8 +30,8 @@ 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');
@@ -170,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',
@@ -204,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)
@@ -291,6 +293,12 @@ function isRecoveryEligible(operation, excludeId) {
     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)
@@ -303,7 +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) => isRecoveryEligible(operation, options.excludeId));
+    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];
@@ -317,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({
@@ -437,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 ?? latestOperation?.lastCode ?? null
+                lastCode: remote.error?.code ?? remote.operations.find((item) => item.status === 'skipped' && item.reasonCode === 'PUSH_REQUIRED')?.reasonCode ?? (succeeded ? null : latestOperation?.lastCode) ?? null
             });
         }
         catch (error) {
@@ -448,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 } : {});
@@ -466,8 +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) => isRecoveryEligible(operation, options.excludeId);
-    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