@fitlab-ai/agent-infra 0.11.8 → 0.11.10

package/dist/lib/task/finalization.js

@@ -619,9 +619,12 @@ function terminalResult(taskId, receipt, steps, changed, error = null) {
     const blocked = [steps.backfill, steps.lifecycle, steps.taskComment, steps.verification, steps.summary].some((step) => step?.status === 'blocked');
     const warnings = openWarnings(receipt);
     const postLifecyclePending = receipt.lifecycle === 'done' && (pending.some((step) => step !== 'lifecycle') || receipt.warningProjection === 'pending');
-    const hardError = error?.code.startsWith('FINALIZATION_') || error?.code === 'TASK_FINALIZATION_RECEIPT_INVALID';
+    const terminalVerificationPending = receipt.lifecycle === 'done' && receipt.verification === 'pending';
+    const resultError = error ?? (terminalVerificationPending ? steps.verification?.error : null) ?? null;
+    const hardError = error?.code.startsWith('FINALIZATION_') || error?.code === 'TASK_FINALIZATION_RECEIPT_INVALID'
+        || terminalVerificationPending;
     return {
-        status: hardError ? (error?.retryable ? 'blocked' : 'failed') : pending.length === 0 ? 'completed' : postLifecyclePending ? 'completed' : blocked ? 'blocked' : 'failed',
+        status: hardError ? (resultError?.retryable ? 'blocked' : 'failed') : pending.length === 0 ? 'completed' : postLifecyclePending ? 'completed' : blocked ? 'blocked' : 'failed',
         changed,
         taskId,
         backfill: steps.backfill ?? null,
@@ -632,7 +635,7 @@ function terminalResult(taskId, receipt, steps, changed, error = null) {
         completedSteps: completedSteps(receipt),
         pendingSteps: pending,
         result: hardError
-            ? (error?.retryable ? 'blocked' : 'failed')
+            ? (resultError?.retryable ? 'blocked' : 'failed')
             : postLifecyclePending
                 ? 'completed_with_warnings'
                 : pending.length === 0
@@ -641,7 +644,7 @@ function terminalResult(taskId, receipt, steps, changed, error = null) {
                         ? 'blocked'
                         : 'failed',
         warnings,
-        error: hardError ? error : postLifecyclePending ? null : error
+        error: hardError ? resultError : postLifecyclePending ? null : resultError
     };
 }
 function preparedResult(taskId, receipt, steps, changed) {
@@ -663,7 +666,6 @@ async function prepareUnderLock(request, taskId, options) {
     const commentSync = options.commentSync ?? syncPlatformComment;
     const issueSync = options.issueSync ?? syncPlatformIssue;
     const issueInspect = options.issueInspect ?? inspectPlatformIssue;
-    const verify = options.verify ?? verifyTaskEvent;
     const consumedCapabilities = new Set();
     let receipt;
     try {
@@ -676,16 +678,6 @@ async function prepareUnderLock(request, taskId, options) {
     catch (error) {
         return failed(taskId, errorOf(error, 'TASK_FINALIZATION_RECEIPT_INVALID'));
     }
-    if (options.controlBinding && (receipt.controlBinding?.generation !== options.controlBinding.generation
-        || receipt.controlBinding.requestId !== options.controlBinding.requestId)) {
-        const state = resolveTaskRef(taskId, { repoRoot });
-        if (!(receipt.lifecycle === 'done' && state.ok && state.state === 'completed')) {
-            return failed(taskId, {
-                code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                message: 'canonical receipt is not bound to the current sandbox request', retryable: false
-            });
-        }
-    }
     const preflightState = resolveTaskRef(taskId, { repoRoot });
     if (options.preflight && preflightState.ok && preflightState.state === 'active') {
         try {
@@ -708,7 +700,7 @@ async function prepareUnderLock(request, taskId, options) {
     if (preflightState.ok && preflightState.state === 'active') {
         const recovery = await recoverPlatformOperations(taskId, 'all', { agent: request.agent, cwd: repoRoot });
         if (recovery.status !== 'applied' && recovery.status !== 'no-op') {
-            return failed(taskId, recovery.error ?? {
+            return failed(taskId, recovery.error ? { ...recovery.error, retryable: true } : {
                 code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
                 message: 'Pending platform operations remain unresolved',
                 retryable: true
@@ -718,12 +710,10 @@ async function prepareUnderLock(request, taskId, options) {
         const taskFrontmatter = parseTaskFrontmatter(taskContent);
         const issueIdentity = taskIssueIdentity(taskFrontmatter);
         if (issueIdentity) {
-            const base = typeof taskFrontmatter.delivery_base_ref === 'string' ? taskFrontmatter.delivery_base_ref.trim() : '';
             let synced;
             try {
                 synced = await issueSync(taskId, {
-                    agent: request.agent, cwd: repoRoot, requirements: true, issueType: true, fields: true,
-                    ...(base ? { inLabels: 'from-diff', base } : {}), dependency: 'required'
+                    agent: request.agent, cwd: repoRoot, requirements: true, issueType: true, fields: true, dependency: 'required'
                 });
             }
             catch (error) {
@@ -731,8 +721,9 @@ async function prepareUnderLock(request, taskId, options) {
                 return failed(taskId, detail);
             }
             const issueOperations = synced.operations;
-            const badOperation = issueOperations?.find((operation) => ['requirements', 'issue-type', 'fields', ...(base ? ['labels:in'] : [])].includes(operation.name)
-                && operation.status !== 'applied' && operation.status !== 'no-op');
+            const badOperation = issueOperations?.find((operation) => ['requirements', 'issue-type', 'fields'].includes(operation.name)
+                && operation.status !== 'applied' && operation.status !== 'no-op'
+                && !(operation.name === 'requirements' && operation.status === 'skipped' && operation.reasonCode === 'NO_REQUIREMENTS_ANCHOR'));
             if ((synced.status !== 'applied' && synced.status !== 'no-op') || synced.error || badOperation) {
                 const error = synced.error ?? {
                     code: badOperation?.reasonCode || 'FINALIZATION_ISSUE_METADATA_UNCONFIRMED',
@@ -756,7 +747,7 @@ async function prepareUnderLock(request, taskId, options) {
                     retryable: true
                 });
             }
-            for (const name of ['requirements', 'issue-type', 'fields', ...(base ? ['labels:in'] : [])]) {
+            for (const name of ['requirements', 'issue-type', 'fields']) {
                 const operation = issueOperations?.find((candidate) => candidate.name === name);
                 if (!operation)
                     return failed(taskId, {
@@ -779,14 +770,6 @@ async function prepareUnderLock(request, taskId, options) {
                             code: 'FINALIZATION_ISSUE_TYPE_UNCONFIRMED', message: 'Issue Type did not match the verified target', retryable: true
                         });
                 }
-                else if (name === 'labels:in') {
-                    const expected = Array.isArray(operation.value) ? operation.value : before?.labels;
-                    if (!expected || expected.filter((label) => label.startsWith('in:')).sort().join('\0')
-                        !== remote.labels.filter((label) => label.startsWith('in:')).sort().join('\0'))
-                        return failed(taskId, {
-                            code: 'FINALIZATION_IN_LABELS_UNCONFIRMED', message: 'Issue in-labels did not match the verified target', retryable: true
-                        });
-                }
                 else {
                     const expected = operation.value && typeof operation.value === 'object'
                         ? operation.value
@@ -907,88 +890,9 @@ async function prepareUnderLock(request, taskId, options) {
             metadataProvider: () => ({ timestamp: projection.timestamp, agentInfraVersion: projection.agentInfraVersion })
         })
         : undefined;
-    let verification = null;
-    if (receipt.verification !== 'pending') {
-        verification = { status: receipt.verification === 'skipped' ? 'skipped' : 'no-op', changed: false, error: null };
-    }
-    else {
-        try {
-            receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-            const verificationState = resolveTaskRef(taskId, { repoRoot });
-            const verificationEvent = verificationState.ok && verificationState.state === 'completed'
-                ? 'complete-task.completed'
-                : 'complete-task.prepared';
-            const result = await verify({ taskRef: taskId, event: verificationEvent }, { repoRoot });
-            verification = verificationStep(result);
-            if (result.status === 'pass') {
-                const resolvedTaskWarning = receipt.warnings.some((warning) => warning.step === 'verification' && warning.status === 'open');
-                const warnings = applyVerificationWarnings(receipt, result);
-                receipt = updateReceipt(repoRoot, receipt, {
-                    verification: 'done', taskComment: resolvedTaskWarning ? 'pending' : receipt.taskComment,
-                    warningProjection: warnings.length > 0 ? 'pending' : 'done', warnings, lastError: null
-                });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-                const finalComment = await syncPendingTaskComment({
-                    repoRoot, taskId, agent: request.agent, receipt, projection: currentProjection(), refreshProjection: currentProjection, commentSync, consumedCapabilities
-                });
-                receipt = finalComment.receipt;
-                if (finalComment.step.status !== 'no-op')
-                    taskComment = finalComment.step;
-                changed = changed || finalComment.changed;
-                if (finalComment.error) {
-                    return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification }, changed, finalComment.error);
-                }
-            }
-            else {
-                const detail = verification.error ?? { code: 'VERIFY_FAILED', message: 'verification failed', retryable: true };
-                const warnings = applyVerificationWarnings(receipt, result);
-                receipt = updateReceipt(repoRoot, receipt, {
-                    verification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: detail
-                });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-                const warningComment = await syncPendingTaskComment({
-                    repoRoot, taskId, agent: request.agent, receipt, projection: currentProjection(), refreshProjection: currentProjection, commentSync, consumedCapabilities
-                });
-                receipt = warningComment.receipt;
-                taskComment = warningComment.step;
-                changed = changed || warningComment.changed;
-                if (warningComment.error) {
-                    return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification }, changed, warningComment.error);
-                }
-                return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification }, changed, detail);
-            }
-        }
-        catch (error) {
-            const detail = errorOf(error, 'VERIFY_FAILED', true);
-            try {
-                const warnings = replaceWarning(receipt, warningFromError('verification', detail), 'open');
-                receipt = updateReceipt(repoRoot, receipt, {
-                    verification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: detail
-                });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-            }
-            catch (writeError) {
-                const persistence = errorOf(writeError, 'FINALIZATION_RECEIPT_WRITE_FAILED', true);
-                const hardError = {
-                    code: 'FINALIZATION_RECEIPT_WRITE_FAILED',
-                    message: `Unable to persist verification failure (${detail.code}: ${detail.message}): ${persistence.message}`,
-                    retryable: true
-                };
-                return terminalResult(taskId, receipt, {
-                    backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail }
-                }, changed, hardError);
-            }
-            try {
-                const warningComment = await syncPendingTaskComment({ repoRoot, taskId, agent: request.agent, receipt, projection: currentProjection(), refreshProjection: currentProjection, commentSync, consumedCapabilities });
-                receipt = warningComment.receipt;
-                if (warningComment.step.status !== 'no-op')
-                    taskComment = warningComment.step;
-                changed = changed || warningComment.changed;
-            }
-            catch { /* preserve the primary error */ }
-            return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail } }, changed, detail);
-        }
-    }
+    const verification = receipt.verification === 'done'
+        ? { status: 'no-op', changed: false, error: null }
+        : { status: 'skipped', changed: false, error: null };
     let summary = receipt.summary === 'pending'
         ? await syncPendingSummary({ repoRoot, taskId, agent: request.agent, receipt, commentSync })
         : { receipt, step: { status: 'no-op', changed: false, error: null }, changed: false, error: null };
@@ -1039,7 +943,7 @@ async function commitPreparedTaskFinalization(request, options) {
     if (!resolved.ok)
         return failed(resolved.taskId, { code: resolved.code, message: resolved.message, retryable: false });
     try {
-        return await withTaskExecutionLock(repoRoot, resolved.taskId, 'task-finalization.commit', () => {
+        return await withTaskExecutionLock(repoRoot, resolved.taskId, 'task-finalization.commit', async () => {
             if (options.controlBinding && options.manifestPath) {
                 try {
                     const manifest = readSandboxControlManifest(options.manifestPath);
@@ -1065,6 +969,7 @@ async function commitPreparedTaskFinalization(request, options) {
                 }
             }
             let receipt = readReceipt(repoRoot, resolved.taskId);
+            let importedHandoff = false;
             if (!receipt && options.controlBinding && options.handoffDirectory && request.handoffSha256) {
                 try {
                     const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
@@ -1075,6 +980,7 @@ async function commitPreparedTaskFinalization(request, options) {
                         throw new Error('TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE');
                     }
                     writeReceipt(repoRoot, receipt);
+                    importedHandoff = true;
                     try {
                         handoff.cleanup();
                     }
@@ -1091,32 +997,24 @@ async function commitPreparedTaskFinalization(request, options) {
                 return failed(resolved.taskId, {
                     code: 'TASK_FINALIZATION_PREPARATION_REQUIRED', message: 'sandbox preparation receipt is unavailable', retryable: true
                 });
-            if (receipt.lifecycle === 'done' && resolved.state === 'completed') {
+            if (receipt.lifecycle === 'done' && receipt.verification !== 'pending' && resolved.state === 'completed') {
                 return terminalResult(resolved.taskId, receipt, { lifecycle: { status: 'no-op', changed: false, error: null } }, false);
             }
             if (options.controlBinding) {
                 const proof = inspectTaskLifecycleProgress(repoRoot, resolved.taskId, request.agent);
-                const oldBinding = receipt.controlBinding;
-                if (!oldBinding || oldBinding.generation !== options.controlBinding.generation || proof === 'unknown') {
+                if (proof === 'unknown') {
                     return failed(resolved.taskId, {
                         code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                        message: 'canonical receipt has no valid host recovery proof', retryable: false
+                        message: 'task lifecycle progress cannot be verified', retryable: false
                     });
                 }
-                if (oldBinding.requestId !== options.controlBinding.requestId && proof === 'not-started') {
-                    if (receipt.lifecycle !== 'pending' || !options.handoffDirectory || !request.handoffSha256) {
-                        return failed(resolved.taskId, {
-                            code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                            message: 'pending receipt cannot be rebound without a current handoff', retryable: false
-                        });
-                    }
+                if (!importedHandoff && options.handoffDirectory && request.handoffSha256) {
                     try {
                         const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
                         const nextReceipt = validateReceipt(handoff.receipt, resolved.taskId);
                         if (nextReceipt.receiptId !== receipt.receiptId || nextReceipt.intent !== receipt.intent
-                            || nextReceipt.lifecycle !== 'pending')
+                            || nextReceipt.lifecycle !== receipt.lifecycle)
                             throw new Error('handoff is not continuous with canonical receipt');
-                        receipt = updateReceipt(repoRoot, receipt, { controlBinding: options.controlBinding });
                         try {
                             handoff.cleanup();
                         }
@@ -1130,7 +1028,7 @@ async function commitPreparedTaskFinalization(request, options) {
                     }
                 }
             }
-            if (receipt.taskComment === 'pending' || receipt.verification === 'pending' || receipt.summary === 'pending' || receipt.warningProjection === 'pending') {
+            if (receipt.taskComment === 'pending' || receipt.summary === 'pending' || receipt.warningProjection === 'pending') {
                 return failed(resolved.taskId, {
                     code: 'TASK_FINALIZATION_PREPARATION_REQUIRED', message: 'sandbox preparation has pending external steps', retryable: true
                 }, { completedSteps: completedSteps(receipt), pendingSteps: pendingSteps(receipt), warnings: openWarnings(receipt) });
@@ -1142,6 +1040,7 @@ async function commitPreparedTaskFinalization(request, options) {
                     message: `cannot verify canonical short-id registry: ${registry.error.code}: ${registry.error.message}`,
                     retryable: false
                 });
+            receipt = updateReceipt(repoRoot, receipt, { verification: 'pending' });
             const lifecycle = options.lifecycle ?? applyTaskLifecycle;
             const result = lifecycle({ taskRef: resolved.taskId, intent: 'complete', agent: request.agent }, { repoRoot, ...(options.metadataProvider ? { metadataProvider: options.metadataProvider } : {}) });
             const step = lifecycleStep(result);
@@ -1149,8 +1048,80 @@ async function commitPreparedTaskFinalization(request, options) {
                 const updated = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: step.error });
                 return terminalResult(resolved.taskId, updated, { lifecycle: step }, result.changed, step.error);
             }
-            const updated = updateReceipt(repoRoot, receipt, { lifecycle: 'done', lastError: null });
-            return terminalResult(resolved.taskId, updated, { lifecycle: step }, result.changed);
+            let verificationResult;
+            try {
+                verificationResult = await (options.verify ?? verifyTaskEvent)({ taskRef: resolved.taskId, event: 'complete-task.completed' }, { repoRoot });
+            }
+            catch (error) {
+                const detail = errorOf(error, 'VERIFY_FAILED', true);
+                const warnings = replaceWarning(receipt, warningFromError('verification', detail), 'open');
+                let updated;
+                try {
+                    updated = updateReceipt(repoRoot, receipt, {
+                        lifecycle: 'done', verification: 'pending', taskComment: 'pending', warningProjection: 'pending',
+                        warnings, lastError: detail
+                    });
+                }
+                catch (persistCause) {
+                    const persistError = errorOf(persistCause, 'FINALIZATION_RECEIPT_WRITE_FAILED', true);
+                    persistError.code = 'FINALIZATION_RECEIPT_WRITE_FAILED';
+                    persistError.message = `${persistError.message}; verification also failed: ${detail.code}: ${detail.message}`;
+                    return failed(resolved.taskId, persistError, {
+                        changed: result.changed,
+                        lifecycle: step,
+                        verification: { status: 'blocked', changed: false, error: persistError },
+                        completedSteps: completedSteps(receipt), pendingSteps: pendingSteps(receipt), warnings: openWarnings(receipt)
+                    });
+                }
+                const verification = { status: detail.retryable ? 'blocked' : 'failed', changed: false, error: detail };
+                return terminalResult(resolved.taskId, updated, { lifecycle: step, verification }, result.changed, detail);
+            }
+            const verification = verificationStep(verificationResult);
+            if (verificationResult.status === 'pass') {
+                const resolvedVerificationWarning = receipt.warnings.some((warning) => warning.step === 'verification' && warning.status === 'open');
+                const warnings = applyVerificationWarnings(receipt, verificationResult);
+                const hasOpenWarnings = warnings.some((warning) => warning.status === 'open');
+                let updated;
+                try {
+                    updated = updateReceipt(repoRoot, receipt, {
+                        lifecycle: 'done', verification: 'done',
+                        taskComment: resolvedVerificationWarning ? 'pending' : receipt.taskComment,
+                        warningProjection: hasOpenWarnings ? 'pending' : 'done', warnings, lastError: null
+                    });
+                }
+                catch (persistCause) {
+                    const persistError = errorOf(persistCause, 'FINALIZATION_RECEIPT_WRITE_FAILED', true);
+                    persistError.code = 'FINALIZATION_RECEIPT_WRITE_FAILED';
+                    return failed(resolved.taskId, persistError, {
+                        changed: result.changed,
+                        lifecycle: step,
+                        verification,
+                        completedSteps: completedSteps(receipt), pendingSteps: pendingSteps(receipt), warnings: openWarnings(receipt)
+                    });
+                }
+                return terminalResult(resolved.taskId, updated, { lifecycle: step, verification }, result.changed);
+            }
+            const detail = verification.error ?? { code: 'VERIFY_FAILED', message: 'verification failed', retryable: true };
+            const warnings = applyVerificationWarnings(receipt, verificationResult);
+            let updated;
+            try {
+                updated = updateReceipt(repoRoot, receipt, {
+                    lifecycle: 'done', verification: 'pending', taskComment: 'pending', warningProjection: 'pending',
+                    warnings, lastError: detail
+                });
+            }
+            catch (persistCause) {
+                const persistError = errorOf(persistCause, 'FINALIZATION_RECEIPT_WRITE_FAILED', true);
+                persistError.code = 'FINALIZATION_RECEIPT_WRITE_FAILED';
+                persistError.message = `${persistError.message}; verification also failed: ${detail.code}: ${detail.message}`;
+                return failed(resolved.taskId, persistError, {
+                    changed: result.changed,
+                    lifecycle: step,
+                    verification: { status: 'blocked', changed: false, error: persistError },
+                    completedSteps: completedSteps(receipt), pendingSteps: pendingSteps(receipt), warnings: openWarnings(receipt)
+                });
+            }
+            return terminalResult(resolved.taskId, updated, { lifecycle: step, verification }, result.changed, detail);
         });
     }
     catch (error) {

package/dist/lib/task/frontmatter.js

@@ -47,7 +47,7 @@ function serializeScalar(value) {
     }
     if (value === '')
         return '';
-    const serialized = stringify(value).trimEnd();
+    const serialized = stringify(value, { lineWidth: 0 }).trimEnd();
     if (serialized.includes('\n') || serialized.includes('\r')) {
         throw new FrontmatterError('MUTATION_INVALID', 'frontmatter values must be scalar');
     }

package/dist/lib/task/ledger-intents.js

@@ -10,6 +10,7 @@ import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkInten
 import { extractSection, extractSubSection } from './sections.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { scanVisibleMarkdown } from './markdown.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
@@ -61,9 +62,8 @@ function findingEvidence(reviewContent, evidence) {
     return semanticFindingEvidence(reviewContent, heading, next?.start ?? reviewContent.length);
 }
 function taskFactDigest(taskDir, content) {
-    const analysisNames = fs.readdirSync(taskDir).filter((name) => /^analysis(?:-r\d+)?\.md$/.test(name));
-    const latest = analysisNames.map((name) => ({ name, round: parseArtifactName(name)?.round ?? 0 })).sort((a, b) => b.round - a.round)[0];
-    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latest.name), 'utf8')) : null;
+    const latest = inspectArtifactDirectory(taskDir, 'analysis').latest;
+    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(latest.path, 'utf8'), latest.name) : null;
     return semanticDigest(JSON.stringify({
         taskInput: normalizedTaskFact(extractSection(content, ['任务输入', 'Task Input'])),
         requirements: normalizedTaskFact(extractSection(content, ['需求', 'Requirements'])),
@@ -220,10 +220,7 @@ function applyLedgerIntent(intent, options = {}) {
             }
             const sourceIdentity = parseArtifactName(intent.sourceArtifact);
             const expectedFamily = `review-${finding.stage}`;
-            const latestSource = fs.readdirSync(resolved.taskDir)
-                .map((name) => parseArtifactName(name))
-                .filter((identity) => identity?.family === expectedFamily)
-                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            const latestSource = inspectArtifactDirectory(resolved.taskDir, expectedFamily).latest;
             if (!sourceIdentity || sourceIdentity.family !== expectedFamily || latestSource?.name !== sourceIdentity.name) {
                 return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact is not the latest review for the finding stage', resolved.taskId);
             }

package/dist/lib/task/orchestration.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
-import { artifactName, maxArtifactRound } from './artifact-name.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
@@ -20,7 +20,6 @@ import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead,
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
-import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { resolveArtifactContext } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
@@ -441,8 +440,11 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
     return { status: 'running', changed: true, taskId: resolved.taskId, run, next: null, error: null };
 }
 function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead) {
-    const reviewRound = maxArtifactRound(fs.readdirSync(taskDir), 'review-code');
-    const reviewContent = fs.readFileSync(path.join(taskDir, artifactName('review-code', reviewRound)), 'utf8');
+    const reviewInventory = inspectArtifactDirectory(taskDir, 'review-code');
+    if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+        return { code: 'ORCHESTRATION_REVIEW_INVALID', message: 'latest completed review-code artifact is unavailable' };
+    }
+    const reviewContent = fs.readFileSync(reviewInventory.latest.path, 'utf8');
     const savedTargetHead = extractReviewTargetHead(reviewContent);
     const savedDiffBase = extractReviewDiffBase(reviewContent);
     const savedReviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
@@ -540,8 +542,11 @@ function routeOrchestration(taskRef, options = {}) {
         if (facts.facts.executionBusy && !run?.pendingDelegation) {
             return failed('ORCHESTRATION_EXECUTION_BUSY', 'clean completion requires no open lifecycle execution', resolved.taskId);
         }
-        const reviewRound = maxArtifactRound(fs.readdirSync(resolved.taskDir), 'review-code');
-        const review = parseReviewSummary(fs.readFileSync(path.join(resolved.taskDir, artifactName('review-code', reviewRound)), 'utf8'));
+        const reviewInventory = inspectArtifactDirectory(resolved.taskDir, 'review-code');
+        if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+            return failed('ORCHESTRATION_REVIEW_INVALID', 'latest completed review-code artifact is unavailable', resolved.taskId);
+        }
+        const review = parseReviewSummary(fs.readFileSync(reviewInventory.latest.path, 'utf8'));
         if (!review.ok || review.summary.manualValidation === null) {
             return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
         }
@@ -678,10 +683,6 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     if (run.stepCount >= run.maxSteps)
         return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
-    const invalidation = reconcileTaskInvalidation(taskRef, { repoRoot: resolved.repoRoot });
-    if (invalidation.status === 'failed') {
-        return failed('ORCHESTRATION_INVALIDATION_RECONCILE_FAILED', `${invalidation.error?.code ?? 'UNKNOWN'}: ${invalidation.error?.message ?? ''}`, resolved.taskId);
-    }
     const routed = routeOrchestration(taskRef, options);
     if (!routed.next)
         return routed;

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

@@ -4,7 +4,6 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isResourceIdentity } from '../platform/resource-identity.js';
 import { resolveTaskRef } from './resolve-ref.js';
 const JOURNAL_FILE = '.platform-operations.json';
-const MAX_ATTEMPTS = 3;
 function operationId(input) {
     return createHash('sha256')
         .update(`${input.kind}\0${input.target}\0${input.expectedDigest}`)
@@ -36,8 +35,7 @@ function parseJournal(file, taskId) {
             || !/^[a-f0-9]{64}$/u.test(item.expectedDigest)
             || !['deferred', 'required'].includes(item.dependency)
             || !['queued', 'pending', 'unknown', 'succeeded', 'failed'].includes(item.state)
-            || !Number.isSafeInteger(item.attempts) || item.attempts < 0 || item.attempts > MAX_ATTEMPTS
-            || item.maxAttempts !== MAX_ATTEMPTS
+            || !Number.isSafeInteger(item.attempts) || item.attempts < 0
             || !(item.lastCode === null || typeof item.lastCode === 'string')
             || (item.kind === 'issue-metadata'
                 ? !item.issueMetadata || typeof item.issueMetadata.requirements !== 'boolean'
@@ -120,7 +118,13 @@ function recordPlatformOperation(input) {
     const { taskId, file } = resolveJournal(input.taskRef, input.cwd);
     const journal = parseJournal(file, taskId);
     const id = operationId(input);
-    const previous = journal.operations.find((item) => item.id === id);
+    const targetIndex = journal.operations.findIndex((item) => item.id === id);
+    const replacementIndex = input.replaceOperationId
+        ? journal.operations.findIndex((item) => item.id === input.replaceOperationId)
+        : -1;
+    const target = targetIndex >= 0 ? journal.operations[targetIndex] : undefined;
+    const replacement = replacementIndex >= 0 ? journal.operations[replacementIndex] : undefined;
+    const previousAttempts = Math.max(target?.attempts ?? 0, replacement?.attempts ?? 0);
     const next = {
         id,
         kind: input.kind,
@@ -128,8 +132,7 @@ function recordPlatformOperation(input) {
         expectedDigest: input.expectedDigest,
         dependency: input.dependency,
         state: input.state,
-        attempts: Math.min(MAX_ATTEMPTS, (previous?.attempts ?? 0) + (input.state === 'pending' ? 1 : 0)),
-        maxAttempts: MAX_ATTEMPTS,
+        attempts: previousAttempts + (input.state === 'pending' ? 1 : 0),
         lastCode: input.lastCode ?? null,
         ...(input.issueMetadata ? { issueMetadata: input.issueMetadata } : {}),
         ...(input.issueCreate ? { issueCreate: input.issueCreate } : {}),
@@ -138,9 +141,13 @@ function recordPlatformOperation(input) {
         ...(input.pullRequestReview ? { pullRequestReview: input.pullRequestReview } : {}),
         updatedAt: new Date().toISOString()
     };
-    const operations = previous
-        ? journal.operations.map((item) => item.id === id ? next : item)
-        : [...journal.operations, next];
+    const operations = replacementIndex >= 0
+        ? journal.operations.flatMap((item, index) => index === replacementIndex
+            ? [next]
+            : index === targetIndex ? [] : [item])
+        : targetIndex >= 0
+            ? journal.operations.map((item, index) => index === targetIndex ? next : item)
+            : [...journal.operations, next];
     writeJournal(file, { version: 1, taskId, operations });
     return next;
 }
@@ -148,5 +155,5 @@ function readPlatformOperationJournal(taskRef, cwd) {
     const { taskId, file } = resolveJournal(taskRef, cwd);
     return parseJournal(file, taskId);
 }
-export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, MAX_ATTEMPTS as PLATFORM_OPERATION_MAX_ATTEMPTS, operationId, recordPlatformOperation, readPlatformOperationJournal };
+export { JOURNAL_FILE as PLATFORM_OPERATION_JOURNAL_FILE, operationId, recordPlatformOperation, readPlatformOperationJournal };
 //# sourceMappingURL=platform-operation-journal.js.map