@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/task/events.js

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { resolveBranchWorktree } from '../git/branch-worktree.js';
-import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
+import { appendActivityEntry, inspectActivityLog } from './activity-log.js';
+import { lifecycleExecutions, serializeLifecycleExecution } from './lifecycle-execution.js';
 import { buildArtifactLinkSection, inspectArtifactDirectory, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
 import { artifactName, parseArtifactName } from './artifact-name.js';
 import { ArtifactReceiptError, parseArtifactReceipts, sha256File, upsertArtifactReceipts } from './artifact-receipts.js';
@@ -13,8 +14,6 @@ import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.
 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';
-import { commitOrchestrationStageCompletion } from './orchestration.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.js';
@@ -23,7 +22,7 @@ import { parseTaskQualification } from './qualification-audit.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { inspectReviewIdentity } from './review-identity.js';
-import { parseCompletionFacts } from './completion-facts.js';
+import { hasValidArtifactCompletion, parseCompletionFacts } from './completion-facts.js';
 import { readManualValidationCompletion } from './manual-validation-completion.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 const eventCatalog = [
@@ -69,17 +68,17 @@ const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'initiator',
 const SCHEMAS = {
     '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'] },
@@ -107,7 +106,7 @@ function validateTaskEventRequest(request) {
     }
     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))
+    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' };
@@ -331,21 +330,12 @@ function validateManualValidationCompletion(taskDir, taskId, request, artifactPa
     return null;
 }
 function openStartedIdentity(rows, family) {
-    const spec = FAMILY[family];
+    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 } : 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 } : null;
 }
 function repairMissingCodeFixQualifier(request, family, open, repoRoot) {
     if (family !== 'code' || open.fixFor !== undefined || !request.fixFor || request.implementationInput !== undefined) {
@@ -369,7 +359,7 @@ function resolveOpenStartedEvent(request, family, open, repoRoot) {
     if (open.row.agent !== request.agent)
         return { status: 'error', error: { code: 'EVENT_LOG_CONFLICT', message: 'open started event has a different agent' } };
     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', error: { code: 'EVENT_LOG_CONFLICT', message: 'open manual-validation started event has a different transactionId' } };
         }
@@ -383,7 +373,7 @@ function resolveOpenStartedEvent(request, family, open, repoRoot) {
             return { status: 'error', error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `fixFor '${request.fixFor}' conflicts with open event` } };
         if ('error' in repair)
             return { status: 'error', error: repair.error, context: repair.context };
-        return { status: 'repair', repair: repair.request, context: repair.context, superseded: { action: open.row.step } };
+        return { status: 'repair', 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', error: { code: 'EVENT_ARTIFACT_CONFLICT', message: `implementationInput '${request.implementationInput ?? ''}' conflicts with open event` } };
@@ -397,14 +387,11 @@ function resolveOpenStartedEvent(request, family, open, repoRoot) {
             fixFor: open.fixFor,
             implementationInput: open.implementationInput
         },
-        startedAt: open.row.started
+        startedAt: open.row.startedAt
     };
 }
-function hasOtherOpenStarted(rows, allowedAction) {
-    return rows.some((row) => row.started && !row.done && row.step !== allowedAction);
-}
 function hasConflictingOpenStarted(rows, recovery) {
-    return recovery ? hasOtherOpenStarted(rows, recovery.action) : rows.some((row) => row.started && !row.done);
+    return rows.some((row) => !recovery || row.family !== recovery.family || row.round !== recovery.round);
 }
 function reviewInputFamily(family) {
     return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
@@ -414,7 +401,7 @@ function lifecycleAction(family) {
 }
 function eventTrigger(request, family) {
     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'),
@@ -422,7 +409,7 @@ function eventTrigger(request, family) {
         ...(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
     };
 }
 function reworkIntentMutationForCompletion(content, taskDir, family, artifact, timestamp) {
@@ -589,10 +576,14 @@ function applyTaskEvent(request, options = {}) {
     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;
+    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 = null;
     let supersededOpenStart = null;
@@ -631,10 +622,11 @@ function applyTaskEvent(request, options = {}) {
     }
     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);
@@ -644,14 +636,22 @@ function applyTaskEvent(request, options = {}) {
         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 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);
@@ -711,10 +711,6 @@ function applyTaskEvent(request, options = {}) {
             }
         }
     }
-    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);
@@ -723,7 +719,7 @@ function applyTaskEvent(request, options = {}) {
         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 });
         }
@@ -731,29 +727,6 @@ function applyTaskEvent(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 });
-    let orchestrationCompletion = 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)();
@@ -782,6 +755,9 @@ function applyTaskEvent(request, options = {}) {
         if (parseCompletionFacts(frontmatter.completion_facts).some((fact) => sameCompletionFact(fact, currentFact))) {
             return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, completionReceipts[0]?.completedAt ?? metadata.timestamp, frontmatter, 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)
@@ -794,16 +770,22 @@ function applyTaskEvent(request, options = {}) {
     }
     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 = 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 = { 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)) {
@@ -869,7 +851,7 @@ function applyTaskEvent(request, options = {}) {
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
         frontmatterSet.last_reviewed_commit = '';
     const mutations = [
-        { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove }
+        { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove, ...(frontmatterSet.lifecycle_execution ? { lifecycleExecutionDomain: 'ordinary' } : {}) }
     ];
     if (completedArtifact) {
         const link = buildArtifactLinkSection(content, completedArtifact);
@@ -901,32 +883,11 @@ function applyTaskEvent(request, options = {}) {
             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,
@@ -946,5 +907,21 @@ function successNoOp(request, taskId, taskMdPath, currentStep, eventIdentity, ti
         artifactContext
     };
 }
-export { eventCatalog, validateTaskEventRequest, applyTaskEvent };
+function applyTaskEventWithWarnings(request, options = {}) {
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    let warnings = [];
+    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 };
 //# sourceMappingURL=events.js.map

package/dist/lib/task/finalization.js

@@ -7,6 +7,7 @@ import { backfillCompletionComments, inspectCompletionBackfillEligibility } from
 import { taskIssueIdentity } from '../platform/task-identities.js';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { resourceIdentityEquals } from '../platform/resource-identity.js';
+import { activityWarnings } from './activity-log.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { recoverPlatformOperations } from './platform-operation-recovery.js';
 import { applyTaskLifecycle, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
@@ -17,6 +18,7 @@ import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
 import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { validateSandboxControlIdentity } from '../sandbox/control/identity-sentinel.js';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent } from '../platform/issue-summary-content.js';
 const RECEIPT_VERSION = 4;
 const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'];
 export function resolveTaskFinalizationDirectory(repoRoot, taskId) {
@@ -206,7 +208,8 @@ function lifecycleStep(result) {
         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', retryable: true }))
     };
 }
 function commentStep(result) {
@@ -220,7 +223,18 @@ function verificationStep(result) {
     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) => typeof message === 'string').map((message) => ({
+                    code: 'VERIFICATION_DIAGNOSTIC', message, retryable: true, step: 'verification',
+                    target: typeof check.checkId === 'string' ? check.checkId : String(check.type ?? 'check'), severity: 'IMPORTANT'
+                }));
+            });
+        })
     };
 }
 function verificationFailure(result) {
@@ -350,7 +364,7 @@ function issueCapability(receipt, scope) {
 }
 function capabilityError(code, message) {
     const error = new Error(message);
-    error.name = 'OrchestrationStateError';
+    error.name = 'TaskFinalizationCapabilityError';
     Object.assign(error, { code });
     return error;
 }
@@ -569,17 +583,25 @@ function readDeliverySummary(taskDir, taskId) {
     catch {
         throw Object.assign(new Error('delivery summary staging record is unavailable'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    if (value.taskId !== taskId || typeof value.body !== 'string' || typeof value.sha256 !== 'string') {
+    if (value.taskId !== taskId || !value.content || typeof value.contentSha256 !== 'string') {
         throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    const canonical = canonicalizeSummaryBody(value.body);
-    if (!canonical.ok || canonical.value !== value.body) {
-        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+    let content;
+    try {
+        content = parseDeliverySummaryContent(value.content);
     }
+    catch {
+        throw Object.assign(new Error('delivery summary staging payload is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
+    }
+    if (content.taskId !== taskId || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== value.contentSha256) {
+        throw Object.assign(new Error('delivery summary staging digest does not match payload'), { code: 'SUMMARY_STAGING_INVALID' });
+    }
+    const body = renderDeliverySummaryContent(content);
+    const canonical = canonicalizeSummaryBody(body);
+    if (!canonical.ok)
+        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
     const digest = createHash('sha256').update(canonical.value).digest('hex');
-    if (digest !== value.sha256)
-        throw Object.assign(new Error('delivery summary staging digest does not match body'), { code: 'SUMMARY_STAGING_INVALID' });
-    return { body: canonical.value, sha256: value.sha256 };
+    return { body: canonical.value, sha256: digest };
 }
 async function syncPendingSummary(input) {
     let { receipt } = input;
@@ -639,7 +661,7 @@ async function syncPendingSummary(input) {
 function terminalResult(taskId, receipt, steps, changed, error = null) {
     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;
@@ -678,7 +700,7 @@ function preparedResult(taskId, receipt, steps, changed) {
         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
     };
 }
 async function prepareTaskFinalizationCore(request, taskId, options) {
@@ -956,7 +978,7 @@ async function prepareTaskFinalizationCore(request, taskId, options) {
     }
     return preparedResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification, summary: summary.step }, changed);
 }
-async function prepareTaskFinalization(request, options) {
+async function prepareTaskFinalizationInner(request, options) {
     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 });
     }
@@ -1135,6 +1157,28 @@ async function commitPreparedTaskFinalization(request, options) {
         return failed(resolved.taskId, detail);
     }
 }
+function withActivityWarnings(result, request, options) {
+    if (result.status === 'failed' || result.status === 'blocked')
+        return result;
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return result;
+    let diagnostics;
+    try {
+        diagnostics = activityWarnings(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    }
+    catch {
+        return result;
+    }
+    const warnings = diagnostics.map((warning) => ({ ...warning, step: 'lifecycle', target: 'activity-log', severity: 'IMPORTANT', retryable: true }));
+    return { ...result, warnings: mergeOperationWarnings(result.warnings, warnings) };
+}
+async function prepareTaskFinalization(request, options) {
+    return withActivityWarnings(await prepareTaskFinalizationInner(request, options), request, options);
+}
+async function commitPreparedTaskFinalizationWithWarnings(request, options) {
+    return withActivityWarnings(await commitPreparedTaskFinalization(request, options), request, options);
+}
 async function applyTaskFinalization(request, options) {
     const prepared = await prepareTaskFinalization(request, options);
     if (prepared.status !== 'prepared')
@@ -1153,7 +1197,8 @@ async function applyTaskFinalization(request, options) {
             });
         }
     }
-    return commitPreparedTaskFinalization(request, options);
+    const committed = await commitPreparedTaskFinalizationWithWarnings(request, options);
+    return { ...committed, warnings: mergeOperationWarnings(prepared.warnings, committed.warnings) };
 }
-export { applyFinalizationReceiptMutation, commitPreparedTaskFinalization, applyTaskFinalization, prepareTaskFinalization, issueCapability as createFinalizationCapability, readTaskFinalizationReceipt, terminalResult };
+export { applyFinalizationReceiptMutation, commitPreparedTaskFinalizationWithWarnings as commitPreparedTaskFinalization, applyTaskFinalization, prepareTaskFinalization, issueCapability as createFinalizationCapability, readTaskFinalizationReceipt, terminalResult };
 //# sourceMappingURL=finalization.js.map

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

@@ -7,7 +7,7 @@ import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SE
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
 import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
-import { extractSection, extractSubSection } from './sections.js';
+import { extractSection } from './sections.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { scanVisibleMarkdown } from './markdown.js';
 import { inspectArtifactDirectory } from './artifact-lifecycle.js';

package/dist/lib/task/lifecycle-execution.js

@@ -1,37 +1,42 @@
-import { inspectOrchestrationStage, pauseOrchestration, planOrchestrationStageCompletion } from './orchestration.js';
-import { resolveTaskRef } from './resolve-ref.js';
-function failure(mode, code, message) {
-    return { ok: false, mode, completionPlan: null, error: { code, message } };
-}
-function inspectLifecycleExecution(taskRef, request, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failure(request.mode, resolved.code, resolved.message);
-    if (request.mode === 'standalone') {
-        return { ok: true, mode: request.mode, completionPlan: null, error: null };
-    }
-    if (request.agent) {
-        const planned = planOrchestrationStageCompletion(taskRef, {
-            ...request.identity,
-            agent: request.agent
-        }, options);
-        if (planned.plan) {
-            return { ok: true, mode: request.mode, completionPlan: planned.plan, error: null };
-        }
-        return failure(request.mode, planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', planned.result.error?.message ?? 'orchestration provenance validation failed');
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+const labels = {
+    'Analyze Task': 'analyze', 'Review Analysis': 'review-analysis', 'Plan Task': 'plan',
+    'Review Plan': 'review-plan', 'Code Task': 'code', 'Review Code': 'review-code',
+    'Run Manual Validation': 'validation-run'
+};
+export function lifecycleExecutions(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+    if (value !== undefined) {
+        if (typeof value !== 'string')
+            throw new Error('invalid lifecycle execution state');
+        const state = JSON.parse(value);
+        if (!state || typeof state !== 'object' || !('version' in state) || state.version !== 1 || !('open' in state) || !Array.isArray(state.open))
+            throw new Error('invalid lifecycle execution state');
+        return state.open.map((item) => {
+            if (!item || typeof item !== 'object' || !('family' in item) || typeof item.family !== 'string' || ![...Object.values(labels), 'manual-validation', 'other'].includes(item.family) || !('agent' in item) || typeof item.agent !== 'string' || !('startedAt' in item) || typeof item.startedAt !== 'string')
+                throw new Error('invalid lifecycle execution identity');
+            return item;
+        });
     }
-    const inspected = inspectOrchestrationStage(taskRef, request.identity, options);
-    if (inspected.status !== 'failed') {
-        return { ok: true, mode: request.mode, completionPlan: null, error: null };
-    }
-    return failure(request.mode, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed');
+    return [];
+}
+export function prReviewExecution(content) {
+    const value = parseTypedTaskFrontmatter(content).lifecycle_execution;
+    if (value === undefined)
+        return { open: null, terminals: [] };
+    if (typeof value !== 'string')
+        throw new Error('invalid lifecycle execution state');
+    const state = JSON.parse(value);
+    if (state.version !== 1 || !Array.isArray(state.open))
+        throw new Error('invalid lifecycle execution state');
+    const pr = state.prReview ?? { open: null, terminals: [] };
+    const valid = (item) => item && typeof item.artifact === 'string' && typeof item.head === 'string' && typeof item.agent === 'string';
+    if (!Array.isArray(pr.terminals) || (pr.open !== null && (!valid(pr.open) || typeof pr.open.startedAt !== 'string')) || !pr.terminals.every((item) => valid(item) && typeof item.note === 'string'))
+        throw new Error('invalid PR review execution state');
+    return pr;
 }
-function validateLifecycleExecution(taskRef, request, options = {}) {
-    const inspected = inspectLifecycleExecution(taskRef, request, options);
-    if (inspected.ok || request.mode === 'standalone' || request.dryRun)
-        return inspected;
-    const paused = pauseOrchestration(taskRef, inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', inspected.error?.message ?? 'orchestration provenance validation failed', true, options);
-    return failure(request.mode, paused.run?.pause?.code ?? inspected.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', paused.run?.pause?.message ?? inspected.error?.message ?? 'orchestration provenance validation failed');
+export function serializeLifecycleExecution(open, content, prReview) {
+    const pr = prReview ?? (content ? prReviewExecution(content) : { open: null, terminals: [] });
+    return JSON.stringify({ version: 1, open, prReview: pr });
 }
-export { inspectLifecycleExecution, validateLifecycleExecution };
 //# sourceMappingURL=lifecycle-execution.js.map