@fitlab-ai/agent-infra 0.11.0 → 0.11.2

package/dist/lib/task/events.js

@@ -1,13 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
-import { buildArtifactLinkSection, inspectArtifactDirectory, parseReviewedInputReference, parseCodePlanInputReference, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { buildArtifactLinkSection, inspectArtifactDirectory, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
 import { artifactName, parseArtifactName } from './artifact-name.js';
 import { ArtifactReceiptError, parseArtifactReceipts, sha256File, upsertArtifactReceipt } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { consumeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
+import { extractReviewBaseline, extractReviewedHead, extractReviewedSnapshotTree } from './review-fingerprint.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { findSectionHeading } from './sections.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
@@ -15,11 +17,10 @@ import { commitOrchestrationStageCompletion } from './orchestration.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { allowsManualOverride } from './guard-override.js';
-import { consumeLocalArtifactFinalizationIntent, readLocalArtifactFinalizationIntent, validateLocalArtifact } from './local-artifact-finalization.js';
-import { writeArtifactRecoveryIntent, readArtifactRecoveryIntent } from './artifact-repair-intent.js';
-import { reconcileArtifactRecovery, recoveryContextFromIntent, sha256Content } from './artifact-recovery.js';
+import { validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart } from './capabilities.js';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
+import { reconcileTaskInvalidation } from './invalidation-command.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';
@@ -36,6 +37,27 @@ const eventCatalog = [
     'manual-validation.started', 'manual-validation.completed',
     'validation-run.started', 'validation-run.completed'
 ];
+function approvedCleanReviewedCommit(reviewContent, verdict, repoRoot) {
+    if (verdict !== 'approved')
+        return null;
+    const reviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
+    const reviewedTree = extractReviewedSnapshotTree(reviewContent);
+    if (!/^[a-f0-9]{40}$/.test(reviewedHead) || !/^[a-f0-9]{40}$/.test(reviewedTree))
+        return null;
+    try {
+        const currentHead = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
+        if (currentHead !== reviewedHead)
+            return null;
+        const currentTree = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD^{tree}'], { encoding: 'utf8' }).trim();
+        if (currentTree !== reviewedTree)
+            return null;
+        execFileSync('git', ['-C', repoRoot, 'diff-index', '--quiet', 'HEAD', '--']);
+        return reviewedHead;
+    }
+    catch {
+        return null;
+    }
+}
 const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
 const SCHEMAS = {
     'analyze.started': { optional: ['round'] },
@@ -315,59 +337,6 @@ 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', 'consumption-started', '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' || intent.state === 'consumption-started') {
-            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';
@@ -593,37 +562,35 @@ function reworkIntentMutationForCompletion(content, taskDir, family, artifact, t
     }
     return { mutation: JSON.stringify(next) === JSON.stringify(parsed.intents) ? null : reworkIntentMutation(content, next) };
 }
-function buildCompletionReceipt(taskDir, family, artifact, completedAt, frontmatter) {
-    if (family === 'code') {
-        let content;
+function buildCompletionReceipt(content, taskDir, family, artifact, completedAt, frontmatter) {
+    const existing = (() => {
         try {
-            content = fs.readFileSync(artifact.path, 'utf8');
+            return parseArtifactReceipts(content).rows.find((receipt) => receipt.output === artifact.name) ?? null;
         }
-        catch (error) {
-            return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
+        catch {
+            return null;
         }
-        const input = parseCodePlanInputReference(content);
-        if (!input)
-            return { ok: false, message: `${artifact.name} does not reference a canonical plan artifact` };
-        const startedInput = typeof frontmatter.code_input_artifact === 'string' ? frontmatter.code_input_artifact : '';
-        const startedSha256 = typeof frontmatter.code_input_sha256 === 'string' ? frontmatter.code_input_sha256 : '';
+    })();
+    if (family === 'code') {
+        const startedInput = typeof frontmatter.code_input_artifact === 'string'
+            ? frontmatter.code_input_artifact : existing?.input ?? '';
+        const startedSha256 = typeof frontmatter.code_input_sha256 === 'string'
+            ? frontmatter.code_input_sha256 : existing?.inputSha256 ?? '';
         if (!startedInput || !startedSha256)
             return { ok: false, message: 'code.started plan input context is missing' };
-        if (input.name !== startedInput)
-            return { ok: false, message: `${artifact.name} plan input '${input.name}' does not match code.started input '${startedInput}'` };
         const plan = inspectArtifactDirectory(taskDir, 'plan');
-        if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== input.name) {
-            return { ok: false, message: `code input '${input.name}' is not the latest plan artifact` };
+        if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== startedInput) {
+            return { ok: false, message: `code input '${startedInput}' is not the latest plan artifact` };
         }
         try {
             const inputSha256 = sha256File(plan.latest.path);
             if (inputSha256 !== startedSha256)
-                return { ok: false, message: `code input ${input.name} changed after code.started` };
+                return { ok: false, message: `code input ${startedInput} changed after code.started` };
             return {
                 ok: true,
                 receipt: {
-                    event: 'code.completed', output: artifact.name, input: input.name,
-                    inputSha256, completedAt
+                    event: 'code.completed', output: artifact.name, input: startedInput,
+                    inputSha256, completedAt: existing?.completedAt ?? completedAt
                 }
             };
         }
@@ -634,25 +601,15 @@ function buildCompletionReceipt(taskDir, family, artifact, completedAt, frontmat
     if (!family.startsWith('review-'))
         return null;
     const expectedFamily = reviewInputFamily(family);
-    let content;
-    try {
-        content = fs.readFileSync(artifact.path, 'utf8');
-    }
-    catch (error) {
-        return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
-    }
-    const input = parseReviewedInputReference(content, expectedFamily);
-    if (!input)
-        return { ok: false, message: `${artifact.name} does not reference a canonical ${expectedFamily} artifact` };
-    const startedInput = typeof frontmatter.review_input_artifact === 'string' ? frontmatter.review_input_artifact : '';
-    const startedSha256 = typeof frontmatter.review_input_sha256 === 'string' ? frontmatter.review_input_sha256 : '';
+    const startedInput = typeof frontmatter.review_input_artifact === 'string'
+        ? frontmatter.review_input_artifact : existing?.input ?? '';
+    const startedSha256 = typeof frontmatter.review_input_sha256 === 'string'
+        ? frontmatter.review_input_sha256 : existing?.inputSha256 ?? '';
     if (!startedInput || !startedSha256)
         return { ok: false, message: 'review started input context is missing' };
-    if (input.name !== startedInput)
-        return { ok: false, message: `${artifact.name} input '${input.name}' does not match review.started input '${startedInput}'` };
     const current = inspectArtifactDirectory(taskDir, expectedFamily);
-    if (current.status !== 'ready' || !current.latest || current.latest.name !== input.name) {
-        return { ok: false, message: `review input '${input.name}' is not the latest ${expectedFamily} artifact` };
+    if (current.status !== 'ready' || !current.latest || current.latest.name !== startedInput) {
+        return { ok: false, message: `review input '${startedInput}' is not the latest ${expectedFamily} artifact` };
     }
     const event = family === 'review-analysis'
         ? 'review-analysis.completed'
@@ -663,19 +620,70 @@ function buildCompletionReceipt(taskDir, family, artifact, completedAt, frontmat
             throw new Error('review input is not a regular file');
         const inputSha256 = sha256File(current.latest.path);
         if (inputSha256 !== startedSha256)
-            return { ok: false, message: `review input ${input.name} changed after review.started` };
+            return { ok: false, message: `review input ${startedInput} changed after review.started` };
         return {
             ok: true,
             receipt: {
-                event, output: artifact.name, input: input.name,
-                inputSha256, completedAt
+                event, output: artifact.name, input: startedInput,
+                inputSha256, completedAt: existing?.completedAt ?? completedAt
             }
         };
     }
     catch (error) {
-        return { ok: false, message: `cannot hash review input ${input.name}: ${error instanceof Error ? error.message : String(error)}` };
+        return { ok: false, message: `cannot hash review input ${startedInput}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+function completionFacts(frontmatter) {
+    if (typeof frontmatter.completion_facts !== 'string')
+        return [];
+    try {
+        const facts = JSON.parse(frontmatter.completion_facts);
+        if (!Array.isArray(facts))
+            return [];
+        return facts.filter((fact) => Boolean(fact && typeof fact === 'object' && !Array.isArray(fact)
+            && typeof fact.event === 'string'
+            && typeof fact.output === 'string'
+            && /^[a-f0-9]{64}$/u.test(fact.outputSha256)
+            && /^[a-f0-9]{64}$/u.test(fact.semanticDigest)
+            && typeof fact.requestId === 'string'
+            && typeof fact.result === 'string'));
+    }
+    catch {
+        return [];
     }
 }
+function currentCompletionFact(request, artifact) {
+    const content = fs.readFileSync(artifact.path, 'utf8');
+    return {
+        event: request.event,
+        output: artifact.name,
+        outputSha256: sha256File(artifact.path),
+        semanticDigest: canonicalSemanticDigest(content),
+        requestId: request.requestId ?? '',
+        result: JSON.stringify({
+            filesModified: request.filesModified,
+            testsPassed: request.testsPassed,
+            blockers: request.blockers,
+            major: request.major,
+            minor: request.minor,
+            manualValidation: request.manualValidation ?? 0,
+            verdict: request.verdict,
+            fixFor: request.fixFor,
+            implementationInput: request.implementationInput
+        })
+    };
+}
+function sameCompletionFact(left, right) {
+    return left.event === right.event
+        && left.output === right.output
+        && left.outputSha256 === right.outputSha256
+        && left.semanticDigest === right.semanticDigest
+        && left.requestId === right.requestId
+        && left.result === right.result;
+}
+function replaceCompletionFact(facts, next) {
+    return [...facts.filter((fact) => !(fact.event === next.event && fact.output === next.output)), next];
+}
 function applyTaskEventUnlocked(request, options = {}) {
     const invalid = validateTaskEventRequest(request);
     if (invalid)
@@ -693,6 +701,24 @@ function applyTaskEventUnlocked(request, options = {}) {
     catch (error) {
         return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
+    const initialParts = eventParts(request.event);
+    if (initialParts.phase === 'started' && !request.dryRun) {
+        const reconciled = reconcileTaskInvalidation(request.taskRef, { repoRoot: resolved.repoRoot });
+        if (reconciled.status === 'failed') {
+            return failed(request, {
+                code: 'EVENT_TRANSITION_INVALID',
+                message: `INVALIDATION_RECONCILE_FAILED: ${reconciled.error?.code ?? 'UNKNOWN'}: ${reconciled.error?.message ?? ''}`
+            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+        }
+        if (reconciled.changed) {
+            try {
+                content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+            }
+            catch (error) {
+                return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+            }
+        }
+    }
     let frontmatter;
     try {
         frontmatter = parseTypedTaskFrontmatter(content);
@@ -706,7 +732,6 @@ function applyTaskEventUnlocked(request, options = {}) {
     const rows = startedBackedRows(pairEntries(section.entries));
     let normalized = request;
     let artifactContext = null;
-    const initialParts = eventParts(request.event);
     if (initialParts.phase === 'started') {
         const openIdentity = openStartedIdentity(rows, initialParts.family);
         if (openIdentity && 'conflict' in openIdentity)
@@ -762,14 +787,12 @@ function applyTaskEventUnlocked(request, options = {}) {
     const currentStep = typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '';
     const matchingRows = rows.filter((item) => item.step === eventIdentity.action);
     const manual = eventIdentity.family === 'manual-validation';
-    if (!manual && matchingRows.length > 1)
-        return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'event identity appears more than once' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
     const openRows = matchingRows.filter((item) => item.started && !item.done);
     const completedRows = matchingRows.filter((item) => item.done);
-    const row = manual ? openRows.at(-1) : matchingRows[0];
+    if (!manual && openRows.length > 1)
+        return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'event identity has more than one open attempt' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+    const row = openRows.at(-1);
     let completedArtifact = null;
-    let localFinalizationIntent = null;
-    let reviewFinalizationIntent = null;
     let reviewContent = null;
     if (eventIdentity.phase === 'started' && row) {
         if (row.agent !== normalized.agent)
@@ -782,21 +805,8 @@ function applyTaskEventUnlocked(request, options = {}) {
         }
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.started, frontmatter, artifactContext);
     }
-    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 (!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'))
-        return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires one open matching started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+    if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0 && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING'))
+        return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires a started event or an earlier completed attempt' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     if (eventIdentity.phase === 'completed') {
         const validated = validateCompletedArtifact(resolved.taskDir, FAMILY[eventIdentity.family].artifact, normalized.artifact, normalized.round);
         if (!validated.ok)
@@ -836,20 +846,6 @@ 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');
@@ -881,29 +877,6 @@ 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 });
             }
-            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.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.authorityDigest !== null) {
-                if (!lifecycleAuthority
-                    || localFinalizationIntent.recoveryOperationId !== lifecycleAuthority.operationId
-                    || localFinalizationIntent.requestId !== lifecycleAuthority.lifecycleRequestId
-                    || localFinalizationIntent.authorityDigest !== lifecycleRecoveryAttestationDigest(lifecycleAuthority)) {
-                    return failed(normalized, {
-                        code: 'EVENT_ARTIFACT_CONFLICT',
-                        message: `local finalizer provenance does not match lifecycle completion authority for ${completedArtifact.name}`
-                    }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
-                }
-            }
         }
     }
     if (eventIdentity.phase === 'waiting' && section.entries.some((entry) => entry.step === eventIdentity.action && entry.note === eventIdentity.note)) {
@@ -927,43 +900,6 @@ 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', 'consumption-started', '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;
@@ -994,14 +930,24 @@ function applyTaskEventUnlocked(request, options = {}) {
         return failed(normalized, { code: 'METADATA_CAPTURE_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
     let completionReceipt = null;
+    let currentFact = null;
     let completionInvalidation = null;
     let completionRework = null;
     if (eventIdentity.phase === 'completed' && completedArtifact) {
-        const receipt = buildCompletionReceipt(resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
+        const receipt = buildCompletionReceipt(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
         if (receipt && !receipt.ok) {
             return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: receipt.message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
         completionReceipt = receipt?.receipt ?? null;
+        try {
+            currentFact = currentCompletionFact(normalized, completedArtifact);
+        }
+        catch (error) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot inspect current completion result: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+        }
+        if (completionFacts(frontmatter).some((fact) => sameCompletionFact(fact, currentFact))) {
+            return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, completionReceipt?.completedAt ?? metadata.timestamp, frontmatter, artifactContext);
+        }
         try {
             const invalidation = invalidationMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp);
             if ('error' in invalidation)
@@ -1020,6 +966,8 @@ function applyTaskEventUnlocked(request, options = {}) {
     const logStep = eventIdentity.phase === 'started' ? `${eventIdentity.action} [started]` : eventIdentity.action;
     const body = appendActivityEntry(section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
     const frontmatterSet = { current_step: step, assigned_to: normalized.agent };
+    if (currentFact)
+        frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(completionFacts(frontmatter), currentFact));
     let frontmatterRemove;
     if (eventIdentity.phase === 'started' && artifactContext) {
         try {
@@ -1060,6 +1008,13 @@ function applyTaskEventUnlocked(request, options = {}) {
     else if (eventIdentity.phase === 'completed' && eventIdentity.family.startsWith('review-')) {
         frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
     }
+    if (eventIdentity.phase === 'completed' && eventIdentity.family === 'review-code' && reviewContent !== null) {
+        const reviewedCommit = approvedCleanReviewedCommit(reviewContent, normalized.verdict, resolved.repoRoot);
+        if (reviewedCommit)
+            frontmatterSet.last_reviewed_commit = reviewedCommit;
+        else if (normalized.verdict === 'approved')
+            frontmatterSet.last_reviewed_commit = '';
+    }
     if (eventIdentity.phase === 'completed')
         frontmatterRemove = [...(frontmatterRemove ?? []), 'qualification_input_relations'];
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
@@ -1100,97 +1055,11 @@ function applyTaskEventUnlocked(request, options = {}) {
         });
     }
     mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
-    if (!normalized.dryRun && localFinalizationIntent && completedArtifact) {
-        try {
-            if (lifecycleAuthority && localFinalizationIntent.state === 'passed') {
-                const expectedIntent = localFinalizationIntent;
-                localFinalizationIntent = {
-                    ...localFinalizationIntent,
-                    state: 'consumption-started',
-                    phase: 'task-event.completed',
-                    authorityDigest: lifecycleRecoveryAttestationDigest(lifecycleAuthority),
-                    requestId: lifecycleAuthority.lifecycleRequestId,
-                    updatedAt: Date.now()
-                };
-                writeArtifactRecoveryIntent(resolved.repoRoot, localFinalizationIntent, { expected: expectedIntent });
-            }
-            else if (!lifecycleAuthority && localFinalizationIntent.state === 'passed') {
-                localFinalizationIntent = consumeLocalArtifactFinalizationIntent(resolved.repoRoot, localFinalizationIntent, { lockAlreadyHeld: options.lockAlreadyHeld });
-            }
-        }
-        catch (error) {
-            return failed(normalized, {
-                code: 'EVENT_ARTIFACT_CONFLICT',
-                message: `local 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
-            });
-        }
-    }
-    if (!normalized.dryRun && reviewFinalizationIntent && completedArtifact && reviewFinalizationIntent.state === 'passed') {
-        try {
-            const expectedIntent = reviewFinalizationIntent;
-            reviewFinalizationIntent = {
-                ...reviewFinalizationIntent,
-                state: 'consumption-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 });
     if (result.status === 'failed')
         return failed(normalized, result.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 && lifecycleAuthority && localFinalizationIntent && completedArtifact) {
-        try {
-            if (!options.deferLifecycleRecoveryConsumption)
-                consumeLifecycleRecoveryAttestation(lifecycleAuthority);
-            writeArtifactRecoveryIntent(resolved.repoRoot, { ...localFinalizationIntent, state: 'consumed', updatedAt: Date.now() }, { expected: localFinalizationIntent });
-        }
-        catch (error) {
-            return failed(normalized, {
-                code: 'EVENT_ARTIFACT_CONFLICT',
-                message: `task completion was written but lifecycle 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 && reviewFinalizationIntent && completedArtifact) {
-        try {
-            if (reviewFinalizationIntent.state === 'consumption-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);
@@ -1230,7 +1099,7 @@ function applyTaskEvent(request, options = {}) {
     const parts = eventParts(request.event);
     if (options.lockAlreadyHeld)
         return applyTaskEventUnlocked(request, options);
-    if (request.dryRun || parts.phase !== 'completed' || parts.family === 'manual-validation') {
+    if (request.dryRun || !['started', 'completed'].includes(parts.phase)) {
         return applyTaskEventUnlocked(request, options);
     }
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });

package/dist/lib/task/finalization-state.js

@@ -1,6 +1,7 @@
 export function taskFinalizationReceiptState(receipt) {
     if (receipt.lifecycle !== 'done' || receipt.taskComment === 'pending'
-        || receipt.verification === 'pending' || receipt.warningProjection !== 'done')
+        || receipt.verification === 'pending' || receipt.summary === 'pending'
+        || receipt.postSummaryVerification === 'pending' || receipt.warningProjection !== 'done')
         return 'pending';
     if (receipt.lastError !== null || receipt.warnings.some((warning) => warning.status === 'open'))
         return 'unresolved';