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

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

@@ -0,0 +1,130 @@
+import { isDeepStrictEqual } from "node:util";
+function compareValue(sourceArtifact, sourceInstance, expectationFieldPath, artifactFieldPath, expected, actual, matched) {
+    return {
+        sourceArtifact,
+        sourceInstance,
+        expectationFieldPath,
+        artifactFieldPath,
+        availability: "available",
+        expected,
+        actual,
+        matched,
+        reason: null
+    };
+}
+function unavailableComparison(sourceArtifact, sourceInstance, expectationFieldPath, expected, reason) {
+    return {
+        sourceArtifact,
+        sourceInstance,
+        expectationFieldPath,
+        artifactFieldPath: null,
+        availability: "unavailable",
+        expected,
+        actual: null,
+        matched: null,
+        reason
+    };
+}
+export function compareExpectedContextCapsuleState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "context-capsule";
+    if (expected.contextAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "contextAdequacyStatus", "contextAdequacy.status", expected.contextAdequacyStatus, artifact.contextAdequacy.status, artifact.contextAdequacy.status === expected.contextAdequacyStatus));
+    }
+    if (expected.roleAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "roleAdequacyStatus", "roleAdequacy.status", expected.roleAdequacyStatus, artifact.roleAdequacy.status, artifact.roleAdequacy.status === expected.roleAdequacyStatus));
+    }
+    if (expected.freshnessState !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "freshnessState", "freshness.state", expected.freshnessState, artifact.freshness.state, artifact.freshness.state === expected.freshnessState));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.fullFileFallbackUsed !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "fullFileFallbackUsed", "fullFileFallback.used", expected.fullFileFallbackUsed, artifact.fullFileFallback.used, artifact.fullFileFallback.used === expected.fullFileFallbackUsed));
+    }
+    if (expected.unresolvedItemIds !== undefined) {
+        comparisons.push(unavailableComparison(SA, sourceInstance, "unresolvedItemIds", expected.unresolvedItemIds, "ContextCapsule unresolvedItems do not expose stable item IDs."));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedRetrievalAuditState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "retrieval-audit-record";
+    if (expected.contextAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "contextAdequacyStatus", "contextAdequacy.status", expected.contextAdequacyStatus, artifact.contextAdequacy.status, artifact.contextAdequacy.status === expected.contextAdequacyStatus));
+    }
+    if (expected.roleAdequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "roleAdequacyStatus", "roleAdequacy.status", expected.roleAdequacyStatus, artifact.roleAdequacy.status, artifact.roleAdequacy.status === expected.roleAdequacyStatus));
+    }
+    if (expected.freshnessState !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "freshnessState", "freshness.state", expected.freshnessState, artifact.freshness.state, artifact.freshness.state === expected.freshnessState));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.fullFileFallbackUsed !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "fullFileFallbackUsed", "fullFileFallback.used", expected.fullFileFallbackUsed, artifact.fullFileFallback.used, artifact.fullFileFallback.used === expected.fullFileFallbackUsed));
+    }
+    if (expected.unresolvedItemIds !== undefined) {
+        comparisons.push(unavailableComparison(SA, sourceInstance, "unresolvedItemIds", expected.unresolvedItemIds, "RetrievalAuditRecord does not serialize unresolved item IDs."));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedWorkflowInstructionPacketState(expected, artifact, sourceInstance) {
+    if (expected === undefined)
+        return [];
+    const comparisons = [];
+    const SA = "workflow-instruction-packet";
+    if (expected.adequacyStatus !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "adequacyStatus", "adequacy.status", expected.adequacyStatus, artifact.adequacy.status, artifact.adequacy.status === expected.adequacyStatus));
+    }
+    if (expected.truncated !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "truncated", "truncation.truncated", expected.truncated, artifact.truncation.truncated, artifact.truncation.truncated === expected.truncated));
+    }
+    if (expected.unresolvedReferences !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "unresolvedReferences", "unresolvedReferences", expected.unresolvedReferences, artifact.unresolvedReferences, isDeepStrictEqual(artifact.unresolvedReferences, expected.unresolvedReferences)));
+    }
+    if (expected.warningCount !== undefined) {
+        comparisons.push(compareValue(SA, sourceInstance, "warningCount", "warnings.length", expected.warningCount, artifact.warnings.length, artifact.warnings.length === expected.warningCount));
+    }
+    return comparisons;
+}
+export function compareExpectedTargetImmutabilityState(expected, targetImmutability) {
+    if (expected === undefined)
+        return [];
+    const SA = "target-immutability";
+    const expectationFieldPath = "expectedStates.targetImmutability.newMutationCount";
+    if (targetImmutability === undefined) {
+        return [
+            unavailableComparison(SA, "target", expectationFieldPath, expected.newMutationCount, "Target immutability configuration was not supplied for this strategy run.")
+        ];
+    }
+    if (targetImmutability.availability === "unavailable") {
+        return [unavailableComparison(SA, "target", expectationFieldPath, expected.newMutationCount, targetImmutability.reason)];
+    }
+    const comparison = targetImmutability.comparison;
+    return [
+        {
+            sourceArtifact: SA,
+            sourceInstance: "target",
+            expectationFieldPath,
+            artifactFieldPath: "targetImmutability.comparison.newMutationCount",
+            availability: "available",
+            expected: expected.newMutationCount,
+            actual: comparison.newMutationCount,
+            matched: expected.newMutationCount === comparison.newMutationCount,
+            reason: null
+        }
+    ];
+}

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

@@ -0,0 +1,85 @@
+function estimateTokens(characterCount) {
+    return Math.ceil(characterCount / 4);
+}
+function pairSources(pair, labelPrefix) {
+    const sources = [];
+    const capsuleCharacterCount = JSON.stringify(pair.contextCapsule).length;
+    sources.push({
+        sourceInstance: `${labelPrefix}.contextCapsule`,
+        sourceKind: "context-capsule",
+        characterCount: capsuleCharacterCount,
+        estimatedTokenCount: estimateTokens(capsuleCharacterCount)
+    });
+    if (pair.retrievalAuditRecord) {
+        const auditCharacterCount = JSON.stringify(pair.retrievalAuditRecord).length;
+        sources.push({
+            sourceInstance: `${labelPrefix}.retrievalAuditRecord`,
+            sourceKind: "retrieval-audit-record",
+            characterCount: auditCharacterCount,
+            estimatedTokenCount: estimateTokens(auditCharacterCount)
+        });
+    }
+    return sources;
+}
+export function calculateV043ExecutionContextSize(execution) {
+    const sources = [];
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            sources.push(...pairSources(payload.implementation, "implementation"));
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            sources.push(...pairSources(payload.architecture, "architecture"));
+            sources.push(...pairSources(payload.implementation, "implementation"));
+            sources.push(...pairSources(payload.testImplementation, "testImplementation"));
+            break;
+        }
+        case "full-workflow-library": {
+            const payload = execution.payload;
+            const characterCount = payload.fullWorkflowLibrary.rawText.length;
+            sources.push({
+                sourceInstance: "fullWorkflowLibrary.rawText",
+                sourceKind: "full-workflow-library-text",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            const characterCount = JSON.stringify(payload.workflowInstructionPacket).length;
+            sources.push({
+                sourceInstance: "workflowInstructionPacket",
+                sourceKind: "workflow-instruction-packet",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                sources.push(...pairSources(pair, `contextArtifacts[${index}]`));
+            });
+            const characterCount = JSON.stringify(payload.workflowInstructionPacket).length;
+            sources.push({
+                sourceInstance: "workflowInstructionPacket",
+                sourceKind: "workflow-instruction-packet",
+                characterCount,
+                estimatedTokenCount: estimateTokens(characterCount)
+            });
+            break;
+        }
+    }
+    const totalCharacterCount = sources.reduce((sum, source) => sum + source.characterCount, 0);
+    const totalEstimatedTokenCount = sources.reduce((sum, source) => sum + source.estimatedTokenCount, 0);
+    return { availability: "available", sources, totalCharacterCount, totalEstimatedTokenCount };
+}

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

@@ -0,0 +1,103 @@
+import { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+const INSTRUCTION_CATEGORIES = ["workflow", "stage", "command", "rule", "report-contract"];
+function buildRatioMetric(filtered, targetOutcome, notApplicableReason) {
+    if (filtered.length === 0) {
+        return {
+            availability: "not-applicable",
+            numerator: null,
+            denominator: null,
+            rate: null,
+            matchedExpectationIds: [],
+            missingExpectationIds: [],
+            reason: notApplicableReason
+        };
+    }
+    const matchedExpectationIds = [];
+    const missingExpectationIds = [];
+    for (const match of filtered) {
+        if (match.outcome === targetOutcome) {
+            matchedExpectationIds.push(match.expectationId);
+        }
+        else {
+            missingExpectationIds.push(match.expectationId);
+        }
+    }
+    return {
+        availability: "available",
+        numerator: matchedExpectationIds.length,
+        denominator: filtered.length,
+        rate: matchedExpectationIds.length / filtered.length,
+        matchedExpectationIds,
+        missingExpectationIds,
+        reason: null
+    };
+}
+export function calculateRequiredEvidenceRecall(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "required");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no required evidence items.");
+}
+export function calculateAllowedEvidenceCoverage(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "allowed");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no allowed evidence items.");
+}
+export function calculateForbiddenEvidenceInclusion(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "forbidden");
+    return buildRatioMetric(filtered, "violated", "The expectation fixture contains no forbidden evidence items.");
+}
+export function calculateRequiredProvenanceRecall(matches) {
+    const filtered = matches.filter((match) => match.inclusion === "required" && match.category === "provenance");
+    return buildRatioMetric(filtered, "matched", "The expectation fixture contains no required provenance items.");
+}
+export function calculateIrrelevantFileInclusion(expectations, observedEvidence) {
+    const fileEvidence = observedEvidence.filter((evidence) => evidence.sourceArtifact === "context-capsule" && evidence.category === "file");
+    if (fileEvidence.length === 0) {
+        return {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "The completed strategy contains no context-capsule file evidence."
+        };
+    }
+    const coveredKeys = new Set(expectations.expectedEvidence
+        .filter((item) => item.sourceArtifact === "context-capsule" &&
+        item.category === "file" &&
+        (item.inclusion === "required" || item.inclusion === "allowed"))
+        .map((item) => buildStageContextExpectationTargetKey(item)));
+    const seen = new Set();
+    const evidenceKeys = [];
+    for (const evidence of fileEvidence) {
+        if (coveredKeys.has(evidence.targetKey))
+            continue;
+        if (seen.has(evidence.targetKey))
+            continue;
+        seen.add(evidence.targetKey);
+        evidenceKeys.push(evidence.targetKey);
+    }
+    return { availability: "available", count: evidenceKeys.length, evidenceKeys, reason: null };
+}
+export function calculateIrrelevantInstructionInclusion(expectations, observedEvidence) {
+    const instructionEvidence = observedEvidence.filter((evidence) => (evidence.sourceArtifact === "workflow-instruction-packet" || evidence.sourceArtifact === "full-workflow-library") &&
+        INSTRUCTION_CATEGORIES.includes(evidence.category));
+    if (instructionEvidence.length === 0) {
+        return {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "The completed strategy contains no workflow instruction evidence."
+        };
+    }
+    const coveredKeys = new Set(expectations.expectedEvidence
+        .filter((item) => INSTRUCTION_CATEGORIES.includes(item.category) && (item.inclusion === "required" || item.inclusion === "allowed"))
+        .map((item) => buildStageContextExpectationTargetKey(item)));
+    const seen = new Set();
+    const evidenceKeys = [];
+    for (const evidence of instructionEvidence) {
+        if (coveredKeys.has(evidence.targetKey))
+            continue;
+        if (seen.has(evidence.targetKey))
+            continue;
+        seen.add(evidence.targetKey);
+        evidenceKeys.push(evidence.targetKey);
+    }
+    return { availability: "available", count: evidenceKeys.length, evidenceKeys, reason: null };
+}

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/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);
+}