@fitlab-ai/agent-infra 0.11.6 → 0.11.7

package/dist/lib/task/invalidation.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { parseArtifactName } from './artifact-name.js';
 import { findSectionRange, parseTable } from './sections.js';
 import { scanVisibleMarkdown } from './markdown.js';
 const INVALIDATION_HEADINGS = ['产物失效记录', 'Artifact Invalidation'];
@@ -7,6 +8,10 @@ const OPERATION_COLUMNS = [
     'status', 'processed', 'total', 'created_at', 'updated_at', 'completed_at', 'error'
 ];
 const TARGET_COLUMNS = [
+    'target_id', 'operation_id', 'target_kind', 'target_family', 'target_artifact', 'target_input',
+    'target_round', 'target_sha256', 'status', 'reason_code', 'updated_at'
+];
+const LEGACY_TARGET_COLUMNS = [
     'target_id', 'operation_id', 'target_kind', 'target_family', 'target_artifact',
     'target_round', 'target_sha256', 'status', 'reason_code', 'updated_at'
 ];
@@ -20,7 +25,7 @@ function operationIdFor(source) {
     return `INV-${hashIdentity([source.sourceFamily, source.sourceArtifact, source.sourceRound, source.sourceSha256])}`;
 }
 function targetIdFor(operationId, target) {
-    return `INV-T-${hashIdentity([operationId, target.targetKind, target.targetFamily, target.targetArtifact, target.targetRound, target.targetSha256])}`;
+    return `INV-T-${hashIdentity([operationId, target.targetKind, target.targetFamily, target.targetArtifact, ...(target.targetKind === 'receipt' && target.targetInput ? [target.targetInput] : []), target.targetRound, target.targetSha256])}`;
 }
 function createInvalidationOperation(source, targets = []) {
     const operationId = source.operationId ?? operationIdFor(source);
@@ -31,14 +36,28 @@ function createInvalidationOperation(source, targets = []) {
         createdAt: source.createdAt, updatedAt: source.updatedAt, completedAt: '', error: ''
     };
 }
-function parseInvalidationTable(body, heading, columns) {
+function parseInvalidationTable(body, heading, columnChoices) {
     const section = findSectionRange(body, [heading], 3);
     const lines = scanVisibleMarkdown(body).lines.filter((line) => line.text.trim());
-    const table = parseTable(lines.map((line) => line.text).join('\n'), { sectionAliases: [heading], columns });
+    let table = null;
+    let legacy = false;
+    for (const columns of columnChoices) {
+        try {
+            const candidate = parseTable(lines.map((line) => line.text).join('\n'), { sectionAliases: [heading], columns });
+            if (candidate) {
+                table = candidate;
+                legacy = columns === LEGACY_TARGET_COLUMNS;
+                break;
+            }
+        }
+        catch {
+            // Try the next explicitly supported schema.
+        }
+    }
     if (!section || !table || lines.filter((line) => line.start >= section.bodyStart && line.start < section.end).length !== table.rows.length + 2) {
         throw new Error(`invalidation ${heading} section must contain only its canonical table`);
     }
-    return table.rows;
+    return { rows: table.rows, legacy };
 }
 function required(value, field) {
     if (!value)
@@ -62,9 +81,10 @@ function parseInvalidationDocument(content) {
         return { ok: true, present: false, document: { operations: [], targets: [] } };
     try {
         const body = content.slice(section.bodyStart, section.end);
-        const operationRows = parseInvalidationTable(body, 'Operations', OPERATION_COLUMNS);
-        const targetRows = parseInvalidationTable(body, 'Targets', TARGET_COLUMNS);
-        const operations = operationRows.map(({ values: row }) => ({
+        const operationRows = parseInvalidationTable(body, 'Operations', [OPERATION_COLUMNS]);
+        // TODO(compat): Remove legacy target table parsing and completed receipt targets without target_input once a workspace inventory confirms all persisted targets have input identities.
+        const targetRows = parseInvalidationTable(body, 'Targets', [TARGET_COLUMNS, LEGACY_TARGET_COLUMNS]);
+        const operations = operationRows.rows.map(({ values: row }) => ({
             operationId: required(row.operation_id, 'operation_id'), sourceFamily: required(row.source_family, 'source_family'),
             sourceArtifact: required(row.source_artifact, 'source_artifact'), sourceRound: numberValue(row.source_round, 'source_round', false),
             sourceSha256: required(row.source_sha256, 'source_sha256'), status: status(row.status, 'operation status'),
@@ -72,10 +92,11 @@ function parseInvalidationDocument(content) {
             createdAt: required(row.created_at, 'created_at'), updatedAt: required(row.updated_at, 'updated_at'),
             completedAt: row.completed_at ?? '', error: row.error ?? ''
         }));
-        const targets = targetRows.map(({ values: row }) => ({
+        const targets = targetRows.rows.map(({ values: row }) => ({
             targetId: required(row.target_id, 'target_id'), operationId: required(row.operation_id, 'operation_id'),
             targetKind: row.target_kind, targetFamily: required(row.target_family, 'target_family'),
             targetArtifact: required(row.target_artifact, 'target_artifact'), targetRound: numberValue(row.target_round, 'target_round', false),
+            ...(row.target_input ? { targetInput: row.target_input } : {}),
             targetSha256: required(row.target_sha256, 'target_sha256'), status: status(row.status, 'target status'),
             reasonCode: required(row.reason_code, 'reason_code'), updatedAt: required(row.updated_at, 'updated_at')
         }));
@@ -100,6 +121,14 @@ function parseInvalidationDocument(content) {
             targetIds.add(target.targetId);
             if (!operationIds.has(target.operationId))
                 throw new Error(`target '${target.targetId}' references an unknown operation`);
+            if (target.targetKind === 'receipt') {
+                if (!target.targetInput && target.status !== 'completed')
+                    throw new Error(`receipt target '${target.targetId}' input identity is required`);
+                if (target.targetInput && !parseArtifactName(target.targetInput))
+                    throw new Error(`receipt target '${target.targetId}' input identity is invalid`);
+            }
+            else if (target.targetInput)
+                throw new Error(`non-receipt target '${target.targetId}' cannot have an input identity`);
             if (target.targetId !== targetIdFor(target.operationId, target))
                 throw new Error(`target '${target.targetId}' has a non-canonical identity`);
             if (!/^[a-f0-9]{64}$/.test(target.targetSha256))
@@ -143,7 +172,7 @@ function renderInvalidation(document) {
         '### Targets', '',
         table(TARGET_COLUMNS, targets.map((row) => [
             row.targetId, row.operationId, row.targetKind, row.targetFamily, row.targetArtifact,
-            row.targetRound, row.targetSha256, row.status, row.reasonCode, row.updatedAt
+            row.targetInput ?? '', row.targetRound, row.targetSha256, row.status, row.reasonCode, row.updatedAt
         ]))
     ].join('\n');
 }

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

@@ -6,6 +6,7 @@ import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 import { getArtifactSchema } from './artifact-schema.js';
+import { validateQualificationAudit } from './qualification-audit.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
     analysis: getArtifactSchema('analysis').sections.map((section) => section.headings.zh),
     plan: getArtifactSchema('plan').sections.map((section) => section.headings.zh),
@@ -82,19 +83,32 @@ function prepareLocalArtifact(request, candidate) {
     const validation = validateLocalArtifact(content, {
         family: request.family, requiredSections: request.requiredSections
     });
+    let qualificationError = null;
+    try {
+        const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        const qualification = validateQualificationAudit(taskContent, content, { family: request.family, artifact: request.artifact });
+        if (!qualification.ok)
+            qualificationError = `${qualification.code}: ${qualification.message}`;
+    }
+    catch (error) {
+        qualificationError = `QUALIFICATION_AUDIT_INVALID: ${String(error)}`;
+    }
     const artifactSha256 = sha256Content(content);
+    const diagnostics = qualificationError
+        ? [...validation.diagnostics, { code: 'LOCAL_STRUCTURAL_INVALID', message: qualificationError, line: null }]
+        : validation.diagnostics;
     const result = failedFinalization(request, {
         code: 'LOCAL_ARTIFACT_INVALID',
-        message: validation.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
+        message: diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ')
     }, {
         taskId: resolved.taskId, taskDir: resolved.taskDir, artifactSha256,
-        semanticDigest: validation.semanticDigest, diagnostics: validation.diagnostics
+        semanticDigest: validation.semanticDigest, diagnostics
     });
     // Trusted local operators edit the canonical artifact directly.  A
     // finalization result is a fresh observation of those bytes, never a
     // capability minted by an earlier recovery attempt or generation.
     return {
-        result: validation.ok ? { ...result, status: 'passed', error: null } : result,
+        result: validation.ok && !qualificationError ? { ...result, status: 'passed', error: null } : result,
         content,
         repoRoot: resolved.repoRoot,
         lockAlreadyHeld: request.lockAlreadyHeld

package/dist/lib/task/qualification-audit.js

@@ -1,30 +1,26 @@
 import { createHash } from 'node:crypto';
 import { parseArtifactName } from './artifact-name.js';
-import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { findSectionRange, parseTable } from './sections.js';
 import { scanVisibleMarkdown } from './markdown.js';
 const TASK_CONSTRAINT_HEADINGS = ['约束', 'Constraints'];
 const TASK_CANDIDATE_HEADINGS = ['候选与否决方案', 'Candidate and Rejected Options', 'Candidates and Rejected Options', 'Candidates and Rejected Alternatives'];
 const AUDIT_HEADINGS = ['资格审计', '资格审计复核', 'Qualification Audit', 'Qualification Audit Review'];
 const CONFIRMATION_HEADINGS = ['资格确认记录', 'Qualification Confirmations'];
-const AUDIT_SUBSECTIONS = ['约束依赖', '候选资格', '分类结果', '上游关系', '依赖快照'];
+const AUDIT_SUBSECTIONS = ['约束依赖', '候选资格', '分类结果', '资格快照'];
 const AUDIT_SUBSECTION_HEADINGS = {
     '约束依赖': ['约束依赖', 'Constraint Dependencies'],
     '候选资格': ['候选资格', 'Candidate Qualification'],
     '分类结果': ['分类结果', 'Classification Results'],
-    '上游关系': ['上游关系', 'Upstream Relations'],
-    '依赖快照': ['依赖快照', 'Dependency Snapshot']
+    '资格快照': ['资格快照', 'Qualification Snapshot']
 };
 const CONSTRAINT_COLUMNS = ['constraint_id', 'statement', 'status', 'authority', 'source', 'evidence', 'derived_from', 'approval_evidence'];
 const CANDIDATE_COLUMNS = ['candidate_id', 'statement', 'status', 'constraint_ids', 'impact', 'evidence'];
 const DEPENDENCY_COLUMNS = ['constraint_id', 'constraint_digest', 'role', 'evidence'];
 const QUALIFICATION_COLUMNS = ['candidate_id', 'status', 'impact', 'constraint_ids', 'evidence'];
 const CLASSIFICATION_COLUMNS = ['decision_id', 'classification', 'evidence'];
-const RELATION_COLUMNS = ['upstream_family', 'upstream_artifact', 'upstream_round', 'upstream_sha256', 'relation'];
-const SNAPSHOT_COLUMNS = ['task_input_digest', 'non_constraint_input_digest', 'upstream_artifact_digest'];
+const SNAPSHOT_COLUMNS = ['task_input_digest', 'non_constraint_input_digest'];
 const CONFIRMATION_COLUMNS = ['qcr_id', 'constraint_id', 'actor', 'entrypoint', 'request_id', 'approved_digest', 'confirmed_at', 'rationale'];
 const ARTIFACT_FAMILIES = ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'];
-const RELATIONS = ['required-input', 'reviewed-input', 'review-context', 'approval-context'];
 const CONSTRAINT_STATUSES = ['confirmed', 'derived', 'assumption', 'open', 'conflicted', 'superseded'];
 const CANDIDATE_STATUSES = ['qualified', 'rejected', 'pending', 'needs-human-decision', 'confirmed', 'excluded'];
 const CLASSIFICATIONS = ['deterministic', 'qualified', 'rejected', 'needs-human-decision', 'not-applicable'];
@@ -215,86 +211,20 @@ function parseAuditTable(content, heading, columns) {
     const table = parseTable(`## Qualification Audit Body\n${subsection}`, { sectionAliases: ['Qualification Audit Body'], columns });
     return table?.rows.map((row) => ({ ...row.values })) ?? null;
 }
-function parseAuditArtifactName(value) {
-    const identity = parseArtifactName(value);
-    return identity && ARTIFACT_FAMILIES.includes(identity.family)
-        ? { family: identity.family, round: identity.round } : null;
-}
-function upstreamArtifactDigest(rows) {
-    return digest([...rows].map((row) => ({ ...row })).sort((a, b) => `${a.upstreamFamily}/${a.upstreamArtifact}/${a.relation}`.localeCompare(`${b.upstreamFamily}/${b.upstreamArtifact}/${b.relation}`)));
-}
-function validateUpstreamRelation(row) {
-    const identity = parseAuditArtifactName(row.upstreamArtifact);
-    if (!ARTIFACT_FAMILIES.includes(row.upstreamFamily) || !identity || identity.family !== row.upstreamFamily
-        || identity.round !== row.upstreamRound || !Number.isSafeInteger(row.upstreamRound)
-        || !/^[a-f0-9]{64}$/i.test(row.upstreamSha256) || !RELATIONS.includes(row.relation)) {
-        throw new Error(`invalid qualification upstream relation '${row.upstreamArtifact}'`);
-    }
-}
-function expectedQualificationRelations(taskContent, family) {
-    let frontmatter;
-    try {
-        frontmatter = parseTypedTaskFrontmatter(taskContent);
-    }
-    catch (error) {
-        return { ok: false, code: 'QUALIFICATION_STARTED_INPUT_INVALID', message: error instanceof Error ? error.message : String(error) };
-    }
-    const encoded = frontmatter.qualification_input_relations;
-    if (typeof encoded === 'string' && encoded) {
-        try {
-            const parsed = JSON.parse(encoded);
-            if (!Array.isArray(parsed))
-                throw new Error('qualification_input_relations must be an array');
-            const relations = parsed.map((value) => {
-                if (!value || typeof value !== 'object' || Array.isArray(value))
-                    throw new Error('qualification input relation must be an object');
-                const row = value;
-                const relation = {
-                    upstreamFamily: row.upstreamFamily,
-                    upstreamArtifact: String(row.upstreamArtifact ?? ''),
-                    upstreamRound: Number(row.upstreamRound),
-                    upstreamSha256: String(row.upstreamSha256 ?? ''),
-                    relation: row.relation
-                };
-                validateUpstreamRelation(relation);
-                return relation;
-            });
-            return { ok: true, relations };
-        }
-        catch (error) {
-            return { ok: false, code: 'QUALIFICATION_STARTED_INPUT_INVALID', message: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    const inputName = family === 'code' ? frontmatter.code_input_artifact : family.startsWith('review-') ? frontmatter.review_input_artifact : '';
-    const inputSha256 = family === 'code' ? frontmatter.code_input_sha256 : family.startsWith('review-') ? frontmatter.review_input_sha256 : '';
-    if (typeof inputName !== 'string' || !inputName || typeof inputSha256 !== 'string' || !inputSha256)
-        return { ok: true, relations: undefined };
-    const identity = parseAuditArtifactName(inputName);
-    if (!identity)
-        return { ok: false, code: 'QUALIFICATION_STARTED_INPUT_INVALID', message: `started input '${inputName}' is not canonical` };
-    const relation = {
-        upstreamFamily: identity.family, upstreamArtifact: inputName, upstreamRound: identity.round,
-        upstreamSha256: inputSha256, relation: family === 'code' ? 'required-input' : 'reviewed-input'
-    };
-    try {
-        validateUpstreamRelation(relation);
-    }
-    catch (error) {
-        return { ok: false, code: 'QUALIFICATION_STARTED_INPUT_INVALID', message: error instanceof Error ? error.message : String(error) };
-    }
-    return { ok: true, relations: [relation] };
-}
 function parseQualificationAudit(content) {
-    if (sectionBody(content, AUDIT_HEADINGS) === null)
-        return { ok: true, audit: { present: false, constraintDependencies: [], candidateQualifications: [], classifications: [], upstreamRelations: [], snapshot: null } };
+    const auditBody = sectionBody(content, AUDIT_HEADINGS);
+    if (auditBody === null)
+        return { ok: true, audit: { present: false, constraintDependencies: [], candidateQualifications: [], classifications: [], snapshot: null } };
     try {
+        if (sectionBody(auditBody, ['上游关系', 'Upstream Relations'], 3) !== null) {
+            throw new Error('qualification audit uses the obsolete lifecycle-relation format; regenerate it using the current format');
+        }
         const dependencies = parseAuditTable(content, '约束依赖', DEPENDENCY_COLUMNS);
         const qualifications = parseAuditTable(content, '候选资格', QUALIFICATION_COLUMNS);
         const classifications = parseAuditTable(content, '分类结果', CLASSIFICATION_COLUMNS);
-        const relations = parseAuditTable(content, '上游关系', RELATION_COLUMNS);
-        const snapshots = parseAuditTable(content, '依赖快照', SNAPSHOT_COLUMNS);
-        if (!dependencies || !qualifications || !classifications || !relations || !snapshots || snapshots.length !== 1) {
-            throw new Error('qualification audit requires all five canonical tables and exactly one dependency snapshot');
+        const snapshots = parseAuditTable(content, '资格快照', SNAPSHOT_COLUMNS);
+        if (!dependencies || !qualifications || !classifications || !snapshots || snapshots.length !== 1) {
+            throw new Error('qualification audit requires three decision tables and exactly one qualification snapshot');
         }
         const constraintDependencies = dependencies.map((row) => {
             if (!/^C-[1-9]\d*$/.test(row.constraint_id ?? '') || !/^[a-f0-9]{64}$/i.test(row.constraint_digest ?? '') || !ROLES.includes(row.role) || !row.evidence?.trim())
@@ -311,20 +241,15 @@ function parseQualificationAudit(content) {
                 throw new Error(`invalid qualification classification '${row.decision_id ?? ''}'`);
             return { decisionId: row.decision_id, classification: row.classification, evidence: row.evidence };
         });
-        const upstreamRelations = relations.map((row) => {
-            const relation = { upstreamFamily: row.upstream_family, upstreamArtifact: row.upstream_artifact ?? '', upstreamRound: Number(row.upstream_round), upstreamSha256: row.upstream_sha256 ?? '', relation: row.relation };
-            validateUpstreamRelation(relation);
-            return relation;
-        });
         const snapshotRow = snapshots[0];
-        if (!/^[a-f0-9]{64}$/i.test(snapshotRow.task_input_digest ?? '') || !/^[a-f0-9]{64}$/i.test(snapshotRow.non_constraint_input_digest ?? '') || !/^[a-f0-9]{64}$/i.test(snapshotRow.upstream_artifact_digest ?? ''))
-            throw new Error('qualification dependency snapshot has invalid digest');
+        if (!/^[a-f0-9]{64}$/i.test(snapshotRow.task_input_digest ?? '') || !/^[a-f0-9]{64}$/i.test(snapshotRow.non_constraint_input_digest ?? ''))
+            throw new Error('qualification snapshot has invalid digest');
         return {
             ok: true,
             audit: {
                 present: true, constraintDependencies, candidateQualifications,
-                classifications: classificationRows, upstreamRelations,
-                snapshot: { taskInputDigest: snapshotRow.task_input_digest, nonConstraintInputDigest: snapshotRow.non_constraint_input_digest, upstreamArtifactDigest: snapshotRow.upstream_artifact_digest }
+                classifications: classificationRows,
+                snapshot: { taskInputDigest: snapshotRow.task_input_digest, nonConstraintInputDigest: snapshotRow.non_constraint_input_digest }
             }
         };
     }
@@ -367,7 +292,7 @@ function validateQualificationAudit(taskContent, artifactContent, options = {})
     const audit = parseQualificationAudit(artifactContent);
     if (!audit.ok)
         return audit;
-    if (!task.qualification.present && !options.require)
+    if (!audit.audit.present && !options.require)
         return { ok: true, qualification: task.qualification, audit: audit.audit };
     if (!task.qualification.present)
         return { ok: false, code: 'QUALIFICATION_TASK_CONTRACT_MISSING', message: 'task qualification contract is missing' };
@@ -424,13 +349,8 @@ function validateQualificationAudit(taskContent, artifactContent, options = {})
         return { ok: false, code: 'QUALIFICATION_TASK_DIGEST_MISMATCH', message: 'qualification audit task input digest is stale' };
     if (snapshot.nonConstraintInputDigest !== task.qualification.nonConstraintInputDigest)
         return { ok: false, code: 'QUALIFICATION_NON_CONSTRAINT_DIGEST_MISMATCH', message: 'qualification audit non-constraint input digest is stale' };
-    if (snapshot.upstreamArtifactDigest !== upstreamArtifactDigest(audit.audit.upstreamRelations))
-        return { ok: false, code: 'QUALIFICATION_UPSTREAM_DIGEST_MISMATCH', message: 'qualification audit upstream digest does not match its relation rows' };
-    if (options.expectedUpstreamRelations && (options.expectedUpstreamRelations.length !== audit.audit.upstreamRelations.length
-        || upstreamArtifactDigest(options.expectedUpstreamRelations) !== upstreamArtifactDigest(audit.audit.upstreamRelations)))
-        return { ok: false, code: 'QUALIFICATION_UPSTREAM_RELATION_MISMATCH', message: 'qualification audit upstream relations do not match the started artifact inputs' };
     if (options.family && options.artifact) {
-        const identity = parseAuditArtifactName(options.artifact);
+        const identity = parseArtifactName(options.artifact);
         if (!identity || identity.family !== options.family)
             return { ok: false, code: 'QUALIFICATION_ARTIFACT_IDENTITY_INVALID', message: `artifact '${options.artifact}' is not canonical for '${options.family}'` };
     }
@@ -443,13 +363,12 @@ function renderQualificationAudit(audit) {
         ...rows.map((row) => `| ${row.map((value) => value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ')).join(' | ')} |`)
     ].join('\n');
     const list = (values) => values.join(',');
-    const snapshot = audit.snapshot ?? { taskInputDigest: '', nonConstraintInputDigest: '', upstreamArtifactDigest: upstreamArtifactDigest(audit.upstreamRelations) };
+    const snapshot = audit.snapshot ?? { taskInputDigest: '', nonConstraintInputDigest: '' };
     return [
         '### 约束依赖', '', table(DEPENDENCY_COLUMNS, audit.constraintDependencies.map((row) => [row.constraintId, row.constraintDigest, row.role, row.evidence])), '',
         '### 候选资格', '', table(QUALIFICATION_COLUMNS, audit.candidateQualifications.map((row) => [row.candidateId, row.status, row.impact, list(row.constraintIds), row.evidence])), '',
         '### 分类结果', '', table(CLASSIFICATION_COLUMNS, audit.classifications.map((row) => [row.decisionId, row.classification, row.evidence])), '',
-        '### 上游关系', '', table(RELATION_COLUMNS, audit.upstreamRelations.map((row) => [row.upstreamFamily, row.upstreamArtifact, String(row.upstreamRound), row.upstreamSha256, row.relation])), '',
-        '### 依赖快照', '', table(SNAPSHOT_COLUMNS, [[snapshot.taskInputDigest, snapshot.nonConstraintInputDigest, snapshot.upstreamArtifactDigest]])
+        '### 资格快照', '', table(SNAPSHOT_COLUMNS, [[snapshot.taskInputDigest, snapshot.nonConstraintInputDigest]])
     ].join('\n');
 }
 function buildQualificationAudit(taskContent, input = {}) {
@@ -462,15 +381,14 @@ function buildQualificationAudit(taskContent, input = {}) {
     const candidates = input.candidates ?? parsed.qualification.candidates.map((row) => row.candidateId);
     const constraintDependencies = parsed.qualification.constraints.filter((row) => ids.has(row.constraintId)).map((row) => ({ constraintId: row.constraintId, constraintDigest: row.digest, role: 'required', evidence: row.evidence }));
     const candidateQualifications = parsed.qualification.candidates.filter((row) => candidates.includes(row.candidateId)).map((row) => ({ candidateId: row.candidateId, status: row.status, impact: row.impact, constraintIds: row.constraintIds, evidence: row.evidence }));
-    const upstreamRelations = [...(input.upstreamRelations ?? [])];
     return {
         ok: true,
         audit: {
             present: true, constraintDependencies, candidateQualifications,
-            classifications: input.classifications ?? [], upstreamRelations,
-            snapshot: { taskInputDigest: parsed.qualification.taskInputDigest, nonConstraintInputDigest: parsed.qualification.nonConstraintInputDigest, upstreamArtifactDigest: upstreamArtifactDigest(upstreamRelations) }
+            classifications: input.classifications ?? [],
+            snapshot: { taskInputDigest: parsed.qualification.taskInputDigest, nonConstraintInputDigest: parsed.qualification.nonConstraintInputDigest }
         }
     };
 }
-export { ARTIFACT_FAMILIES, AUDIT_HEADINGS, AUDIT_SUBSECTIONS, CONFIRMATION_COLUMNS, CONFIRMATION_HEADINGS, CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, DEPENDENCY_COLUMNS, QUALIFICATION_COLUMNS, CLASSIFICATION_COLUMNS, RELATION_COLUMNS, SNAPSHOT_COLUMNS, constraintDigest, expectedQualificationRelations, buildQualificationAudit, nonConstraintInputDigest, parseQualificationAudit, parseQualificationConfirmations, parseTaskQualification, renderQualificationAudit, taskInputDigest, upstreamArtifactDigest, validateQualificationAudit };
+export { ARTIFACT_FAMILIES, AUDIT_HEADINGS, AUDIT_SUBSECTIONS, CONFIRMATION_COLUMNS, CONFIRMATION_HEADINGS, CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS, DEPENDENCY_COLUMNS, QUALIFICATION_COLUMNS, CLASSIFICATION_COLUMNS, SNAPSHOT_COLUMNS, constraintDigest, buildQualificationAudit, nonConstraintInputDigest, parseQualificationAudit, parseQualificationConfirmations, parseTaskQualification, renderQualificationAudit, taskInputDigest, validateQualificationAudit };
 //# sourceMappingURL=qualification-audit.js.map

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

@@ -10,6 +10,7 @@ import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { getArtifactSchema } from './artifact-schema.js';
+import { validateQualificationAudit } from './qualification-audit.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 const STAGES = {
     analysis: { family: 'review-analysis' },
@@ -186,6 +187,12 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
             artifactSha256, semanticDigest: structure.semanticDigest
         });
     }
+    const qualification = validateQualificationAudit(taskContent, artifactContent, { family: spec.family, artifact: request.artifact });
+    if (!qualification.ok) {
+        return reject('REVIEW_ARTIFACT_STRUCTURE_INVALID', `${qualification.code}: ${qualification.message}`, {
+            artifactSha256, semanticDigest
+        });
+    }
     const transformed = finalizeReviewSummaryContent(artifactContent, stageStatus.unresolvedFindingCounts, {
         refreshNumericCounts: true
     });

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

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { resolveBranchWorktree } from '../git/branch-worktree.js';
+import { snapshotReview } from '../git/review-snapshot.js';
+import { resolveDeliveryTarget } from './delivery-target.js';
+import { parseTypedTaskFrontmatter } from './frontmatter.js';
+import { extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedHead, extractReviewTargetHead, extractReviewedSnapshotTree, loadPostReviewConfig, resolvePostReviewGlobs } from './review-fingerprint.js';
+function git(cwd, args) {
+    return execFileSync('git', ['-C', cwd, ...args], { encoding: 'utf8' }).trim();
+}
+function result(status, message, reviewedHead = null, currentHead = null) {
+    return { status, message, reviewedHead, currentHead };
+}
+export function inspectReviewIdentity(taskDir, reportContent, repositoryRoot) {
+    const reviewedHead = extractReviewedHead(reportContent);
+    const targetHead = extractReviewTargetHead(reportContent);
+    const diffBase = extractReviewDiffBase(reportContent);
+    const fingerprint = extractReviewDiffFingerprint(reportContent);
+    const reviewedTree = extractReviewedSnapshotTree(reportContent);
+    if (!reviewedHead || !targetHead || !diffBase || !fingerprint || !reviewedTree) {
+        return result('indeterminate', 'Review report is missing commit or snapshot identity', reviewedHead || null);
+    }
+    try {
+        const metadata = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
+        const taskRepositoryRoot = git(taskDir, ['rev-parse', '--show-toplevel']);
+        const branch = String(metadata.branch ?? '').trim();
+        const gitRoot = branch ? resolveBranchWorktree(taskRepositoryRoot, branch) : taskRepositoryRoot;
+        if (!gitRoot)
+            return result('indeterminate', `Task branch '${branch}' is not checked out in a registered worktree`, reviewedHead);
+        const currentHead = git(gitRoot, ['rev-parse', 'HEAD']);
+        const baseline = git(gitRoot, ['rev-parse', `${reviewedHead}^{commit}`]);
+        if (baseline !== currentHead)
+            return result('different', 'Reviewed commit differs from current HEAD', baseline, currentHead);
+        const remote = String(metadata.delivery_remote ?? '').trim();
+        const baseRef = String(metadata.delivery_base_ref ?? '').trim();
+        if (!remote || !baseRef)
+            return result('indeterminate', 'Task delivery target is not bound', baseline, currentHead);
+        const target = resolveDeliveryTarget(gitRoot, { remote, baseRef });
+        if (!target.ok)
+            return result('indeterminate', target.message, baseline, currentHead);
+        const currentTarget = git(gitRoot, ['rev-parse', `${targetHead}^{commit}`]);
+        const computedDiffBase = git(gitRoot, ['merge-base', baseline, currentTarget]);
+        if (git(gitRoot, ['rev-parse', `${diffBase}^{commit}`]) !== computedDiffBase) {
+            return result('different', 'Saved review diff base no longer matches the current target', baseline, currentHead);
+        }
+        const globs = resolvePostReviewGlobs({}, loadPostReviewConfig(repositoryRoot ?? taskRepositoryRoot));
+        const trackedChanges = git(gitRoot, ['diff', '--name-only', '-z', baseline, '--', ...globs]);
+        const untrackedChanges = git(gitRoot, ['ls-files', '-o', '--exclude-standard', '-z', '--', ...globs]);
+        if (trackedChanges || untrackedChanges)
+            return result('different', 'Reviewed worktree contains uncommitted changes', baseline, currentHead);
+        const snapshot = snapshotReview({
+            cwd: gitRoot,
+            mode: 'worktree',
+            baseline,
+            diffBase: computedDiffBase,
+            globs
+        });
+        if (snapshot.fingerprint !== fingerprint)
+            return result('different', 'Reviewed diff fingerprint differs from the current worktree', baseline, currentHead);
+        if (snapshot.tree !== reviewedTree)
+            return result('different', 'Reviewed snapshot tree differs from the current worktree', baseline, currentHead);
+        return result('matched', 'Review report matches the current commit and clean worktree', baseline, currentHead);
+    }
+    catch (error) {
+        return result('indeterminate', error instanceof Error ? error.message : String(error), reviewedHead);
+    }
+}
+//# sourceMappingURL=review-identity.js.map

package/dist/lib/task/sections.js

@@ -17,8 +17,8 @@ function parseTable(content, input) {
         new Set(input.columns).size !== input.columns.length) {
         throw new DocumentMutationError('MUTATION_INVALID', 'table columns are invalid');
     }
-    const keyColumn = input.keyColumn ?? input.columns[0];
-    if (!input.columns.includes(keyColumn)) {
+    const keyColumn = input.keyColumn === undefined ? input.columns[0] : input.keyColumn;
+    if (keyColumn !== null && !input.columns.includes(keyColumn)) {
         throw new DocumentMutationError('MUTATION_INVALID', 'table key column is invalid');
     }
     const sections = matchingSections(content, input.sectionAliases);
@@ -68,11 +68,12 @@ function parseTable(content, input) {
             column,
             decodeCell(parsed.cells[columnIndex]).trim()
         ]));
-        const key = values[keyColumn];
-        if (seen.has(key)) {
+        const key = keyColumn === null ? null : values[keyColumn];
+        if (key !== null && seen.has(key)) {
             throw new DocumentMutationError('TABLE_DUPLICATE_KEY', `duplicate table key '${key}'`);
         }
-        seen.add(key);
+        if (key !== null)
+            seen.add(key);
         rows.push({ values, sourceLine: index - Math.max(firstContent, 0) });
     }
     return { heading: section.heading, rows };

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

@@ -29,9 +29,12 @@ function mapLinkError(operation, error, key) {
     }
     return new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', `lifecycle lock hard-link operation '${operation}' failed`, detail);
 }
-function lockKey(repoRoot, taskId) {
+function lockKey(repoRoot, taskId, identityScope) {
     const canonicalRepoRoot = fs.realpathSync.native(repoRoot);
-    const key = createHash('sha256').update(`${canonicalRepoRoot}\0${taskId}`).digest('hex');
+    const identity = identityScope === undefined
+        ? `${canonicalRepoRoot}\0${taskId}`
+        : `${identityScope}\0${taskId}`;
+    const key = createHash('sha256').update(identity).digest('hex');
     return { canonicalRepoRoot, key };
 }
 function parseOwner(raw, key) {
@@ -133,7 +136,7 @@ function cleanStaleCandidates(lockRoot, key, identityMatches) {
 function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options = {}) {
     let identity;
     try {
-        identity = lockKey(repoRoot, taskId);
+        identity = lockKey(repoRoot, taskId, options.identityScope);
     }
     catch (error) {
         throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'failed to canonicalize the repository for lifecycle locking', { operation: 'canonicalize', errno: errno(error), key: 'unresolved' });