@fitlab-ai/agent-infra 0.9.13 → 0.9.15

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

@@ -1,24 +1,32 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { ARTIFACT_FAMILY_CATALOG, artifactName, parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { locateActivityLog } from './activity-log.js';
+import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.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'] }
-];
-const FAMILY_SET = new Set(artifactFamilyCatalog.map((item) => item.family));
+import { validateQualificationAudit } from './qualification-audit.js';
+const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
+const ARTIFACT_STEPS = {
+    analysis: 'Analyze Task', 'review-analysis': 'Review Analysis',
+    plan: 'Plan Task', 'review-plan': 'Review Plan',
+    code: 'Code Task', 'review-code': 'Review Code'
+};
+/** Init, repair and finalization share the same authoritative round identity. */
+export function hasOpenArtifactRound(content, family, round) {
+    const activity = locateActivityLog(content);
+    const step = ARTIFACT_STEPS[family];
+    if (!activity || !step)
+        return false;
+    const qualifier = family === 'code'
+        ? '(?:, (?:fix for review-code(?:-r(?:[2-9]|[1-9]\\d+))?\\.md|decision II-[1-9]\\d*))?'
+        : '';
+    const expected = new RegExp(`^${step} \\(Round ${round}${qualifier}\\)$`);
+    return startedBackedRows(pairEntries(activity.entries)).filter((row) => expected.test(row.step) && !row.done).length === 1;
+}
 const BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
     'DUPLICATE_LOGICAL_ROUND', 'NON_REGULAR_FILE', 'SYMBOLIC_LINK',
@@ -27,30 +35,6 @@ const BLOCKING_DIAGNOSTICS = new Set([
 function familySpec(family) {
     return artifactFamilyCatalog.find((item) => item.family === family) ?? null;
 }
-function artifactName(family, round) {
-    if (!FAMILY_SET.has(family))
-        throw new Error(`unknown artifact family '${family}'`);
-    if (!Number.isSafeInteger(round) || round < 1)
-        throw new Error('artifact round must be a safe positive integer');
-    return round === 1 ? `${family}.md` : `${family}-r${round}.md`;
-}
-function parseArtifactName(name) {
-    if (path.basename(name) !== name)
-        return null;
-    const matches = [];
-    for (const spec of artifactFamilyCatalog) {
-        if (name === `${spec.family}.md`)
-            matches.push({ family: spec.family, round: 1, name });
-        const match = new RegExp(`^${escapeRegExp(spec.family)}-r([1-9]\\d*)\\.md$`).exec(name);
-        if (!match)
-            continue;
-        const round = Number(match[1]);
-        if (Number.isSafeInteger(round) && round >= 2 && String(round) === match[1]) {
-            matches.push({ family: spec.family, round, name });
-        }
-    }
-    return matches.length === 1 ? matches[0] : null;
-}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -286,6 +270,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')
@@ -302,6 +287,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];
@@ -311,11 +299,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);
@@ -327,6 +330,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`);
@@ -346,6 +362,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)
@@ -355,8 +376,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;
@@ -449,6 +470,16 @@ function validateCompletedArtifact(taskDir, family, name, round) {
     const artifact = inventory.artifacts.find((item) => item.name === name);
     return artifact ? { ok: true, artifact } : { ok: false, error: { code: 'ARTIFACT_NOT_FOUND', message: `artifact '${name}' is not in inventory` } };
 }
+/** A candidate may replace its current slot or fill the next slot, never skip rounds. */
+export function validateArtifactPublication(taskDir, family, name) {
+    const inventory = inspectArtifactDirectory(taskDir, family);
+    const error = assertWritableInventory(inventory);
+    if (error)
+        return error;
+    if (inventory.next?.name === name || inventory.artifacts.some((artifact) => artifact.name === name))
+        return null;
+    return { code: 'ARTIFACT_IDENTITY_INVALID', message: `artifact '${name}' is not a current or next ${family} slot` };
+}
 function buildArtifactLinkSection(content, artifact) {
     const spec = familySpec(artifact.family);
     const aliases = [...spec.sectionAliases];
@@ -478,5 +509,5 @@ function buildArtifactLinkSection(content, artifact) {
     body = lines.join('\n').replace(/^\n+|\n+$/g, '');
     return { aliases, heading, body };
 }
-export { artifactFamilyCatalog, artifactName, parseArtifactName, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
+export { artifactFamilyCatalog, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
 //# sourceMappingURL=artifact-lifecycle.js.map

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

@@ -0,0 +1,36 @@
+const ARTIFACT_FAMILY_CATALOG = [
+    { 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'] }
+];
+const FAMILIES = new Set(ARTIFACT_FAMILY_CATALOG.map(({ family }) => family));
+export function artifactName(family, round) {
+    if (!FAMILIES.has(family))
+        throw new Error(`unknown artifact family '${family}'`);
+    if (!Number.isSafeInteger(round) || round < 1)
+        throw new Error('artifact round must be a safe positive integer');
+    return round === 1 ? `${family}.md` : `${family}-r${round}.md`;
+}
+export function parseArtifactName(name) {
+    const match = /^(.+?)(?:-r([1-9]\d*))?\.md$/.exec(name);
+    if (!match || match[0] !== name || !FAMILIES.has(match[1]))
+        return null;
+    const round = match[2] ? Number(match[2]) : 1;
+    if (!Number.isSafeInteger(round) || (match[2] && round < 2))
+        return null;
+    return { family: match[1], round, name };
+}
+export function maxArtifactRound(names, family) {
+    return names.reduce((max, name) => {
+        const identity = parseArtifactName(name);
+        return identity?.family === family ? Math.max(max, identity.round) : max;
+    }, 0);
+}
+export { ARTIFACT_FAMILY_CATALOG };
+//# sourceMappingURL=artifact-name.js.map