@fitlab-ai/agent-infra 0.11.3 → 0.11.4

package/dist/lib/task/events.js

@@ -18,15 +18,16 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 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,21 +38,46 @@ 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;
+    try {
+        const records = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe']
+        }).trim().split(/\r?\n\r?\n/);
+        const expectedRef = `refs/heads/${branch}`;
+        for (const record of records) {
+            const worktree = /^worktree (.+)$/m.exec(record)?.[1];
+            const branchRef = /^branch (.+)$/m.exec(record)?.[1];
+            if (worktree && branchRef === expectedRef)
+                return worktree;
+        }
+    }
+    catch {
+        // A missing worktree must not anchor a review to an unrelated repository.
+    }
+    return null;
+}
+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 {
@@ -283,7 +309,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 +369,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 +569,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 +605,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 +626,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-'))
@@ -753,6 +784,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)
@@ -822,25 +859,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 +879,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, {
@@ -892,7 +915,9 @@ function applyTaskEventUnlocked(request, options = {}) {
         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) && !capabilityOverride) {
             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 +926,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 +995,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 +1027,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 = [