@fitlab-ai/agent-infra 0.9.13 → 0.9.14

package/dist/lib/task/events.js

@@ -14,11 +14,13 @@ 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 { LOCAL_ARTIFACT_REQUIRED_PATTERNS, LOCAL_ARTIFACT_REQUIRED_SECTIONS, consumeLocalArtifactFinalizationIntent, readLocalArtifactFinalizationIntent, validateLocalArtifact } from './local-artifact-finalization.js';
-import { loadVerificationConfig } from './verification-config.js';
+import { consumeLocalArtifactFinalizationIntent, readLocalArtifactFinalizationIntent, validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart } from './capabilities.js';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.js';
+import { ARTIFACT_FAMILIES, expectedQualificationRelations, parseQualificationAudit, parseTaskQualification, upstreamArtifactDigest, validateQualificationAudit } from './qualification-audit.js';
+import { getArtifactSchema } from './artifact-schema.js';
+import { inspectArtifactContract } from './artifact-operations.js';
 const eventCatalog = [
     'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
     'review-analysis.started', 'review-analysis.completed',
@@ -49,31 +51,6 @@ const SCHEMAS = {
     'validation-run.started': { optional: ['round'] },
     'validation-run.completed': { required: ['artifact'], optional: ['round'] }
 };
-function localArtifactValidationConfig(repoRoot, family) {
-    const fallback = {
-        requiredSections: LOCAL_ARTIFACT_REQUIRED_SECTIONS[family],
-        requiredPatterns: LOCAL_ARTIFACT_REQUIRED_PATTERNS
-    };
-    const skillName = family === 'analysis' ? 'analyze-task' : family === 'plan' ? 'plan-task' : 'code-task';
-    try {
-        const artifact = loadVerificationConfig(repoRoot, skillName).checks.artifact;
-        if (!artifact || typeof artifact !== 'object' || Array.isArray(artifact))
-            return fallback;
-        const sections = artifact.required_sections;
-        const patterns = artifact.required_patterns;
-        return {
-            requiredSections: Array.isArray(sections)
-                ? sections.filter((value) => typeof value === 'string')
-                : fallback.requiredSections,
-            requiredPatterns: Array.isArray(patterns)
-                ? patterns.filter((value) => typeof value === 'string')
-                : fallback.requiredPatterns
-        };
-    }
-    catch {
-        return fallback;
-    }
-}
 function validateTaskEventRequest(request) {
     if (!eventCatalog.includes(request.event))
         return { code: 'EVENT_UNKNOWN', message: `unknown task event '${request.event}'` };
@@ -300,6 +277,24 @@ 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;
 }
@@ -328,6 +323,7 @@ function invalidationMutationForCompletion(content, taskDir, family, artifact, t
         code: ['review-code']
     };
     const sourceFamily = family;
+    const sourceArtifactFamily = sourceFamily === 'analyze' ? 'analysis' : sourceFamily;
     let receipts = [];
     try {
         receipts = parseArtifactReceipts(content).rows;
@@ -335,46 +331,134 @@ function invalidationMutationForCompletion(content, taskDir, family, artifact, t
     catch (error) {
         return { error: error instanceof Error ? error.message : String(error) };
     }
-    const targets = downstream[sourceFamily].flatMap((targetFamily) => {
-        const names = fs.readdirSync(taskDir).filter((name) => {
-            const pattern = targetFamily === 'review-analysis' ? /^review-analysis(?:-r\d+)?\.md$/
-                : targetFamily === 'review-plan' ? /^review-plan(?:-r\d+)?\.md$/
-                    : targetFamily === 'review-code' ? /^review-code(?:-r\d+)?\.md$/
-                        : new RegExp(`^${targetFamily}(?:-r\\d+)?\\.md$`);
-            return pattern.test(name);
-        });
-        return names.flatMap((name) => {
-            try {
-                const stat = fs.lstatSync(path.join(taskDir, name));
-                if (!stat.isFile() || stat.isSymbolicLink())
-                    return [];
-                const targetRound = parseArtifactName(name)?.round ?? 1;
-                const targetSha256 = sha256File(path.join(taskDir, name));
-                const shapes = [
-                    { targetKind: 'artifact', targetFamily, targetArtifact: name, targetRound, targetSha256 }
-                ];
-                const receipt = receipts.find((candidate) => candidate.output === name);
-                if (receipt)
-                    shapes.push({
-                        targetKind: 'receipt', targetFamily, targetArtifact: name, targetRound,
-                        targetSha256: receipt.inputSha256
-                    });
-                if (targetFamily.startsWith('review-')) {
-                    shapes.push({ targetKind: 'approval', targetFamily, targetArtifact: name, targetRound, targetSha256 });
-                }
-                if (targetFamily === 'review-code') {
-                    shapes.push({ targetKind: 'reviewed-snapshot', targetFamily, targetArtifact: name, targetRound, targetSha256 });
+    const inventory = fs.readdirSync(taskDir).flatMap((name) => {
+        const identity = parseArtifactName(name);
+        if (!identity || !ARTIFACT_FAMILIES.includes(identity.family))
+            return [];
+        try {
+            const stat = fs.lstatSync(path.join(taskDir, name));
+            if (!stat.isFile() || stat.isSymbolicLink())
+                return [];
+            return [{ family: identity.family, name, round: identity.round, sha256: sha256File(path.join(taskDir, name)) }];
+        }
+        catch (error) {
+            throw new Error(`cannot inspect invalidation artifact '${name}': ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    const taskQualification = parseTaskQualification(content);
+    if (!taskQualification.ok)
+        return { error: taskQualification.message };
+    const nodeMap = new Map(inventory.map((node) => [`${node.family}/${node.name}`, node]));
+    const audits = new Map();
+    let taskInputChanged = false;
+    let graphUsable = taskQualification.qualification.present;
+    if (graphUsable) {
+        for (const node of inventory) {
+            const artifactContent = fs.readFileSync(path.join(taskDir, node.name), 'utf8');
+            const parsedAudit = parseQualificationAudit(artifactContent);
+            if (!parsedAudit.ok || !parsedAudit.audit.present || !parsedAudit.audit.snapshot) {
+                graphUsable = false;
+                break;
+            }
+            audits.set(`${node.family}/${node.name}`, parsedAudit.audit);
+            if (parsedAudit.audit.snapshot.taskInputDigest !== taskQualification.qualification.taskInputDigest)
+                taskInputChanged = true;
+            if (parsedAudit.audit.snapshot.nonConstraintInputDigest !== taskQualification.qualification.nonConstraintInputDigest) {
+                graphUsable = false;
+                break;
+            }
+            if (parsedAudit.audit.snapshot.upstreamArtifactDigest !== upstreamArtifactDigest(parsedAudit.audit.upstreamRelations)) {
+                graphUsable = false;
+                break;
+            }
+            for (const relation of parsedAudit.audit.upstreamRelations) {
+                const upstream = nodeMap.get(`${relation.upstreamFamily}/${relation.upstreamArtifact}`);
+                if (!upstream || upstream.round !== relation.upstreamRound || upstream.sha256 !== relation.upstreamSha256) {
+                    graphUsable = false;
+                    break;
                 }
-                return shapes.map((targetShape) => ({
-                    ...targetShape,
-                    targetId: targetIdFor('pending', targetShape), operationId: 'pending', status: 'pending',
-                    reasonCode: 'upstream-replaced', updatedAt: timestamp
-                }));
             }
-            catch (error) {
-                throw new Error(`cannot inspect invalidation target '${name}': ${error instanceof Error ? error.message : String(error)}`);
+            if (!graphUsable)
+                break;
+        }
+    }
+    const selected = new Set();
+    if (graphUsable) {
+        const changedConstraints = new Set();
+        for (const audit of audits.values()) {
+            for (const dependency of audit.constraintDependencies) {
+                const current = taskQualification.qualification.constraints.find((row) => row.constraintId === dependency.constraintId);
+                if (!current || current.digest !== dependency.constraintDigest)
+                    changedConstraints.add(dependency.constraintId);
             }
-        });
+        }
+        const currentCandidates = new Map(taskQualification.qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
+        const candidateSnapshotMatches = [...audits.values()].every((audit) => audit.candidateQualifications.length === currentCandidates.size && audit.candidateQualifications.every((row) => {
+            const current = currentCandidates.get(row.candidateId);
+            return Boolean(current && current.status === row.status && current.impact === row.impact
+                && current.evidence === row.evidence && current.constraintIds.join(',') === row.constraintIds.join(','));
+        }));
+        // A task-input digest also covers candidates. A narrowed invalidation graph
+        // is safe only when the old audit rows show that the candidate projection
+        // stayed unchanged and the change is explained by at least one constraint.
+        if (taskInputChanged && (changedConstraints.size === 0 || !candidateSnapshotMatches))
+            graphUsable = false;
+        for (const node of inventory) {
+            const audit = audits.get(`${node.family}/${node.name}`);
+            if (audit.constraintDependencies.some((dependency) => changedConstraints.has(dependency.constraintId)))
+                selected.add(`${node.family}/${node.name}`);
+            if (audit.upstreamRelations.some((relation) => relation.upstreamFamily === sourceArtifactFamily))
+                selected.add(`${node.family}/${node.name}`);
+        }
+        // Relation rows point from a consumer to its actual upstream artifact. Walk
+        // that reverse edge so review-only seeds and multi-hop consumers receive the
+        // same derived targets as ordinary executor seeds.
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const node of inventory) {
+                const key = `${node.family}/${node.name}`;
+                const audit = audits.get(key);
+                if (audit.upstreamRelations.some((relation) => selected.has(`${relation.upstreamFamily}/${relation.upstreamArtifact}`)) && !selected.has(key)) {
+                    selected.add(key);
+                    changed = true;
+                }
+            }
+        }
+        // A relation cycle cannot establish a safe downstream closure.
+        const visiting = new Set();
+        const visited = new Set();
+        const hasCycle = (key) => {
+            if (visiting.has(key))
+                return true;
+            if (visited.has(key))
+                return false;
+            visiting.add(key);
+            const cycle = audits.get(key)?.upstreamRelations.some((relation) => hasCycle(`${relation.upstreamFamily}/${relation.upstreamArtifact}`)) ?? false;
+            visiting.delete(key);
+            visited.add(key);
+            return cycle;
+        };
+        if ([...nodeMap.keys()].some(hasCycle))
+            graphUsable = false;
+    }
+    const reasonCode = graphUsable ? 'qualification-changed' : 'upstream-replaced';
+    const targetNodes = (graphUsable
+        ? inventory.filter((node) => selected.has(`${node.family}/${node.name}`))
+        : inventory.filter((node) => downstream[sourceFamily].includes(node.family)))
+        .filter((node) => !(node.family === FAMILY[family].artifact && node.name === artifact.name));
+    const targets = targetNodes.flatMap((node) => {
+        const shapes = [
+            { targetKind: 'artifact', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 }
+        ];
+        const receipt = receipts.find((candidate) => candidate.output === node.name);
+        if (receipt)
+            shapes.push({ targetKind: 'receipt', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: receipt.inputSha256 });
+        if (node.family.startsWith('review-'))
+            shapes.push({ targetKind: 'approval', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 });
+        if (node.family === 'review-code')
+            shapes.push({ targetKind: 'reviewed-snapshot', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 });
+        return shapes.map((targetShape) => ({ ...targetShape, targetId: targetIdFor('pending', targetShape), operationId: 'pending', status: 'pending', reasonCode, updatedAt: timestamp }));
     });
     if (targets.length === 0)
         return { mutation: null };
@@ -589,6 +673,32 @@ function applyTaskEventUnlocked(request, options = {}) {
         if (!validated.ok)
             return failed(normalized, validated.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         completedArtifact = validated.artifact;
+        if (eventIdentity.family.startsWith('review-')) {
+            let reviewContent;
+            try {
+                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 });
+            }
+            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'
                 ? 'analysis'
@@ -600,11 +710,10 @@ function applyTaskEventUnlocked(request, options = {}) {
             catch (error) {
                 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 validationConfig = localArtifactValidationConfig(resolved.repoRoot, localFamily);
             const local = validateLocalArtifact(artifactContent, {
                 family: localFamily,
-                requiredSections: validationConfig.requiredSections,
-                requiredPatterns: validationConfig.requiredPatterns
+                taskContent: content,
+                artifact: completedArtifact.name
             });
             if (!local.ok) {
                 return failed(normalized, {
@@ -726,6 +835,14 @@ function applyTaskEventUnlocked(request, options = {}) {
     const body = appendActivityEntry(section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
     const frontmatterSet = { current_step: step, assigned_to: normalized.agent };
     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');
         if (!planInput)
@@ -757,6 +874,8 @@ function applyTaskEventUnlocked(request, options = {}) {
     else if (eventIdentity.phase === 'completed' && eventIdentity.family.startsWith('review-')) {
         frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
     }
+    if (eventIdentity.phase === 'completed')
+        frontmatterRemove = [...(frontmatterRemove ?? []), 'qualification_input_relations'];
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
         frontmatterSet.last_reviewed_commit = '';
     const mutations = [

package/dist/lib/task/index.js

@@ -1,3 +1,4 @@
+import { PUBLIC_CLI_ROUTE_SELECTORS, PUBLIC_CLI_SELECTOR_ALIASES } from '../internal/cli-route-inventory.js';
 const USAGE = `Usage: ai task <command> [options]
 
 Commands:
@@ -30,6 +31,7 @@ Examples:
   ai task status --task 11
 
 Run 'ai task <command> --help' for details.`;
+const TASK_OPERATIONS = PUBLIC_CLI_ROUTE_SELECTORS.task;
 export async function runTask(args) {
     const [subcommand, ...rest] = args;
     if (!subcommand) {
@@ -41,14 +43,20 @@ export async function runTask(args) {
         process.stdout.write(`${USAGE}\n`);
         return;
     }
-    switch (subcommand) {
+    const routeSelector = PUBLIC_CLI_SELECTOR_ALIASES.task[subcommand] ?? subcommand;
+    if (!TASK_OPERATIONS.includes(routeSelector)) {
+        process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
+        process.stdout.write(`${USAGE}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    switch (routeSelector) {
         case 'cat': {
             const { cat } = await import('./commands/cat.js');
             cat(rest);
             break;
         }
-        case 'decisions':
-        case 'd': {
+        case 'decisions': {
             const { decisions } = await import('./commands/decisions.js');
             decisions(rest);
             break;