@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/dist/lib/sandbox/control/task-view.js

@@ -13,11 +13,10 @@ function receiptIdentity(value, generation, requestId) {
     if (!binding || typeof binding !== 'object' || Array.isArray(binding))
         return null;
     const controlBinding = binding;
-    if (receipt.version !== 3 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
+    if (receipt.version !== 4 || typeof receipt.receiptId !== 'string' || receipt.receiptId.length === 0
         || !Number.isSafeInteger(receipt.revision) || receipt.revision < 0
         || receipt.lifecycle !== 'done'
         || !['pending', 'done', 'skipped'].includes(String(receipt.summary))
-        || !['pending', 'done', 'skipped'].includes(String(receipt.postSummaryVerification))
         || controlBinding.generation !== generation
         || typeof controlBinding.requestId !== 'string'
         || !/^[a-f0-9-]{16,64}$/u.test(controlBinding.requestId)

package/dist/lib/sandbox/task-cleanup.js

@@ -8,7 +8,6 @@ import { enumerateAllTaskDirs } from '../task/resolve-ref.js';
 import { resolveSandboxCleanupTarget } from './workspace-identity.js';
 import { readSandboxControlManifest } from './control/lifecycle.js';
 import { readJsonFile, readSandboxControlStatus } from './control/state.js';
-import { finalizationTerminalResponse } from './control/finalization-response.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 function matchingControlManifest(repoRoot, controlRoot, taskId, binding) {
     if (!controlRootIdentity(controlRoot))
@@ -77,11 +76,9 @@ function canonicalPath(input) {
         return path.resolve(input);
     }
 }
-function taskFinalizationReceiptComplete(receipt, taskId, binding) {
+function taskFinalizationReceiptComplete(receipt, taskId) {
     return receipt.taskId === taskId
-        && taskFinalizationReceiptState(receipt) === 'complete'
-        && receipt.controlBinding?.generation === binding.generation
-        && receipt.controlBinding.requestId === binding.requestId;
+        && taskFinalizationReceiptState(receipt) === 'complete';
 }
 function terminalControlBindingEvidence(repoRootInput, controlRootInput, taskId, binding) {
     const repoRoot = canonicalPath(repoRootInput);
@@ -105,26 +102,22 @@ function terminalControlBindingEvidence(repoRootInput, controlRootInput, taskId,
                 return false;
         }
         const receipt = readTaskFinalizationReceipt(repoRoot, taskId);
-        if (!receipt || !taskFinalizationReceiptComplete(receipt, taskId, binding)) {
+        if (!receipt || !taskFinalizationReceiptComplete(receipt, taskId)) {
             return false;
         }
-        const status = readSandboxControlStatus(manifest.publicStatusDir);
-        const viewReceipt = status.taskView.receipt;
-        const terminalTaskView = (status.taskView.state === 'current' && status.taskView.observedSource === 'completed')
-            || (status.taskView.state === 'finalized-stale' && status.taskView.observedSource === 'active');
-        if (status.generation !== binding.generation || status.state !== 'healthy'
-            || status.activeRequestId !== null || !terminalTaskView || status.taskView.taskId !== taskId
-            || !viewReceipt || viewReceipt.generation !== binding.generation
-            || viewReceipt.requestId !== binding.requestId
-            || viewReceipt.receiptId !== receipt.receiptId
-            || viewReceipt.revision !== receipt.revision)
-            return false;
         const responsePath = path.join(manifest.channelDir, 'responses', `${binding.requestId}.json`);
         if (!inspectOwnedPath(path.join(controlRoot, 'channel'), responsePath, 'file'))
             return false;
         const actual = readJsonFile(responsePath);
-        const expected = finalizationTerminalResponse(taskId, binding.requestId, receipt);
-        return JSON.stringify(actual) === JSON.stringify(expected);
+        const response = actual;
+        if (response.version !== 2 || response.id !== binding.requestId || response.phase !== 'completed'
+            || response.exitCode !== 0 || typeof response.stdout !== 'string')
+            return false;
+        const envelope = JSON.parse(response.stdout);
+        const result = envelope.result;
+        return envelope.status === 'completed' && envelope.accepted === true
+            && result !== null && typeof result === 'object'
+            && result.status === 'completed' && result.taskId === taskId;
     }
     catch {
         return false;
@@ -153,7 +146,7 @@ function removedControlBindingEvidence(repoRootInput, journal, taskId, binding)
         return false;
     try {
         const receipt = readTaskFinalizationReceipt(repoRoot, taskId);
-        return receipt !== null && taskFinalizationReceiptComplete(receipt, taskId, binding);
+        return receipt !== null && taskFinalizationReceiptComplete(receipt, taskId);
     }
     catch {
         return false;

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

@@ -13,7 +13,7 @@ export function parseArtifactCommand(args) {
     }
     const fields = {};
     const allowed = {
-        inspect: ['--family'],
+        inspect: ['--family', '--source-finding', '--source-artifact', '--source-sha256'],
         init: ['--family', '--artifact', '--locale'],
         'preflight': ['--family', '--artifact'],
         'finalize-local': ['--family', '--artifact']
@@ -37,8 +37,10 @@ export function parseArtifactCommand(args) {
     if (locale !== undefined && locale !== 'zh-CN' && locale !== 'en')
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
     return {
-        taskRef, operation: operation, family: fields['--family'],
-        artifact: fields['--artifact'] ?? '', locale
+        taskRef, operation: operation, family: fields['--family'] ?? '',
+        artifact: fields['--artifact'] ?? '', locale,
+        sourceFinding: fields['--source-finding'], sourceArtifact: fields['--source-artifact'],
+        sourceSha256: fields['--source-sha256']
     };
 }
 /** Resolve authoritative task metadata separately from a trusted candidate directory. */
@@ -46,7 +48,12 @@ export function executeArtifactCommand(command, options = {}) {
     const { taskRef, operation, family, artifact, locale } = command;
     const fail = (code, message) => ({ status: 'failed', changed: false, error: { code, message } });
     if (operation === 'inspect') {
-        const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
+        const result = resolveArtifactContext(taskRef, family, {
+            repoRoot: options.repoRoot,
+            sourceFinding: command.sourceFinding,
+            sourceArtifact: command.sourceArtifact,
+            sourceSha256: command.sourceSha256
+        });
         return family === 'code' && result.codeMode ? {
             ...result, mode: result.codeMode.mode, code_max: result.codeMode.codeMax, rev_max: result.codeMode.reviewMax,
             verdict: result.codeMode.verdict, next_round: result.next?.round ?? null, next_artifact: result.next?.name ?? null,

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');
 }
@@ -194,27 +193,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 +222,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: [

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