@fitlab-ai/agent-infra 0.9.12 → 0.9.14

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

@@ -6,17 +6,10 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
-const artifactFamilyCatalog = [
-    { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
-    { family: 'review-analysis', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['需求分析审查', 'Analysis Review'] },
-    { family: 'plan', sectionAliases: ['设计', 'Design'], heading: '设计', labels: ['技术方案', 'Technical Plan'] },
-    { family: 'review-plan', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['技术方案审查', 'Plan Review'] },
-    { family: 'code', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['实现报告', 'Implementation Report'] },
-    { family: 'review-code', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['代码审查', 'Code Review'] },
-    { family: 'manual-validation', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['人工验证', 'Manual Validation'] },
-    { family: 'validation-run', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['验证运行证据', 'Validation Run Evidence'] },
-    { family: 'pr-review', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['PR 审查报告', 'PR Review Report'] }
-];
+import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
+import { validateQualificationAudit } from './qualification-audit.js';
+import { ARTIFACT_FAMILY_CATALOG } from './artifact-schema.js';
+const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 const FAMILY_SET = new Set(artifactFamilyCatalog.map((item) => item.family));
 const BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
@@ -85,7 +78,24 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
+    let invalidation = { operations: [], targets: [] };
+    try {
+        const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const parsed = parseInvalidationDocument(taskContent);
+        if (!parsed.ok) {
+            return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: parsed.message }, {
+                taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+            });
+        }
+        invalidation = parsed.document;
+    }
+    catch (error) {
+        return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: String(error) }, {
+            taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
+        });
+    }
     const artifacts = [];
+    const knownArtifacts = [];
     const diagnostics = [];
     for (const entry of entries) {
         const parsed = parseArtifactName(entry.name);
@@ -117,19 +127,23 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
                 diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, `artifact is not readable: ${entry.name}`));
                 continue;
             }
-            artifacts.push({ ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs });
+            const identity = { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
+            knownArtifacts.push(identity);
+            if (!isArtifactInvalidated(invalidation, family, entry.name))
+                artifacts.push(identity);
         }
         catch (error) {
             diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, String(error)));
         }
     }
     artifacts.sort((left, right) => left.round - right.round);
-    const rounds = new Set(artifacts.map((item) => item.round));
-    if (artifacts.length > 0 && !rounds.has(1))
+    knownArtifacts.sort((left, right) => left.round - right.round);
+    const knownRounds = new Set(knownArtifacts.map((item) => item.round));
+    if (knownArtifacts.length > 0 && !knownRounds.has(1))
         diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
-    const max = artifacts.at(-1)?.round ?? 0;
+    const max = knownArtifacts.at(-1)?.round ?? 0;
     for (let round = 1; round <= max; round += 1) {
-        if (!rounds.has(round))
+        if (!knownRounds.has(round))
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
     const latest = artifacts.at(-1) ?? null;
@@ -163,6 +177,12 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
         const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const invalidation = parseInvalidationDocument(taskContent);
+        if (!invalidation.ok)
+            throw new Error(invalidation.message);
+        if (isArtifactInvalidated(invalidation.document, expectedFamily, parsed.name)) {
+            throw new Error(`${parsed.name} is invalidated`);
+        }
         const receipt = receiptForOutput(taskContent, review.name);
         if (!receipt)
             throw new Error(`receipt for ${review.name} is missing`);
@@ -258,6 +278,7 @@ const OPTIONAL_CONTEXT = {
     'manual-validation': { family: 'review-code' },
     'validation-run': { family: 'review-code' }
 };
+const QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS = new Set(['analysis', 'plan']);
 function resolveArtifactContext(taskRef, family, options = {}) {
     const inventory = inspectTaskArtifacts(taskRef, family, options);
     if (inventory.status === 'failed')
@@ -274,6 +295,9 @@ function resolveArtifactContext(taskRef, family, options = {}) {
         if (input.status === 'failed' || !input.latest) {
             return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_INPUT_MISSING', message: `latest ${required} artifact is required` } };
         }
+        const qualificationError = qualificationErrorForArtifact(input.latest);
+        if (qualificationError)
+            return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
         inputs.push(input.latest);
     }
     const optional = OPTIONAL_CONTEXT[inventory.family];
@@ -283,11 +307,26 @@ function resolveArtifactContext(taskRef, family, options = {}) {
             if (optional.requireReference && !context.reviewedInput) {
                 return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: `${context.latest.name} has no valid reviewed input` } };
             }
+            const qualificationError = qualificationErrorForArtifact(context.latest);
+            if (qualificationError && !QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS.has(inventory.family)) {
+                return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
+            }
             inputs.push(context.latest);
         }
     }
     return { ...inventory, inputs, codeMode: null };
 }
+function qualificationErrorForArtifact(artifact) {
+    try {
+        const taskContent = fs.readFileSync(path.join(path.dirname(artifact.path), 'task.md'), 'utf8');
+        const artifactContent = fs.readFileSync(artifact.path, 'utf8');
+        const result = validateQualificationAudit(taskContent, artifactContent);
+        return result.ok ? null : `${result.code}: ${result.message}`;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 function resolveCodeContext(inventory, options) {
     const taskRef = inventory.requestRef;
     const plan = inspectTaskArtifacts(taskRef, 'plan', options);
@@ -299,6 +338,19 @@ function resolveCodeContext(inventory, options) {
     const codeMax = latestCode?.round ?? 0;
     const reviewMax = reviewCode.latest?.round ?? 0;
     const inputs = [plan.latest];
+    const planQualificationError = qualificationErrorForArtifact(plan.latest);
+    if (planQualificationError)
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', planQualificationError);
+    if (latestCode) {
+        const qualificationError = qualificationErrorForArtifact(latestCode);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, latestCode.name);
+    }
+    if (reviewCode.latest) {
+        const qualificationError = qualificationErrorForArtifact(reviewCode.latest);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, reviewCode.latest.name);
+    }
     if (!latestCode) {
         if (!reviewPlan.latest || reviewPlan.reviewedInput?.name !== plan.latest.name) {
             return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `latest plan '${plan.latest.name}' requires a matching approved review-plan`);
@@ -318,6 +370,11 @@ function resolveCodeContext(inventory, options) {
     if (reviewPlan.latest && !reviewPlan.reviewedInput) {
         return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `${reviewPlan.latest.name} has no valid reviewed input`, reviewPlan.latest.name);
     }
+    if (reviewPlan.latest) {
+        const qualificationError = qualificationErrorForArtifact(reviewPlan.latest);
+        if (qualificationError)
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', qualificationError, reviewPlan.latest.name);
+    }
     if (reviewPlan.latest && reviewPlan.reviewedInput?.name === plan.latest.name) {
         const verdict = parseVerdict(reviewPlan.latest.path);
         if (!verdict.ok)
@@ -327,8 +384,8 @@ function resolveCodeContext(inventory, options) {
             return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
         }
     }
-    if (reviewMax < codeMax) {
-        const expected = artifactName('review-code', codeMax);
+    if (!reviewCode.latest || reviewCode.reviewedInput?.name !== latestCode.name) {
+        const expected = reviewCode.next?.name ?? artifactName('review-code', reviewMax + 1);
         return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `${expected} is required before another code round`, expected);
     }
     const review = reviewCode.latest;