@fitlab-ai/agent-infra 0.9.15 → 0.10.0

package/dist/lib/task/commit-operation.js

@@ -181,6 +181,16 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
+function samePreparedCheckpointIdentity(pending, identity) {
+    return pending.state === 'prepared'
+        && pending.taskId === identity.taskId
+        && pending.branch === identity.branch
+        && pending.mode === identity.mode
+        && pending.expectedHead === identity.expectedHead
+        && pending.message === identity.message
+        && pending.round === identity.round
+        && JSON.stringify(pending.paths) === JSON.stringify(identity.paths);
+}
 function executeUnlocked(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
@@ -214,11 +224,28 @@ function executeUnlocked(input, task, mode) {
                     error: { code: 'COMMIT_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) }
                 };
             }
-            if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity))
-                return {
-                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
-                    error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+            if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
+                if (!input.recoverPreparedIntent || !samePreparedCheckpointIdentity(pendingIntent, identity))
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+                    };
+                pendingIntent = {
+                    ...pendingIntent,
+                    expectedTree: identity.expectedTree,
+                    digest: checkpointIntentDigest(identity),
+                    updatedAt: checkpointTimestamp()
                 };
+                try {
+                    writeCheckpointIntent(task.repoRoot, pendingIntent);
+                }
+                catch (error) {
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_WRITE_FAILED', message: error instanceof Error ? error.message : String(error) }
+                    };
+                }
+            }
             if (!pendingIntent) {
                 const timestamp = checkpointTimestamp();
                 pendingIntent = {

package/dist/lib/task/control-authority.js

@@ -8,12 +8,13 @@ import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegatio
 import { prepareCodexOrchestrationDelegation } from './codex-orchestration.js';
 import { applyTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle, taskLifecycleFailure } from './lifecycle.js';
+import { recoverStartedLifecycleUnderLock, recoveryFailure } from './lifecycle-recovery.js';
 import { locateActivityLog } from './activity-log.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { findArtifactRepairIntentsByOperation, writeArtifactRepairIntent } from './artifact-repair-intent.js';
+import { findArtifactRecoveryIntentsByOperation, writeArtifactRecoveryIntent } from './artifact-repair-intent.js';
 import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 const lifecycleAuthorityPhases = [
     'orchestration.prepare', 'artifact.finalize-local', 'task-event.completed'
@@ -184,7 +185,7 @@ export function queryLifecycleRecoveryOperation(operationId, options = {}) {
     const store = options.capabilityStore ?? createCodexCapabilityStore();
     const registry = authorityOperationMap.get(store);
     const known = [...(registry?.values() ?? [])].filter((value) => value.operationId === operationId);
-    const intents = options.repoRoot ? findArtifactRepairIntentsByOperation(options.repoRoot, operationId) : [];
+    const intents = options.repoRoot ? findArtifactRecoveryIntentsByOperation(options.repoRoot, operationId) : [];
     const capabilities = store.findByRecoveryOperation(operationId);
     const phaseMap = new Map();
     for (const capability of capabilities) {
@@ -312,19 +313,19 @@ export function recoverLifecycleRecoveryOperation(input, options) {
     if (!phase) {
         throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PHASE_MISSING', 'durable task completion phase is missing');
     }
-    const intents = findArtifactRepairIntentsByOperation(options.repoRoot, selector.operationId)
+    const intents = findArtifactRecoveryIntentsByOperation(options.repoRoot, selector.operationId)
         .filter((intent) => intent.taskId === selector.taskId
         && intent.family === selector.family
         && intent.artifact === selector.artifact);
     if (intents.length !== 1) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact repair intent does not identify this task event');
+        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not identify this task event');
     }
     const intent = intents[0];
     if (!lifecycleRecoveryIntentMatches(intent, selector)
         || intent.phase !== selector.phase
         || intent.requestId !== selector.lifecycleRequestId
         || intent.authorityDigest === null) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact repair intent does not match the recovery request');
+        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not match the recovery request');
     }
     if (!lifecycleRecoveryEventCommitted(selector, options.repoRoot)) {
         throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_COMMIT_UNCONFIRMED', 'task completion is not durably present; compensation is not allowed');
@@ -339,7 +340,7 @@ export function recoverLifecycleRecoveryOperation(input, options) {
         throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_STATE_INVALID', 'consumed capability has an unconsumed completion phase');
     }
     if (intent.state !== 'consumed') {
-        writeArtifactRepairIntent(options.repoRoot, {
+        writeArtifactRecoveryIntent(options.repoRoot, {
             ...intent,
             state: 'consumed',
             updatedAt: (options.now ?? Date.now)()
@@ -473,6 +474,9 @@ async function applyLifecycleWithAuthority(context, request) {
         return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
     }
     const execute = async () => {
+        if (request.intent === 'recover-started') {
+            return recoverStartedLifecycleUnderLock(request, { repoRoot: context.repoRoot });
+        }
         const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
         if (lifecycleResult.status !== 'failed' || !request.overrideTicket)
             return lifecycleResult;
@@ -506,6 +510,9 @@ async function applyLifecycleWithAuthority(context, request) {
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
             throw error;
+        if (request.intent === 'recover-started') {
+            return recoveryFailure(request, 'owner-unknown', error.code, error.message);
+        }
         return taskLifecycleFailure(request, { code: error.code, message: error.message }, taskId);
     }
 }
@@ -616,7 +623,7 @@ function operationInvalid(message) {
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+    '--stage', '--round', '--artifact', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
 ]);
 const FINALIZATION_FLAGS = new Set(['--agent']);
 const ORCHESTRATION_FLAGS = new Set([
@@ -692,8 +699,32 @@ export function parseTaskControlOperation(family, args) {
             ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
             ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
             ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
+            ...(value(values, '--stage') ? { stage: value(values, '--stage') } : {}),
+            ...(value(values, '--round') ? { round: Number(value(values, '--round')) } : {}),
+            ...(value(values, '--artifact') ? { artifact: value(values, '--artifact') } : {}),
             ...(values['--dry-run'] === true ? { dryRun: true } : {})
         };
+        if (intent === 'recover-started') {
+            const recoveryFlags = new Set(['--agent', '--stage', '--round', '--artifact', '--reason']);
+            for (const flag of Object.keys(values)) {
+                if (!recoveryFlags.has(flag))
+                    operationInvalid(`option '${flag}' is not supported for recover-started`);
+            }
+            required(values, ['--stage', '--round', '--artifact', '--reason']);
+            const stage = value(values, '--stage');
+            if (!['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(stage ?? '')) {
+                operationInvalid('--stage must be a supported lifecycle stage');
+            }
+            const round = Number(value(values, '--round'));
+            if (!Number.isSafeInteger(round) || round < 1)
+                operationInvalid('--round must be a positive integer');
+            if (value(values, '--reason').includes('\n') || value(values, '--reason').includes('\r')) {
+                operationInvalid('--reason must be a single line');
+            }
+        }
+        else if (values['--stage'] !== undefined || values['--round'] !== undefined || values['--artifact'] !== undefined) {
+            operationInvalid('--stage, --round, and --artifact are only supported for recover-started');
+        }
         return { family, request: input };
     }
     const values = parseValues(args, 2, ORCHESTRATION_FLAGS);

package/dist/lib/task/control-recovery.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { isCompletionEvidence } from './orchestration.js';
 import { TASK_WORKFLOW_OPERATIONS } from './workflow-command.js';
+import { sameRecoveryWarning } from './recovery-warning.js';
 /** Normalize the command result once at the control transport boundary. */
 export function parseControlOutput(output) {
     if (output === null)
@@ -18,7 +19,7 @@ export function parseControlOutput(output) {
 export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
-const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'];
+const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
 const ORCHESTRATION_INTENTS = [
     'begin-or-resume', 'route.read', 'route.clean-completion', 'status', 'prepare', 'dispatch',
     'await-activation', 'recover-prepared', 'hook-start', 'hook-stop', 'advance', 'pause'
@@ -65,6 +66,15 @@ function domainEvidenceMatches(operation, result, domain) {
             && snapshot.worktreeTree === completion.worktreeTree
             && lastReviewedCommit === completion.lastReviewedCommit;
     }
+    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') {
+        const retryRequired = domain.recoveryState === 'retry-required'
+            && sameRecoveryWarning(domain.warning, result.warning);
+        return result.targetState === 'active'
+            && ['applied', 'no-op'].includes(String(result.status))
+            && domain.recovery === true
+            && domain.targetState === 'active'
+            && (domain.recoveryState === 'released' || retryRequired);
+    }
     if (operation.class === 'read-only')
         return result.changed === false && domain.snapshotValid === true;
     return true;
@@ -119,7 +129,9 @@ export function classifySandboxControlRecovery(input) {
         responseReconstructable: true,
         reasonCode: input.operation.class === 'route.clean-completion' && result.changed === false
             ? 'RECOVERY_ROUTE_COMPLETION_NOOP'
-            : 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
+            : input.operation.intent === 'recover-started' && input.domain?.recoveryState === 'retry-required'
+                ? 'RECOVERY_RELEASE_RETRY_REQUIRED'
+                : 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
     };
 }
 export function operationRecoveryBinding(requestId, generation, taskId, family, intent) {

package/dist/lib/task/create-service.js

@@ -1,5 +1,3 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { syncPlatformComment } from '../platform/issue-comments.js';
 import { createPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { VERSION } from '../version.js';
@@ -139,11 +137,6 @@ function platformOperations(prefix, operations) {
         reasonCode: operation.reasonCode ?? null
     }));
 }
-function issueFromTask(repoRoot, taskId) {
-    const content = fs.readFileSync(path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md'), 'utf8');
-    const match = /^issue_number:\s*(\d+)\s*$/m.exec(content);
-    return match ? { number: Number(match[1]), url: '' } : null;
-}
 async function createTask(value, options) {
     const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
     let candidate;
@@ -163,7 +156,7 @@ async function createTask(value, options) {
     const operations = [{
             name: 'task:local', status: local.status, reasonCode: null
         }];
-    let issue = issueFromTask(options.repoRoot, local.task.id);
+    let issue = null;
     const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
     operations.push(...platformOperations('platform-create', created.operations));
     if (created.issue)

package/dist/lib/task/delegation-receipts.js

@@ -92,7 +92,8 @@ function hasCurrentCodexEvidence(receipt) {
     const provenance = receipt.lifecycleProvenance;
     if (!provenance)
         return false;
-    const activated = ['activated', 'stage-completed', 'sealed', 'consumed'].includes(receipt.status);
+    const activated = ['activated', 'stage-completed', 'sealed', 'consumed'].includes(receipt.status)
+        || (receipt.status === 'aborted' && receipt.activatedAt !== null);
     if (!activated)
         return receipt.hostEvidence === null;
     const host = receipt.hostEvidence;
@@ -124,6 +125,12 @@ function hasCurrentCodexEvidence(receipt) {
             && host.consumer === receipt.id
             && exactText(host.consumedAt);
     }
+    if (receipt.status === 'aborted') {
+        return Number.isSafeInteger(host.stopRevision)
+            && host.stopRevision > host.startRevision
+            && host.consumer === `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+            && exactText(host.consumedAt);
+    }
     return host.stopRevision === null && host.consumer === null && host.consumedAt === null;
 }
 const RECEIPT_KEYS = [
@@ -147,7 +154,8 @@ function hasStatusBoundEvidence(receipt) {
     const dispatchComplete = dispatchFields.every((field) => field !== null);
     if (!dispatchEmpty && !dispatchComplete)
         return false;
-    const beforeActivation = ['prepared', 'aborted', 'expired'].includes(receipt.status);
+    const beforeActivation = ['prepared', 'expired'].includes(receipt.status)
+        || (receipt.status === 'aborted' && receipt.activatedAt === null);
     if (beforeActivation) {
         return receipt.parentId === null
             && receipt.childId === null
@@ -181,6 +189,20 @@ function hasStatusBoundEvidence(receipt) {
             && receipt.sealedAt === null
             && receipt.consumedAt === null;
     }
+    if (receipt.status === 'aborted') {
+        const host = receipt.hostEvidence;
+        return receipt.agent === null
+            && receipt.afterFingerprint === null
+            && receipt.changedPaths.length === 0
+            && receipt.sealedAt === null
+            && receipt.consumedAt === null
+            && host !== null
+            && host !== undefined
+            && Number.isSafeInteger(host.stopRevision)
+            && host.stopRevision > host.startRevision
+            && host.consumer === `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+            && exactText(host.consumedAt);
+    }
     if (!exactText(receipt.agent)
         || normalizeAgentToken(receipt.agent) !== normalizeAgentToken(receipt.client))
         return false;
@@ -429,6 +451,45 @@ function abortPreparedDelegation(receipt) {
         receipt: Object.freeze({ ...receipt, status: 'aborted' })
     };
 }
+function abortActivatedDelegation(receipt, event) {
+    if (receipt.status !== 'activated') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
+    }
+    if (receipt.client !== 'codex'
+        || !receipt.lifecycleProvenance
+        || receipt.hostEvidence?.kind !== 'codex-lifecycle-v2'
+        || typeof receipt.lifecycleProvenance.controllerInstanceDigest !== 'string'
+        || typeof receipt.lifecycleProvenance.controlGeneration !== 'string'
+        || typeof receipt.hostEvidence.controllerInstanceDigest !== 'string'
+        || typeof receipt.hostEvidence.controlGeneration !== 'string') {
+        return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'activated delegation lacks the current Codex controller binding');
+    }
+    if (event.childId !== receipt.childId
+        || !Number.isSafeInteger(event.stopRevision)
+        || event.stopRevision <= receipt.hostEvidence.startRevision
+        || event.consumer !== `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+        || !exactText(event.consumedAt)) {
+        return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'recovery stop evidence does not match the activated delegation');
+    }
+    return {
+        ok: true,
+        receipt: Object.freeze({
+            ...receipt,
+            status: 'aborted',
+            agent: null,
+            afterFingerprint: null,
+            changedPaths: Object.freeze([]),
+            sealedAt: null,
+            consumedAt: null,
+            hostEvidence: Object.freeze({
+                ...receipt.hostEvidence,
+                stopRevision: event.stopRevision,
+                consumer: event.consumer,
+                consumedAt: event.consumedAt
+            })
+        })
+    };
+}
 function completeDelegationStage(receipt, event) {
     if (receipt.status !== 'activated')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
@@ -494,5 +555,5 @@ function consumeDelegation(receipt, options = {}) {
             consumedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }
-export { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation };
+export { activateDelegation, abortActivatedDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation };
 //# sourceMappingURL=delegation-receipts.js.map

package/dist/lib/task/events.js

@@ -16,13 +16,14 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { allowsManualOverride } from './guard-override.js';
 import { consumeLocalArtifactFinalizationIntent, readLocalArtifactFinalizationIntent, validateLocalArtifact } from './local-artifact-finalization.js';
-import { writeArtifactRepairIntent } from './artifact-repair-intent.js';
+import { writeArtifactRecoveryIntent, readArtifactRecoveryIntent } from './artifact-repair-intent.js';
+import { reconcileArtifactRecovery, recoveryContextFromIntent, sha256Content } from './artifact-recovery.js';
 import { buildLifecycleFacts, canStart } from './capabilities.js';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.js';
 import { ARTIFACT_FAMILIES, expectedQualificationRelations, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest, validateQualificationAudit } from './qualification-audit.js';
 import { getArtifactSchema } from './artifact-schema.js';
-import { inspectArtifactContract } from './artifact-operations.js';
+import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { consumeLifecycleRecoveryAttestation, lifecycleRecoveryAttestationDigest, validateLifecycleRecoveryAttestation } from './control-authority.js';
 import { readManualValidationCompletion } from './manual-validation-completion.js';
 const eventCatalog = [
@@ -314,6 +315,59 @@ function openStartedIdentity(rows, family) {
 function reviewInputFamily(family) {
     return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
 }
+function reconcileReviewCompletionReplay(repoRoot, taskDir, taskId, family, artifact, round) {
+    const stage = REVIEW_LEDGER_STAGES[family];
+    if (!stage)
+        return null;
+    const reviewFamily = family;
+    try {
+        let intent = readArtifactRecoveryIntent(repoRoot, taskId, reviewFamily, artifact);
+        if (!intent)
+            return null;
+        if (intent.state === 'commit-started') {
+            const reconciled = reconcileArtifactRecovery(recoveryContextFromIntent(repoRoot, taskDir, intent), { lockAlreadyHeld: true });
+            if (reconciled.status !== 'passed' && reconciled.status !== 'consumed') {
+                return {
+                    code: 'EVENT_ARTIFACT_CONFLICT',
+                    message: `review finalizer recovery remains ${reconciled.status} for ${artifact}`
+                };
+            }
+            intent = reconciled.intent;
+        }
+        if (!['passed', 'consumed'].includes(intent.state)) {
+            return {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `review finalizer provenance is incomplete for ${artifact}`
+            };
+        }
+        const validated = validateCompletedArtifact(taskDir, FAMILY[family].artifact, artifact, round);
+        if (!validated.ok) {
+            return { code: 'EVENT_ARTIFACT_CONFLICT', message: validated.error.message };
+        }
+        const content = fs.readFileSync(validated.artifact.path, 'utf8');
+        const expectedRequestId = `review-finalize:${taskId}:${stage}:${round}`;
+        if (intent.round !== round
+            || intent.requestId !== expectedRequestId
+            || intent.finalArtifactSha256 !== sha256Content(content)
+            || intent.finalSemanticDigest !== canonicalSemanticDigest(content)) {
+            return {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `review finalizer provenance does not match ${artifact}`
+            };
+        }
+        if (intent.state === 'passed') {
+            const consumed = { ...intent, state: 'consumed', updatedAt: Date.now() };
+            writeArtifactRecoveryIntent(repoRoot, consumed, { expected: intent });
+        }
+        return null;
+    }
+    catch (error) {
+        return {
+            code: 'EVENT_ARTIFACT_CONFLICT',
+            message: `review finalizer recovery could not be reconciled for ${artifact}: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
 function relationForStartedInput(family, input) {
     if (family.startsWith('review-')) {
         return input.family === reviewInputFamily(family) ? 'reviewed-input' : 'approval-context';
@@ -715,6 +769,8 @@ function applyTaskEventUnlocked(request, options = {}) {
     const row = manual ? openRows.at(-1) : matchingRows[0];
     let completedArtifact = null;
     let localFinalizationIntent = null;
+    let reviewFinalizationIntent = null;
+    let reviewContent = null;
     if (eventIdentity.phase === 'started' && row) {
         if (row.agent !== normalized.agent)
             return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'open started event has a different agent' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
@@ -729,8 +785,14 @@ function applyTaskEventUnlocked(request, options = {}) {
     if (eventIdentity.phase === 'started' && !manual && completedRows.length > 0)
         return failed(normalized, { code: 'EVENT_ALREADY_COMPLETED', message: 'event identity is already completed' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     const done = completedRows.find((item) => item.note === eventIdentity.note);
-    if (eventIdentity.phase === 'completed' && done)
+    if (eventIdentity.phase === 'completed' && done) {
+        if (!normalized.dryRun && eventIdentity.family.startsWith('review-') && normalized.artifact && normalized.round) {
+            const recoveryError = reconcileReviewCompletionReplay(resolved.repoRoot, resolved.taskDir, resolved.taskId, eventIdentity.family, normalized.artifact, normalized.round);
+            if (recoveryError)
+                return failed(normalized, recoveryError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, done.done, frontmatter, artifactContext);
+    }
     if (eventIdentity.phase === 'completed' && completedRows.length > 0 && openRows.length === 0)
         return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'event identity is already completed with a different payload' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     if (eventIdentity.phase === 'completed' && !row?.started && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING'))
@@ -746,7 +808,6 @@ function applyTaskEventUnlocked(request, options = {}) {
                 return failed(normalized, validationError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
         if (eventIdentity.family.startsWith('review-')) {
-            let reviewContent;
             try {
                 reviewContent = fs.readFileSync(completedArtifact.path, 'utf8');
             }
@@ -775,6 +836,20 @@ function applyTaskEventUnlocked(request, options = {}) {
             const localFamily = eventIdentity.family === 'analyze'
                 ? 'analysis'
                 : eventIdentity.family === 'plan' ? 'plan' : 'code';
+            try {
+                localFinalizationIntent = readLocalArtifactFinalizationIntent(resolved.repoRoot, resolved.taskId, localFamily, completedArtifact.name);
+                if (localFinalizationIntent?.state === 'commit-started') {
+                    const reconciled = reconcileArtifactRecovery(recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, localFinalizationIntent), { lockAlreadyHeld: true });
+                    if (reconciled.status === 'passed' || reconciled.status === 'consumed')
+                        localFinalizationIntent = reconciled.intent;
+                }
+            }
+            catch (error) {
+                return failed(normalized, {
+                    code: 'EVENT_ARTIFACT_CONFLICT',
+                    message: `local finalizer recovery could not be reconciled for ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}`
+                }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+            }
             let artifactContent;
             try {
                 artifactContent = fs.readFileSync(completedArtifact.path, 'utf8');
@@ -806,33 +881,23 @@ function applyTaskEventUnlocked(request, options = {}) {
                     message: `semantic digest does not match finalizer result for ${completedArtifact.name}`
                 }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
-            try {
-                localFinalizationIntent = readLocalArtifactFinalizationIntent(resolved.repoRoot, resolved.taskId, localFamily, completedArtifact.name);
-            }
-            catch (error) {
-                return failed(normalized, {
-                    code: 'EVENT_ARTIFACT_CONFLICT',
-                    message: `cannot read local finalizer provenance for ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}`
-                }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-            }
-            if (!localFinalizationIntent || !['passed', 'consumed', 'finalize-ready', 'commit-started'].includes(localFinalizationIntent.state)) {
+            if (!localFinalizationIntent || !['passed', 'consumed'].includes(localFinalizationIntent.state)) {
                 return failed(normalized, {
                     code: 'EVENT_ARTIFACT_CONFLICT',
                     message: `local finalizer provenance is missing or incomplete for ${completedArtifact.name}`
                 }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
-            if (localFinalizationIntent.artifactSha256 !== actualSha256 || localFinalizationIntent.semanticDigest !== local.semanticDigest) {
+            if (localFinalizationIntent.finalArtifactSha256 !== actualSha256 || localFinalizationIntent.finalSemanticDigest !== local.semanticDigest) {
                 return failed(normalized, {
                     code: 'EVENT_ARTIFACT_CONFLICT',
                     message: `local finalizer provenance does not match ${completedArtifact.name}`
                 }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
-            if (localFinalizationIntent.recoveryOperationId !== null) {
+            if (localFinalizationIntent.authorityDigest !== null) {
                 if (!lifecycleAuthority
                     || localFinalizationIntent.recoveryOperationId !== lifecycleAuthority.operationId
                     || localFinalizationIntent.requestId !== lifecycleAuthority.lifecycleRequestId
-                    || (localFinalizationIntent.phase !== 'artifact.finalize-local'
-                        && localFinalizationIntent.authorityDigest !== lifecycleRecoveryAttestationDigest(lifecycleAuthority))) {
+                    || localFinalizationIntent.authorityDigest !== lifecycleRecoveryAttestationDigest(lifecycleAuthority)) {
                     return failed(normalized, {
                         code: 'EVENT_ARTIFACT_CONFLICT',
                         message: `local finalizer provenance does not match lifecycle completion authority for ${completedArtifact.name}`
@@ -862,6 +927,43 @@ function applyTaskEventUnlocked(request, options = {}) {
     const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
     if (findingCountError)
         return failed(normalized, findingCountError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+    if (eventIdentity.phase === 'completed' && eventIdentity.family.startsWith('review-') && completedArtifact && reviewContent !== null) {
+        try {
+            reviewFinalizationIntent = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, eventIdentity.family, completedArtifact.name);
+            if (!normalized.dryRun && reviewFinalizationIntent?.state === 'commit-started') {
+                const reconciled = reconcileArtifactRecovery(recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, reviewFinalizationIntent), { lockAlreadyHeld: true });
+                if (reconciled.status === 'passed' || reconciled.status === 'consumed')
+                    reviewFinalizationIntent = reconciled.intent;
+            }
+            if (!reviewFinalizationIntent || !['passed', 'consumed'].includes(reviewFinalizationIntent.state)) {
+                return failed(normalized, {
+                    code: 'EVENT_ARTIFACT_CONFLICT',
+                    message: `review finalizer provenance is missing or incomplete for ${completedArtifact.name}`
+                }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+            }
+            const reviewStage = eventIdentity.family === 'review-analysis'
+                ? 'analysis'
+                : eventIdentity.family === 'review-plan' ? 'plan' : 'code';
+            const actualSha256 = sha256File(completedArtifact.path);
+            const actualSemanticDigest = canonicalSemanticDigest(reviewContent);
+            const expectedRequestId = `review-finalize:${resolved.taskId}:${reviewStage}:${normalized.round}`;
+            if (reviewFinalizationIntent.round !== normalized.round
+                || reviewFinalizationIntent.requestId !== expectedRequestId
+                || reviewFinalizationIntent.finalArtifactSha256 !== actualSha256
+                || reviewFinalizationIntent.finalSemanticDigest !== actualSemanticDigest) {
+                return failed(normalized, {
+                    code: 'EVENT_ARTIFACT_CONFLICT',
+                    message: `review finalizer provenance does not match ${completedArtifact.name}`
+                }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+            }
+        }
+        catch (error) {
+            return failed(normalized, {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `review finalizer recovery could not be reconciled for ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}`
+            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
+    }
     let orchestrationCompletion = null;
     if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
         const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
@@ -1010,10 +1112,10 @@ function applyTaskEventUnlocked(request, options = {}) {
                     requestId: lifecycleAuthority.lifecycleRequestId,
                     updatedAt: Date.now()
                 };
-                writeArtifactRepairIntent(resolved.repoRoot, localFinalizationIntent, { expected: expectedIntent });
+                writeArtifactRecoveryIntent(resolved.repoRoot, localFinalizationIntent, { expected: expectedIntent });
             }
             else if (!lifecycleAuthority && localFinalizationIntent.state === 'passed') {
-                localFinalizationIntent = consumeLocalArtifactFinalizationIntent(resolved.repoRoot, localFinalizationIntent);
+                localFinalizationIntent = consumeLocalArtifactFinalizationIntent(resolved.repoRoot, localFinalizationIntent, { lockAlreadyHeld: options.lockAlreadyHeld });
             }
         }
         catch (error) {
@@ -1031,6 +1133,32 @@ function applyTaskEventUnlocked(request, options = {}) {
             });
         }
     }
+    if (!normalized.dryRun && reviewFinalizationIntent && completedArtifact && reviewFinalizationIntent.state === 'passed') {
+        try {
+            const expectedIntent = reviewFinalizationIntent;
+            reviewFinalizationIntent = {
+                ...reviewFinalizationIntent,
+                state: 'commit-started',
+                phase: 'task-event.completed',
+                updatedAt: Date.now()
+            };
+            writeArtifactRecoveryIntent(resolved.repoRoot, reviewFinalizationIntent, { expected: expectedIntent });
+        }
+        catch (error) {
+            return failed(normalized, {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `review finalizer provenance could not be advanced before task write for ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}`
+            }, {
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                fromStep: currentStep,
+                toStep: step,
+                action: eventIdentity.action,
+                phase: eventIdentity.phase,
+                artifactContext
+            });
+        }
+    }
     const sourceCompletion = eventIdentity.phase === 'completed'
         && ['analyze', 'plan', 'code'].includes(eventIdentity.family);
     const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
@@ -1040,7 +1168,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         try {
             if (!options.deferLifecycleRecoveryConsumption)
                 consumeLifecycleRecoveryAttestation(lifecycleAuthority);
-            writeArtifactRepairIntent(resolved.repoRoot, { ...localFinalizationIntent, state: 'consumed', updatedAt: Date.now() }, { expected: localFinalizationIntent });
+            writeArtifactRecoveryIntent(resolved.repoRoot, { ...localFinalizationIntent, state: 'consumed', updatedAt: Date.now() }, { expected: localFinalizationIntent });
         }
         catch (error) {
             return failed(normalized, {
@@ -1049,6 +1177,20 @@ function applyTaskEventUnlocked(request, options = {}) {
             }, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
         }
     }
+    if (!normalized.dryRun && reviewFinalizationIntent && completedArtifact) {
+        try {
+            if (reviewFinalizationIntent.state === 'commit-started') {
+                const consumed = { ...reviewFinalizationIntent, state: 'consumed', updatedAt: Date.now() };
+                writeArtifactRecoveryIntent(resolved.repoRoot, consumed, { expected: reviewFinalizationIntent });
+            }
+        }
+        catch (error) {
+            return failed(normalized, {
+                code: 'EVENT_ARTIFACT_CONFLICT',
+                message: `review finalizer recovery consumption is incomplete: ${error instanceof Error ? error.message : String(error)}`
+            }, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
+        }
+    }
     if (!normalized.dryRun && orchestrationCompletion) {
         try {
             (options.commitOrchestrationCompletion ?? commitOrchestrationStageCompletion)(orchestrationCompletion);
@@ -1095,7 +1237,7 @@ function applyTaskEvent(request, options = {}) {
     if (!resolved.ok)
         return applyTaskEventUnlocked(request, options);
     try {
-        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, () => applyTaskEventUnlocked(request, options));
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, () => applyTaskEventUnlocked(request, { ...options, lockAlreadyHeld: true }));
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))