@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/dist/lib/task/create.js

@@ -8,6 +8,7 @@ import { readDeliveryDefaults, validateBaseRef, validateRemote } from './deliver
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.js';
 import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, parseTaskQualification } from './qualification-audit.js';
 import { enumerateAllTaskDirs } from './resolve-ref.js';
+import { serializeLifecycleExecution } from './lifecycle-execution.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { AGENT_TOKEN_VALUES } from '../agent-clients/tokens.js';
 import { resolveProjectTaskWorkspaceRoot } from './workspace-root.js';
@@ -23,7 +24,6 @@ function payloadError(message) {
 }
 function exactKeys(value, expected, label, optional = []) {
     const actual = Object.keys(value).sort();
-    const wanted = [...expected].sort();
     const allowed = new Set([...expected, ...optional]);
     if (actual.some((key) => !allowed.has(key))) {
         payloadError(`${label} has unknown or missing fields`);
@@ -134,9 +134,6 @@ function taskIdFor(date) {
     const pad = (value) => String(value).padStart(2, '0');
     return `TASK-${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
 }
-function yamlString(value) {
-    return JSON.stringify(value);
-}
 function markdownBlock(value) {
     return value.split(/\r?\n/).map((line) => /^(?:#{1,6}\s|```)/.test(line) ? `\\${line}` : line).join('\n');
 }
@@ -237,6 +234,7 @@ function renderTask(params) {
         'target_date:',
         'current_step: requirement-analysis',
         `assigned_to: ${candidate.agent}`,
+        `lifecycle_execution: ${JSON.stringify(serializeLifecycleExecution([]))}`,
         `pr_delivery_fact: ${JSON.stringify(encodePrDeliveryFact(buildUnboundFact()))}`,
         `delivery_remote: ${candidate.deliveryRemote ?? params.delivery.remote}`,
         `delivery_base_ref: ${candidate.deliveryBaseRef ?? params.delivery.baseRef}`,

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

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { isDecisionItem, listDecisionItems, selectDecisionItem } from './decision-items.js';
 import { createImplementationInput, finalizeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs, selectDeclaredImplementationInput } from './implementation-inputs.js';
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument } from './ledger.js';
@@ -77,7 +77,7 @@ function applyHumanDecision(request, options = {}) {
             const replay = existingDecision(content, direct[0], request.decision.trim(), request.needsImplementation);
             if ('conflict' in replay)
                 return failed('DECISION_CONFLICT', replay.conflict, resolved.taskId, direct[0].id);
-            return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0].id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null };
+            return { status: 'no-op', changed: false, taskId: resolved.taskId, ledgerId: direct[0].id, recordId: replay.recordId, implementationInputId: replay.implementationInputId, operations: [], error: null, warnings: activityWarnings(content) };
         }
         catch (error) {
             return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, direct[0].id);
@@ -126,8 +126,6 @@ function applyHumanDecision(request, options = {}) {
     const decision = request.decision.trim();
     const record = `### ${recordId}\n\n- **原账本 ID**：${row.id}\n- **裁决时间**：${metadata.timestamp}\n- **裁决结果**：${decision}`;
     const activity = locateActivityLog(content);
-    if (!activity)
-        return failed('DECISION_ACTIVITY_MISSING', 'activity log section is missing or ambiguous', resolved.taskId, row.id);
     const mutations = [
         {
             kind: 'table-row', action: 'upsert', sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS,
@@ -155,10 +153,11 @@ function applyHumanDecision(request, options = {}) {
             body: renderImplementationInputs(nextInputs)
         });
     }
-    mutations.push({
-        kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
-        body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
-    });
+    if (activity)
+        mutations.push({
+            kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
+            body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
+        });
     try {
         const parsedRework = parseReworkIntentDocument(content);
         if (!parsedRework.ok)
@@ -177,7 +176,7 @@ function applyHumanDecision(request, options = {}) {
     });
     if (writeResult.status === 'failed')
         return failed(writeResult.error.code, writeResult.error.message, writeResult.taskId, row.id);
-    return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null };
+    return { status: writeResult.status, changed: writeResult.changed, taskId: writeResult.taskId, ledgerId: row.id, recordId, implementationInputId, operations: writeResult.operations, error: null, warnings: activityWarnings(content) };
 }
 export { applyHumanDecision };
 //# sourceMappingURL=decision-intents.js.map

package/dist/lib/task/delivery-target.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
 const REMOTE_RE = /^(?!-)(?!.*\.\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._/-]+$/;
 const REF_RE = /^(?!-)(?!.*\.\.)(?!.*(?:^|\/)\.)(?!.*[~^:?*\\\s])[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
 function validateRemote(value) {
@@ -55,43 +54,5 @@ function resolveDeliveryTarget(repoRoot, existing = {}, explicit = {}) {
         return defaults;
     return bindDeliveryTarget({ defaults: defaults.value, existing, explicit });
 }
-function gitText(repoRoot, args) {
-    return execFileSync('git', [...args], {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe']
-    }).trim();
-}
-function resolveTargetHead(repoRoot, target) {
-    try {
-        const output = gitText(repoRoot, ['ls-remote', '--refs', target.remote, `refs/heads/${target.baseRef}`]);
-        const head = output.split(/\s+/)[0] ?? '';
-        if (!/^[a-f0-9]{40}$/i.test(head)) {
-            return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: `Delivery target ${target.remote}/${target.baseRef} is unavailable` };
-        }
-        try {
-            gitText(repoRoot, ['cat-file', '-e', `${head}^{commit}`]);
-        }
-        catch {
-            return { ok: false, code: 'DELIVERY_TARGET_OBJECT_MISSING', message: `Delivery target commit ${head} is not available locally` };
-        }
-        return { ok: true, value: target, head };
-    }
-    catch (error) {
-        return { ok: false, code: 'DELIVERY_TARGET_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
-    }
-}
-function resolveDiffBase(repoRoot, reviewedHead, targetHead) {
-    try {
-        const diffBase = gitText(repoRoot, ['merge-base', reviewedHead, targetHead]);
-        if (!/^[a-f0-9]{40}$/i.test(diffBase)) {
-            return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: 'Git returned an invalid diff base' };
-        }
-        return { ok: true, diffBase };
-    }
-    catch (error) {
-        return { ok: false, code: 'DELIVERY_DIFF_BASE_UNAVAILABLE', message: error instanceof Error ? error.message : String(error) };
-    }
-}
-export { bindDeliveryTarget, readDeliveryDefaults, resolveDeliveryTarget, resolveTargetHead, resolveDiffBase, validateBaseRef, validateRemote };
+export { bindDeliveryTarget, readDeliveryDefaults, resolveDeliveryTarget, validateBaseRef, validateRemote };
 //# sourceMappingURL=delivery-target.js.map

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';
@@ -207,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) {
@@ -221,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) {
@@ -351,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;
 }
@@ -648,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;
@@ -687,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) {
@@ -965,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 });
     }
@@ -1144,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')
@@ -1162,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';