@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/lib/task/activity-log.ts

@@ -5,6 +5,7 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 const ABORTED_SUFFIX_RE = /\s*\[aborted\]\s*$/;
 const ATTEMPT_RE = /(?:^|;\s*)attempt=([A-Za-z0-9-]{8,64})(?:;|$)/;
 const COMMIT_STARTED_RE = /^started; attempt=([A-Za-z0-9-]{8,64}); baseline=([a-f0-9]{40,64}); agent=([a-z-]+)$/;
+const LIFECYCLE_STEP_RE = /^(?:Complete Manual Validation|(?:Analyze Task|Review Analysis|Plan Task|Review Plan|Code Task|Review Code|Run Manual Validation) \(Round [1-9]\d*(?:(?:, fix for review-code(?:-r[2-9]|-r[1-9]\d+)?\.md)|(?:, decision II-[1-9]\d*))?\))$/;
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
 type StepRow = { step: string; agent: string; started: string; done: string; note: string; attempt?: string };
@@ -93,9 +94,16 @@ function startedBackedRows(rows: StepRow[]): StepRow[] {
   return rows.filter((row) => row.started !== '');
 }
 
+function hasOpenLifecycleExecution(content: string): boolean {
+  const section = locateActivityLog(content);
+  if (!section) return false;
+  return pairEntries(section.entries).some((row) => row.done === '' && LIFECYCLE_STEP_RE.test(row.step));
+}
+
 export {
   activityAttempt,
   appendActivityEntry,
+  hasOpenLifecycleExecution,
   commitAttemptStartedNote,
   locateActivityLog,
   pairEntries,

package/lib/task/artifact-lifecycle.ts

@@ -8,21 +8,13 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
 import { receiptForOutput, sha256File } from './artifact-receipts.ts';
+import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.ts';
+import type { InvalidationDocument } from './invalidation.ts';
+import { validateQualificationAudit } from './qualification-audit.ts';
+import { ARTIFACT_FAMILY_CATALOG } from './artifact-schema.ts';
+import type { ArtifactFamily, ArtifactFamilySpec } from './artifact-schema.ts';
 
-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'] }
-] as const;
-
-type ArtifactFamily = (typeof artifactFamilyCatalog)[number]['family'];
-type ArtifactFamilySpec = (typeof artifactFamilyCatalog)[number];
+const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 type ArtifactIdentity = {
   family: ArtifactFamily;
   round: number;
@@ -47,7 +39,7 @@ type ArtifactErrorCode =
   | 'ARTIFACT_REFERENCE_INVALID' | 'ARTIFACT_PATH_INVALID'
   | 'ARTIFACT_IDENTITY_INVALID' | 'ARTIFACT_NOT_FOUND'
   | 'ARTIFACT_NOT_REGULAR' | 'ARTIFACT_NOT_READABLE' | 'ARTIFACT_VERDICT_INVALID'
-  | 'ARTIFACT_MODE_REFUSED';
+  | 'ARTIFACT_MODE_REFUSED' | 'ARTIFACT_INVALIDATION_INVALID';
 type ArtifactError = { code: ArtifactErrorCode; message: string };
 type ArtifactInventoryResult = {
   status: 'ready' | 'failed';
@@ -154,7 +146,23 @@ function inspectArtifactDirectory(
       taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
     });
   }
+  let invalidation: InvalidationDocument = { 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: ArtifactIdentity[] = [];
+  const knownArtifacts: ArtifactIdentity[] = [];
   const diagnostics: ArtifactDiagnostic[] = [];
   for (const entry of entries) {
     const parsed = parseArtifactName(entry.name);
@@ -184,17 +192,20 @@ function inspectArtifactDirectory(
         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)) diagnostics.push(diagnostic('MISSING_BASE', family, null, `${family}.md is missing`));
-  const max = artifacts.at(-1)?.round ?? 0;
+  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 = knownArtifacts.at(-1)?.round ?? 0;
   for (let round = 1; round <= max; round += 1) {
-    if (!rounds.has(round)) diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
+    if (!knownRounds.has(round)) diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
   }
   const latest = artifacts.at(-1) ?? null;
   const reviewedInput = family.startsWith('review-') && latest
@@ -230,6 +241,11 @@ function resolveReviewedInput(
     const stat = fs.lstatSync(abs);
     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`);
     const expectedEvent = reviewEventName(review.family);
@@ -314,6 +330,7 @@ const OPTIONAL_CONTEXT: Partial<Record<ArtifactFamily, { family: ArtifactFamily;
   'manual-validation': { family: 'review-code' },
   'validation-run': { family: 'review-code' }
 };
+const QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS = new Set<ArtifactFamily>(['analysis', 'plan']);
 
 function resolveArtifactContext(taskRef: string, family: string, options: InspectOptions = {}): ArtifactContextResult {
   const inventory = inspectTaskArtifacts(taskRef, family, options);
@@ -328,6 +345,8 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
     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 as ArtifactFamily];
@@ -337,12 +356,27 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
       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 as ArtifactFamily)) {
+        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: ArtifactIdentity): string | null {
+  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: ArtifactInventoryResult, options: InspectOptions): ArtifactContextResult {
   const taskRef = inventory.requestRef;
   const plan = inspectTaskArtifacts(taskRef, 'plan', options);
@@ -353,6 +387,16 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
   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`);
@@ -372,6 +416,10 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
   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) return contextFailure(inventory, 'ARTIFACT_VERDICT_INVALID', `${verdict.code}: ${verdict.message}`, reviewPlan.latest.name);
@@ -383,8 +431,8 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
         `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;