@dailephd/my-dev-kit-lab 0.4.2 → 0.4.4

package/dist/src/evaluation/stageContextMetrics/calculateReadinessAgreement.js

@@ -0,0 +1,152 @@
+// v0.4.4 Batch 2: readiness/raw-evidence agreement. Readiness stays observed consumer
+// output (Batch 1) -- this module only compares it against an explicit fixture-declared
+// expectation. It never calls, imports, or reimplements contextReadiness.ts.
+import { checkSupplementalReadinessIdentityConsistency } from "../upstreamArtifacts/index.js";
+function unavailableStructural(field, reason) {
+    return { field, expectedValue: null, observedValue: null, agreement: null, availability: "unavailable", reason };
+}
+export function calculateReadinessStructuralAgreement(readiness, supplementalPacket, packetSourcePath) {
+    const results = [];
+    if (readiness === undefined) {
+        results.push(unavailableStructural("canonicalRepositoryIdentity", "No readiness result was supplied."));
+        results.push(unavailableStructural("packetPath", "No readiness result was supplied."));
+        return results;
+    }
+    if (supplementalPacket === undefined) {
+        results.push(unavailableStructural("canonicalRepositoryIdentity", "No supplemental document was supplied to compare against readiness."));
+    }
+    else {
+        const diagnostic = checkSupplementalReadinessIdentityConsistency(supplementalPacket, readiness);
+        results.push({
+            field: "canonicalRepositoryIdentity",
+            expectedValue: supplementalPacket.indexIdentity,
+            observedValue: readiness.indexIdentity ?? null,
+            agreement: diagnostic === null,
+            availability: readiness.indexIdentity === undefined ? "unavailable" : "available",
+            reason: readiness.indexIdentity === undefined ? "The readiness result does not declare indexIdentity." : diagnostic?.message ?? null
+        });
+    }
+    if (packetSourcePath === undefined) {
+        results.push(unavailableStructural("packetPath", "No packet source path was supplied to compare against readiness.packetPath."));
+    }
+    else {
+        results.push({
+            field: "packetPath",
+            expectedValue: packetSourcePath,
+            observedValue: readiness.packetPath,
+            agreement: packetSourcePath === readiness.packetPath,
+            availability: "available",
+            reason: null
+        });
+    }
+    return results;
+}
+export function calculateReadinessDecisionAgreement(readiness, expectation) {
+    if (expectation === undefined) {
+        return {
+            availability: "not-applicable",
+            observedDecision: readiness?.decision ?? null,
+            allowedDecisions: null,
+            decisionAgreement: null,
+            observedClassification: readiness?.classification ?? null,
+            expectedClassification: null,
+            classificationAgreement: null,
+            observedIssueCodes: readiness?.blockingIssueCodes ?? [],
+            expectedIssueCodes: null,
+            issueCodesAgreement: null,
+            observedPrimaryIssueCode: readiness?.primaryIssue?.code ?? null,
+            expectedPrimaryIssueCode: null,
+            primaryIssueAgreement: null,
+            reason: "The expectation fixture declares no readiness expectation."
+        };
+    }
+    if (readiness === undefined) {
+        return {
+            availability: "unavailable",
+            observedDecision: null,
+            allowedDecisions: expectation.allowedDecisions ?? null,
+            decisionAgreement: null,
+            observedClassification: null,
+            expectedClassification: expectation.expectedClassification ?? null,
+            classificationAgreement: null,
+            observedIssueCodes: [],
+            expectedIssueCodes: expectation.expectedIssueCodes ?? null,
+            issueCodesAgreement: null,
+            observedPrimaryIssueCode: null,
+            expectedPrimaryIssueCode: expectation.expectedPrimaryIssueCode ?? null,
+            primaryIssueAgreement: null,
+            reason: "No readiness result was supplied."
+        };
+    }
+    const decisionAgreement = expectation.allowedDecisions === undefined ? null : expectation.allowedDecisions.includes(readiness.decision);
+    const classificationAgreement = expectation.expectedClassification === undefined ? null : expectation.expectedClassification === readiness.classification;
+    const issueCodesAgreement = expectation.expectedIssueCodes === undefined
+        ? null
+        : expectation.expectedIssueCodes.length === readiness.blockingIssueCodes.length &&
+            expectation.expectedIssueCodes.every((code) => readiness.blockingIssueCodes.includes(code));
+    const primaryIssueAgreement = expectation.expectedPrimaryIssueCode === undefined
+        ? null
+        : expectation.expectedPrimaryIssueCode === (readiness.primaryIssue?.code ?? null);
+    return {
+        availability: "available",
+        observedDecision: readiness.decision,
+        allowedDecisions: expectation.allowedDecisions ?? null,
+        decisionAgreement,
+        observedClassification: readiness.classification,
+        expectedClassification: expectation.expectedClassification ?? null,
+        classificationAgreement,
+        observedIssueCodes: readiness.blockingIssueCodes,
+        expectedIssueCodes: expectation.expectedIssueCodes ?? null,
+        issueCodesAgreement,
+        observedPrimaryIssueCode: readiness.primaryIssue?.code ?? null,
+        expectedPrimaryIssueCode: expectation.expectedPrimaryIssueCode ?? null,
+        primaryIssueAgreement,
+        reason: null
+    };
+}
+export function calculateInvalidReady(readiness, expectation) {
+    if (readiness === undefined) {
+        return { availability: "unavailable", invalidReady: null, observedDecision: null, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "No readiness result was supplied." };
+    }
+    if (expectation === undefined) {
+        return { availability: "not-applicable", invalidReady: null, observedDecision: readiness.decision, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "The expectation fixture declares no readiness expectation." };
+    }
+    const expectsBlocking = (expectation.allowedDecisions !== undefined &&
+        !expectation.allowedDecisions.includes("ready") &&
+        (expectation.allowedDecisions.includes("refresh-required") || expectation.allowedDecisions.length > 0)) ||
+        (expectation.expectedIssueCodes !== undefined && expectation.expectedIssueCodes.length > 0);
+    if (!expectsBlocking) {
+        return { availability: "not-applicable", invalidReady: null, observedDecision: readiness.decision, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "The expectation fixture does not require blocked or refresh-required behavior." };
+    }
+    if (readiness.decision !== "ready") {
+        return { availability: "available", invalidReady: false, observedDecision: readiness.decision, expectedBlockingDecision: true, missingExpectedIssueCodes: [], reason: null };
+    }
+    const expectedCodes = expectation.expectedIssueCodes ?? [];
+    const missing = expectedCodes.filter((code) => !readiness.blockingIssueCodes.includes(code));
+    return { availability: "available", invalidReady: true, observedDecision: readiness.decision, expectedBlockingDecision: true, missingExpectedIssueCodes: missing, reason: null };
+}
+export function calculateValidBlocked(readiness, expectation) {
+    if (readiness === undefined) {
+        return { availability: "unavailable", validBlocked: null, validRefreshRequired: null, observedDecision: null, reason: "No readiness result was supplied." };
+    }
+    if (expectation === undefined) {
+        return { availability: "not-applicable", validBlocked: null, validRefreshRequired: null, observedDecision: readiness.decision, reason: "The expectation fixture declares no readiness expectation." };
+    }
+    if (readiness.decision !== "refresh-required") {
+        return { availability: "available", validBlocked: false, validRefreshRequired: false, observedDecision: readiness.decision, reason: null };
+    }
+    const allowsRefreshRequired = expectation.allowedDecisions === undefined || expectation.allowedDecisions.includes("refresh-required");
+    const issueCodesMatch = expectation.expectedIssueCodes === undefined ||
+        expectation.expectedIssueCodes.every((code) => readiness.blockingIssueCodes.includes(code));
+    const primaryMatches = expectation.expectedPrimaryIssueCode === undefined || expectation.expectedPrimaryIssueCode === (readiness.primaryIssue?.code ?? null);
+    const valid = allowsRefreshRequired && issueCodesMatch && primaryMatches;
+    return { availability: "available", validBlocked: valid, validRefreshRequired: valid, observedDecision: readiness.decision, reason: null };
+}
+export function calculateReadinessAgreementMetrics(readiness, expectation, supplementalPacket, packetSourcePath) {
+    return {
+        structuralAgreement: calculateReadinessStructuralAgreement(readiness, supplementalPacket, packetSourcePath),
+        decisionAgreement: calculateReadinessDecisionAgreement(readiness, expectation),
+        invalidReady: calculateInvalidReady(readiness, expectation),
+        validBlocked: calculateValidBlocked(readiness, expectation)
+    };
+}

package/dist/src/evaluation/stageContextMetrics/calculateResponsibilityMappingMetrics.js

@@ -0,0 +1,36 @@
+function buildMetric(sourceArtifact, sourceInstance, requested, operational, mappings) {
+    let mappedCount = 0;
+    let partiallyMappedCount = 0;
+    let unmappedCount = 0;
+    let notApplicableCount = 0;
+    for (const mapping of mappings) {
+        if (mapping.mappingStatus === "mapped")
+            mappedCount += 1;
+        else if (mapping.mappingStatus === "partially-mapped")
+            partiallyMappedCount += 1;
+        else if (mapping.mappingStatus === "unmapped")
+            unmappedCount += 1;
+        else if (mapping.mappingStatus === "not-applicable")
+            notApplicableCount += 1;
+    }
+    const denominator = mappedCount + partiallyMappedCount + unmappedCount;
+    const mappedRate = denominator > 0 ? mappedCount / denominator : null;
+    return {
+        sourceArtifact,
+        sourceInstance,
+        requested,
+        operational,
+        mappedCount,
+        partiallyMappedCount,
+        unmappedCount,
+        notApplicableCount,
+        denominator,
+        mappedRate
+    };
+}
+export function calculateContextCapsuleResponsibilityMappingMetric(artifact, sourceInstance) {
+    return buildMetric("context-capsule", sourceInstance, artifact.responsibilityMappings.requested, artifact.responsibilityMappings.operational, artifact.responsibilityMappings.mappings);
+}
+export function calculateRetrievalAuditResponsibilityMappingMetric(artifact, sourceInstance) {
+    return buildMetric("retrieval-audit-record", sourceInstance, artifact.responsibilityMappings.requested, artifact.responsibilityMappings.operational, artifact.responsibilityMappings.mappings);
+}

package/dist/src/evaluation/stageContextMetrics/calculateSupplementalRawAgreement.js

@@ -0,0 +1,50 @@
+function extractRawIdentity(artifact) {
+    return {
+        projectRoot: artifact.index.projectRoot,
+        role: artifact.request.role,
+        freshnessState: artifact.freshness.state,
+        truncated: artifact.truncation.truncated
+    };
+}
+function truncationToYesNo(value) {
+    return value ? "yes" : "no";
+}
+function buildField(field, rawValue, supplementalValue, unavailableReason) {
+    if (unavailableReason !== null) {
+        return { field, rawValue, supplementalValue, agreement: null, availability: "unavailable", reason: unavailableReason };
+    }
+    return { field, rawValue, supplementalValue, agreement: rawValue === supplementalValue, availability: "available", reason: null };
+}
+export function calculateSupplementalRawAgreement(supplemental, raw) {
+    if (supplemental === undefined || raw === undefined) {
+        const reason = supplemental === undefined && raw === undefined
+            ? "Neither a supplemental document nor a raw artifact was supplied."
+            : supplemental === undefined
+                ? "No supplemental document was supplied."
+                : "No raw context-capsule or retrieval-audit artifact was supplied.";
+        const fields = [
+            buildField("canonicalRepositoryIdentity", null, supplemental?.indexIdentity ?? null, reason),
+            buildField("role", null, supplemental?.role ?? null, reason),
+            buildField("freshness", null, supplemental?.freshness ?? null, reason),
+            buildField("requiredEvidenceTruncated", null, supplemental?.requiredEvidenceTruncated ?? null, reason)
+        ];
+        return { fields, contradictions: [], upstreamProducerParityPreserved: null };
+    }
+    const rawIdentity = extractRawIdentity(raw);
+    const fields = [];
+    fields.push(buildField("canonicalRepositoryIdentity", rawIdentity.projectRoot ?? null, supplemental.indexIdentity, rawIdentity.projectRoot === undefined ? "The raw artifact does not declare index.projectRoot." : null));
+    const roleComparable = rawIdentity.role === "implementation" || rawIdentity.role === "test-implementation";
+    fields.push(buildField("role", rawIdentity.role, supplemental.role, roleComparable ? null : `Raw role "${rawIdentity.role}" has no supplemental-document counterpart in this vocabulary.`));
+    fields.push(buildField("freshness", rawIdentity.freshnessState, supplemental.freshness, null));
+    fields.push(buildField("requiredEvidenceTruncated", truncationToYesNo(rawIdentity.truncated), supplemental.requiredEvidenceTruncated, supplemental.requiredEvidenceTruncated === "unknown"
+        ? "The supplemental document declares truncation as \"unknown\", so agreement with the raw boolean cannot be determined."
+        : null));
+    const contradictions = fields.filter((f) => f.availability === "available" && f.agreement === false);
+    return {
+        fields,
+        contradictions,
+        // A successfully read raw pair is itself the observed outcome of the frozen
+        // assertRawEvidenceParity() write-time guard; see file header. Never recomputed here.
+        upstreamProducerParityPreserved: true
+    };
+}

package/dist/src/evaluation/stageContextMetrics/calculateTruncationClassification.js

@@ -0,0 +1,44 @@
+export function classifyTruncationRecord(record, sourceArtifact, sourceInstance) {
+    const base = {
+        groupId: record.affectedGroup,
+        sourceArtifact,
+        sourceInstance,
+        limit: record.limit,
+        used: record.used,
+        available: record.available,
+        omittedRequiredEvidenceIds: record.requiredEvidenceLost ? record.droppedEvidenceIds : []
+    };
+    if (!record.requiredEvidenceLost) {
+        return {
+            ...base,
+            cause: "none",
+            availability: "available",
+            reason: "No fixture-required evidence was reported lost for this group."
+        };
+    }
+    if (record.limit === null) {
+        return {
+            ...base,
+            cause: "unresolved",
+            availability: "available",
+            reason: "Required evidence was lost but no hard limit is declared for this group, so avoidability cannot be proven either way."
+        };
+    }
+    if (record.used < record.limit) {
+        return {
+            ...base,
+            cause: "avoidable",
+            availability: "available",
+            reason: `Required evidence was lost while used (${record.used}) remained below the declared limit (${record.limit}); compatible headroom existed under the hard limit.`
+        };
+    }
+    return {
+        ...base,
+        cause: "genuine-hard-limit",
+        availability: "available",
+        reason: `Required evidence was lost and used (${record.used}) reached or exceeded the declared limit (${record.limit}); no compatible headroom remained.`
+    };
+}
+export function classifyTruncationRecords(records, sourceArtifact, sourceInstance) {
+    return records.map((record) => classifyTruncationRecord(record, sourceArtifact, sourceInstance));
+}

package/dist/src/evaluation/stageContextMetrics/collectContextCapsuleEvidence.js

@@ -0,0 +1,312 @@
+const SOURCE_ARTIFACT = "context-capsule";
+function pathKey(category, path) {
+    return `${SOURCE_ARTIFACT}|${category}|path:${path}`;
+}
+function symbolKey(category, symbolId) {
+    return `${SOURCE_ARTIFACT}|${category}|symbolId:${symbolId}`;
+}
+function sourceRangeKey(filePath, startLine, endLine) {
+    return `context-capsule|source-range|filePath:${filePath}|startLine:${startLine}|endLine:${endLine}`;
+}
+function responsibilityKey(responsibilityId) {
+    return `${SOURCE_ARTIFACT}|production-responsibility|responsibilityId:${responsibilityId}`;
+}
+function packageScriptKey(name) {
+    return `context-capsule|package-script|name:${name}`;
+}
+function testCommandKey(commandText) {
+    return `context-capsule|test-command|commandText:${commandText}`;
+}
+function provenanceKey(evidenceId) {
+    return `${SOURCE_ARTIFACT}|provenance|evidenceId:${evidenceId}`;
+}
+function pushFileEvidenceFromRefs(records, items, fieldPrefix, category, sourceInstance) {
+    items.forEach((item, index) => {
+        if (item.path !== undefined) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category,
+                targetKey: pathKey(category, item.path),
+                sourceFieldPath: `${fieldPrefix}[${index}].path`
+            });
+        }
+        if (item.sourceLocation?.filePath !== undefined) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category,
+                targetKey: pathKey(category, item.sourceLocation.filePath),
+                sourceFieldPath: `${fieldPrefix}[${index}].sourceLocation.filePath`
+            });
+        }
+    });
+}
+function pushSymbolEvidenceFromRefs(records, items, fieldPrefix, category, sourceInstance) {
+    items.forEach((item, index) => {
+        if (item.symbolId !== undefined) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category,
+                targetKey: symbolKey(category, item.symbolId),
+                sourceFieldPath: `${fieldPrefix}[${index}].symbolId`
+            });
+        }
+        if (item.nodeId !== undefined) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category,
+                targetKey: symbolKey(category, item.nodeId),
+                sourceFieldPath: `${fieldPrefix}[${index}].nodeId`
+            });
+        }
+    });
+}
+function dedupeEvidence(records) {
+    const seen = new Set();
+    const result = [];
+    for (const record of records) {
+        const key = `${record.sourceInstance} ${record.category} ${record.targetKey}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(record);
+    }
+    return result;
+}
+export function collectContextCapsuleEvidence(artifact, sourceInstance) {
+    const records = [];
+    // Section 25: general file evidence
+    artifact.candidateFiles.forEach((candidate, index) => {
+        if (candidate.retained) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "file",
+                targetKey: pathKey("file", candidate.path),
+                sourceFieldPath: `candidateFiles[${index}].path`
+            });
+        }
+    });
+    artifact.selectedGraph.nodes.forEach((node, index) => {
+        if (node.filePath !== undefined) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "file",
+                targetKey: pathKey("file", node.filePath),
+                sourceFieldPath: `selectedGraph.nodes[${index}].filePath`
+            });
+        }
+    });
+    artifact.selectedSource.slices.forEach((slice, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "file",
+            targetKey: pathKey("file", slice.filePath),
+            sourceFieldPath: `selectedSource.slices[${index}].filePath`
+        });
+    });
+    artifact.selectedSourceBundles.bundles.forEach((bundle, bundleIndex) => {
+        bundle.blocks.forEach((block, blockIndex) => {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "file",
+                targetKey: pathKey("file", block.filePath),
+                sourceFieldPath: `selectedSourceBundles.bundles[${bundleIndex}].blocks[${blockIndex}].filePath`
+            });
+        });
+    });
+    artifact.roleContext.changedSurface.files.forEach((file, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "file",
+            targetKey: pathKey("file", file.path),
+            sourceFieldPath: `roleContext.changedSurface.files[${index}].path`
+        });
+    });
+    artifact.evidenceGroups.forEach((group, groupIndex) => {
+        pushFileEvidenceFromRefs(records, group.items, `evidenceGroups[${groupIndex}].items`, "file", sourceInstance);
+    });
+    pushFileEvidenceFromRefs(records, artifact.selectedOwners, "selectedOwners", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.selectedContracts, "selectedContracts", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.selectedTests, "selectedTests", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.relatedTests, "testInfrastructure.relatedTests", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.fixtures, "testInfrastructure.fixtures", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.factories, "testInfrastructure.factories", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.mocks, "testInfrastructure.mocks", "file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.setupFiles, "testInfrastructure.setupFiles", "file", sourceInstance);
+    artifact.testInfrastructure.testConfigurations.forEach((config, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "file",
+            targetKey: pathKey("file", config.path),
+            sourceFieldPath: `testInfrastructure.testConfigurations[${index}].path`
+        });
+    });
+    artifact.testInfrastructure.packageScripts.forEach((script, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "file",
+            targetKey: pathKey("file", script.packageJsonPath),
+            sourceFieldPath: `testInfrastructure.packageScripts[${index}].packageJsonPath`
+        });
+    });
+    artifact.testInfrastructure.testCommands.forEach((command, commandIndex) => {
+        command.testFiles.forEach((testFile, fileIndex) => {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "file",
+                targetKey: pathKey("file", testFile),
+                sourceFieldPath: `testInfrastructure.testCommands[${commandIndex}].testFiles[${fileIndex}]`
+            });
+        });
+    });
+    // Section 26: specific path-category evidence
+    pushFileEvidenceFromRefs(records, artifact.selectedTests, "selectedTests", "test-file", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.relatedTests, "testInfrastructure.relatedTests", "test-file", sourceInstance);
+    artifact.testInfrastructure.testCommands.forEach((command, commandIndex) => {
+        command.testFiles.forEach((testFile, fileIndex) => {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "test-file",
+                targetKey: pathKey("test-file", testFile),
+                sourceFieldPath: `testInfrastructure.testCommands[${commandIndex}].testFiles[${fileIndex}]`
+            });
+        });
+    });
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.fixtures, "testInfrastructure.fixtures", "fixture", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.factories, "testInfrastructure.factories", "factory", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.mocks, "testInfrastructure.mocks", "mock", sourceInstance);
+    pushFileEvidenceFromRefs(records, artifact.testInfrastructure.setupFiles, "testInfrastructure.setupFiles", "setup-file", sourceInstance);
+    artifact.testInfrastructure.testConfigurations.forEach((config, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "test-configuration",
+            targetKey: pathKey("test-configuration", config.path),
+            sourceFieldPath: `testInfrastructure.testConfigurations[${index}].path`
+        });
+    });
+    // Section 27: symbol and symbol-subtype evidence
+    artifact.candidateNodes.forEach((node, index) => {
+        if (node.retained) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "symbol",
+                targetKey: symbolKey("symbol", node.nodeId),
+                sourceFieldPath: `candidateNodes[${index}].nodeId`
+            });
+        }
+    });
+    artifact.selectedGraph.nodes.forEach((node, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "symbol",
+            targetKey: symbolKey("symbol", node.nodeId),
+            sourceFieldPath: `selectedGraph.nodes[${index}].nodeId`
+        });
+    });
+    artifact.evidenceGroups.forEach((group, groupIndex) => {
+        pushSymbolEvidenceFromRefs(records, group.items, `evidenceGroups[${groupIndex}].items`, "symbol", sourceInstance);
+    });
+    pushSymbolEvidenceFromRefs(records, artifact.selectedOwners, "selectedOwners", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.selectedContracts, "selectedContracts", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.selectedTests, "selectedTests", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.testInfrastructure.relatedTests, "testInfrastructure.relatedTests", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.testInfrastructure.fixtures, "testInfrastructure.fixtures", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.testInfrastructure.factories, "testInfrastructure.factories", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.testInfrastructure.mocks, "testInfrastructure.mocks", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.testInfrastructure.setupFiles, "testInfrastructure.setupFiles", "symbol", sourceInstance);
+    pushSymbolEvidenceFromRefs(records, artifact.selectedContracts, "selectedContracts", "contract", sourceInstance);
+    artifact.responsibilityMappings.mappings.forEach((mapping, mappingIndex) => {
+        pushSymbolEvidenceFromRefs(records, mapping.contracts, `responsibilityMappings.mappings[${mappingIndex}].contracts`, "contract", sourceInstance);
+    });
+    artifact.responsibilityMappings.mappings.forEach((mapping, mappingIndex) => {
+        pushSymbolEvidenceFromRefs(records, mapping.validators, `responsibilityMappings.mappings[${mappingIndex}].validators`, "validator", sourceInstance);
+    });
+    artifact.responsibilityMappings.mappings.forEach((mapping, mappingIndex) => {
+        pushSymbolEvidenceFromRefs(records, mapping.constants, `responsibilityMappings.mappings[${mappingIndex}].constants`, "constant", sourceInstance);
+    });
+    artifact.responsibilityMappings.mappings.forEach((mapping, mappingIndex) => {
+        pushSymbolEvidenceFromRefs(records, mapping.errors, `responsibilityMappings.mappings[${mappingIndex}].errors`, "error", sourceInstance);
+    });
+    pushSymbolEvidenceFromRefs(records, artifact.selectedContracts, "selectedContracts", "schema-or-serializer", sourceInstance);
+    artifact.responsibilityMappings.mappings.forEach((mapping, mappingIndex) => {
+        pushSymbolEvidenceFromRefs(records, mapping.contracts, `responsibilityMappings.mappings[${mappingIndex}].contracts`, "schema-or-serializer", sourceInstance);
+    });
+    // Section 28: source-range evidence
+    artifact.selectedSource.slices.forEach((slice, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "source-range",
+            targetKey: sourceRangeKey(slice.filePath, slice.startLine, slice.endLine),
+            sourceFieldPath: `selectedSource.slices[${index}]`
+        });
+    });
+    artifact.selectedSourceBundles.bundles.forEach((bundle, bundleIndex) => {
+        bundle.blocks.forEach((block, blockIndex) => {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "source-range",
+                targetKey: sourceRangeKey(block.filePath, block.startLine, block.endLine),
+                sourceFieldPath: `selectedSourceBundles.bundles[${bundleIndex}].blocks[${blockIndex}]`
+            });
+        });
+    });
+    // Section 29: production-responsibility evidence
+    artifact.responsibilityMappings.mappings.forEach((mapping, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "production-responsibility",
+            targetKey: responsibilityKey(mapping.responsibilityId),
+            sourceFieldPath: `responsibilityMappings.mappings[${index}].responsibilityId`
+        });
+    });
+    // Section 30: package-script and test-command evidence
+    artifact.testInfrastructure.packageScripts.forEach((script, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "package-script",
+            targetKey: packageScriptKey(script.name),
+            sourceFieldPath: `testInfrastructure.packageScripts[${index}].name`
+        });
+    });
+    artifact.testInfrastructure.testCommands.forEach((command, index) => {
+        if (command.commandText !== null) {
+            records.push({
+                sourceArtifact: SOURCE_ARTIFACT,
+                sourceInstance,
+                category: "test-command",
+                targetKey: testCommandKey(command.commandText),
+                sourceFieldPath: `testInfrastructure.testCommands[${index}].commandText`
+            });
+        }
+    });
+    // Section 31: context-capsule provenance evidence
+    artifact.provenance.forEach((provenanceRecord, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(provenanceRecord.evidenceId),
+            sourceFieldPath: `provenance[${index}].evidenceId`
+        });
+    });
+    return dedupeEvidence(records);
+}

package/dist/src/evaluation/stageContextMetrics/collectRetrievalAuditEvidence.js

@@ -0,0 +1,35 @@
+const SOURCE_ARTIFACT = "retrieval-audit-record";
+function dedupeEvidence(records) {
+    const seen = new Set();
+    const result = [];
+    for (const record of records) {
+        const key = `${record.sourceInstance} ${record.category} ${record.targetKey}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(record);
+    }
+    return result;
+}
+export function collectRetrievalAuditEvidence(artifact, sourceInstance) {
+    const records = [];
+    artifact.responsibilityMappings.mappings.forEach((mapping, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "production-responsibility",
+            targetKey: `${SOURCE_ARTIFACT}|production-responsibility|responsibilityId:${mapping.responsibilityId}`,
+            sourceFieldPath: `responsibilityMappings.mappings[${index}].responsibilityId`
+        });
+    });
+    artifact.provenance.forEach((provenanceRecord, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: `${SOURCE_ARTIFACT}|provenance|evidenceId:${provenanceRecord.evidenceId}`,
+            sourceFieldPath: `provenance[${index}].evidenceId`
+        });
+    });
+    return dedupeEvidence(records);
+}