@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/task/events.ts

@@ -4,7 +4,9 @@ import { execFileSync } from 'node:child_process';
 
 import { resolveBranchWorktree } from '../git/branch-worktree.ts';
 
-import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
+import { appendActivityEntry, inspectActivityLog } from './activity-log.ts';
+import { lifecycleExecutions, serializeLifecycleExecution } from './lifecycle-execution.ts';
+import type { LifecycleExecution } from './lifecycle-execution.ts';
 import {
   buildArtifactLinkSection,
   inspectArtifactDirectory,
@@ -28,13 +30,9 @@ import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.
 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';
-import { commitOrchestrationStageCompletion } from './orchestration.ts';
-import type { OrchestrationStageCompletion } from './orchestration.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from './write.ts';
 import { validateLocalArtifact } from './local-artifact-finalization.ts';
-import type { LocalArtifactFamily } from './local-artifact-finalization.ts';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.ts';
 import type { ExplicitTrigger, LifecycleAction, TriggerInitiator, TriggerReason } from './capabilities.ts';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.ts';
@@ -43,7 +41,7 @@ import { parseTaskQualification } from './qualification-audit.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.ts';
 import { inspectReviewIdentity } from './review-identity.ts';
-import { parseCompletionFacts, type CompletionFact } from './completion-facts.ts';
+import { hasValidArtifactCompletion, parseCompletionFacts, type CompletionFact } from './completion-facts.ts';
 import { readManualValidationCompletion } from './manual-validation-completion.ts';
 import { parseLifecyclePathDecision } from './lifecycle-path.ts';
 
@@ -65,14 +63,13 @@ type TaskEventErrorCode =
   | 'EVENT_LOG_MISSING' | 'EVENT_START_MISSING' | 'EVENT_ALREADY_COMPLETED'
   | 'EVENT_LOG_CONFLICT' | 'EVENT_ARTIFACT_CONFLICT' | 'EVENT_FINDING_COUNT_MISMATCH'
   | 'EVENT_VERDICT_INVALID'
-  | 'EVENT_ORCHESTRATION_COMMIT_FAILED'
   | 'MANUAL_VALIDATION_RECEIPT_MISSING' | 'MANUAL_VALIDATION_RECEIPT_INVALID'
   | 'MANUAL_VALIDATION_RECEIPT_IDENTITY_MISMATCH'
   | 'MANUAL_VALIDATION_TRANSACTION_MISSING' | 'MANUAL_VALIDATION_TRANSACTION_INVALID'
   | 'MANUAL_VALIDATION_TRANSACTION_IDENTITY_MISMATCH' | 'MANUAL_VALIDATION_TRANSACTION_PHASE_INVALID'
   | ArtifactErrorCode | TaskWriteErrorCode;
 type TaskEventRequest = {
-  taskRef: string; event: TaskEventName | string; agent: string; dryRun?: boolean; orchestrated?: boolean;
+  taskRef: string; event: TaskEventName | string; agent: string; dryRun?: boolean;
   initiator?: TriggerInitiator; requestId?: string; reasonCode?: TriggerReason;
   sourceFinding?: string; sourceArtifact?: string; sourceSha256?: string;
   round?: number; question?: number; artifact?: string; fixFor?: string; implementationInput?: string;
@@ -83,9 +80,7 @@ type TaskEventRequest = {
   transactionId?: string; receiptDigest?: string; prHeadSha?: string;
 };
 type TaskEventError = { code: TaskEventErrorCode; message: string };
-type TaskEventOptions = TaskWriteOptions & {
-  commitOrchestrationCompletion?: (plan: OrchestrationStageCompletion) => void;
-};
+type TaskEventOptions = TaskWriteOptions;
 type TaskEventResult = {
   status: 'planned' | 'applied' | 'no-op' | 'failed'; changed: boolean;
   event: string; requestRef: string; taskId: string | null; taskMdPath: string | null;
@@ -95,6 +90,7 @@ type TaskEventResult = {
   artifactContext: ArtifactContextResult | null;
   timestamp: string | null; agentInfraVersion: string | null;
   operations: readonly TaskOperationSummary[]; error: TaskEventError | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 
 function branchWorktree(repoRoot: string, branch: string): string | null {
@@ -125,17 +121,17 @@ const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'initiator',
 const SCHEMAS: Record<TaskEventName, { required?: string[]; optional?: string[] }> = {
   'analyze.started': { optional: ['round'] },
   'analyze.awaiting-input': { required: ['question'] },
-  'analyze.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round', 'orchestrated'] },
+  'analyze.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round'] },
   'review-analysis.started': { optional: ['round'] },
-  'review-analysis.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
+  'review-analysis.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
   'plan.started': { optional: ['round'] },
-  'plan.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round', 'orchestrated'] },
+  'plan.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round'] },
   'review-plan.started': { optional: ['round'] },
-  'review-plan.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
+  'review-plan.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
   'code.started': { optional: ['round', 'fixFor', 'implementationInput'] },
-  'code.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round', 'fixFor', 'implementationInput', 'filesModified', 'testsPassed', 'blockers', 'major', 'minor', 'manualValidation', 'orchestrated'] },
+  'code.completed': { required: ['artifact', 'artifactSha256', 'semanticDigest'], optional: ['round', 'fixFor', 'implementationInput', 'filesModified', 'testsPassed', 'blockers', 'major', 'minor', 'manualValidation'] },
   'review-code.started': { optional: ['round'] },
-  'review-code.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
+  'review-code.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round'] },
   'manual-validation.started': { optional: ['round', 'transactionId'] },
   'manual-validation.completed': { required: ['artifact', 'summaryResult', 'transactionId', 'receiptDigest', 'prHeadSha'], optional: ['round'] },
   'validation-run.started': { optional: ['round'] },
@@ -157,7 +153,7 @@ function validateTaskEventRequest(request: TaskEventRequest): TaskEventError | n
     if (value !== undefined && (!Number.isInteger(value) || value < (key === 'round' || key === 'question' ? 1 : 0))) return { code: 'EVENT_PAYLOAD_INVALID', message: `'${key}' must be a ${key === 'round' || key === 'question' ? 'positive' : 'non-negative'} integer` };
   }
   if (request.verdict && !['approved', 'changes-requested', 'rejected'].includes(request.verdict)) return { code: 'EVENT_PAYLOAD_INVALID', message: 'verdict is invalid' };
-  if (request.initiator && !['human', 'model', 'orchestrator'].includes(request.initiator)) return { code: 'EVENT_PAYLOAD_INVALID', message: 'initiator is invalid' };
+  if (request.initiator && !['human', 'model'].includes(request.initiator)) return { code: 'EVENT_PAYLOAD_INVALID', message: 'initiator is invalid' };
   if (request.requestId !== undefined && (!request.requestId.trim() || /[\r\n]/.test(request.requestId))) return { code: 'EVENT_PAYLOAD_INVALID', message: 'requestId must be a non-empty single line' };
   if (request.reasonCode && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'manual-review-supplement', 'retry', 'validation-rerun'].includes(request.reasonCode)) return { code: 'EVENT_PAYLOAD_INVALID', message: 'reasonCode is invalid' };
   for (const [name, value] of [['sourceFinding', request.sourceFinding], ['sourceArtifact', request.sourceArtifact], ['sourceSha256', request.sourceSha256]] as const) {
@@ -368,27 +364,19 @@ function validateManualValidationCompletion(
   return null;
 }
 
-function openStartedIdentity(rows: ReturnType<typeof pairEntries>, family: EventFamily) {
-  const spec = FAMILY[family];
+function openStartedIdentity(rows: LifecycleExecution[], family: EventFamily) {
+  const matches = rows.filter((item) => item.family === family);
   if (family === 'manual-validation') {
-    const row = rows.filter((item) => item.step === spec.label && item.started && !item.done).at(-1);
-    const completed = rows.filter((item) => item.step === spec.label && item.done).length;
-    return row ? { row, round: completed + 1, fixFor: undefined, implementationInput: undefined } : null;
-  }
-  const escaped = spec.label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const pattern = new RegExp(`^${escaped} \\(Round (\\d+)(?:(?:, fix for (review-code(?:-r\\d+)?\\.md))|(?:, decision (II-[1-9]\\d*)))?\\)$`);
-  const matches = rows.flatMap((row) => {
-    if (!row.started || row.done) return [];
-    const match = pattern.exec(row.step);
-    return match ? [{ row, round: Number(match[1]), fixFor: match[2], implementationInput: match[3] }] : [];
-  });
-  return matches.length === 1 ? matches[0] : matches.length > 1 ? { conflict: true as const } : null;
+    const row = matches.at(-1);
+    return row ? { row, round: row.round!, fixFor: undefined, implementationInput: undefined } : null;
+  }
+  return matches.length === 1 ? { row: matches[0]!, round: matches[0]!.round!, fixFor: matches[0]!.fixFor, implementationInput: matches[0]!.implementationInput } : matches.length > 1 ? { conflict: true as const } : null;
 }
 
 function repairMissingCodeFixQualifier(
   request: TaskEventRequest,
   family: EventFamily,
-  open: { row: { step: string }; round: number; fixFor?: string; implementationInput?: string },
+  open: { row: LifecycleExecution; round: number; fixFor?: string; implementationInput?: string },
   repoRoot: string
 ) {
   if (family !== 'code' || open.fixFor !== undefined || !request.fixFor || request.implementationInput !== undefined) {
@@ -411,12 +399,12 @@ function repairMissingCodeFixQualifier(
 function resolveOpenStartedEvent(
   request: TaskEventRequest,
   family: EventFamily,
-  open: { row: { step: string; agent: string; started: string; note: string }; round: number; fixFor?: string; implementationInput?: string },
+  open: { row: LifecycleExecution; round: number; fixFor?: string; implementationInput?: string },
   repoRoot: string
 ) {
   if (open.row.agent !== request.agent) return { status: 'error' as const, error: { code: 'EVENT_LOG_CONFLICT', message: 'open started event has a different agent' } as TaskEventError };
   if (family === 'manual-validation' && request.transactionId !== undefined) {
-    const existingTransactionId = /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(open.row.note)?.[1];
+    const existingTransactionId = open.row.transactionId;
     if (existingTransactionId !== undefined && existingTransactionId !== request.transactionId) {
       return { status: 'error' as const, error: { code: 'EVENT_LOG_CONFLICT', message: 'open manual-validation started event has a different transactionId' } as TaskEventError };
     }
@@ -428,7 +416,7 @@ function resolveOpenStartedEvent(
     const repair = repairMissingCodeFixQualifier(request, family, open, repoRoot);
     if (!repair) return { status: 'error' as const, error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `fixFor '${request.fixFor}' conflicts with open event` } as TaskEventError };
     if ('error' in repair) return { status: 'error' as const, error: repair.error, context: repair.context };
-    return { status: 'repair' as const, repair: repair.request, context: repair.context, superseded: { action: open.row.step } };
+    return { status: 'repair' as const, repair: repair.request, context: repair.context, superseded: { action: `${FAMILY[family].label} (Round ${open.round})`, family: open.row.family, round: open.row.round } };
   }
   if (request.implementationInput !== open.implementationInput) {
     return { status: 'error' as const, error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `implementationInput '${request.implementationInput ?? ''}' conflicts with open event` } as TaskEventError };
@@ -442,19 +430,12 @@ function resolveOpenStartedEvent(
       fixFor: open.fixFor,
       implementationInput: open.implementationInput
     },
-    startedAt: open.row.started
+    startedAt: open.row.startedAt
   };
 }
 
-function hasOtherOpenStarted(rows: ReturnType<typeof pairEntries>, allowedAction: string): boolean {
-  return rows.some((row) => row.started && !row.done && row.step !== allowedAction);
-}
-
-function hasConflictingOpenStarted(
-  rows: ReturnType<typeof pairEntries>,
-  recovery: { action: string } | null
-): boolean {
-  return recovery ? hasOtherOpenStarted(rows, recovery.action) : rows.some((row) => row.started && !row.done);
+function hasConflictingOpenStarted(rows: LifecycleExecution[], recovery: { family: string; round?: number } | null): boolean {
+  return rows.some((row) => !recovery || row.family !== recovery.family || row.round !== recovery.round);
 }
 
 function reviewInputFamily(family: EventFamily): ArtifactFamily {
@@ -467,7 +448,7 @@ function lifecycleAction(family: EventFamily): LifecycleAction {
 
 function eventTrigger(request: TaskEventRequest, family: EventFamily): ExplicitTrigger {
   return {
-    initiator: request.initiator ?? (request.orchestrated ? 'orchestrator' : request.agent === 'human' ? 'human' : 'model'),
+    initiator: request.initiator ?? (request.agent === 'human' ? 'human' : 'model'),
     requestId: request.requestId ?? `${request.taskRef}:${request.event}:${request.round ?? 1}`,
     requestedAction: lifecycleAction(family),
     reasonCode: request.reasonCode ?? (request.fixFor || request.implementationInput ? 'review-finding' : 'user-request'),
@@ -475,7 +456,7 @@ function eventTrigger(request: TaskEventRequest, family: EventFamily): ExplicitT
     ...(request.sourceArtifact ? { sourceArtifact: request.sourceArtifact } : {}),
     ...(request.sourceSha256 ? { sourceSha256: request.sourceSha256 } : {}),
     ...(request.implementationInput ? { implementationInput: request.implementationInput } : {}),
-    explicitRequest: request.requestId !== undefined || request.reasonCode !== undefined || request.initiator !== undefined || request.orchestrated === true
+    explicitRequest: request.requestId !== undefined || request.reasonCode !== undefined || request.initiator !== undefined
   };
 }
 
@@ -639,12 +620,16 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   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 }); }
-  const section = locateActivityLog(content);
-  if (!section) return failed(request, { code: 'EVENT_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-  const rows = startedBackedRows(pairEntries(section.entries));
+  const section = inspectActivityLog(content).section;
+  let rows: LifecycleExecution[];
+  try {
+    rows = lifecycleExecutions(content);
+  } catch (error) {
+    return failed(request, { code: 'EVENT_TRANSITION_INVALID', message: error instanceof Error ? error.message : String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+  }
   let normalized = request;
   let artifactContext: ArtifactContextResult | null = null;
-  let supersededOpenStart: { action: string } | null = null;
+  let supersededOpenStart: { action: string; family: string; round?: number } | null = null;
   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 });
@@ -674,10 +659,11 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   }
   const eventIdentity = identity(normalized);
   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';
-  const openRows = matchingRows.filter((item) => item.started && !item.done);
-  const completedRows = matchingRows.filter((item) => item.done);
+  const openRows = rows.filter((item) => item.family === eventIdentity.family && (manual || (item.round === normalized.round && item.fixFor === normalized.fixFor && item.implementationInput === normalized.implementationInput)));
+  const completionRecorded = normalized.artifact !== undefined && parseCompletionFacts(frontmatter.completion_facts)
+    .some((fact) => fact.event === normalized.event && fact.output === normalized.artifact);
+  const hasStartedIdentity = openRows.length > 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;
@@ -685,14 +671,22 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   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 });
     if (manual && normalized.transactionId !== undefined) {
-      const existingTransactionId = /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(row.note)?.[1];
+      const existingTransactionId = row.transactionId;
       if (existingTransactionId !== undefined && existingTransactionId !== normalized.transactionId) {
         return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'open manual-validation started event has a different transactionId' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
       }
     }
-    return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.started, frontmatter, artifactContext);
-  }
-  if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0) 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 });
+    return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.startedAt, frontmatter, artifactContext);
+  }
+  const replayFact = eventIdentity.phase === 'completed' && normalized.artifact && normalized.requestId
+    ? parseCompletionFacts(frontmatter.completion_facts).find((fact) => fact.event === normalized.event
+      && fact.output === normalized.artifact && fact.requestId === normalized.requestId)
+    : undefined;
+  const validReplayFact = Boolean(replayFact && normalized.artifact
+    && hasValidArtifactCompletion(content, resolved.taskDir, normalized.artifact, normalized.event));
+  const completedByHistory = manual || eventIdentity.family === 'validation-run';
+  const completedHistoryReplay = completedByHistory && completionRecorded;
+  if (eventIdentity.phase === 'completed' && !hasStartedIdentity && !completedHistoryReplay && !validReplayFact) 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 });
@@ -750,10 +744,6 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
       }
     }
   }
-  if (eventIdentity.phase === 'waiting' && section.entries.some((entry) => entry.step === eventIdentity.action && entry.note === eventIdentity.note)) {
-    const existing = section.entries.find((entry) => entry.step === eventIdentity.action && entry.note === eventIdentity.note)!;
-    return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, existing.time, frontmatter, artifactContext);
-  }
   if (eventIdentity.phase === 'started') {
     const trigger = eventTrigger(normalized, eventIdentity.family);
     const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state, false, resolved.repoRoot);
@@ -761,7 +751,7 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
     const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
     const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
       || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
-    if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)
+    if (!capability.allowed && safetyFailure
       && !(supersededOpenStart && capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN')) {
       return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     }
@@ -773,29 +763,6 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
     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 });
-  let orchestrationCompletion: OrchestrationStageCompletion | null = null;
-  if (eventIdentity.phase === 'completed' && normalized.orchestrated
-    && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
-    const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
-    const execution = validateLifecycleExecution(normalized.taskRef, {
-      mode: 'orchestrated',
-      identity: {
-        stage: orchestrationStage,
-        round: normalized.round!,
-        artifact: normalized.artifact!,
-        role: eventIdentity.family.startsWith('review-') ? 'reviewer' : 'executor'
-      },
-      agent: normalized.agent,
-      dryRun: normalized.dryRun
-    }, { repoRoot: options.repoRoot });
-    if (!execution.ok) {
-      return failed(normalized, {
-        code: 'EVENT_TRANSITION_INVALID',
-        message: `${execution.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH'}: ${execution.error?.message ?? 'orchestration provenance validation failed'}`
-      }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
-    }
-    orchestrationCompletion = execution.completionPlan;
-  }
   let metadata;
   try { metadata = (options.metadataProvider ?? captureTaskWriteMetadata)(); }
   catch (error) { return failed(normalized, { code: 'METADATA_CAPTURE_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath }); }
@@ -828,6 +795,9 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
         artifactContext
       );
     }
+    if (!hasStartedIdentity && !completedHistoryReplay) {
+      return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion replay does not match the existing completion fact' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+    }
     try {
       const rework = reworkIntentMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp);
       if ('error' in rework) return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: rework.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -838,19 +808,22 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   }
   const step = eventIdentity.phase === 'started' || eventIdentity.target === null ? currentStep : eventIdentity.target;
   const logStep = eventIdentity.phase === 'started' ? `${eventIdentity.action} [started]` : eventIdentity.action;
-  const supersededBody = supersededOpenStart
-    ? appendActivityEntry(section, {
-      time: metadata.timestamp,
-      step: `${supersededOpenStart.action} [aborted]`,
-      agent: normalized.agent,
-      note: `superseded by ${eventIdentity.action}`
-    })
-    : section.body;
-  const body = appendActivityEntry(
-    supersededOpenStart ? { ...section, body: supersededBody } : section,
-    { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note }
-  );
+  let body: string | null = null;
+  if (section) {
+    const supersededBody = supersededOpenStart
+      ? appendActivityEntry(section, {
+        time: metadata.timestamp, step: `${supersededOpenStart.action} [aborted]`,
+        agent: normalized.agent, note: `superseded by ${eventIdentity.action}`
+      }) : section.body;
+    body = appendActivityEntry({ ...section, body: supersededBody },
+      { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
+  }
   const frontmatterSet: Record<string, string> = { current_step: step, assigned_to: normalized.agent };
+  if (eventIdentity.phase === 'started' || eventIdentity.phase === 'completed') {
+    const open = rows.filter((item) => !openRows.includes(item) && (!supersededOpenStart || item.family !== supersededOpenStart.family || item.round !== supersededOpenStart.round));
+    if (eventIdentity.phase === 'started') open.push({ family: eventIdentity.family, agent: normalized.agent, startedAt: metadata.timestamp, round: normalized.round, fixFor: normalized.fixFor, implementationInput: normalized.implementationInput, transactionId: normalized.transactionId });
+    frontmatterSet.lifecycle_execution = serializeLifecycleExecution(open, content);
+  }
   if (currentFact) frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(parseCompletionFacts(frontmatter.completion_facts), currentFact));
   if (completedArtifact && ['analyze', 'plan', 'code'].includes(eventIdentity.family)) {
     const task = parseTaskQualification(content);
@@ -909,7 +882,7 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
   }
   if (eventIdentity.phase === 'started' && normalized.implementationInput) frontmatterSet.last_reviewed_commit = '';
   const mutations: Parameters<typeof writeTask>[0]['mutations'][number][] = [
-    { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove }
+    { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove, ...(frontmatterSet.lifecycle_execution ? { lifecycleExecutionDomain: 'ordinary' as const } : {}) }
   ];
   if (completedArtifact) {
     const link = buildArtifactLinkSection(content, completedArtifact);
@@ -942,30 +915,9 @@ function applyTaskEvent(request: TaskEventRequest, options: TaskEventOptions = {
       body: renderImplementationInputs(implementationRows)
     });
   }
-  mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
+  if (section && body !== null) mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
   const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, 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 && orchestrationCompletion) {
-    try {
-      (options.commitOrchestrationCompletion ?? commitOrchestrationStageCompletion)(orchestrationCompletion);
-    } catch (error) {
-      return failed(normalized, {
-        code: 'EVENT_ORCHESTRATION_COMMIT_FAILED',
-        message: `task.md was written but orchestration completion could not be persisted; manual recovery is required: ${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
-      });
-    }
-  }
   return {
     status: result.status, changed: result.changed, event: normalized.event,
     requestRef: normalized.taskRef, taskId: result.taskId, taskMdPath: result.taskMdPath,
@@ -991,5 +943,19 @@ function successNoOp(
   };
 }
 
-export { eventCatalog, validateTaskEventRequest, applyTaskEvent };
+function applyTaskEventWithWarnings(request: TaskEventRequest, options: TaskEventOptions = {}): TaskEventResult {
+  const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+  let warnings: { code: string; message: string }[] = [];
+  if (resolved.ok) {
+    try {
+      const inspected = inspectActivityLog(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+      if (!inspected.section) warnings = [{ code: 'ACTIVITY_LOG_UNAVAILABLE', message: 'Activity Log is missing or ambiguous; no entry was appended' }];
+      else if (inspected.invalidEntries.length) warnings = [{ code: 'ACTIVITY_LOG_INVALID_ENTRIES', message: 'Activity Log contains malformed entries' }];
+    } catch { /* The core reports task read errors. */ }
+  }
+  const result = applyTaskEvent(request, options);
+  return result.status === 'failed' || warnings.length === 0 ? result : { ...result, warnings };
+}
+
+export { eventCatalog, validateTaskEventRequest, applyTaskEventWithWarnings as applyTaskEvent };
 export type { TaskEventName, TaskEventRequest, TaskEventResult, TaskEventError, TaskEventErrorCode, TaskEventOptions, Verdict };

package/lib/task/finalization.ts

@@ -10,13 +10,13 @@ import { taskIssueIdentity } from '../platform/task-identities.ts';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.ts';
 import type { IssueResult, SyncOptions as IssueSyncOptions } from '../platform/issues.ts';
 import { resourceIdentityEquals } from '../platform/resource-identity.ts';
+import { activityWarnings } from './activity-log.ts';
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { recoverPlatformOperations } from './platform-operation-recovery.ts';
 import {
   applyTaskLifecycle,
   inspectTaskLifecycleProgress,
   type TaskLifecycleOptions,
-  type TaskLifecycleRequest,
   type TaskLifecycleResult,
   type TaskCompletionProjection,
   previewTaskCompletion
@@ -106,6 +106,7 @@ type TaskFinalizationStep = Readonly<{
   error: FinalizationError | null;
   completedSteps?: readonly string[];
   pendingSteps?: readonly string[];
+  warnings?: readonly OperationWarning[];
 }>;
 
 type TaskCommentSyncOutcome = Readonly<{
@@ -332,7 +333,8 @@ function lifecycleStep(result: TaskLifecycleResult): TaskFinalizationStep {
     changed: result.changed,
     error: result.error ? errorOf(result.error, 'LIFECYCLE_FAILED') : null,
     completedSteps: result.completedSteps ?? [],
-    pendingSteps: result.pendingSteps ?? []
+    pendingSteps: result.pendingSteps ?? [],
+    warnings: (result.warnings ?? []).map((warning) => ({ ...warning, step: 'lifecycle', target: 'activity-log', severity: 'IMPORTANT' as const, retryable: true }))
   };
 }
 
@@ -348,7 +350,17 @@ function verificationStep(result: TaskVerificationResult): TaskFinalizationStep
   return {
     status: result.status,
     changed: false,
-    error: result.status === 'pass' ? null : verificationFailure(result)
+    error: result.status === 'pass' ? null : verificationFailure(result),
+    warnings: result.invocations.flatMap(({ payload }) => {
+      const checks = Array.isArray(payload.checks) ? payload.checks : [payload];
+      return checks.flatMap((check) => {
+        if (!check || typeof check !== 'object' || !Array.isArray(check.warnings)) return [];
+        return check.warnings.filter((message: unknown): message is string => typeof message === 'string').map((message: string) => ({
+          code: 'VERIFICATION_DIAGNOSTIC', message, retryable: true, step: 'verification',
+          target: typeof check.checkId === 'string' ? check.checkId : String(check.type ?? 'check'), severity: 'IMPORTANT' as const
+        }));
+      });
+    })
   };
 }
 
@@ -494,7 +506,7 @@ function issueCapability(receipt: TaskFinalizationReceipt, scope: Exclude<Finali
 
 function capabilityError(code: 'FINALIZATION_CAPABILITY_STALE' | 'FINALIZATION_SCOPE_INVALID', message: string): Error {
   const error = new Error(message);
-  error.name = 'OrchestrationStateError';
+  error.name = 'TaskFinalizationCapabilityError';
   Object.assign(error, { code });
   return error;
 }
@@ -815,7 +827,7 @@ function terminalResult(
 ): TaskFinalizationResult {
   const pending = pendingSteps(receipt);
   const blocked = [steps.backfill, steps.lifecycle, steps.taskComment, steps.verification, steps.summary].some((step) => step?.status === 'blocked');
-  const warnings = openWarnings(receipt);
+  const warnings = mergeOperationWarnings(openWarnings(receipt), steps.lifecycle?.warnings ?? [], steps.verification?.warnings ?? []);
   const postLifecyclePending = receipt.lifecycle === 'done' && (pending.some((step) => step !== 'lifecycle') || receipt.warningProjection === 'pending');
   const terminalVerificationPending = receipt.lifecycle === 'done' && receipt.verification === 'pending';
   const resultError = error ?? (terminalVerificationPending ? steps.verification?.error : null) ?? null;
@@ -860,7 +872,7 @@ function preparedResult(
     verification: steps.verification ?? null,
     summary: steps.summary ?? null,
     completedSteps: completedSteps(receipt), pendingSteps: pendingSteps(receipt),
-    result: 'prepared', warnings: openWarnings(receipt), error: null
+    result: 'prepared', warnings: mergeOperationWarnings(openWarnings(receipt), steps.lifecycle?.warnings ?? []), error: null
   };
 }
 
@@ -1135,7 +1147,7 @@ async function prepareTaskFinalizationCore(
   return preparedResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification, summary: summary.step }, changed);
 }
 
-async function prepareTaskFinalization(request: TaskFinalizationRequest, options: TaskFinalizationOptions): Promise<TaskFinalizationResult> {
+async function prepareTaskFinalizationInner(request: TaskFinalizationRequest, options: TaskFinalizationOptions): Promise<TaskFinalizationResult> {
   if (request.intent !== 'complete' || !request.taskRef || !request.agent) {
     return failed(null, { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'complete finalization requires taskRef and agent', retryable: false });
   }
@@ -1311,6 +1323,25 @@ async function commitPreparedTaskFinalization(request: TaskFinalizationRequest,
   }
 }
 
+function withActivityWarnings(result: TaskFinalizationResult, request: TaskFinalizationRequest, options: TaskFinalizationOptions): TaskFinalizationResult {
+  if (result.status === 'failed' || result.status === 'blocked') return result;
+  const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) return result;
+  let diagnostics: ReturnType<typeof activityWarnings>;
+  try { diagnostics = activityWarnings(fs.readFileSync(resolved.taskMdPath, 'utf8')); }
+  catch { return result; }
+  const warnings = diagnostics.map((warning) => ({ ...warning, step: 'lifecycle', target: 'activity-log', severity: 'IMPORTANT' as const, retryable: true }));
+  return { ...result, warnings: mergeOperationWarnings(result.warnings, warnings) };
+}
+
+async function prepareTaskFinalization(request: TaskFinalizationRequest, options: TaskFinalizationOptions): Promise<TaskFinalizationResult> {
+  return withActivityWarnings(await prepareTaskFinalizationInner(request, options), request, options);
+}
+
+async function commitPreparedTaskFinalizationWithWarnings(request: TaskFinalizationRequest, options: TaskFinalizationOptions): Promise<TaskFinalizationResult> {
+  return withActivityWarnings(await commitPreparedTaskFinalization(request, options), request, options);
+}
+
 async function applyTaskFinalization(request: TaskFinalizationRequest, options: TaskFinalizationOptions): Promise<TaskFinalizationResult> {
   const prepared = await prepareTaskFinalization(request, options);
   if (prepared.status !== 'prepared') return prepared;
@@ -1327,12 +1358,13 @@ async function applyTaskFinalization(request: TaskFinalizationRequest, options:
       });
     }
   }
-  return commitPreparedTaskFinalization(request, options);
+  const committed = await commitPreparedTaskFinalizationWithWarnings(request, options);
+  return { ...committed, warnings: mergeOperationWarnings(prepared.warnings, committed.warnings) };
 }
 
 export {
   applyFinalizationReceiptMutation,
-  commitPreparedTaskFinalization,
+  commitPreparedTaskFinalizationWithWarnings as commitPreparedTaskFinalization,
   applyTaskFinalization,
   prepareTaskFinalization,
   issueCapability as createFinalizationCapability,

package/lib/task/ledger-intents.ts

@@ -16,7 +16,7 @@ import { writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
 import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.ts';
 import type { ReworkClassification, ReworkIntent, ReworkTarget } from './rework-intent.ts';
-import { extractSection, extractSubSection } from './sections.ts';
+import { extractSection } from './sections.ts';
 import { parseLifecyclePathDecision } from './lifecycle-path.ts';
 import { scanVisibleMarkdown } from './markdown.ts';
 import { inspectArtifactDirectory } from './artifact-lifecycle.ts';