@fitlab-ai/agent-infra 0.11.0 → 0.11.2

package/lib/task/events.ts

@@ -1,12 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 
 import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
 import {
   buildArtifactLinkSection,
   inspectArtifactDirectory,
-  parseReviewedInputReference,
-  parseCodePlanInputReference,
   resolveArtifactContext,
   validateCompletedArtifact
 } from './artifact-lifecycle.ts';
@@ -24,6 +23,7 @@ import {
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import type { ReviewStage } from './ledger.ts';
 import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.ts';
+import { extractReviewBaseline, extractReviewedHead, extractReviewedSnapshotTree } from './review-fingerprint.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { findSectionHeading } from './sections.ts';
 import { validateLifecycleExecution } from './lifecycle-execution.ts';
@@ -33,19 +33,13 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from './write.ts';
 import { allowsManualOverride } from './guard-override.ts';
-import {
-  consumeLocalArtifactFinalizationIntent,
-  readLocalArtifactFinalizationIntent,
-  validateLocalArtifact
-} from './local-artifact-finalization.ts';
-import { writeArtifactRecoveryIntent, readArtifactRecoveryIntent } from './artifact-repair-intent.ts';
-import { reconcileArtifactRecovery, recoveryContextFromIntent, sha256Content } from './artifact-recovery.ts';
-import type { ArtifactRecoveryIntent } from './artifact-repair-intent.ts';
-import type { LocalArtifactFamily, LocalArtifactFinalizationIntent } from './local-artifact-finalization.ts';
+import { validateLocalArtifact } from './local-artifact-finalization.ts';
+import type { LocalArtifactFamily } from './local-artifact-finalization.ts';
 import { buildLifecycleFacts, canStart } from './capabilities.ts';
 import type { ExplicitTrigger, LifecycleAction, TriggerInitiator, TriggerReason } from './capabilities.ts';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.ts';
 import type { InvalidationTargetKind } from './invalidation.ts';
+import { reconcileTaskInvalidation } from './invalidation-command.ts';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.ts';
 import { ARTIFACT_FAMILIES, expectedQualificationRelations, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest, validateQualificationAudit } from './qualification-audit.ts';
 import type { QualificationAudit, UpstreamRelation } from './qualification-audit.ts';
@@ -113,6 +107,23 @@ type TaskEventResult = {
   operations: readonly TaskOperationSummary[]; error: TaskEventError | null;
 };
 
+function approvedCleanReviewedCommit(reviewContent: string, verdict: Verdict | undefined, repoRoot: string): string | null {
+  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: Record<TaskEventName, { required?: string[]; optional?: string[] }> = {
   'analyze.started': { optional: ['round'] },
@@ -375,67 +386,6 @@ function reviewInputFamily(family: EventFamily): ArtifactFamily {
   return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
 }
 
-function reconcileReviewCompletionReplay(
-  repoRoot: string,
-  taskDir: string,
-  taskId: string,
-  family: EventFamily,
-  artifact: string,
-  round: number
-): TaskEventError | null {
-  const stage = REVIEW_LEDGER_STAGES[family];
-  if (!stage) return null;
-  const reviewFamily = family as 'review-analysis' | 'review-plan' | 'review-code';
-  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' as const, 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: EventFamily, input: ArtifactIdentity): UpstreamRelation['relation'] {
   if (family.startsWith('review-')) {
     return input.family === reviewInputFamily(family) ? 'reviewed-input' : 'approval-context';
@@ -645,34 +595,38 @@ function reworkIntentMutationForCompletion(
 }
 
 function buildCompletionReceipt(
+  content: string,
   taskDir: string,
   family: EventFamily,
   artifact: ArtifactIdentity,
   completedAt: string,
   frontmatter: Record<string, unknown>
 ): { ok: true; receipt: ArtifactReceipt } | { ok: false; message: string } | null {
+  const existing = (() => {
+    try {
+      return parseArtifactReceipts(content).rows.find((receipt) => receipt.output === artifact.name) ?? null;
+    } catch {
+      return null;
+    }
+  })();
   if (family === 'code') {
-    let content: string;
-    try { content = fs.readFileSync(artifact.path, 'utf8'); }
-    catch (error) { return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` }; }
-    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 : '';
+    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` };
+      if (inputSha256 !== startedSha256) 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
         }
       };
     } catch (error) {
@@ -681,18 +635,14 @@ function buildCompletionReceipt(
   }
   if (!family.startsWith('review-')) return null;
   const expectedFamily = reviewInputFamily(family);
-  let content: string;
-  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' as const
@@ -701,19 +651,82 @@ function buildCompletionReceipt(
     const stat = fs.lstatSync(current.latest.path);
     if (!stat.isFile() || stat.isSymbolicLink()) 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` };
+    if (inputSha256 !== startedSha256) 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)}` };
   }
 }
 
+type CompletionFact = Readonly<{
+  event: string;
+  output: string;
+  outputSha256: string;
+  semanticDigest: string;
+  requestId: string;
+  result: string;
+}>;
+
+function completionFacts(frontmatter: Record<string, unknown>): CompletionFact[] {
+  if (typeof frontmatter.completion_facts !== 'string') return [];
+  try {
+    const facts: unknown = JSON.parse(frontmatter.completion_facts);
+    if (!Array.isArray(facts)) return [];
+    return facts.filter((fact): fact is CompletionFact => Boolean(
+      fact && typeof fact === 'object' && !Array.isArray(fact)
+      && typeof (fact as CompletionFact).event === 'string'
+      && typeof (fact as CompletionFact).output === 'string'
+      && /^[a-f0-9]{64}$/u.test((fact as CompletionFact).outputSha256)
+      && /^[a-f0-9]{64}$/u.test((fact as CompletionFact).semanticDigest)
+      && typeof (fact as CompletionFact).requestId === 'string'
+      && typeof (fact as CompletionFact).result === 'string'
+    ));
+  } catch {
+    return [];
+  }
+}
+
+function currentCompletionFact(request: TaskEventRequest, artifact: ArtifactIdentity): CompletionFact {
+  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: CompletionFact, right: CompletionFact): boolean {
+  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: readonly CompletionFact[], next: CompletionFact): CompletionFact[] {
+  return [...facts.filter((fact) => !(fact.event === next.event && fact.output === next.output)), next];
+}
+
 function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOptions = {}): TaskEventResult {
   const invalid = validateTaskEventRequest(request);
   if (invalid) return failed(request, invalid);
@@ -724,6 +737,20 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   let content: string;
   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 }); }
+  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); }
   catch (error) { return failed(request, { code: 'TASK_DOCUMENT_INVALID', message: error instanceof Error ? error.message : String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath }); }
@@ -732,7 +759,6 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   const rows = startedBackedRows(pairEntries(section.entries));
   let normalized = request;
   let artifactContext: ArtifactContextResult | null = null;
-  const initialParts = eventParts(request.event);
   if (initialParts.phase === 'started') {
     const openIdentity = openStartedIdentity(rows, initialParts.family);
     if (openIdentity && 'conflict' in openIdentity) return failed(request, { code: 'EVENT_LOG_CONFLICT', message: 'artifact family has more than one open started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
@@ -777,13 +803,11 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   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: ArtifactIdentity | null = null;
-  let localFinalizationIntent: LocalArtifactFinalizationIntent | null = null;
-  let reviewFinalizationIntent: ArtifactRecoveryIntent | null = null;
   let reviewContent: string | null = 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 });
@@ -795,24 +819,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     }
     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) return failed(normalized, validated.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -853,23 +860,6 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
       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: string;
       try { artifactContent = fs.readFileSync(completedArtifact.path, 'utf8'); }
       catch (error) {
@@ -899,29 +889,6 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
           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)) {
@@ -948,49 +915,6 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     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 as 'review-analysis' | 'review-plan' | 'review-code',
-        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: OrchestrationStageCompletion | null = null;
   if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
     const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
@@ -1017,14 +941,32 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   try { metadata = (options.metadataProvider ?? captureTaskWriteMetadata)(); }
   catch (error) { return failed(normalized, { code: 'METADATA_CAPTURE_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath }); }
   let completionReceipt: ArtifactReceipt | null = null;
+  let currentFact: CompletionFact | null = null;
   let completionInvalidation: ReturnType<typeof invalidationMutation> | null = null;
   let completionRework: ReturnType<typeof reworkIntentMutation> | null = 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) return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: invalidation.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -1040,6 +982,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   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: Record<string, string> = { current_step: step, assigned_to: normalized.agent };
+  if (currentFact) frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(completionFacts(frontmatter), currentFact));
   let frontmatterRemove: string[] | undefined;
   if (eventIdentity.phase === 'started' && artifactContext) {
     try {
@@ -1072,6 +1015,11 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   } 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) frontmatterSet.last_reviewed_commit = '';
   const mutations: Parameters<typeof writeTask>[0]['mutations'][number][] = [
@@ -1110,90 +1058,10 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     });
   }
   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' as const, 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);
@@ -1231,7 +1099,7 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   if (invalid) return failed(request, invalid);
   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/lib/task/finalization-state.ts

@@ -5,7 +5,8 @@ export type TaskControlBindingEvidence = (taskId: string, binding: TaskControlBi
 
 export function taskFinalizationReceiptState(receipt: TaskFinalizationReceipt): 'pending' | 'unresolved' | 'complete' {
   if (receipt.lifecycle !== 'done' || receipt.taskComment === 'pending'
-    || receipt.verification === 'pending' || receipt.warningProjection !== 'done') return 'pending';
+    || 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';
   return 'complete';
 }