@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/dist/lib/task/delivery.js

@@ -3,8 +3,7 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead, validateBaseRef, validateRemote } from './delivery-target.js';
-import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.js';
+import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.js';
 function classifyDeliveryState(localHead, remoteHead, lastDelivered) {
@@ -27,41 +26,6 @@ function gitValue(cwd, args) {
 function validateBranch(cwd, branch) {
     return git(cwd, ['check-ref-format', `refs/heads/${branch}`]).status === 0;
 }
-function validateReviewTargetCompatibility(repoRoot, taskDir, target, reviewedHead) {
-    const artifact = findAuthoritativeReviewCodeArtifact(taskDir);
-    if (!artifact.ok || !artifact.path)
-        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'A current review-code artifact is required before delivery' };
-    let content;
-    try {
-        content = fs.readFileSync(artifact.path, 'utf8');
-    }
-    catch (error) {
-        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: error instanceof Error ? error.message : String(error) };
-    }
-    const savedReviewedHead = extractReviewedHead(content) || extractReviewBaseline(content);
-    const savedTargetHead = extractReviewTargetHead(content);
-    const savedDiffBase = extractReviewDiffBase(content);
-    if (!savedReviewedHead || !savedTargetHead || !savedDiffBase) {
-        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: 'review-code must save reviewed head, target head, and diff base before delivery' };
-    }
-    if (savedReviewedHead !== reviewedHead) {
-        return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'review-code reviewed head does not match last_reviewed_commit' };
-    }
-    const saved = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
-    if (!saved.ok || saved.diffBase !== savedDiffBase) {
-        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: saved.ok ? 'saved review diff base does not match saved target head' : saved.message };
-    }
-    const currentTarget = resolveTargetHead(repoRoot, target);
-    if (!currentTarget.ok)
-        return { ok: false, code: currentTarget.code, message: currentTarget.message };
-    const current = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head);
-    if (!current.ok)
-        return { ok: false, code: current.code, message: current.message };
-    if (current.diffBase !== savedDiffBase) {
-        return { ok: false, code: 'DELIVERY_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
-    }
-    return { ok: true };
-}
 function failure(taskId, code, message, retryable = false, status = retryable ? 'blocked' : 'failed') {
     return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
@@ -102,12 +66,6 @@ function deliverUnlocked(taskId, taskDir, repoRoot, options) {
         return failure(taskId, 'DELIVERY_GIT_INSPECT_FAILED', status.stderr.trim() || 'Unable to inspect Git state');
     if (status.stdout.trim())
         return failure(taskId, 'DELIVERY_WORKTREE_DIRTY', 'Working tree must be clean before branch delivery');
-    const reviewed = frontmatter.last_reviewed_commit ?? '';
-    if (reviewed !== localHead)
-        return failure(taskId, 'DELIVERY_REVIEW_REQUIRED', 'Local HEAD must equal last_reviewed_commit before delivery');
-    const reviewTarget = validateReviewTargetCompatibility(repoRoot, taskDir, target.value, reviewed);
-    if (!reviewTarget.ok)
-        return failure(taskId, reviewTarget.code, reviewTarget.message, reviewTarget.code.includes('UNAVAILABLE'), reviewTarget.code.includes('UNAVAILABLE') ? 'blocked' : 'failed');
     const ref = `refs/heads/${branch}`;
     const remoteOutput = git(repoRoot, ['ls-remote', '--refs', target.value.remote, ref]);
     if (remoteOutput.status !== 0)

package/dist/lib/task/events.js

@@ -1,6 +1,7 @@
 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 { buildArtifactLinkSection, inspectArtifactDirectory, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
 import { artifactName, parseArtifactName } from './artifact-name.js';
@@ -16,17 +17,17 @@ import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { commitOrchestrationStageCompletion } from './orchestration.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
 import { validateLocalArtifact } from './local-artifact-finalization.js';
-import { buildLifecycleFacts, canStart } from './capabilities.js';
+import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.js';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
 import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.js';
-import { ARTIFACT_FAMILIES, expectedQualificationRelations, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest, validateQualificationAudit } from './qualification-audit.js';
+import { ARTIFACT_FAMILIES, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest } from './qualification-audit.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { consumeLifecycleRecoveryAttestation, lifecycleRecoveryAttestationDigest, validateLifecycleRecoveryAttestation } from './control-authority.js';
 import { readManualValidationCompletion } from './manual-validation-completion.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
 const eventCatalog = [
     'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
     'review-analysis.started', 'review-analysis.completed',
@@ -37,28 +38,36 @@ const eventCatalog = [
     'manual-validation.started', 'manual-validation.completed',
     'validation-run.started', 'validation-run.completed'
 ];
-function approvedCleanReviewedCommit(reviewContent, verdict, repoRoot) {
+function branchWorktree(repoRoot, branch) {
+    if (!branch)
+        return repoRoot;
+    return resolveBranchWorktree(repoRoot, branch);
+}
+function approvedCleanReviewedCommit(reviewContent, verdict, repoRoot, branch) {
     if (verdict !== 'approved')
         return null;
     const reviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
     const reviewedTree = extractReviewedSnapshotTree(reviewContent);
     if (!/^[a-f0-9]{40}$/.test(reviewedHead) || !/^[a-f0-9]{40}$/.test(reviewedTree))
         return null;
+    const worktree = branchWorktree(repoRoot, branch);
+    if (!worktree)
+        return null;
     try {
-        const currentHead = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
+        const currentHead = execFileSync('git', ['-C', worktree, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim();
         if (currentHead !== reviewedHead)
             return null;
-        const currentTree = execFileSync('git', ['-C', repoRoot, 'rev-parse', 'HEAD^{tree}'], { encoding: 'utf8' }).trim();
+        const currentTree = execFileSync('git', ['-C', worktree, 'rev-parse', 'HEAD^{tree}'], { encoding: 'utf8' }).trim();
         if (currentTree !== reviewedTree)
             return null;
-        execFileSync('git', ['-C', repoRoot, 'diff-index', '--quiet', 'HEAD', '--']);
+        execFileSync('git', ['-C', worktree, 'diff-index', '--quiet', 'HEAD', '--']);
         return reviewedHead;
     }
     catch {
         return null;
     }
 }
-const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
+const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
 const SCHEMAS = {
     'analyze.started': { optional: ['round'] },
     'analyze.awaiting-input': { required: ['question'] },
@@ -283,7 +292,13 @@ function failed(request, error, extra = {}) {
 }
 function normalizeStarted(request, repoRoot) {
     const family = eventParts(request.event).family;
-    const context = resolveArtifactContext(request.taskRef, FAMILY[family].artifact, { repoRoot });
+    const context = resolveArtifactContext(request.taskRef, FAMILY[family].artifact, {
+        repoRoot,
+        reasonCode: request.reasonCode,
+        sourceFinding: request.sourceFinding,
+        sourceArtifact: request.sourceArtifact,
+        sourceSha256: request.sourceSha256
+    });
     if (context.status !== 'ready' || !context.next) {
         return { error: { code: context.error?.code ?? 'EVENT_ARTIFACT_CONFLICT', message: context.error?.message ?? context.codeMode?.message ?? 'artifact context is not writable' }, context };
     }
@@ -337,24 +352,6 @@ function openStartedIdentity(rows, family) {
 function reviewInputFamily(family) {
     return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
 }
-function relationForStartedInput(family, input) {
-    if (family.startsWith('review-')) {
-        return input.family === reviewInputFamily(family) ? 'reviewed-input' : 'approval-context';
-    }
-    const consumer = family === 'analyze' ? 'analysis' : family;
-    if ((consumer === 'plan' && input.family === 'analysis') || (consumer === 'code' && input.family === 'plan'))
-        return 'required-input';
-    return 'review-context';
-}
-function qualificationRelationsForStarted(family, inputs) {
-    return inputs.map((input) => ({
-        upstreamFamily: input.family,
-        upstreamArtifact: input.name,
-        upstreamRound: input.round,
-        upstreamSha256: sha256File(input.path),
-        relation: relationForStartedInput(family, input)
-    }));
-}
 function lifecycleAction(family) {
     return family === 'analyze' ? 'analysis' : family;
 }
@@ -555,7 +552,21 @@ function reworkIntentMutationForCompletion(content, taskDir, family, artifact, t
                 return [];
             }
         }));
-        next = consumeReworkIntents(next, family === 'analyze' ? 'analysis' : family, hashes, timestamp).intents;
+        const action = family === 'analyze' ? 'analysis' : family;
+        let target = action;
+        if (family === 'analyze') {
+            const previousAnalysis = fs.readdirSync(taskDir)
+                .map((name) => parseArtifactName(name))
+                .filter((identity) => identity?.family === 'analysis' && identity.name !== artifact.name)
+                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            const pathState = previousAnalysis
+                ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, previousAnalysis.name), 'utf8'))
+                : undefined;
+            const pending = next.find((intent) => intent.status === 'pending');
+            if (pending && effectiveReworkTarget(pending.target, pathState) === action)
+                target = pending.target;
+        }
+        next = consumeReworkIntents(next, target, hashes, timestamp).intents;
     }
     if (family === 'review-analysis' || family === 'review-plan' || family === 'review-code') {
         next = supersedeReworkIntents(next, artifact.name, hash, timestamp).intents;
@@ -577,13 +588,16 @@ function buildCompletionReceipt(content, taskDir, family, artifact, completedAt,
         const startedSha256 = typeof frontmatter.code_input_sha256 === 'string'
             ? frontmatter.code_input_sha256 : existing?.inputSha256 ?? '';
         if (!startedInput || !startedSha256)
-            return { ok: false, message: 'code.started plan input context is missing' };
-        const plan = inspectArtifactDirectory(taskDir, 'plan');
-        if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== startedInput) {
-            return { ok: false, message: `code input '${startedInput}' is not the latest plan artifact` };
+            return { ok: false, message: 'code.started lifecycle input context is missing' };
+        const inputIdentity = parseArtifactName(startedInput);
+        if (!inputIdentity || !['analysis', 'plan'].includes(inputIdentity.family))
+            return { ok: false, message: `code input '${startedInput}' has an invalid family` };
+        const lifecycleInput = inspectArtifactDirectory(taskDir, inputIdentity.family);
+        if (lifecycleInput.status !== 'ready' || !lifecycleInput.latest || lifecycleInput.latest.name !== startedInput) {
+            return { ok: false, message: `code input '${startedInput}' is not the latest ${inputIdentity.family} artifact` };
         }
         try {
-            const inputSha256 = sha256File(plan.latest.path);
+            const inputSha256 = sha256File(lifecycleInput.latest.path);
             if (inputSha256 !== startedSha256)
                 return { ok: false, message: `code input ${startedInput} changed after code.started` };
             return {
@@ -595,7 +609,7 @@ function buildCompletionReceipt(content, taskDir, family, artifact, completedAt,
             };
         }
         catch (error) {
-            return { ok: false, message: `cannot hash code input plan: ${error instanceof Error ? error.message : String(error)}` };
+            return { ok: false, message: `cannot hash code lifecycle input: ${error instanceof Error ? error.message : String(error)}` };
         }
     }
     if (!family.startsWith('review-'))
@@ -691,8 +705,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(request, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
-    const stateOverride = allowsManualOverride(options.manualOverride, 'task-event', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     let content;
     try {
@@ -753,6 +766,12 @@ function applyTaskEventUnlocked(request, options = {}) {
             normalized = { ...request, round: openIdentity.round, artifact: artifactName(FAMILY[initialParts.family].artifact, openIdentity.round), fixFor: openIdentity.fixFor, implementationInput: openIdentity.implementationInput };
             return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, typeof frontmatter.current_step === 'string' ? frontmatter.current_step : '', identity(normalized), openIdentity.row.started, frontmatter, null);
         }
+        if (rows.some((item) => item.started && !item.done)) {
+            return failed(request, {
+                code: 'EVENT_TRANSITION_INVALID',
+                message: 'EXECUTION_BUSY: another lifecycle execution is open'
+            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
+        }
         const result = normalizeStarted(request, resolved.repoRoot);
         artifactContext = result.context;
         if ('error' in result)
@@ -805,7 +824,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         }
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.started, frontmatter, artifactContext);
     }
-    if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0 && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING'))
+    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 });
     if (eventIdentity.phase === 'completed') {
         const validated = validateCompletedArtifact(resolved.taskDir, FAMILY[eventIdentity.family].artifact, normalized.artifact, normalized.round);
@@ -822,25 +841,13 @@ function applyTaskEventUnlocked(request, options = {}) {
                 reviewContent = fs.readFileSync(completedArtifact.path, 'utf8');
             }
             catch (error) {
-                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read qualification audit from ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read ${completedArtifact.name}: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
             const schema = getArtifactSchema(eventIdentity.family);
             const structure = schema ? inspectArtifactContract(reviewContent, schema) : null;
             if (structure && !structure.ok) {
                 return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `shared artifact structure invalid: ${structure.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
-            const expected = expectedQualificationRelations(content, eventIdentity.family);
-            if (!expected.ok) {
-                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `${expected.code}: ${expected.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-            }
-            const qualification = validateQualificationAudit(content, reviewContent, {
-                family: eventIdentity.family,
-                artifact: completedArtifact.name,
-                expectedUpstreamRelations: expected.relations
-            });
-            if (!qualification.ok) {
-                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `${qualification.code}: ${qualification.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-            }
         }
         if (eventIdentity.family === 'analyze' || eventIdentity.family === 'plan' || eventIdentity.family === 'code') {
             const localFamily = eventIdentity.family === 'analyze'
@@ -854,9 +861,7 @@ function applyTaskEventUnlocked(request, options = {}) {
                 return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot read ${completedArtifact.name}: ${String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
             }
             const local = validateLocalArtifact(artifactContent, {
-                family: localFamily,
-                taskContent: content,
-                artifact: completedArtifact.name
+                family: localFamily
             });
             if (!local.ok) {
                 return failed(normalized, {
@@ -889,10 +894,9 @@ function applyTaskEventUnlocked(request, options = {}) {
         if (!facts.ok)
             return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${facts.code}: ${facts.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
-        const capabilityOverride = capability.reasonCode === 'TASK_NOT_ACTIVE'
-            ? stateOverride
-            : allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID');
-        if (!capability.allowed && !capabilityOverride) {
+        const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
+            || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
+        if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)) {
             const code = capability.reasonCode === 'INVALIDATION_INCOMPLETE' ? 'TASK_INVALIDATION_BLOCKED' : 'EVENT_TRANSITION_INVALID';
             return failed(normalized, { code, message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
@@ -901,10 +905,11 @@ function applyTaskEventUnlocked(request, options = {}) {
     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' && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
+    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: normalized.orchestrated ? 'orchestrated' : 'standalone',
+            mode: 'orchestrated',
             identity: {
                 stage: orchestrationStage,
                 round: normalized.round,
@@ -969,18 +974,10 @@ function applyTaskEventUnlocked(request, options = {}) {
     if (currentFact)
         frontmatterSet.completion_facts = JSON.stringify(replaceCompletionFact(completionFacts(frontmatter), currentFact));
     let frontmatterRemove;
-    if (eventIdentity.phase === 'started' && artifactContext) {
-        try {
-            frontmatterSet.qualification_input_relations = JSON.stringify(qualificationRelationsForStarted(eventIdentity.family, artifactContext.inputs));
-        }
-        catch (error) {
-            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot capture qualification input relations: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
-        }
-    }
     if (eventIdentity.phase === 'started' && eventIdentity.family === 'code') {
-        const planInput = artifactContext?.inputs.find((input) => input.family === 'plan');
+        const planInput = artifactContext?.inputs.find((input) => input.family === 'plan' || input.family === 'analysis');
         if (!planInput)
-            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started plan input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started lifecycle input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
         try {
             frontmatterSet.code_input_artifact = planInput.name;
             frontmatterSet.code_input_sha256 = sha256File(planInput.path);
@@ -1009,14 +1006,12 @@ function applyTaskEventUnlocked(request, options = {}) {
         frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
     }
     if (eventIdentity.phase === 'completed' && eventIdentity.family === 'review-code' && reviewContent !== null) {
-        const reviewedCommit = approvedCleanReviewedCommit(reviewContent, normalized.verdict, resolved.repoRoot);
+        const reviewedCommit = approvedCleanReviewedCommit(reviewContent, normalized.verdict, resolved.repoRoot, typeof frontmatter.branch === 'string' ? frontmatter.branch : '');
         if (reviewedCommit)
             frontmatterSet.last_reviewed_commit = reviewedCommit;
         else if (normalized.verdict === 'approved')
             frontmatterSet.last_reviewed_commit = '';
     }
-    if (eventIdentity.phase === 'completed')
-        frontmatterRemove = [...(frontmatterRemove ?? []), 'qualification_input_relations'];
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
         frontmatterSet.last_reviewed_commit = '';
     const mutations = [
@@ -1057,7 +1052,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
     const sourceCompletion = eventIdentity.phase === 'completed'
         && ['analyze', 'plan', 'code'].includes(eventIdentity.family);
-    const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
+    const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
     if (!normalized.dryRun && orchestrationCompletion) {

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

@@ -0,0 +1,92 @@
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const HANDOFF_VERSION = 1;
+const MAX_HANDOFF_BYTES = 1024 * 1024;
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+export function finalizationHandoffPath(directory, taskId) {
+    return path.join(directory, '.agent-infra', 'task-finalization', `${taskId}.json`);
+}
+export function publishTaskFinalizationHandoff(directory, receipt, binding) {
+    if (receipt.taskId === '' || receipt.controlBinding?.generation !== binding.generation
+        || receipt.controlBinding.requestId !== binding.requestId) {
+        throw new Error('TASK_FINALIZATION_HANDOFF_BINDING_INVALID');
+    }
+    const envelope = {
+        version: HANDOFF_VERSION, taskId: receipt.taskId, binding, receipt, receiptSha256: digest(receipt)
+    };
+    const target = finalizationHandoffPath(directory, receipt.taskId);
+    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+    const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(envelope)}\n`, { mode: 0o600, flag: 'wx' });
+    try {
+        fs.renameSync(temporary, target);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* preserve the primary error */ }
+        throw error;
+    }
+    return digest(envelope);
+}
+export function readTaskFinalizationHandoff(directory, taskId, binding, handoffSha256) {
+    const file = finalizationHandoffPath(directory, taskId);
+    const initial = fs.lstatSync(file);
+    if (!initial.isFile() || initial.isSymbolicLink() || initial.size > MAX_HANDOFF_BYTES) {
+        throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+    }
+    const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    let content;
+    try {
+        const opened = fs.fstatSync(descriptor);
+        if (!opened.isFile() || opened.dev !== initial.dev || opened.ino !== initial.ino
+            || opened.size > MAX_HANDOFF_BYTES)
+            throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+        const bytes = Buffer.alloc(MAX_HANDOFF_BYTES + 1);
+        const length = fs.readSync(descriptor, bytes, 0, bytes.length, 0);
+        if (length !== opened.size || length > MAX_HANDOFF_BYTES)
+            throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+        content = bytes.toString('utf8', 0, length);
+        const after = fs.fstatSync(descriptor);
+        if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size) {
+            throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+        }
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+    const envelope = JSON.parse(content);
+    if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)
+        || Object.keys(envelope).sort().join('\0') !== ['binding', 'receipt', 'receiptSha256', 'taskId', 'version'].join('\0')
+        || envelope.version !== HANDOFF_VERSION || envelope.taskId !== taskId
+        || !envelope.binding || typeof envelope.binding !== 'object' || Array.isArray(envelope.binding)
+        || Object.keys(envelope.binding).sort().join('\0') !== ['generation', 'requestId'].join('\0')
+        || envelope.binding.generation !== binding.generation
+        || envelope.binding.requestId !== binding.requestId || !envelope.receipt
+        || envelope.receipt.controlBinding?.generation !== binding.generation
+        || envelope.receipt.controlBinding.requestId !== binding.requestId
+        || typeof envelope.receiptSha256 !== 'string' || envelope.receiptSha256 !== digest(envelope.receipt)
+        || digest(envelope) !== handoffSha256) {
+        throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+    }
+    return {
+        receipt: envelope.receipt,
+        cleanup: () => {
+            try {
+                const current = fs.lstatSync(file);
+                if (current.isFile() && !current.isSymbolicLink()
+                    && current.dev === initial.dev && current.ino === initial.ino)
+                    fs.unlinkSync(file);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    };
+}
+//# sourceMappingURL=finalization-handoff.js.map