@fitlab-ai/agent-infra 0.11.3 → 0.11.5

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

@@ -8,7 +8,9 @@ import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, sha256File } from './artifact-receipts.js';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
-import { validateQualificationAudit } from './qualification-audit.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
+import { parseReworkIntentDocument } from './rework-intent.js';
+import { selectArtifactDisposition } from './artifact-selection.js';
 const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
 const ARTIFACT_STEPS = {
     analysis: 'Analyze Task', 'review-analysis': 'Review Analysis',
@@ -27,6 +29,14 @@ export function hasOpenArtifactRound(content, family, round) {
     const expected = new RegExp(`^${step} \\(Round ${round}${qualifier}\\)$`);
     return startedBackedRows(pairEntries(activity.entries)).filter((row) => expected.test(row.step) && !row.done).length === 1;
 }
+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 BLOCKING_DIAGNOSTICS = new Set([
     'NONCANONICAL_NAME', 'ROUND_OUT_OF_RANGE', 'MISSING_BASE', 'ROUND_GAP',
     'DUPLICATE_LOGICAL_ROUND', 'NON_REGULAR_FILE', 'SYMBOLIC_LINK',
@@ -205,15 +215,29 @@ function resolveCodeInputReceipt(taskDir, code) {
     }
     if (!receipt || receipt.event !== 'code.completed')
         return null;
-    const plan = inspectArtifactDirectory(taskDir, 'plan');
-    if (plan.status !== 'ready')
+    const identity = parseArtifactName(receipt.input);
+    if (!identity || !['analysis', 'plan'].includes(identity.family))
+        return null;
+    const source = inspectArtifactDirectory(taskDir, identity.family);
+    if (source.status !== 'ready')
         return null;
-    const input = plan.artifacts.find((artifact) => artifact.name === receipt.input);
+    const input = source.artifacts.find((artifact) => artifact.name === receipt.input);
     return input ? { input, inputSha256: receipt.inputSha256 } : null;
 }
 function resolveCodePlanInput(taskDir, code) {
     return resolveCodeInputReceipt(taskDir, code);
 }
+function lifecyclePathState(taskDir) {
+    const analysis = inspectArtifactDirectory(taskDir, 'analysis');
+    if (analysis.status !== 'ready' || !analysis.latest)
+        return { status: 'missing', decision: null, message: 'analysis artifact is missing' };
+    try {
+        return parseLifecyclePathDecision(fs.readFileSync(analysis.latest.path, 'utf8'), analysis.latest.name, sha256File(analysis.latest.path));
+    }
+    catch (error) {
+        return { status: 'invalid', decision: null, message: error instanceof Error ? error.message : String(error) };
+    }
+}
 function assertWritableInventory(inventory) {
     if (inventory.status === 'failed')
         return inventory.error;
@@ -227,13 +251,87 @@ const REQUIRED_INPUT = {
     'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan', 'review-code': 'code'
 };
 const OPTIONAL_CONTEXT = {
-    analysis: { family: 'review-analysis', requireReference: true },
-    plan: { family: 'review-plan', requireReference: true },
+    analysis: { family: 'review-analysis' },
+    plan: { family: 'review-plan' },
     'review-code': { family: 'review-plan' },
     'manual-validation': { family: 'review-code' },
     'validation-run': { family: 'review-code' }
 };
-const QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS = new Set(['analysis', 'plan']);
+function hasSelectionEvidence(content, family, options, context) {
+    if (options.sourceFinding && options.sourceArtifact && options.sourceSha256)
+        return true;
+    if (options.reasonCode === 'new-requirement' || options.reasonCode === 'upstream-fact-doubt')
+        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);
+        if (currentInput && context.reviewedInput?.name !== currentInput.name)
+            return true;
+    }
+    const target = family === 'analysis' ? 'analysis' : family === 'plan' ? 'plan' : family === 'code' ? 'code' : null;
+    if (target) {
+        const parsed = parseReworkIntentDocument(content);
+        if (!parsed.ok)
+            throw new Error(`${parsed.code}: ${parsed.message}`);
+        if (parsed.intents.some((intent) => intent.status === 'pending'
+            && (intent.target === target || family === 'analysis' && intent.target === 'plan')))
+            return true;
+    }
+    if (family === 'code') {
+        if (context.latest && context.codeMode?.mode === 'init')
+            return true;
+        if (parseImplementationInputs(content).rows.some((input) => input.needsImplementation && input.status === 'pending'))
+            return true;
+    }
+    return context.inputs.filter((candidate) => candidate.family.startsWith('review-')).some((input) => {
+        const verdict = parseVerdict(input.path);
+        if (!verdict.ok || verdict.verdict !== 'Changes Requested' || !context.latest)
+            return false;
+        const receipt = receiptForOutput(content, input.name);
+        return receipt?.event === reviewEventName(input.family)
+            && receipt.input === context.latest.name
+            && receipt.inputSha256 === sha256File(context.latest.path);
+    });
+}
+function attachArtifactSelection(context, pathState, options) {
+    if (context.status !== 'ready' || !context.taskDir || !context.taskId
+        || (context.family !== 'analysis' && pathState.status !== 'valid'))
+        return context;
+    const family = context.family;
+    const fail = (code, message) => ({
+        ...context, status: 'failed', selection: null, error: { code, message }
+    });
+    if (!context.next)
+        return fail('ARTIFACT_SELECTION_INDETERMINATE', 'artifact inventory did not provide a writable identity');
+    let taskContent;
+    try {
+        taskContent = fs.readFileSync(path.join(context.taskDir, 'task.md'), 'utf8');
+    }
+    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;
+    try {
+        const hasChangeEvidence = hasSelectionEvidence(taskContent, family, options, context);
+        const selection = selectArtifactDisposition({
+            next: { family, round: selectedIdentity.round, name: selectedIdentity.name },
+            latest: context.latest,
+            open,
+            hasChangeEvidence
+        });
+        return {
+            ...context,
+            selection,
+            next: selection.writeRequired ? { round: selection.artifact.round, name: selection.artifact.name } : null
+        };
+    }
+    catch (error) {
+        return fail('ARTIFACT_SELECTION_INDETERMINATE', error instanceof Error ? error.message : String(error));
+    }
+}
 function resolveArtifactContext(taskRef, family, options = {}) {
     const inventory = inspectTaskArtifacts(taskRef, family, options);
     if (inventory.status === 'failed')
@@ -241,8 +339,43 @@ function resolveArtifactContext(taskRef, family, options = {}) {
     const writableError = assertWritableInventory(inventory);
     if (writableError)
         return { ...inventory, status: 'failed', inputs: [], codeMode: null, error: writableError };
-    if (inventory.family === 'code')
-        return resolveCodeContext(inventory, options);
+    const pathState = lifecyclePathState(inventory.taskDir);
+    if (inventory.family !== 'analysis' && pathState.status !== 'valid') {
+        return contextFailure(inventory, 'LIFECYCLE_PATH_INVALID', pathState.message);
+    }
+    if (inventory.family === 'code') {
+        const code = resolveCodeContext(inventory, options);
+        const selected = attachArtifactSelection(code, pathState, options);
+        if (selected.status !== 'ready' || !selected.selection)
+            return selected;
+        if (selected.selection.disposition === 'reuse')
+            return selected;
+        if (selected.codeMode?.mode === 'error') {
+            return {
+                ...selected,
+                status: 'ready',
+                codeMode: {
+                    ...selected.codeMode,
+                    mode: 'init',
+                    message: 'A new implementation round was requested.'
+                },
+                error: null
+            };
+        }
+        if (selected.codeMode?.mode === 'refused') {
+            return {
+                ...selected,
+                status: 'ready',
+                codeMode: {
+                    ...selected.codeMode,
+                    mode: 'init',
+                    message: 'A new implementation round was requested.'
+                },
+                error: null
+            };
+        }
+        return selected;
+    }
     const required = REQUIRED_INPUT[inventory.family];
     const inputs = [];
     if (required) {
@@ -250,98 +383,71 @@ function resolveArtifactContext(taskRef, family, options = {}) {
         if (input.status === 'failed' || !input.latest) {
             return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_INPUT_MISSING', message: `latest ${required} artifact is required` } };
         }
-        const qualificationError = qualificationErrorForArtifact(input.latest);
-        if (qualificationError)
-            return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
         inputs.push(input.latest);
     }
     const optional = OPTIONAL_CONTEXT[inventory.family];
     if (optional) {
         const context = inspectTaskArtifacts(taskRef, optional.family, options);
         if (context.status === 'ready' && context.latest) {
-            if (optional.requireReference && !context.reviewedInput) {
-                return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: `${context.latest.name} has no valid reviewed input` } };
-            }
-            const qualificationError = qualificationErrorForArtifact(context.latest);
-            if (qualificationError && !QUALIFICATION_RECOVERY_OPTIONAL_CONTEXT_CONSUMERS.has(inventory.family)) {
-                return { ...inventory, status: 'failed', inputs, codeMode: null, error: { code: 'ARTIFACT_REFERENCE_INVALID', message: qualificationError } };
-            }
             inputs.push(context.latest);
         }
     }
-    return { ...inventory, inputs, codeMode: null };
-}
-function qualificationErrorForArtifact(artifact) {
-    try {
-        const taskContent = fs.readFileSync(path.join(path.dirname(artifact.path), 'task.md'), 'utf8');
-        const artifactContent = fs.readFileSync(artifact.path, 'utf8');
-        const result = validateQualificationAudit(taskContent, artifactContent);
-        return result.ok ? null : `${result.code}: ${result.message}`;
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : String(error);
+    if (inventory.family === 'manual-validation' || inventory.family === 'validation-run') {
+        return { ...inventory, inputs, codeMode: null };
     }
+    return attachArtifactSelection({ ...inventory, inputs, codeMode: null }, pathState, options);
 }
 function resolveCodeContext(inventory, options) {
     const taskRef = inventory.requestRef;
-    const plan = inspectTaskArtifacts(taskRef, 'plan', options);
-    if (plan.status === 'failed' || !plan.latest)
-        return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', 'latest plan artifact is required');
-    const reviewPlan = inspectTaskArtifacts(taskRef, 'review-plan', options);
+    const pathState = lifecyclePathState(inventory.taskDir);
+    if (pathState.status !== 'valid')
+        return contextFailure(inventory, 'LIFECYCLE_PATH_INVALID', pathState.message);
+    const inputFamily = pathState.decision.path === 'streamlined' ? 'analysis' : 'plan';
+    const source = inspectTaskArtifacts(taskRef, inputFamily, 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);
     const latestCode = inventory.latest;
     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);
+    const inputs = [source.latest];
     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`);
+        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 verdict = parseVerdict(reviewPlan.latest.path);
-        if (!verdict.ok)
-            return contextFailure(inventory, 'ARTIFACT_VERDICT_INVALID', `${verdict.code}: ${verdict.message}`, reviewPlan.latest.name);
-        if (verdict.verdict !== 'Approved') {
-            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `latest ${reviewPlan.latest.name} is not approved`, reviewPlan.latest.name);
+        catch (error) {
+            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
         }
+    }
+    if (!latestCode) {
         return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, null, null, 'No prior code artifact. Starting initial implementation (round 1 -> code.md).');
     }
     const codePlanInput = resolveCodePlanInput(inventory.taskDir, latestCode);
     if (!codePlanInput) {
-        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `code completion receipt for ${latestCode.name} is missing or does not match the current plan`, latestCode.name);
-    }
-    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);
-        const reviewedPlanSha256 = sha256File(reviewPlan.reviewedInput.path);
-        if (verdict.ok && verdict.verdict === 'Approved' && (codePlanInput.input.name !== plan.latest.name || codePlanInput.inputSha256 !== reviewedPlanSha256)) {
-            return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
-        }
+        return withCodeMode(inventory, inputs, 'ready', 'error', codeMax, reviewMax, null, null, `Code input receipt for ${latestCode.name} is unavailable.`);
+    }
+    const currentInputSha256 = sha256File(source.latest.path);
+    if (codePlanInput.input.name !== source.latest.name || codePlanInput.inputSha256 !== currentInputSha256) {
+        return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, null, null, `Latest ${source.latest.name} is not captured by the latest code input receipt. Entering replan-driven init.`);
     }
     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);
+        return withCodeMode(inventory, inputs, 'ready', 'error', codeMax, reviewMax, null, expected, `${expected} is required before another code round`);
     }
     const review = reviewCode.latest;
     if (!review)
@@ -349,18 +455,31 @@ function resolveCodeContext(inventory, options) {
     const verdict = parseVerdict(review.path);
     if (!verdict.ok)
         return contextFailure(inventory, 'ARTIFACT_VERDICT_INVALID', `${verdict.code}: ${verdict.message}`, review.name);
-    if (verdict.verdict === 'Approved') {
-        const decision = resolveDecisionImplementationInput(inventory, review);
-        if ('error' in decision)
-            return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', decision.error, review.name);
-        if (decision.input) {
-            return withCodeMode(inventory, [...inputs, review], 'ready', 'decision', codeMax, reviewMax, verdict.verdict, review.name, `Implementation input ${decision.input.id} requires a new code round.`, decision.input.id, decision.input.ledgerId, decision.input.decisionEvidence);
+    const decision = resolveDecisionImplementationInput(inventory, review);
+    if ('error' in decision)
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', decision.error, review.name);
+    if (decision.input) {
+        return withCodeMode(inventory, [...inputs, review], 'ready', 'decision', codeMax, reviewMax, verdict.verdict, review.name, `Implementation input ${decision.input.id} requires a new code round.`, decision.input.id, decision.input.ledgerId, decision.input.decisionEvidence);
+    }
+    try {
+        const taskContent = fs.readFileSync(path.join(inventory.taskDir, 'task.md'), 'utf8');
+        const rework = parseReworkIntentDocument(taskContent);
+        const reviewSha256 = sha256File(review.path);
+        if (rework.ok && rework.intents.some((intent) => intent.status === 'pending'
+            && intent.target === 'code'
+            && intent.sourceArtifact === review.name
+            && intent.sourceSha256 === reviewSha256)) {
+            return withCodeMode(inventory, [...inputs, review], 'ready', 'fix', codeMax, reviewMax, verdict.verdict, review.name, `Pending rework evidence requires a new code round after ${review.name}.`);
         }
     }
-    if (verdict.verdict === 'Approved' || verdict.verdict === 'Rejected') {
-        return withCodeMode(inventory, [...inputs, review], 'refused', 'refused', codeMax, reviewMax, verdict.verdict, review.name, verdict.verdict === 'Approved'
-            ? `Latest ${review.name} verdict is Approved with no findings. Nothing to fix. Run /commit to proceed.`
-            : `Latest ${review.name} verdict is Rejected. Re-plan before re-running code-task.`);
+    catch (error) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error), review.name);
+    }
+    if (verdict.verdict === 'Approved') {
+        return withCodeMode(inventory, [...inputs, review], 'ready', 'refused', codeMax, reviewMax, verdict.verdict, review.name, `Latest ${review.name} verdict is Approved with no findings. Nothing to fix. Run /commit to proceed.`);
+    }
+    if (verdict.verdict === 'Rejected') {
+        return withCodeMode(inventory, [...inputs, review], 'ready', 'refused', codeMax, reviewMax, verdict.verdict, review.name, `Latest ${review.name} verdict is Rejected. Re-plan before re-running code-task.`);
     }
     return withCodeMode(inventory, [...inputs, review], 'ready', 'fix', codeMax, reviewMax, verdict.verdict, review.name, `Latest ${review.name} requires or permits fixes. Entering fix mode.`);
 }
@@ -439,8 +558,21 @@ export function validateArtifactPublication(taskDir, family, name) {
     const error = assertWritableInventory(inventory);
     if (error)
         return error;
-    if (inventory.next?.name === name || inventory.artifacts.some((artifact) => artifact.name === name))
+    if (inventory.next?.name === name)
         return null;
+    const existing = inventory.artifacts.find((artifact) => artifact.name === name);
+    if (existing) {
+        try {
+            const task = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+            if (hasCompletedArtifactRound(task, family, existing.round, name)) {
+                return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completed artifact '${name}' is immutable` };
+            }
+        }
+        catch (error) {
+            return { code: 'ARTIFACT_SELECTION_INDETERMINATE', message: error instanceof Error ? error.message : String(error) };
+        }
+        return null;
+    }
     return { code: 'ARTIFACT_IDENTITY_INVALID', message: `artifact '${name}' is not a current or next ${family} slot` };
 }
 function buildArtifactLinkSection(content, artifact) {

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

@@ -6,7 +6,6 @@ import { parseArtifactName } from './artifact-name.js';
 import { scanVisibleMarkdown } from './markdown.js';
 import { getArtifactSchema, renderArtifactSkeleton } from './artifact-schema.js';
 import { withTaskExecutionLock } from './task-execution-lock.js';
-import { buildQualificationAudit, expectedQualificationRelations, parseTaskQualification, renderQualificationAudit } from './qualification-audit.js';
 function sha256Content(content) {
     return createHash('sha256').update(content, 'utf8').digest('hex');
 }
@@ -167,10 +166,44 @@ function inspectArtifactPatterns(content, schema) {
         diagnostics
     };
 }
-function inspectArtifactContract(content, schema) {
+function inspectArtifactStateCheck(content, schema, scopeToStateCheckSection) {
+    const stateCheck = schema.sections.find((section) => section.id === 'state-check');
+    if (!stateCheck || schema.stateCheckPatterns.length === 0) {
+        return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };
+    }
+    if (!scopeToStateCheckSection) {
+        const diagnostics = schema.stateCheckPatterns
+            .filter((pattern) => !new RegExp(pattern, 'm').test(content))
+            .map((pattern) => diagnostic('ARTIFACT_STATE_CHECK_PATTERN_MISSING', `artifact is missing required state-check command '${pattern}'`, stateCheck.id, null));
+        return {
+            ok: diagnostics.length === 0,
+            family: schema.family,
+            semanticDigest: canonicalSemanticDigest(content),
+            diagnostics
+        };
+    }
+    const scanned = scanVisibleMarkdown(content);
+    const headings = scanned.headings.filter((heading) => (heading.level === 2 && sectionHeadings(schema, stateCheck).includes(heading.text)));
+    if (headings.length !== 1) {
+        return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };
+    }
+    const bodyBounds = sectionBodyBounds(content, headings[0], scanned);
+    const body = content.slice(bodyBounds.start, bodyBounds.end);
+    const diagnostics = schema.stateCheckPatterns
+        .filter((pattern) => !new RegExp(pattern, 'm').test(body))
+        .map((pattern) => diagnostic('ARTIFACT_STATE_CHECK_PATTERN_MISSING', `state-check section is missing required command '${pattern}'`, stateCheck.id, lineNumber(content, headings[0].start)));
+    return {
+        ok: diagnostics.length === 0,
+        family: schema.family,
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
+    };
+}
+function inspectArtifactContract(content, schema, options = {}) {
     const structure = inspectArtifactStructure(content, schema);
+    const stateCheck = inspectArtifactStateCheck(content, schema, options.scopeStateCheckSection === true);
     const patterns = inspectArtifactPatterns(content, schema);
-    const diagnostics = [...structure.diagnostics, ...patterns.diagnostics];
+    const diagnostics = [...structure.diagnostics, ...stateCheck.diagnostics, ...patterns.diagnostics];
     return {
         ok: diagnostics.length === 0,
         family: schema.family,
@@ -194,27 +227,6 @@ function artifactRound(family, artifact) {
     const identity = parseArtifactName(artifact);
     return identity?.family === family ? identity.round : null;
 }
-function qualificationAuditForInit(request) {
-    let taskContent;
-    try {
-        taskContent = readStableFileSync(path.join(request.taskDir, 'task.md'), { maxBytes: 1024 * 1024 }).bytes.toString('utf8');
-    }
-    catch (error) {
-        return { ok: false, code: 'ARTIFACT_INIT_TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error) };
-    }
-    const qualification = parseTaskQualification(taskContent);
-    if (!qualification.ok)
-        return qualification;
-    if (!qualification.qualification.present)
-        return { ok: true, content: '' };
-    const relations = expectedQualificationRelations(taskContent, request.family);
-    if (!relations.ok)
-        return relations;
-    const audit = buildQualificationAudit(taskContent, { upstreamRelations: relations.relations ?? [] });
-    if (!audit.ok)
-        return audit;
-    return { ok: true, content: `\n## 资格审计\n\n${renderQualificationAudit(audit.audit)}\n` };
-}
 function initializeArtifactSkeleton(request) {
     const schema = getArtifactSchema(request.family);
     if (!schema)
@@ -244,10 +256,7 @@ function initializeArtifactSkeleton(request) {
                 artifact: request.artifact,
                 ...(request.locale ? { locale: request.locale } : {})
             });
-            const audit = qualificationAuditForInit(request);
-            if (!audit.ok)
-                return resultFailure(audit.code, audit.message);
-            const content = `${skeleton.trimEnd()}${audit.content}`;
+            const content = skeleton.trimEnd();
             const tempPath = path.join(request.taskDir, `.${request.artifact}.init-${process.pid}-${Date.now()}.tmp`);
             try {
                 fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600, flag: 'wx' });

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

@@ -36,7 +36,10 @@ function validateReceiptShape(event, output, input) {
     if (!outputIdentity || !inputIdentity)
         throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
     const shape = RECEIPT_SHAPES[event];
-    if (outputIdentity.family !== shape.output || inputIdentity.family !== shape.input) {
+    const inputMatches = event === 'code.completed'
+        ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan'
+        : inputIdentity.family === shape.input;
+    if (outputIdentity.family !== shape.output || !inputMatches) {
         throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
     }
 }

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

@@ -7,6 +7,7 @@ const LOCAL_SECTIONS = {
         ['impact', '影响评估', 'Impact Assessment'],
         ['risks', '技术风险', 'Technical Risks'],
         ['effort', '工作量和复杂度评估', 'Effort and Complexity Assessment'],
+        ['flow-decision', '流程裁定', 'Flow Decision'],
         ['state-check', '状态核对', 'State Check']
     ],
     plan: [
@@ -80,21 +81,21 @@ function buildSections(family) {
         marker: `artifact-section:${family}:${id}`
     }));
 }
+const TASK_SNAPSHOT_PATTERN = 'agent-infra-internal[ \\t]+task-snapshot\\b';
 const ARTIFACT_SCHEMAS = [
-    { family: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), requiredPatterns: ['^\\$ '] },
-    { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
-    { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), requiredPatterns: ['^\\$ '] },
-    { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
-    { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), requiredPatterns: ['^\\$ '] },
+    { family: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+    { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+    { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+    { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+    { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
     { family: 'review-code', title: { zh: '代码审查报告', en: 'Code Review Report' }, sections: buildSections('review-code'), requiredPatterns: [
             '^### (?:审查决定|Approval Decision)$',
-            '^\\$ ',
             '^- \\*\\*(?:总体结论|Overall Verdict)\\*\\*[:：]\\s*(?:通过|需要修改|拒绝|Approved|Changes Requested|Rejected)\\s*$',
             '^- \\*\\*(?:审查基线提交|Review Baseline Commit)\\*\\*[:：]\\s*\\S',
             '^- \\*\\*(?:审查差异基线|Reviewed Diff Base)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$',
             '^- \\*\\*(?:审查差异指纹|Reviewed Diff Fingerprint)\\*\\*[:：]\\s*sha256:[0-9a-f]{64}\\s*$',
             '^- \\*\\*(?:审查快照树|Reviewed Snapshot Tree)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$'
-        ] }
+        ], stateCheckPatterns: [TASK_SNAPSHOT_PATTERN] }
 ];
 function getArtifactSchema(family) {
     return ARTIFACT_SCHEMAS.find((schema) => schema.family === family) ?? null;

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

@@ -0,0 +1,25 @@
+function selectArtifactDisposition(request) {
+    if (request.open) {
+        return {
+            disposition: 'resume', reasonCode: 'open-round', artifact: request.next,
+            writeRequired: true
+        };
+    }
+    if (!request.latest) {
+        return {
+            disposition: 'create',
+            reasonCode: request.next.round === 1 ? 'no-history' : 'invalidated-history',
+            artifact: request.next, writeRequired: true
+        };
+    }
+    const reasonCode = request.hasChangeEvidence ? 'change-evidence' : 'history-matched';
+    const reuse = reasonCode === 'history-matched';
+    return {
+        disposition: reuse ? 'reuse' : 'create',
+        reasonCode,
+        artifact: reuse ? request.latest : request.next,
+        writeRequired: !reuse
+    };
+}
+export { selectArtifactDisposition };
+//# sourceMappingURL=artifact-selection.js.map