@fitlab-ai/agent-infra 0.11.8 → 0.11.10

package/dist/lib/task/events.js

@@ -19,10 +19,8 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { validateLocalArtifact } from './local-artifact-finalization.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, parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
+import { parseTaskQualification } from './qualification-audit.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { inspectReviewIdentity } from './review-identity.js';
@@ -370,235 +368,6 @@ function eventTrigger(request, family) {
         explicitRequest: request.requestId !== undefined || request.reasonCode !== undefined || request.initiator !== undefined || request.orchestrated === true
     };
 }
-function receiptGraphHasCycle(receipts) {
-    const edges = new Map();
-    for (const receipt of receipts) {
-        const outputs = edges.get(receipt.input) ?? [];
-        outputs.push(receipt.output);
-        edges.set(receipt.input, outputs);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (node) => {
-        if (visiting.has(node))
-            return true;
-        if (visited.has(node))
-            return false;
-        visiting.add(node);
-        for (const output of edges.get(node) ?? [])
-            if (visit(output))
-                return true;
-        visiting.delete(node);
-        visited.add(node);
-        return false;
-    };
-    return [...edges.keys()].some(visit);
-}
-function qualificationInvalidationSeeds(content, taskDir, inventory, baselineDigest) {
-    const task = parseTaskQualification(content);
-    if (!task.ok)
-        return { changed: true, safe: false, seeds: [] };
-    if (baselineDigest !== undefined) {
-        if (!/^[a-f0-9]{64}$/u.test(baselineDigest))
-            return { changed: true, safe: false, seeds: [] };
-        if (baselineDigest === task.qualification.taskInputDigest)
-            return { changed: false, safe: true, seeds: [] };
-    }
-    const audits = [];
-    let observedQualification = false;
-    for (const artifact of inventory) {
-        let artifactContent;
-        try {
-            artifactContent = fs.readFileSync(path.join(taskDir, artifact.name), 'utf8');
-        }
-        catch {
-            return { changed: true, safe: false, seeds: [] };
-        }
-        const parsed = parseQualificationAudit(artifactContent);
-        if (!parsed.ok)
-            return { changed: true, safe: false, seeds: [] };
-        if (!parsed.audit.present)
-            continue;
-        observedQualification = true;
-        const snapshot = parsed.audit.snapshot;
-        if (!snapshot)
-            return { changed: true, safe: false, seeds: [] };
-        audits.push({
-            name: artifact.name,
-            snapshotTaskDigest: snapshot.taskInputDigest,
-            snapshotNonConstraintDigest: snapshot.nonConstraintInputDigest,
-            dependencies: parsed.audit.constraintDependencies,
-            candidates: parsed.audit.candidateQualifications
-        });
-    }
-    if (!task.qualification.present)
-        return { changed: false, safe: true, seeds: [] };
-    const allAuditsPresent = observedQualification && audits.length === inventory.length;
-    if (!allAuditsPresent)
-        return { changed: true, safe: false, seeds: [] };
-    if (baselineDigest === undefined && audits.every((audit) => audit.snapshotTaskDigest === task.qualification.taskInputDigest)) {
-        return { changed: false, safe: true, seeds: [] };
-    }
-    const candidateMap = new Map(task.qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
-    const currentConstraints = new Map(task.qualification.constraints.map((constraint) => [constraint.constraintId, constraint.digest]));
-    const snapshotsMatch = audits.every((audit) => audit.snapshotNonConstraintDigest === task.qualification.nonConstraintInputDigest);
-    const candidatesMatch = audits.every((audit) => audit.candidates.length === candidateMap.size
-        && audit.candidates.every((row) => {
-            const current = candidateMap.get(row.candidateId);
-            return Boolean(current && row.status === current.status && row.impact === current.impact
-                && row.evidence === current.evidence && row.constraintIds.join(',') === current.constraintIds.join(','));
-        }));
-    const changedConstraints = new Set();
-    let referencesValid = true;
-    for (const audit of audits) {
-        for (const dependency of audit.dependencies) {
-            const currentDigest = currentConstraints.get(dependency.constraintId);
-            if (!currentDigest)
-                referencesValid = false;
-            else if (currentDigest !== dependency.constraintDigest)
-                changedConstraints.add(dependency.constraintId);
-        }
-    }
-    const safe = allAuditsPresent && snapshotsMatch && candidatesMatch && referencesValid && changedConstraints.size > 0;
-    if (!safe)
-        return { changed: true, safe: false, seeds: [] };
-    const seeds = new Set();
-    for (const audit of audits) {
-        if (audit.dependencies.some((dependency) => changedConstraints.has(dependency.constraintId)))
-            seeds.add(audit.name);
-    }
-    return { changed: true, safe: true, seeds: [...seeds] };
-}
-function invalidationMutationForCompletion(content, taskDir, family, artifact, timestamp, frontmatter) {
-    if (!['analyze', 'plan', 'code'].includes(family))
-        return { mutation: null };
-    const parsed = parseInvalidationDocument(content);
-    if (!parsed.ok)
-        return { error: parsed.message };
-    const downstream = {
-        analyze: ['review-analysis', 'plan', 'review-plan', 'code', 'review-code'],
-        plan: ['review-plan', 'code', 'review-code'],
-        code: ['review-code']
-    };
-    const qualificationFallback = ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'];
-    const sourceFamily = family;
-    const sourceArtifactFamily = sourceFamily === 'analyze' ? 'analysis' : sourceFamily;
-    let receipts = [];
-    try {
-        receipts = parseArtifactReceipts(content).rows;
-    }
-    catch (error) {
-        return { error: error instanceof Error ? error.message : String(error) };
-    }
-    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 nodeMap = new Map(inventory.map((node) => [`${node.family}/${node.name}`, node]));
-    let graphUsable = receipts.length > 0;
-    for (const receipt of receipts) {
-        const output = parseArtifactName(receipt.output);
-        const input = nodeMap.get(`${parseArtifactName(receipt.input)?.family}/${receipt.input}`);
-        if (!output || !nodeMap.has(`${output.family}/${receipt.output}`) || !input || input.sha256 !== receipt.inputSha256) {
-            graphUsable = false;
-            break;
-        }
-    }
-    if (graphUsable && receiptGraphHasCycle(receipts))
-        graphUsable = false;
-    if (inventory.some((node) => node.family !== 'analysis' && node.name !== artifact.name
-        && !receipts.some((receipt) => receipt.output === node.name)))
-        graphUsable = false;
-    const selected = new Set();
-    if (graphUsable) {
-        const currentIdentity = parseArtifactName(artifact.name);
-        const previousName = currentIdentity && currentIdentity.round > 1 ? artifactName(sourceArtifactFamily, currentIdentity.round - 1) : null;
-        const previous = previousName ? inventory.find((node) => node.family === sourceArtifactFamily && node.name === previousName) : null;
-        const previousFact = previousName ? parseCompletionFacts(frontmatter.completion_facts).find((fact) => fact.output === previousName && fact.event === `${sourceFamily === 'analyze' ? 'analysis' : sourceFamily}.completed`) : null;
-        if (!previous || !previousFact || previousFact.outputSha256 !== previous.sha256)
-            graphUsable = false;
-        if (graphUsable && previous) {
-            selected.add(`${previous.family}/${previous.name}`);
-            let changed = true;
-            while (changed) {
-                changed = false;
-                for (const receipt of receipts) {
-                    const consumer = `${parseArtifactName(receipt.output).family}/${receipt.output}`;
-                    if (selected.has(`${parseArtifactName(receipt.input).family}/${receipt.input}`) && !selected.has(consumer)) {
-                        selected.add(consumer);
-                        changed = true;
-                    }
-                }
-            }
-            selected.delete(`${previous.family}/${previous.name}`);
-        }
-    }
-    const qualification = qualificationInvalidationSeeds(content, taskDir, inventory, typeof frontmatter.qualification_input_digest === 'string' ? frontmatter.qualification_input_digest : undefined);
-    let qualificationChange = qualification.changed;
-    if (qualificationChange && (!graphUsable || !qualification.safe))
-        graphUsable = false;
-    if (qualificationChange && graphUsable) {
-        for (const seed of qualification.seeds)
-            selected.add(`${parseArtifactName(seed)?.family}/${seed}`);
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const receipt of receipts) {
-                const consumer = `${parseArtifactName(receipt.output).family}/${receipt.output}`;
-                if (selected.has(`${parseArtifactName(receipt.input).family}/${receipt.input}`) && !selected.has(consumer)) {
-                    selected.add(consumer);
-                    changed = true;
-                }
-            }
-        }
-    }
-    const reasonCode = qualificationChange ? 'qualification-changed' : 'upstream-replaced';
-    const fallbackFamilies = qualificationChange ? qualificationFallback : downstream[sourceFamily];
-    const targetNodes = (graphUsable
-        ? inventory.filter((node) => selected.has(`${node.family}/${node.name}`))
-        : inventory.filter((node) => fallbackFamilies.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 }
-        ];
-        for (const receipt of receipts.filter((candidate) => candidate.output === node.name)) {
-            shapes.push({ targetKind: 'receipt', targetFamily: node.family, targetArtifact: node.name, targetInput: receipt.input, 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 };
-    const source = {
-        sourceFamily: lifecycleAction(family), sourceArtifact: artifact.name,
-        sourceRound: parseArtifactName(artifact.name)?.round ?? 1, sourceSha256: sha256File(artifact.path),
-        createdAt: timestamp, updatedAt: timestamp
-    };
-    const operation = createInvalidationOperation(source);
-    const normalizedTargets = targets.map((target) => ({
-        ...target, operationId: operation.operationId,
-        targetId: targetIdFor(operation.operationId, target)
-    }));
-    const operationWithTotal = createInvalidationOperation(source, normalizedTargets);
-    const next = upsertInvalidation(parsed.document, operationWithTotal, normalizedTargets);
-    if (!next.ok)
-        return { error: next.message };
-    return { mutation: next.changed ? invalidationMutation(content, next.document) : null };
-}
 function reworkIntentMutationForCompletion(content, taskDir, family, artifact, timestamp) {
     const parsed = parseReworkIntentDocument(content);
     if (!parsed.ok)
@@ -606,23 +375,15 @@ function reworkIntentMutationForCompletion(content, taskDir, family, artifact, t
     const hash = sha256File(artifact.path);
     let next = parsed.intents;
     if (family === 'analyze' || family === 'plan' || family === 'code') {
-        const hashes = Object.fromEntries(fs.readdirSync(taskDir).flatMap((name) => {
-            if (!/^review-(?:analysis|plan|code)(?:-r\d+)?\.md$/.test(name))
-                return [];
-            try {
-                return [[name, sha256File(path.join(taskDir, name))]];
-            }
-            catch {
-                return [];
-            }
+        const hashes = Object.fromEntries(['review-analysis', 'review-plan', 'review-code'].flatMap((reviewFamily) => {
+            const inventory = inspectArtifactDirectory(taskDir, reviewFamily);
+            return inventory.status === 'ready' ? inventory.completed.map((review) => [review.name, sha256File(review.path)]) : [];
         }));
         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 previousAnalysis = inspectArtifactDirectory(taskDir, 'analysis').completed
+                .filter((identity) => identity.name !== artifact.name).at(-1);
             const pathState = previousAnalysis
                 ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, previousAnalysis.name), 'utf8'))
                 : undefined;
@@ -764,23 +525,6 @@ function applyTaskEventUnlocked(request, options = {}) {
         return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
     const initialParts = eventParts(request.event);
-    if (initialParts.phase === 'started' && !request.dryRun) {
-        const reconciled = reconcileTaskInvalidation(request.taskRef, { repoRoot: resolved.repoRoot });
-        if (reconciled.status === 'failed') {
-            return failed(request, {
-                code: 'EVENT_TRANSITION_INVALID',
-                message: `INVALIDATION_RECONCILE_FAILED: ${reconciled.error?.code ?? 'UNKNOWN'}: ${reconciled.error?.message ?? ''}`
-            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-        }
-        if (reconciled.changed) {
-            try {
-                content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-            }
-            catch (error) {
-                return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            }
-        }
-    }
     let frontmatter;
     try {
         frontmatter = parseTypedTaskFrontmatter(content);
@@ -946,8 +690,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
             || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
         if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)) {
-            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 });
+            return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
     }
     const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
@@ -985,7 +728,6 @@ function applyTaskEventUnlocked(request, options = {}) {
     }
     let completionReceipts = [];
     let currentFact = null;
-    let completionInvalidation = null;
     let completionRework = null;
     if (eventIdentity.phase === 'completed' && completedArtifact) {
         const receipt = buildCompletionReceipt(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter, normalized);
@@ -1006,10 +748,6 @@ function applyTaskEventUnlocked(request, options = {}) {
             return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, completionReceipts[0]?.completedAt ?? metadata.timestamp, frontmatter, artifactContext);
         }
         try {
-            const invalidation = invalidationMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
-            if ('error' in invalidation)
-                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: invalidation.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-            completionInvalidation = invalidation.mutation;
             const rework = reworkIntentMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp);
             if ('error' in rework)
                 return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: rework.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -1104,8 +842,6 @@ function applyTaskEventUnlocked(request, options = {}) {
             return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
     }
-    if (completionInvalidation)
-        mutations.push(completionInvalidation);
     if (completionRework)
         mutations.push(completionRework);
     if (eventIdentity.phase === 'completed' && normalized.implementationInput) {
@@ -1123,9 +859,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         });
     }
     mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
-    const sourceCompletion = eventIdentity.phase === 'completed'
-        && ['analyze', 'plan', 'code'].includes(eventIdentity.family);
-    const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
+    const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
     if (!normalized.dryRun && orchestrationCompletion) {

package/dist/lib/task/execution-inputs.js

@@ -0,0 +1,14 @@
+import { pathIncludes } from './lifecycle-path.js';
+function expectedExecutionInputFamilies(stage, pathState) {
+    if (pathState.status !== 'valid')
+        return [];
+    const input = stage === 'plan' ? 'analysis' : pathIncludes(pathState, 'plan') ? 'plan' : 'analysis';
+    const review = input === 'plan' ? 'review-plan' : 'review-analysis';
+    return [input, ...(pathIncludes(pathState, review) ? [review] : [])];
+}
+function executionInputsMatchLatest(stage, pathState, latest, captured) {
+    const expected = expectedExecutionInputFamilies(stage, pathState);
+    return expected.every((family) => Boolean(latest[family] && captured.includes(latest[family])));
+}
+export { expectedExecutionInputFamilies, executionInputsMatchLatest };
+//# sourceMappingURL=execution-inputs.js.map

package/dist/lib/task/finalization-envelope.js

@@ -0,0 +1,4 @@
+export function serializeTaskFinalizationEnvelope(envelope) {
+    return `${JSON.stringify({ version: 2, ...envelope })}\n`;
+}
+//# sourceMappingURL=finalization-envelope.js.map