@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/dist/lib/task/ledger-intents.js

@@ -7,7 +7,10 @@ import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SE
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
 import { allowsManualOverride } from './guard-override.js';
-import { parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
+import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
+import { extractSection, extractSubSection } from './sections.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
+import { scanVisibleMarkdown } from './markdown.js';
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
@@ -23,15 +26,50 @@ function ledgerReadErrorCode(error) {
         return code;
     return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
 }
-function maxHandshakeRounds(repoRoot) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
-        const value = parsed.review?.maxHandshakeRounds;
-        return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 3;
-    }
-    catch {
-        return 3;
+const CLASSIFICATION_TARGET = {
+    'scope-or-requirement': 'analysis', design: 'plan', implementation: 'code',
+    'human-decision': 'pause', 'insufficient-evidence': 'pause'
+};
+function semanticDigest(value) {
+    return createHash('sha256').update(value.normalize('NFKC').replace(/\s+/g, ' ').trim()).digest('hex');
+}
+function normalizedTaskFact(value) {
+    return value.normalize('NFKC').replace(/\s+/g, ' ').trim();
+}
+function semanticFindingEvidence(reviewContent, heading, end) {
+    const title = heading.text.replace(/^\d+[.、：:]\s*/, '').trim();
+    return `${title}\n${reviewContent.slice(heading.end, end)}`;
+}
+function findingEvidence(reviewContent, evidence) {
+    const anchor = evidence.split('#')[1];
+    if (!anchor)
+        return null;
+    const markdown = scanVisibleMarkdown(reviewContent);
+    const explicit = markdown.anchors.find((candidate) => candidate.id === anchor);
+    if (explicit) {
+        const heading = markdown.headings.find((candidate) => candidate.start > explicit.start);
+        const next = heading && markdown.headings.find((candidate) => candidate.start > heading.start && candidate.level <= heading.level);
+        const end = next?.start ?? reviewContent.length;
+        return heading ? semanticFindingEvidence(reviewContent, heading, end) : reviewContent.slice(explicit.end, end);
     }
+    const heading = markdown.headings.find((candidate) => {
+        const escapedAnchor = anchor.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return candidate.text === anchor || new RegExp(`^${escapedAnchor}(?:\\s|[.、：:])`).test(candidate.text);
+    });
+    if (!heading)
+        return null;
+    const next = markdown.headings.find((candidate) => candidate.start > heading.start && candidate.level <= heading.level);
+    return semanticFindingEvidence(reviewContent, heading, next?.start ?? reviewContent.length);
+}
+function taskFactDigest(taskDir, content) {
+    const analysisNames = fs.readdirSync(taskDir).filter((name) => /^analysis(?:-r\d+)?\.md$/.test(name));
+    const latest = analysisNames.map((name) => ({ name, round: parseArtifactName(name)?.round ?? 0 })).sort((a, b) => b.round - a.round)[0];
+    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latest.name), 'utf8')) : null;
+    return semanticDigest(JSON.stringify({
+        taskInput: normalizedTaskFact(extractSection(content, ['任务输入', 'Task Input'])),
+        requirements: normalizedTaskFact(extractSection(content, ['需求', 'Requirements'])),
+        flow: flow?.status === 'valid' ? flow.decision.semanticDigest : flow?.status ?? 'missing'
+    }));
 }
 function nextFindingId(rows, stage) {
     const prefix = PREFIX[stage];
@@ -89,12 +127,15 @@ function applyLedgerIntent(intent, options = {}) {
         return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: nextHdId(rows), before: null, after: null, operations: [], error: null };
     }
     if (intent.kind === 'rework-intent-upsert') {
-        if (!/^RI-[1-9]\d*$/.test(intent.intentId) || !/^(AN|PL|CD)-[1-9]\d*$/.test(intent.findingId) || !['analysis', 'plan', 'code'].includes(intent.target) || !/^[a-f0-9]{64}$/.test(intent.sourceSha256)) {
-            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rework intent identity, target, or source hash is invalid', resolved.taskId, intent.intentId);
+        if (!/^RI-[1-9]\d*$/.test(intent.intentId) || !/^(AN|PL|CD)-[1-9]\d*$/.test(intent.findingId) || !(intent.classification in CLASSIFICATION_TARGET) || !/^[a-f0-9]{64}$/.test(intent.sourceSha256)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rework intent identity, classification, or source hash is invalid', resolved.taskId, intent.intentId);
         }
         const finding = rows.find((row) => row.id === intent.findingId);
         if (!finding || finding.severity === 'decision')
             return failed(intent, 'LEDGER_NOT_FOUND', `finding '${intent.findingId}' was not found`, resolved.taskId, intent.findingId);
+        if (intent.classification === 'human-decision' && finding.status !== 'needs-human-decision') {
+            return failed(intent, 'LEDGER_TRANSITION_INVALID', 'human-decision classification requires a needs-human-decision finding', resolved.taskId, intent.findingId);
+        }
         const sourceFromEvidence = finding.evidence.split('#')[0];
         if (sourceFromEvidence !== intent.sourceArtifact || parseArtifactName(intent.sourceArtifact)?.family !== `review-${finding.stage}`) {
             return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact does not match finding evidence', resolved.taskId, intent.intentId);
@@ -106,12 +147,35 @@ function applyLedgerIntent(intent, options = {}) {
             const parsed = parseReworkIntentDocument(content);
             if (!parsed.ok)
                 return failed(intent, parsed.code, parsed.message, resolved.taskId, intent.intentId);
-            const nextIntent = {
+            const reviewContent = fs.readFileSync(path.join(resolved.taskDir, intent.sourceArtifact), 'utf8');
+            const evidenceBlock = findingEvidence(reviewContent, finding.evidence);
+            if (!evidenceBlock)
+                return failed(intent, 'LEDGER_EVIDENCE_INVALID', `finding evidence anchor '${finding.evidence}' was not found`, resolved.taskId, intent.intentId);
+            const evidenceDigest = semanticDigest(evidenceBlock);
+            const factsDigest = taskFactDigest(resolved.taskDir, content);
+            const requestedIntent = {
                 intentId: intent.intentId, findingId: intent.findingId, sourceArtifact: intent.sourceArtifact,
-                sourceSha256: intent.sourceSha256, target: intent.target, status: 'pending',
+                sourceSha256: intent.sourceSha256, target: CLASSIFICATION_TARGET[intent.classification], classification: intent.classification,
+                evidenceDigest, taskFactDigest: factsDigest, status: 'pending',
                 declaredAt: new Date().toISOString(), consumedAt: ''
             };
-            const next = upsertReworkIntent(parsed.intents, nextIntent);
+            if (parsed.intents.some((candidate) => candidate.intentId === intent.intentId)) {
+                const replay = upsertReworkIntent(parsed.intents, requestedIntent);
+                if (!replay.changed) {
+                    return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: intent.intentId, before: null, after: null, operations: [], error: null };
+                }
+            }
+            const same = parsed.intents.find((candidate) => candidate.findingId === intent.findingId
+                && candidate.evidenceDigest === evidenceDigest && candidate.taskFactDigest === factsDigest
+                && candidate.classification === intent.classification && candidate.target === CLASSIFICATION_TARGET[intent.classification]);
+            const classification = same ? 'insufficient-evidence' : intent.classification;
+            const nextIntent = {
+                ...requestedIntent, target: CLASSIFICATION_TARGET[classification], classification
+            };
+            const now = nextIntent.declaredAt;
+            const superseded = parsed.intents.map((candidate) => candidate.status === 'pending'
+                ? { ...candidate, status: 'superseded', consumedAt: now } : candidate);
+            const next = upsertReworkIntent(superseded, nextIntent);
             if (!next.changed)
                 return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: intent.intentId, before: null, after: null, operations: [], error: null };
             const result = writeTask({ taskRef: intent.taskRef, expectedState: 'active', dryRun: intent.dryRun, mutations: [reworkIntentMutation(content, next.intents)] }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
@@ -123,6 +187,84 @@ function applyLedgerIntent(intent, options = {}) {
             return failed(intent, 'LEDGER_IDENTITY_CONFLICT', error instanceof Error ? error.message : String(error), resolved.taskId, intent.intentId);
         }
     }
+    if (intent.kind === 'rework-intent-rebuild') {
+        const beforeSha256 = createHash('sha256').update(content).digest('hex');
+        const supplied = [intent.findingId, intent.sourceArtifact, intent.sourceSha256, intent.classification].filter((value) => value !== undefined).length;
+        if (supplied !== 0 && supplied !== 4)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rebuild binding options must be provided together', resolved.taskId);
+        const current = parseReworkIntentDocument(content);
+        if (current.ok && current.present) {
+            if (supplied !== 0)
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'current rework intent format does not accept rebuild binding options', resolved.taskId);
+            return {
+                status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: null,
+                before: null, after: null, operations: [], error: null,
+                rebuild: { mode: 'format-only', beforeSha256, afterSha256: beforeSha256, converted: current.intents.length, newIntentId: null }
+            };
+        }
+        const legacy = parseLegacyReworkIntentDocument(content);
+        if (!legacy.ok)
+            return failed(intent, legacy.code, legacy.message, resolved.taskId);
+        const pending = legacy.intents.filter((row) => row.status === 'pending');
+        if (pending.length === 0 && supplied !== 0)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'format-only rebuild does not accept finding or classification options', resolved.taskId);
+        if (pending.length > 0 && supplied !== 4)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'legacy pending intents require finding, review, hash, and classification', resolved.taskId);
+        const now = new Date().toISOString();
+        let next = legacy.intents.map((row) => row.status === 'pending' ? { ...row, status: 'superseded', consumedAt: now } : row);
+        let entityId = null;
+        if (pending.length > 0) {
+            const finding = rows.find((row) => row.id === intent.findingId);
+            if (!finding || finding.severity === 'decision' || finding.evidence.split('#')[0] !== intent.sourceArtifact)
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild binding does not match a review finding', resolved.taskId);
+            if (intent.classification === 'human-decision' && finding.status !== 'needs-human-decision') {
+                return failed(intent, 'LEDGER_TRANSITION_INVALID', 'human-decision classification requires a needs-human-decision finding', resolved.taskId);
+            }
+            const sourceIdentity = parseArtifactName(intent.sourceArtifact);
+            const expectedFamily = `review-${finding.stage}`;
+            const latestSource = fs.readdirSync(resolved.taskDir)
+                .map((name) => parseArtifactName(name))
+                .filter((identity) => identity?.family === expectedFamily)
+                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            if (!sourceIdentity || sourceIdentity.family !== expectedFamily || latestSource?.name !== sourceIdentity.name) {
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact is not the latest review for the finding stage', resolved.taskId);
+            }
+            const sourcePath = path.join(resolved.taskDir, intent.sourceArtifact);
+            const actualHash = createHash('sha256').update(fs.readFileSync(sourcePath)).digest('hex');
+            if (actualHash !== intent.sourceSha256)
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact hash does not match', resolved.taskId);
+            const max = next.reduce((value, row) => Math.max(value, Number(row.intentId.slice(3))), 0);
+            entityId = `RI-${max + 1}`;
+            const reviewContent = fs.readFileSync(sourcePath, 'utf8');
+            const classification = intent.classification;
+            if (!(classification in CLASSIFICATION_TARGET))
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rebuild classification is invalid', resolved.taskId);
+            const evidenceBlock = findingEvidence(reviewContent, finding.evidence);
+            if (!evidenceBlock)
+                return failed(intent, 'LEDGER_EVIDENCE_INVALID', `finding evidence anchor '${finding.evidence}' was not found`, resolved.taskId);
+            next = [...next, {
+                    intentId: entityId, findingId: intent.findingId, sourceArtifact: intent.sourceArtifact, sourceSha256: intent.sourceSha256,
+                    target: CLASSIFICATION_TARGET[classification], classification,
+                    evidenceDigest: semanticDigest(evidenceBlock),
+                    taskFactDigest: taskFactDigest(resolved.taskDir, content), status: 'pending', declaredAt: now, consumedAt: ''
+                }];
+        }
+        const result = writeTask({ taskRef: intent.taskRef, expectedState: 'active', dryRun: intent.dryRun, mutations: [reworkIntentMutation(content, next)] }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
+        if (result.status === 'failed')
+            return failed(intent, result.error.code, result.error.message, result.taskId, entityId);
+        const afterContent = result.status === 'applied' || result.status === 'no-op' ? fs.readFileSync(resolved.taskMdPath, 'utf8') : content;
+        return {
+            status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId,
+            before: null, after: null, operations: result.operations, error: null,
+            rebuild: {
+                mode: pending.length > 0 ? 'pending-reclassification' : 'format-only',
+                beforeSha256,
+                afterSha256: createHash('sha256').update(afterContent).digest('hex'),
+                converted: legacy.intents.length,
+                newIntentId: entityId
+            }
+        };
+    }
     let before = null;
     let after;
     if (intent.kind === 'finding-upsert') {
@@ -199,7 +341,7 @@ function applyLedgerIntent(intent, options = {}) {
                         ? new Set(['confirmed', 'open', 'needs-human-decision'])
                         : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
                 const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
-                if (((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot)))
+                if ((!sameRoundMinorClose && !allowed.has(intent.status))
                     && !allowsManualOverride(options.manualOverride, 'ledger-intent', 'LEDGER_TRANSITION_INVALID')) {
                     return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
                 }

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

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { extractSection } from './sections.js';
+const PATH_STAGES = {
+    streamlined: ['analysis', 'code', 'review-code'],
+    standard: ['analysis', 'plan', 'code', 'review-code'],
+    full: ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']
+};
+const FIELD_ALIASES = {
+    path: ['本任务路径', 'Path'],
+    basis: ['判定依据', 'Basis'],
+    unmetHigherConditions: ['未满足的更高路径条件', '未满足的较低路径条件', 'Unmet Higher-path Conditions'],
+    upgradeTriggers: ['升级触发条件', 'Upgrade Triggers']
+};
+function normalizeText(value) {
+    return value.normalize('NFKC').replace(/\s+/g, ' ').trim().replace(/[。.]$/, '');
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function pathToken(value) {
+    const normalized = normalizeText(value).toLowerCase().replace(/[`*_]/g, '');
+    if (/^(?:streamlined|精简路径|精简)$/.test(normalized))
+        return 'streamlined';
+    if (/^(?:standard|标准路径|标准)$/.test(normalized))
+        return 'standard';
+    if (/^(?:full|完整路径|完整)$/.test(normalized))
+        return 'full';
+    return null;
+}
+function fieldValues(body, aliases) {
+    const wanted = new Set(aliases);
+    const values = [];
+    for (const line of body.split(/\r?\n/)) {
+        const match = /^\s*[-*]\s+\*\*([^*]+)\*\*[:：]\s*(.*?)\s*$/.exec(line);
+        if (match && wanted.has(match[1].trim()))
+            values.push(match[2].trim());
+    }
+    return values;
+}
+function parseLifecyclePathDecision(analysisContent, sourceArtifact = '', sourceSha256 = '') {
+    const body = extractSection(analysisContent, ['流程裁定', 'Flow Decision']);
+    if (!body)
+        return { status: 'missing', decision: null, message: 'analysis flow decision section is missing' };
+    const fields = Object.fromEntries(Object.entries(FIELD_ALIASES).map(([key, aliases]) => [key, fieldValues(body, aliases)]));
+    const invalid = Object.entries(fields).find(([, values]) => values.length !== 1);
+    if (invalid)
+        return { status: 'invalid', decision: null, message: `flow decision field '${invalid[0]}' must appear exactly once` };
+    const path = pathToken(fields.path[0]);
+    if (!path)
+        return { status: 'invalid', decision: null, message: `unknown lifecycle path '${fields.path[0]}'` };
+    const basis = normalizeText(fields.basis[0]);
+    const unmetHigherConditions = normalizeText(fields.unmetHigherConditions[0]);
+    const upgradeTriggers = normalizeText(fields.upgradeTriggers[0]);
+    if (!basis || !unmetHigherConditions || !upgradeTriggers)
+        return { status: 'invalid', decision: null, message: 'flow decision fields must be non-empty' };
+    return {
+        status: 'valid',
+        message: null,
+        decision: {
+            path,
+            stages: PATH_STAGES[path],
+            basis,
+            unmetHigherConditions,
+            upgradeTriggers,
+            semanticDigest: digest({ path, basis, unmetHigherConditions, upgradeTriggers }),
+            sourceArtifact,
+            sourceSha256
+        }
+    };
+}
+function pathIncludes(state, stage) {
+    return state?.status === 'valid' && state.decision.stages.includes(stage);
+}
+export { PATH_STAGES, parseLifecyclePathDecision, pathIncludes };
+//# sourceMappingURL=lifecycle-path.js.map

package/dist/lib/task/lifecycle.js

@@ -151,7 +151,7 @@ function actionAndNote(request, restoredFiles = 0) {
     if (request.intent === 'close-dependabot')
         return { action: 'Close Dependabot', note: `Dependabot alert #${request.alertNumber} dismissed: ${request.reason}` };
     if (request.intent === 'recover-started')
-        return { action: 'Recover Started', note: request.reason };
+        return { action: 'Recover Started', note: 'automatic recovery' };
     return { action: 'Restore Task', note: `Restored ${restoredFiles} files from Issue #${request.issueNumber}` };
 }
 function matchingCompletion(content, request, restoredFiles = 0) {
@@ -578,6 +578,16 @@ function applyTaskLifecycle(requestInput, options = {}) {
             return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         }
     }
+    if (options.prepareOnly && !completed.has('directory-moved')) {
+        return {
+            ...failed(request, { code: '', message: '' }), status: 'applied', changed: true, error: null,
+            taskId, sourceState, targetState: spec.target, sourcePath, targetPath,
+            task: { operations: taskOperations }, directory: { effect: 'unchanged', changed: false },
+            shortId: { effect: 'unchanged', shortId: null, changed: false },
+            timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion,
+            journalPath, completedSteps: [...completed], pendingSteps: STEPS.filter((step) => !completed.has(step))
+        };
+    }
     if (fs.existsSync(targetPath) && !fs.existsSync(sourcePath))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {

package/dist/lib/task/local-artifact-finalization.js

@@ -3,9 +3,7 @@ import path from 'node:path';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { scanVisibleMarkdown } from './markdown.js';
 import { parseArtifactName } from './artifact-name.js';
-import { hasOpenArtifactRound, } from './artifact-lifecycle.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
 import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.js';
 import { getArtifactSchema } from './artifact-schema.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
@@ -57,21 +55,6 @@ function validateLocalArtifact(content, options) {
     const decisionDetails = inspectDecisionDetailDuplicates(content);
     if (!decisionDetails.ok)
         diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, line: null });
-    if (options.taskContent !== undefined) {
-        const identity = options.artifact ? parseArtifactName(options.artifact) : null;
-        const expected = identity?.family === options.family && hasOpenArtifactRound(options.taskContent, options.family, identity.round)
-            ? expectedQualificationRelations(options.taskContent, options.family)
-            : undefined;
-        if (expected && !expected.ok)
-            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${expected.code}: ${expected.message}`, line: null });
-        const qualification = validateQualificationAudit(options.taskContent, content, {
-            family: options.family,
-            artifact: options.artifact,
-            expectedUpstreamRelations: expected?.ok ? expected.relations : undefined
-        });
-        if (!qualification.ok)
-            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${qualification.code}: ${qualification.message}`, line: null });
-    }
     return {
         ok: diagnostics.length === 0,
         family: options.family,
@@ -98,10 +81,8 @@ function prepareLocalArtifact(request, candidate) {
     const parsed = parseArtifactName(request.artifact);
     if (!parsed || parsed.family !== request.family)
         return failed('ARTIFACT_IDENTITY_INVALID', `artifact '${request.artifact}' does not match ${request.family}`);
-    let taskContent;
     let content;
     try {
-        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
         const artifactPath = path.join(resolved.taskDir, request.artifact);
         if (!fs.statSync(artifactPath).isFile())
             return failed('ARTIFACT_NOT_REGULAR', `artifact '${request.artifact}' is not a regular file`);
@@ -114,7 +95,7 @@ function prepareLocalArtifact(request, candidate) {
         return failed('ARTIFACT_IDENTITY_INVALID', 'artifact finalization requires an active task');
     }
     const validation = validateLocalArtifact(content, {
-        family: request.family, requiredSections: request.requiredSections, taskContent, artifact: request.artifact
+        family: request.family, requiredSections: request.requiredSections
     });
     const artifactSha256 = sha256Content(content);
     const result = failedFinalization(request, {

package/dist/lib/task/manual-validation-receipt.js

@@ -4,6 +4,7 @@ import { createHash } from 'node:crypto';
 import { MANUAL_VALIDATION_ARTIFACT as ARTIFACT, MANUAL_VALIDATION_SHA40 as SHA40, MANUAL_VALIDATION_SHA64 as SHA64, MANUAL_VALIDATION_TASK_ID as TASK_ID, exactKeys, isRecord, validTimestamp, writeJsonAtomic } from './manual-validation-shared.js';
 const MANUAL_VALIDATION_RECEIPT_SCHEMA = 'agent-infra/manual-validation-receipt';
 const MANUAL_VALIDATION_RECEIPT_VERSION = 1;
+const MANUAL_VALIDATION_RECEIPT_PLACEHOLDER = '[[manual-validation-receipt]]';
 function invalid(message) {
     return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_INVALID', message } };
 }
@@ -33,12 +34,16 @@ function manualValidationFinalSummaryDigest(body) {
     const projection = heading
         ? body.slice(heading.index, heading.index + heading[0].length + (nextSection?.index ?? afterHeading.length)).replace(/\s+$/u, '')
         : body;
-    const preimage = projection.replace(/receipt=(?:[a-f0-9]{64}|<receipt>)/gu, 'receipt=<receipt>');
+    const preimage = projection
+        .replace(/\n*<!--\s*canonical-pr-change-report\s*-->\s*/gu, '')
+        .replace(/<!--\s*manual-validation-receipt:\s*[\s\S]*?-->/gu, MANUAL_VALIDATION_RECEIPT_PLACEHOLDER)
+        .replace(/receipt=(?:[a-f0-9]{64}|<receipt>)/gu, 'receipt=<receipt>');
     return createHash('sha256').update(preimage, 'utf8').digest('hex');
 }
 function manualValidationFinalSummaryProjectionMatches(body, receipt) {
     const identity = `transaction=${receipt.transactionId}; receipt=${receipt.receiptDigest}; evidence=${receipt.evidenceDigest}; head=${receipt.prHeadSha}`;
-    return body.includes(identity) && manualValidationFinalSummaryDigest(body) === receipt.finalSummaryDigest;
+    return (body.includes(identity) || body.includes(MANUAL_VALIDATION_RECEIPT_PLACEHOLDER))
+        && manualValidationFinalSummaryDigest(body) === receipt.finalSummaryDigest;
 }
 function validateManualValidationReceipt(value, expected) {
     if (!isRecord(value))
@@ -101,5 +106,5 @@ function readManualValidationReceipt(taskDir, expected) {
     }
     return validateManualValidationReceipt(value, expected);
 }
-export { MANUAL_VALIDATION_RECEIPT_SCHEMA, MANUAL_VALIDATION_RECEIPT_VERSION, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, manualValidationReceiptDigest, manualValidationReceiptPath, readManualValidationReceipt, validateManualValidationReceipt, writeManualValidationReceiptAtomic };
+export { MANUAL_VALIDATION_RECEIPT_SCHEMA, MANUAL_VALIDATION_RECEIPT_VERSION, MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, manualValidationReceiptDigest, manualValidationReceiptPath, readManualValidationReceipt, validateManualValidationReceipt, writeManualValidationReceiptAtomic };
 //# sourceMappingURL=manual-validation-receipt.js.map

package/dist/lib/task/orchestration.js

@@ -22,6 +22,7 @@ import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js'
 import { hasOpenLifecycleExecution } from './activity-log.js';
 import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
+import { resolveArtifactContext } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -479,17 +480,13 @@ function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead)
 function routeFromFacts(facts) {
     const recommendation = recommendNext(facts);
     if (!recommendation.action)
-        return { completion: true };
+        return recommendation.reasonCode === 'LIFECYCLE_REVIEWED' ? { completion: true } : null;
     const action = recommendation.action;
     if (action === 'manual-validation' || action === 'validation-run')
         return null;
-    const family = action === 'analysis' ? 'analysis' : action;
-    const round = maxArtifactRound([
-        ...(facts.artifacts[family] ?? []), ...(facts.staleArtifacts?.[family] ?? [])
-    ], family) + 1;
     const command = action === 'analysis' ? 'analyze-task' : action === 'plan' ? 'plan-task' : action === 'code' ? 'code-task' : action;
     const role = action.startsWith('review-') ? 'reviewer' : 'executor';
-    return { action: command, role, stage: action, round, artifact: artifactName(family, round) };
+    return { action: command, role, stage: action };
 }
 function routeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -619,8 +616,19 @@ function routeOrchestration(taskRef, options = {}) {
         return { status: 'completed', changed: true, taskId: resolved.taskId, run: completed, next: null, error: null };
     }
     const action = routed.stage;
+    const family = action === 'analysis' ? 'analysis' : action;
+    const artifactContext = resolveArtifactContext(taskRef, family, {
+        repoRoot: resolved.repoRoot
+    });
+    if (artifactContext.status !== 'ready' || !artifactContext.selection) {
+        return failed(artifactContext.error?.code ?? 'ORCHESTRATION_ARTIFACT_SELECTION_FAILED', artifactContext.error?.message ?? 'cannot determine artifact selection', resolved.taskId);
+    }
+    if (artifactContext.selection.disposition === 'reuse') {
+        return failed('ORCHESTRATION_REUSE_STALLED', `lifecycle still routes to ${action} after reusing ${artifactContext.selection.artifact.name}`, resolved.taskId);
+    }
+    const selected = artifactContext.selection.artifact;
     const capability = canStart(action, facts.facts, {
-        initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${routed.round}`,
+        initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${selected.round}`,
         requestedAction: action, reasonCode: 'user-request', explicitRequest: true
     });
     if (!capability.allowed)
@@ -628,6 +636,8 @@ function routeOrchestration(taskRef, options = {}) {
     const policy = run ? rolePolicy(run, routed.role) : null;
     const next = {
         ...routed,
+        round: selected.round,
+        artifact: selected.name,
         requestedModel: policy?.model ?? null,
         requestedReasoningEffort: policy?.reasoningEffort ?? null
     };
@@ -1075,6 +1085,14 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
         return failed('ORCHESTRATION_PREPARED_RECOVERY_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
 }
+function recoveryReceiptMatches(receipt, taskId, event) {
+    return receipt.taskId === taskId
+        && receipt.stage === event.stage
+        && receipt.round === event.round
+        && receipt.artifact === event.artifact
+        && receipt.childId === event.childId
+        && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
+}
 function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -1089,12 +1107,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     const receipt = matches.find((candidate) => candidate.id === event.receiptId);
     if (!receipt)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'recovery receipt does not exist', resolved.taskId);
-    if (receipt.taskId !== resolved.taskId
-        || receipt.stage !== event.stage
-        || receipt.round !== event.round
-        || receipt.artifact !== event.artifact
-        || receipt.childId !== event.childId
-        || normalizeAgentToken(event.startedAgent) !== normalizeAgentToken(receipt.client)) {
+    if (!recoveryReceiptMatches(receipt, resolved.taskId, event)) {
         return failed('ORCHESTRATION_PROVENANCE_MISMATCH', 'recovery selector does not match the delegation receipt', resolved.taskId);
     }
     if (receipt.status === 'aborted' && run.pendingDelegation === null) {
@@ -1106,6 +1119,9 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     if (run.receipts.some((candidate) => candidate.id === receipt.id)) {
         return failed('ORCHESTRATION_RECEIPT_DUPLICATE', 'recovery receipt already exists in the completed receipt history', resolved.taskId);
     }
+    if (run.status !== 'running' || run.pause !== null) {
+        return failed('ORCHESTRATION_RECOVERY_UNSAFE', 'activated recovery cannot replace an unrelated orchestration pause', resolved.taskId);
+    }
     const aborted = abortActivatedDelegation(receipt, {
         childId: event.childId,
         stopRevision: event.stopRevision,

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

@@ -12,7 +12,6 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { allowsManualOverride } from './guard-override.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
 const STAGES = {
     analysis: { family: 'review-analysis' },
     plan: { family: 'review-plan' },
@@ -66,10 +65,8 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
     const publicationError = validateArtifactPublication(resolved.taskDir, spec.family, request.artifact);
     if (publicationError)
         return preflightFailed(request, 'REVIEW_ARTIFACT_IDENTITY_INVALID', publicationError.message, resolved.taskId);
-    let taskContent;
     let content;
     try {
-        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
         const validated = validateCompletedArtifact(resolved.taskDir, spec.family, request.artifact);
         if (!validated.ok)
             return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
@@ -89,22 +86,12 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
     const semanticDigest = canonicalSemanticDigest(content);
     const detail = inspectDecisionDetailDuplicates(content);
     const structure = inspectArtifactContract(content, getArtifactSchema(spec.family));
-    const expected = expectedQualificationRelations(taskContent, spec.family);
-    if (!expected.ok)
-        return preflightFailed(request, 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', `${expected.code}: ${expected.message}`, resolved.taskId, { artifactSha256, semanticDigest });
-    const qualification = validateQualificationAudit(taskContent, content, {
-        family: spec.family,
-        artifact: request.artifact,
-        expectedUpstreamRelations: expected.relations
-    });
-    const qualificationError = qualification.ok ? null : qualification;
-    if (!detail.ok || !structure.ok || qualificationError) {
+    if (!detail.ok || !structure.ok) {
         const diagnostics = [
             ...(!detail.ok ? [`${detail.code}: ${detail.message}`] : []),
-            ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`),
-            ...(qualificationError ? [`${qualificationError.code}: ${qualificationError.message}`] : [])
+            ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`)
         ].join('; ');
-        return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : !structure.ok ? 'REVIEW_ARTIFACT_STRUCTURE_INVALID' : 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', diagnostics, resolved.taskId, {
+        return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : 'REVIEW_ARTIFACT_STRUCTURE_INVALID', diagnostics, resolved.taskId, {
             artifactSha256, semanticDigest,
         });
     }