@fitlab-ai/agent-infra 0.11.9 → 0.11.10

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

@@ -4,15 +4,16 @@ import { ARTIFACT_FAMILY_CATALOG, artifactName, parseArtifactName } from './arti
 import { resolveTaskRef } from './resolve-ref.js';
 import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
-import { receiptForOutput, sha256File } from './artifact-receipts.js';
-import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { receiptForOutput, receiptsForOutput, sha256File } from './artifact-receipts.js';
+import { artifactCompletionOrder, hasArtifactCompletionFact, hasArtifactCompletionLog, parseCompletionFacts } from './completion-facts.js';
 import { inspectReviewIdentity } from './review-identity.js';
-import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { parseReworkIntentDocument } from './rework-intent.js';
 import { selectArtifactDisposition } from './artifact-selection.js';
+import { executionInputsMatchLatest } from './execution-inputs.js';
 const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 const ARTIFACT_STEPS = {
     analysis: 'Analyze Task', 'review-analysis': 'Review Analysis',
@@ -21,28 +22,46 @@ const ARTIFACT_STEPS = {
 };
 /** Init, repair and finalization share the same authoritative round identity. */
 export function hasOpenArtifactRound(content, family, round) {
+    return openArtifactRounds(content, family).includes(round);
+}
+function openArtifactRounds(content, family) {
     const activity = locateActivityLog(content);
     const step = ARTIFACT_STEPS[family];
     if (!activity || !step)
-        return false;
+        return [];
     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 expected = new RegExp(`^${step} \\(Round ([1-9]\\d*)${qualifier}\\)$`);
+    return [...new Set(startedBackedRows(pairEntries(activity.entries))
+            .filter((row) => expected.test(row.step) && !row.done)
+            .map((row) => Number(expected.exec(row.step)?.[1])))].sort((left, right) => left - right);
 }
 function hasCompletedArtifactRound(content, family, round, name) {
-    const activity = locateActivityLog(content);
-    const step = ARTIFACT_STEPS[family];
-    if (!activity || !step)
-        return false;
-    const expected = new RegExp(`^${escapeRegExp(step)} \\(Round ${round}(?:, [^)]+)?\\)$`);
-    return startedBackedRows(pairEntries(activity.entries)).some((row) => expected.test(row.step) && Boolean(row.done) && row.note.includes(`→ ${name}`));
+    const event = completionEvent(family);
+    return Boolean(event && parseArtifactName(name)?.round === round
+        && artifactCompletionOrder(content, name, event) !== null
+        && hasArtifactCompletionFact(content, name, event));
+}
+function completionEvent(family) {
+    if (family === 'analysis')
+        return 'analyze.completed';
+    if (family === 'review-analysis')
+        return 'review-analysis.completed';
+    if (family === 'plan')
+        return 'plan.completed';
+    if (family === 'review-plan')
+        return 'review-plan.completed';
+    if (family === 'code')
+        return 'code.completed';
+    if (family === 'review-code')
+        return 'review-code.completed';
+    return null;
 }
 const BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
     'DUPLICATE_LOGICAL_ROUND', 'NON_REGULAR_FILE', 'SYMBOLIC_LINK',
-    'FILESYSTEM_RACE', 'CATALOG_CONFLICT'
+    'FILESYSTEM_RACE', 'CATALOG_CONFLICT', 'MULTIPLE_OPEN_ROUNDS'
 ]);
 function familySpec(family) {
     return artifactFamilyCatalog.find((item) => item.family === family) ?? null;
@@ -53,7 +72,7 @@ function escapeRegExp(value) {
 function failure(requestRef, family, error, extra = {}) {
     return {
         status: 'failed', changed: false, requestRef, taskId: null, taskDir: null,
-        taskState: null, family, artifacts: [], latest: null, next: null,
+        taskState: null, family, artifacts: [], completed: [], latest: null, next: null, openRounds: [],
         reviewedInput: null, diagnostics: [], error, ...extra
     };
 }
@@ -82,19 +101,12 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
-    let invalidation = { operations: [], targets: [] };
+    let taskContent;
     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;
+        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
     }
     catch (error) {
-        return failure(requestRef, family, { code: 'ARTIFACT_INVALIDATION_INVALID', message: String(error) }, {
+        return failure(requestRef, family, { code: 'ARTIFACT_DIRECTORY_READ_FAILED', message: String(error) }, {
             taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null
         });
     }
@@ -133,8 +145,7 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
             }
             const identity = { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
             knownArtifacts.push(identity);
-            if (!isArtifactInvalidated(invalidation, family, entry.name))
-                artifacts.push(identity);
+            artifacts.push(identity);
         }
         catch (error) {
             diagnostics.push(diagnostic('FILESYSTEM_RACE', family, entry.name, String(error)));
@@ -142,19 +153,32 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
     }
     artifacts.sort((left, right) => left.round - right.round);
     knownArtifacts.sort((left, right) => left.round - right.round);
+    const openRounds = openArtifactRounds(taskContent, family);
     const knownRounds = new Set(knownArtifacts.map((item) => item.round));
-    if (knownArtifacts.length > 0 && !knownRounds.has(1))
+    for (const round of openRounds)
+        knownRounds.add(round);
+    const max = Math.max(...knownRounds, 0);
+    if (max > 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 (!knownRounds.has(round))
             diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
     }
-    const latest = artifacts.at(-1) ?? null;
+    const event = completionEvent(family);
+    const completed = event
+        ? artifacts.flatMap((artifact) => {
+            const order = artifactCompletionOrder(taskContent, artifact.name, event);
+            return order !== null && hasArtifactCompletionFact(taskContent, artifact.path, event)
+                ? [{ artifact, order }] : [];
+        }).sort((left, right) => left.order - right.order).map(({ artifact }) => artifact)
+        : [];
+    if (openRounds.length > 1)
+        diagnostics.push(diagnostic('MULTIPLE_OPEN_ROUNDS', family, null, `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`));
+    const latest = completed.at(-1) ?? null;
     let hasReviewCodeReceipt = false;
     if (family === 'review-code' && latest) {
         try {
-            hasReviewCodeReceipt = Boolean(receiptForOutput(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'), latest.name));
+            hasReviewCodeReceipt = Boolean(receiptForOutput(taskContent, latest.name));
         }
         catch {
             hasReviewCodeReceipt = false;
@@ -165,9 +189,9 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
         : null;
     return {
         status: 'ready', changed: false, requestRef, taskId: identity.taskId ?? null,
-        taskDir, taskState: identity.taskState ?? null, family, artifacts, latest,
+        taskDir, taskState: identity.taskState ?? null, family, artifacts, completed, latest,
         next: { round: max + 1, name: artifactName(family, max + 1) },
-        reviewedInput, diagnostics, error: null
+        openRounds, reviewedInput, diagnostics, error: null
     };
 }
 function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
@@ -184,11 +208,6 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         const stat = fs.lstatSync(abs);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
-        const invalidation = parseInvalidationDocument(taskContent);
-        if (!invalidation.ok)
-            throw new Error(invalidation.message);
-        if (isArtifactInvalidated(invalidation.document, expectedFamily, input.name))
-            throw new Error(`${input.name} is invalidated`);
         const actualSha256 = sha256File(abs);
         if (actualSha256 !== receipt.inputSha256) {
             throw new Error(`${input.name} content digest does not match receipt`);
@@ -270,11 +289,27 @@ const OPTIONAL_CONTEXT = {
     'manual-validation': ['review-code'],
     'validation-run': ['review-code']
 };
-function hasSelectionEvidence(content, family, options, context) {
+function hasSelectionEvidence(content, family, options, context, pathState) {
     if (options.sourceFinding && options.sourceArtifact && options.sourceSha256)
         return true;
     if (options.reasonCode === 'new-requirement' || options.reasonCode === 'upstream-fact-doubt')
         return true;
+    if ((family === 'plan' || family === 'code') && context.latest) {
+        const latestInputs = Object.fromEntries(context.inputs.map((input) => [input.family, input.name]));
+        const capturedInputs = receiptsForOutput(content, context.latest.name)
+            .filter((receipt) => receipt.event === `${family}.completed`)
+            .filter((receipt) => {
+            try {
+                return sha256File(path.join(context.taskDir, receipt.input)) === receipt.inputSha256;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((receipt) => receipt.input);
+        if (!executionInputsMatchLatest(family, pathState, latestInputs, capturedInputs))
+            return true;
+    }
     if (family.startsWith('review-')) {
         const reviewedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
         const currentInput = context.inputs.find((input) => input.family === reviewedFamily);
@@ -337,16 +372,20 @@ function attachArtifactSelection(context, pathState, options) {
     catch (error) {
         return fail('ARTIFACT_SELECTION_INDETERMINATE', error instanceof Error ? error.message : String(error));
     }
-    const openLatest = context.latest ? hasOpenArtifactRound(taskContent, family, context.latest.round) : false;
-    const openNext = hasOpenArtifactRound(taskContent, family, context.next.round);
-    const open = openLatest || openNext;
-    const selectedIdentity = openLatest ? context.latest : context.next;
+    const openRounds = openArtifactRounds(taskContent, family);
+    if (openRounds.length > 1)
+        return fail('ARTIFACT_TOPOLOGY_CONFLICT', `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`);
+    const openRound = openRounds[0] ?? null;
+    const selectedIdentity = openRound === null ? context.next : {
+        family, round: openRound, name: artifactName(family, openRound),
+        path: path.join(context.taskDir, artifactName(family, openRound)), size: 0, mtimeMs: 0
+    };
     try {
-        const hasChangeEvidence = hasSelectionEvidence(taskContent, family, options, context);
+        const hasChangeEvidence = hasSelectionEvidence(taskContent, family, options, context, pathState);
         const selection = selectArtifactDisposition({
             next: { family, round: selectedIdentity.round, name: selectedIdentity.name },
             latest: context.latest,
-            open,
+            open: openRound !== null,
             hasChangeEvidence
         });
         return {
@@ -377,7 +416,8 @@ function resolveArtifactContext(taskRef, family, options = {}) {
             return selected;
         if (selected.selection.disposition === 'reuse')
             return selected;
-        if (selected.codeMode?.mode === 'error') {
+        if (selected.codeMode?.mode === 'error'
+            && selected.codeMode.message.includes('is not captured by the latest code input receipt')) {
             return {
                 ...selected,
                 status: 'ready',
@@ -435,32 +475,42 @@ function resolveCodeContext(inventory, options) {
     if (source.status === 'failed' || !source.latest)
         return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', `latest ${inputFamily} artifact is required`);
     const reviewCode = inspectTaskArtifacts(taskRef, 'review-code', options);
+    try {
+        const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');
+        const hasPendingImplementation = parseImplementationInputs(taskContent).rows.some((input) => input.needsImplementation && input.status === 'pending');
+        if (hasPendingImplementation && !reviewCode.latest) {
+            const candidate = reviewCode.artifacts.at(-1)?.name ?? 'review-code.md';
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `cannot find completed Activity Log identity for ${candidate}`);
+        }
+    }
+    catch (error) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
+    }
     const latestCode = inventory.latest;
-    const codeMax = latestCode?.round ?? 0;
+    const codeMax = inventory.next?.round ? inventory.next.round - 1 : latestCode?.round ?? 0;
     const reviewMax = reviewCode.latest?.round ?? 0;
     const inputs = [source.latest];
     const sourceReviewFamily = inputFamily === 'analysis' ? 'review-analysis' : 'review-plan';
     const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options);
     if (sourceReview.status === 'ready' && sourceReview.latest && sourceReview.reviewedInput?.name === source.latest.name)
         inputs.push(sourceReview.latest);
-    if (latestCode) {
+    if (inventory.openRounds.length > 0) {
         try {
             const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');
-            if (hasOpenArtifactRound(taskContent, 'code', latestCode.round)) {
-                const review = reviewCode.latest;
-                const openInputs = review ? [...inputs, review] : inputs;
-                const openVerdict = review ? parseVerdict(review.path) : null;
-                const openRow = locateActivityLog(taskContent)
-                    ? startedBackedRows(pairEntries(locateActivityLog(taskContent).entries))
-                        .find((row) => row.step.startsWith(`Code Task (Round ${latestCode.round}`) && !row.done)
-                    : null;
-                const decisionInput = /, decision (II-[1-9]\d*)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
-                const fixInput = /, fix for (review-code(?:-r\d+)?\.md)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
-                const mode = decisionInput ? 'decision'
-                    : fixInput || (openVerdict?.ok && openVerdict.verdict === 'Changes Requested') ? 'fix'
-                        : 'init';
-                return withCodeMode(inventory, openInputs, 'ready', mode, codeMax, reviewMax, openVerdict?.ok ? openVerdict.verdict : null, fixInput ?? review?.name ?? null, `Resuming open code round ${latestCode.round}.`, decisionInput);
-            }
+            const openRound = inventory.openRounds[0];
+            const review = reviewCode.latest;
+            const openInputs = review ? [...inputs, review] : inputs;
+            const openVerdict = review ? parseVerdict(review.path) : null;
+            const openRow = locateActivityLog(taskContent)
+                ? startedBackedRows(pairEntries(locateActivityLog(taskContent).entries))
+                    .find((row) => row.step.startsWith(`Code Task (Round ${openRound}`) && !row.done)
+                : null;
+            const decisionInput = /, decision (II-[1-9]\d*)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
+            const fixInput = /, fix for (review-code(?:-r\d+)?\.md)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
+            const mode = decisionInput ? 'decision'
+                : fixInput || (openVerdict?.ok && openVerdict.verdict === 'Changes Requested') ? 'fix'
+                    : 'init';
+            return withCodeMode(inventory, openInputs, 'ready', mode, codeMax, reviewMax, openVerdict?.ok ? openVerdict.verdict : null, fixInput ?? review?.name ?? null, `Resuming open code round ${openRound}.`, decisionInput);
         }
         catch (error) {
             return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
@@ -599,6 +649,13 @@ export function validateArtifactPublication(taskDir, family, name) {
             if (hasCompletedArtifactRound(task, family, existing.round, name)) {
                 return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completed artifact '${name}' is immutable` };
             }
+            const event = completionEvent(family);
+            const frontmatter = parseTypedTaskFrontmatter(task);
+            const completionFactExists = event !== null && parseCompletionFacts(frontmatter.completion_facts)
+                .some((fact) => fact.event === event && fact.output === name);
+            if (event && completionFactExists && artifactCompletionOrder(task, name, event) !== null) {
+                return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completion evidence for '${name}' does not match its current content` };
+            }
         }
         catch (error) {
             return { code: 'ARTIFACT_SELECTION_INDETERMINATE', message: error instanceof Error ? error.message : String(error) };

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

@@ -8,7 +8,7 @@ function selectArtifactDisposition(request) {
     if (!request.latest) {
         return {
             disposition: 'create',
-            reasonCode: request.next.round === 1 ? 'no-history' : 'invalidated-history',
+            reasonCode: 'no-completed-history',
             artifact: request.next, writeRequired: true
         };
     }

package/dist/lib/task/capabilities.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseArtifactName } from './artifact-name.js';
-import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { parseArtifactReceipts, receiptForOutput } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
@@ -14,6 +13,8 @@ import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.js';
 import { parseImplementationInputs } from './implementation-inputs.js';
 import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
 import { inspectReviewIdentity } from './review-identity.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
+import { executionInputsMatchLatest as executionReceiptsMatchLatest } from './execution-inputs.js';
 const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 const REASONS = new Set([
     'user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'
@@ -52,8 +53,6 @@ function canStart(action, facts, trigger) {
     }
     if (facts.taskState !== 'active')
         return deny('TASK_NOT_ACTIVE', `state=${facts.taskState}`);
-    if (invalidationBlocks(facts.invalidation))
-        return deny('INVALIDATION_INCOMPLETE');
     if (facts.executionBusy)
         return deny('EXECUTION_BUSY');
     const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
@@ -102,7 +101,9 @@ function canStart(action, facts, trigger) {
         return allow('analysis-review-approved');
     }
     if (action === 'review-plan') {
-        return hasArtifact(facts, 'plan') ? allow('plan-artifact') : deny('PLAN_ARTIFACT_REQUIRED');
+        if (!hasArtifact(facts, 'plan'))
+            return deny('PLAN_ARTIFACT_REQUIRED');
+        return executionInputsMatchLatest(facts, 'plan') ? allow('plan-artifact') : deny('PLAN_INPUT_STALE');
     }
     if (action === 'code') {
         if (trigger.implementationInput) {
@@ -141,11 +142,15 @@ function canStart(action, facts, trigger) {
         return allow('plan-review-approved');
     }
     if (action === 'review-code') {
+        if (hasArtifact(facts, 'code') && !executionInputsMatchLatest(facts, 'code'))
+            return deny('CODE_INPUT_STALE');
         return allow(hasArtifact(facts, 'code') ? 'optional-code-context' : 'review-current-git-diff');
     }
     if (action === 'manual-validation' || action === 'validation-run') {
         if (!hasArtifact(facts, 'review-code'))
             return deny('CODE_REVIEW_REQUIRED');
+        if (!executionInputsMatchLatest(facts, 'code'))
+            return deny('CODE_INPUT_STALE');
         if (hasArtifact(facts, 'code') && !reviewMatchesLatest(facts, 'code', 'review-code'))
             return deny('CODE_REVIEW_NOT_LATEST');
         if (!facts.reviewCodeIdentityValid)
@@ -159,13 +164,22 @@ function canStart(action, facts, trigger) {
     return deny('CAPABILITY_ACTION_UNKNOWN');
 }
 function latestArtifact(names) {
-    return names.map(parseArtifactName).filter((identity) => identity !== null)
-        .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0]?.name ?? null;
+    return names.at(-1) ?? null;
 }
 function reviewMatchesLatest(facts, source, review) {
     const latestSource = latestArtifact(facts.artifacts[source] ?? []);
     return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
 }
+function executionInputsMatchLatest(facts, stage) {
+    if (!facts.pathState || facts.pathState.status !== 'valid' || facts.executionInputs === undefined)
+        return true;
+    return executionReceiptsMatchLatest(stage, facts.pathState, {
+        analysis: latestArtifact(facts.artifacts.analysis ?? []) ?? undefined,
+        'review-analysis': latestArtifact(facts.artifacts['review-analysis'] ?? []) ?? undefined,
+        plan: latestArtifact(facts.artifacts.plan ?? []) ?? undefined,
+        'review-plan': latestArtifact(facts.artifacts['review-plan'] ?? []) ?? undefined
+    }, facts.executionInputs[stage] ?? []);
+}
 function qualificationCandidateSnapshotMatches(audit, qualification) {
     const current = new Map(qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
     return audit.candidateQualifications.length === current.size && audit.candidateQualifications.every((row) => {
@@ -201,6 +215,8 @@ function recommendNext(facts) {
             }
             if (stage === 'plan' && !hasArtifact(facts, stage))
                 return { action: stage, reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+            if (stage === 'plan' && !executionInputsMatchLatest(facts, stage))
+                return { action: stage, reasonCode: 'PLAN_INPUT_STALE', evidence: ['latest plan does not record the current selected analysis inputs'] };
             if (stage === 'review-plan' && (!reviewMatchesLatest(facts, 'plan', stage) || facts.reviews[stage] !== 'approved')) {
                 if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.plan === 'review') {
                     return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['plan decision was resolved'] };
@@ -211,6 +227,8 @@ function recommendNext(facts) {
             }
             if (stage === 'code' && !hasArtifact(facts, stage))
                 return { action: stage, reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+            if (stage === 'code' && !executionInputsMatchLatest(facts, stage))
+                return { action: stage, reasonCode: 'CODE_INPUT_STALE', evidence: ['latest code does not record the current selected execution inputs'] };
             if (stage === 'review-code' && (!reviewMatchesLatest(facts, 'code', stage) || facts.reviews[stage] !== 'approved')) {
                 if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.code) {
                     return facts.resolvedHumanDecisions.code === 'implementation'
@@ -234,6 +252,8 @@ function recommendNext(facts) {
     }
     if (!hasArtifact(facts, 'plan'))
         return { action: 'plan', reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+    if (!executionInputsMatchLatest(facts, 'plan'))
+        return { action: 'plan', reasonCode: 'PLAN_INPUT_STALE', evidence: ['latest plan does not record the current selected analysis inputs'] };
     if (!hasArtifact(facts, 'review-plan') || !reviewMatchesLatest(facts, 'plan', 'review-plan')) {
         return { action: 'review-plan', reasonCode: 'PLAN_REVIEW_MISSING', evidence: ['plan review does not bind the latest plan artifact'] };
     }
@@ -242,6 +262,8 @@ function recommendNext(facts) {
     }
     if (!hasArtifact(facts, 'code'))
         return { action: 'code', reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+    if (!executionInputsMatchLatest(facts, 'code'))
+        return { action: 'code', reasonCode: 'CODE_INPUT_STALE', evidence: ['latest code does not record the current selected execution inputs'] };
     if (!hasArtifact(facts, 'review-code') || !reviewMatchesLatest(facts, 'code', 'review-code')) {
         return { action: 'review-code', reasonCode: 'CODE_REVIEW_MISSING', evidence: ['code review does not bind the latest code artifact'] };
     }
@@ -253,9 +275,6 @@ function recommendNext(facts) {
 function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBusy = false) {
     try {
         const metadata = parseTypedTaskFrontmatter(content);
-        const invalidation = parseInvalidationDocument(content);
-        if (!invalidation.ok)
-            return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: invalidation.message };
         const rework = parseReworkIntentDocument(content);
         if (!rework.ok)
             return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: rework.message };
@@ -276,22 +295,38 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             const family = parseArtifactName(name)?.family;
             return artifactFamilies.find((candidate) => candidate === family) ?? null;
         };
-        const activeFiles = files.filter((name) => {
-            const family = familyFor(name);
-            return !family || !isArtifactInvalidated(invalidation.document, family, name);
-        });
         const allArtifactHashes = {};
         for (const name of files)
             allArtifactHashes[name] = sha256File(path.join(taskDir, name));
         const artifactHashes = {};
-        for (const name of activeFiles)
+        for (const name of files)
             artifactHashes[name] = allArtifactHashes[name];
+        const completedByFamily = new Map();
+        for (const family of artifactFamilies) {
+            const inventory = inspectArtifactDirectory(taskDir, family);
+            if (inventory.status !== 'ready')
+                continue;
+            completedByFamily.set(family, inventory.completed.map((artifact) => artifact.name));
+        }
+        const completedFiles = new Set([...completedByFamily.values()].flat());
+        const activeFiles = [
+            ...files.filter((name) => !familyFor(name)),
+            ...artifactFamilies.flatMap((family) => completedByFamily.get(family) ?? [])
+        ];
         const artifacts = Object.fromEntries(artifactFamilies.map((family) => [
             family, activeFiles.filter((name) => familyFor(name) === family)
         ]));
-        const staleArtifacts = Object.fromEntries(artifactFamilies.map((family) => [
-            family, files.filter((name) => familyFor(name) === family && isArtifactInvalidated(invalidation.document, family, name))
-        ]));
+        const receipts = parseArtifactReceipts(content).rows;
+        const executionInputs = {};
+        for (const family of ['plan', 'code']) {
+            const output = latestArtifact(artifacts[family] ?? []);
+            if (!output)
+                continue;
+            executionInputs[family] = receipts.filter((receipt) => receipt.output === output
+                && receipt.event === `${family}.completed`
+                && completedFiles.has(receipt.input)
+                && artifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => receipt.input);
+        }
         const qualification = parseTaskQualification(content);
         if (!qualification.ok)
             return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: qualification.message };
@@ -362,9 +397,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                 reviews[family] = verdict.verdict === 'Approved' ? 'approved' : verdict.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
         }
         const reworkClassificationRequired = [];
-        const receipts = parseArtifactReceipts(content).rows;
         for (const [reviewFamily, stage] of [['review-analysis', 'analysis'], ['review-plan', 'plan'], ['review-code', 'code']]) {
-            const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && files.includes(receipt.output)
+            const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && completedFiles.has(receipt.output)
                 && allArtifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => {
                 const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, receipt.output), 'utf8'));
                 const verdict = parsed.ok ? resolveCanonicalVerdict(parsed.summary) : null;
@@ -415,8 +449,8 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         }
         const facts = {
             taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
-            staleArtifacts, reviewedInputs, artifactHashes,
-            invalidation: invalidation.document, reworkIntents: rework.intents,
+            reviewedInputs, executionInputs, artifactHashes,
+            reworkIntents: rework.intents,
             unresolvedLedger,
             executionBusy: executionBusy || hasOpenLifecycleExecution(content),
             recommendedAction: null,

package/dist/lib/task/commands/status.js

@@ -11,8 +11,6 @@ import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workfl
 import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-log.js';
 import { readRun } from '../orchestration.js';
 import { statusCard } from '../../server/display.js';
-import { invalidationBlocks, parseInvalidationDocument } from '../invalidation.js';
-import { parseReworkIntentDocument } from '../rework-intent.js';
 import { buildLifecycleFacts, recommendNext } from '../capabilities.js';
 const USAGE = `Usage: ai task status [--task <ref> | -t <ref>]
 
@@ -320,11 +318,6 @@ function renderStatus(model) {
     else {
         lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
     }
-    lines.push('', 'Invalidation', ...renderPairs([
-        ['status', model.invalidation?.status ?? 'unknown'],
-        ['processed', `${model.invalidation?.processed ?? 0}/${model.invalidation?.total ?? 0}`],
-        ['pending_intents', String(model.invalidation?.pendingIntents ?? 0)]
-    ]));
     lines.push('', 'Recommendation', ...renderPairs([
         ['path', model.lifecyclePath ?? DASH],
         ['action', model.recommendation ?? DASH],
@@ -374,10 +367,6 @@ function renderStatus(model) {
     return lines;
 }
 function modelTone(model) {
-    if (model.invalidation?.status === 'invalid')
-        return 'danger';
-    if (model.invalidation?.status === 'pending' || model.invalidation?.status === 'in-progress')
-        return 'warning';
     if (model.orchestration.status === 'paused')
         return 'warning';
     if (model.orchestration.status === 'running')
@@ -399,21 +388,6 @@ function buildFromResolved(input) {
     const run = input.run ?? makeRunner(input.repoRoot);
     const artifacts = enumerateArtifacts(input.taskDir);
     const workflow = collectWorkflow(content, input.now);
-    const invalidation = parseInvalidationDocument(content);
-    const rework = parseReworkIntentDocument(content);
-    const pendingIntents = rework.ok ? rework.intents.filter((intent) => intent.status === 'pending').length : 0;
-    const invalidationInfo = !invalidation.ok
-        ? { status: 'invalid', processed: 0, total: 0, pendingIntents }
-        : {
-            status: invalidation.present
-                ? invalidationBlocks(invalidation.document)
-                    ? invalidation.document.operations.some((operation) => operation.status === 'in-progress') ? 'in-progress' : 'pending'
-                    : 'completed'
-                : 'none',
-            processed: invalidation.document.operations.reduce((sum, operation) => sum + operation.processed, 0),
-            total: invalidation.document.operations.reduce((sum, operation) => sum + operation.total, 0),
-            pendingIntents
-        };
     const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
     const next = facts.ok ? recommendNext(facts.facts) : null;
     const recommendation = next?.action ?? DASH;
@@ -427,7 +401,6 @@ function buildFromResolved(input) {
         workflow,
         runtime: collectRuntime(input.taskDir, workflow, run),
         orchestration: collectOrchestration(input.taskDir),
-        invalidation: invalidationInfo,
         recommendation,
         recommendationReason: next?.reasonCode ?? 'TASK_CAPABILITY_FACTS_INVALID',
         lifecyclePath: facts.ok && facts.facts.pathState?.status === 'valid' ? facts.facts.pathState.decision.path : facts.ok ? facts.facts.pathState?.status ?? DASH : DASH,

package/dist/lib/task/commit-identity.js

@@ -6,19 +6,34 @@ function gitText(repoRoot, args) {
         stdio: ['ignore', 'pipe', 'pipe']
     }).trim();
 }
+function gitOutput(repoRoot, args) {
+    return execFileSync('git', [...args], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+}
+function commitPaths(repoRoot, head, pathspec) {
+    const args = ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', head];
+    if (pathspec && pathspec.length > 0)
+        args.push('--', ...pathspec);
+    return gitOutput(repoRoot, args).split('\0').filter(Boolean).sort();
+}
+function canonicalMessage(message) {
+    return message.replace(/\r\n/g, '\n').replace(/\n+$/, '');
+}
 function checkpointCommitMatches(repoRoot, intent, head) {
     try {
         const parent = gitText(repoRoot, ['rev-parse', `${head}^`]);
         const tree = gitText(repoRoot, ['rev-parse', `${head}^{tree}`]);
-        const message = gitText(repoRoot, ['show', '-s', '--format=%s', head]);
-        const changed = gitText(repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head])
-            .split('\n')
-            .filter(Boolean)
-            .sort();
+        const message = canonicalMessage(gitOutput(repoRoot, ['show', '-s', '--format=%B', head]));
+        const changed = commitPaths(repoRoot, head);
+        const selected = commitPaths(repoRoot, head, intent.paths);
         return parent === intent.expectedHead
             && tree === intent.expectedTree
-            && message === intent.message
-            && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
+            && message === canonicalMessage(intent.message)
+            && changed.length > 0
+            && JSON.stringify(changed) === JSON.stringify(selected);
     }
     catch {
         return false;