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

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

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

@@ -0,0 +1,137 @@
+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;
+}
+function workflowStableIdKey(sourceArtifact, category, id) {
+    return `${sourceArtifact}|${category}|id:${id}`;
+}
+function provenanceKey(sourceArtifact, evidenceId) {
+    return `${sourceArtifact}|provenance|evidenceId:${evidenceId}`;
+}
+export function collectWorkflowInstructionPacketEvidence(artifact, sourceInstance) {
+    const SOURCE_ARTIFACT = "workflow-instruction-packet";
+    const records = [];
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "workflow",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "workflow", artifact.workflowId),
+        sourceFieldPath: "workflowId"
+    });
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "stage",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "stage", artifact.stageId),
+        sourceFieldPath: "stageId"
+    });
+    artifact.resolvedCommands.forEach((command, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "command",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "command", command.id),
+            sourceFieldPath: `resolvedCommands[${index}].id`
+        });
+    });
+    artifact.resolvedRules.forEach((rule, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "rule",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "rule", rule.id),
+            sourceFieldPath: `resolvedRules[${index}].id`
+        });
+    });
+    records.push({
+        sourceArtifact: SOURCE_ARTIFACT,
+        sourceInstance,
+        category: "report-contract",
+        targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "report-contract", artifact.reportContract.id),
+        sourceFieldPath: "reportContract.id"
+    });
+    artifact.resolutionProvenance.forEach((entry, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, entry.sourceEntryId),
+            sourceFieldPath: `resolutionProvenance[${index}].sourceEntryId`
+        });
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, entry.referencedEntryId),
+            sourceFieldPath: `resolutionProvenance[${index}].referencedEntryId`
+        });
+    });
+    return dedupeEvidence(records);
+}
+export function collectFullWorkflowLibraryEvidence(fixture, sourceInstance) {
+    const SOURCE_ARTIFACT = "full-workflow-library";
+    const records = [];
+    fixture.workflowIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "workflow",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "workflow", id),
+            sourceFieldPath: `workflowIds[${index}]`
+        });
+    });
+    fixture.stageIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "stage",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "stage", id),
+            sourceFieldPath: `stageIds[${index}]`
+        });
+    });
+    fixture.commandIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "command",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "command", id),
+            sourceFieldPath: `commandIds[${index}]`
+        });
+    });
+    fixture.ruleIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "rule",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "rule", id),
+            sourceFieldPath: `ruleIds[${index}]`
+        });
+    });
+    fixture.reportContractIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "report-contract",
+            targetKey: workflowStableIdKey(SOURCE_ARTIFACT, "report-contract", id),
+            sourceFieldPath: `reportContractIds[${index}]`
+        });
+    });
+    fixture.provenanceEvidenceIds.forEach((id, index) => {
+        records.push({
+            sourceArtifact: SOURCE_ARTIFACT,
+            sourceInstance,
+            category: "provenance",
+            targetKey: provenanceKey(SOURCE_ARTIFACT, id),
+            sourceFieldPath: `provenanceEvidenceIds[${index}]`
+        });
+    });
+    return dedupeEvidence(records);
+}

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

@@ -0,0 +1,247 @@
+import { collectContextCapsuleEvidence } from "./collectContextCapsuleEvidence.js";
+import { collectRetrievalAuditEvidence } from "./collectRetrievalAuditEvidence.js";
+import { collectFullWorkflowLibraryEvidence, collectWorkflowInstructionPacketEvidence } from "./collectWorkflowInstructionEvidence.js";
+import { matchStageContextExpectations } from "./matchStageContextExpectations.js";
+import { calculateAllowedEvidenceCoverage, calculateForbiddenEvidenceInclusion, calculateIrrelevantFileInclusion, calculateIrrelevantInstructionInclusion, calculateRequiredEvidenceRecall, calculateRequiredProvenanceRecall } from "./calculateExpectationMetrics.js";
+import { calculateContextCapsuleResponsibilityMappingMetric, calculateRetrievalAuditResponsibilityMappingMetric } from "./calculateResponsibilityMappingMetrics.js";
+import { compareExpectedContextCapsuleState, compareExpectedRetrievalAuditState, compareExpectedTargetImmutabilityState, compareExpectedWorkflowInstructionPacketState } from "./calculateArtifactStateMetrics.js";
+import { calculateV043ExecutionContextSize } from "./calculateContextSizeMetrics.js";
+function collectExecutionEvidence(execution) {
+    const evidence = [];
+    function pushPairEvidence(pair, labelPrefix) {
+        evidence.push(...collectContextCapsuleEvidence(pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            evidence.push(...collectRetrievalAuditEvidence(pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            pushPairEvidence(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairEvidence(payload.architecture, "architecture");
+            pushPairEvidence(payload.implementation, "implementation");
+            pushPairEvidence(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "full-workflow-library": {
+            const payload = execution.payload;
+            evidence.push(...collectFullWorkflowLibraryEvidence(payload.fullWorkflowLibrary, "fullWorkflowLibrary"));
+            break;
+        }
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            evidence.push(...collectWorkflowInstructionPacketEvidence(payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairEvidence(pair, `contextArtifacts[${index}]`);
+            });
+            evidence.push(...collectWorkflowInstructionPacketEvidence(payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+    }
+    return evidence;
+}
+function collectResponsibilityMetrics(execution) {
+    const metrics = [];
+    function pushPairMetrics(pair, labelPrefix) {
+        metrics.push(calculateContextCapsuleResponsibilityMappingMetric(pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            metrics.push(calculateRetrievalAuditResponsibilityMappingMetric(pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            pushPairMetrics(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairMetrics(payload.architecture, "architecture");
+            pushPairMetrics(payload.implementation, "implementation");
+            pushPairMetrics(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairMetrics(pair, `contextArtifacts[${index}]`);
+            });
+            break;
+        }
+        case "full-workflow-library":
+        case "bounded-workflow-instruction-packet":
+            break;
+    }
+    return metrics;
+}
+function buildTargetImmutabilityMetric(targetImmutability) {
+    if (targetImmutability === undefined) {
+        return {
+            availability: "unavailable",
+            count: null,
+            evidenceKeys: [],
+            reason: "Target immutability configuration was not supplied for this strategy run."
+        };
+    }
+    if (targetImmutability.availability === "unavailable") {
+        return {
+            availability: "unavailable",
+            count: null,
+            evidenceKeys: [],
+            reason: targetImmutability.reason
+        };
+    }
+    return {
+        availability: "available",
+        count: targetImmutability.comparison.newMutationCount,
+        evidenceKeys: targetImmutability.comparison.mutations.map((mutation) => mutation.id),
+        reason: null
+    };
+}
+function collectStateComparisons(execution, targetImmutability) {
+    const expectedStates = execution.expectations.expectedStates;
+    const comparisons = [];
+    function pushPairComparisons(pair, labelPrefix) {
+        comparisons.push(...compareExpectedContextCapsuleState(expectedStates.contextCapsule, pair.contextCapsule, `${labelPrefix}.contextCapsule`));
+        if (pair.retrievalAuditRecord) {
+            comparisons.push(...compareExpectedRetrievalAuditState(expectedStates.retrievalAuditRecord, pair.retrievalAuditRecord, `${labelPrefix}.retrievalAuditRecord`));
+        }
+    }
+    switch (execution.strategyId) {
+        case "architecture-context-only": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            break;
+        }
+        case "architecture-plus-implementation-refresh": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            pushPairComparisons(payload.implementation, "implementation");
+            break;
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const payload = execution.payload;
+            pushPairComparisons(payload.architecture, "architecture");
+            pushPairComparisons(payload.implementation, "implementation");
+            pushPairComparisons(payload.testImplementation, "testImplementation");
+            break;
+        }
+        case "full-workflow-library":
+            break;
+        case "bounded-workflow-instruction-packet": {
+            const payload = execution.payload;
+            comparisons.push(...compareExpectedWorkflowInstructionPacketState(expectedStates.workflowInstructionPacket, payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+        case "combined-bounded-stage-context": {
+            const payload = execution.payload;
+            payload.contextArtifacts.forEach((pair, index) => {
+                pushPairComparisons(pair, `contextArtifacts[${index}]`);
+            });
+            comparisons.push(...compareExpectedWorkflowInstructionPacketState(expectedStates.workflowInstructionPacket, payload.workflowInstructionPacket, "workflowInstructionPacket"));
+            break;
+        }
+    }
+    comparisons.push(...compareExpectedTargetImmutabilityState(expectedStates.targetImmutability, targetImmutability));
+    return comparisons;
+}
+export function evaluateV043StageContextExecution(execution, context) {
+    try {
+        if (execution.status === "invalid-input") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "invalid-input",
+                reason: "Metrics are not applicable because strategy input validation failed."
+            };
+        }
+        if (execution.status === "failed") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "failed",
+                reason: "Metrics are not applicable because strategy execution failed."
+            };
+        }
+        const status = execution.status;
+        if (status === "unavailable") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "unavailable",
+                reason: "Metrics are not applicable because strategy execution is unavailable."
+            };
+        }
+        if (status === "not-applicable") {
+            return {
+                status: "not-applicable",
+                strategyId: execution.strategyId,
+                executionStatus: "not-applicable",
+                reason: "Metrics are not applicable to this strategy execution."
+            };
+        }
+        const observedEvidence = collectExecutionEvidence(execution);
+        const expectationMatches = matchStageContextExpectations(execution.expectations, observedEvidence);
+        const metrics = {
+            requiredEvidenceRecall: calculateRequiredEvidenceRecall(expectationMatches),
+            allowedEvidenceCoverage: calculateAllowedEvidenceCoverage(expectationMatches),
+            forbiddenEvidenceInclusion: calculateForbiddenEvidenceInclusion(expectationMatches),
+            irrelevantFileInclusion: calculateIrrelevantFileInclusion(execution.expectations, observedEvidence),
+            irrelevantInstructionInclusion: calculateIrrelevantInstructionInclusion(execution.expectations, observedEvidence),
+            requiredProvenanceRecall: calculateRequiredProvenanceRecall(expectationMatches),
+            responsibilityMappingCompleteness: collectResponsibilityMetrics(execution),
+            stateComparisons: collectStateComparisons(execution, context?.targetImmutability),
+            contextSize: calculateV043ExecutionContextSize(execution),
+            consideredButUnselectedReads: {
+                availability: "unavailable",
+                count: null,
+                evidenceKeys: [],
+                reason: "The published upstream artifacts do not expose considered-but-unselected reads."
+            },
+            unnecessaryReads: {
+                availability: "unavailable",
+                count: null,
+                evidenceKeys: [],
+                reason: "The published upstream artifacts do not expose unnecessary-read evidence."
+            },
+            targetImmutability: buildTargetImmutabilityMetric(context?.targetImmutability)
+        };
+        return {
+            status: "completed",
+            strategyId: execution.strategyId,
+            executionStatus: "completed",
+            expectationMatches,
+            observedEvidence,
+            metrics,
+            warnings: []
+        };
+    }
+    catch {
+        return {
+            status: "failed",
+            strategyId: execution.strategyId,
+            executionStatus: execution.status,
+            reason: "Unexpected v0.4.3 stage-context metric evaluation failure."
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+export { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+export { collectContextCapsuleEvidence } from "./collectContextCapsuleEvidence.js";
+export { collectRetrievalAuditEvidence } from "./collectRetrievalAuditEvidence.js";
+export { collectFullWorkflowLibraryEvidence, collectWorkflowInstructionPacketEvidence } from "./collectWorkflowInstructionEvidence.js";
+export { matchStageContextExpectations } from "./matchStageContextExpectations.js";
+export { calculateAllowedEvidenceCoverage, calculateForbiddenEvidenceInclusion, calculateIrrelevantFileInclusion, calculateIrrelevantInstructionInclusion, calculateRequiredEvidenceRecall, calculateRequiredProvenanceRecall } from "./calculateExpectationMetrics.js";
+export { compareExpectedContextCapsuleState, compareExpectedRetrievalAuditState, compareExpectedTargetImmutabilityState, compareExpectedWorkflowInstructionPacketState } from "./calculateArtifactStateMetrics.js";
+export { calculateContextCapsuleResponsibilityMappingMetric, calculateRetrievalAuditResponsibilityMappingMetric } from "./calculateResponsibilityMappingMetrics.js";
+export { calculateV043ExecutionContextSize } from "./calculateContextSizeMetrics.js";
+export { evaluateV043StageContextExecution } from "./evaluateV043StageContextExecution.js";

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

@@ -0,0 +1,38 @@
+import { buildStageContextExpectationTargetKey } from "./targetKeys.js";
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+export function matchStageContextExpectations(expectations, observedEvidence) {
+    return expectations.expectedEvidence.map((item) => {
+        const targetKey = buildStageContextExpectationTargetKey(item);
+        const observedMatches = observedEvidence.filter((evidence) => evidence.sourceArtifact === item.sourceArtifact && evidence.category === item.category && evidence.targetKey === targetKey);
+        const matchedSourceInstances = dedupeStrings(observedMatches.map((evidence) => evidence.sourceInstance));
+        const matchedSourceFieldPaths = dedupeStrings(observedMatches.map((evidence) => evidence.sourceFieldPath));
+        const hasMatch = observedMatches.length > 0;
+        let outcome;
+        if (item.inclusion === "forbidden") {
+            outcome = hasMatch ? "violated" : "matched";
+        }
+        else {
+            outcome = hasMatch ? "matched" : "missing";
+        }
+        return {
+            expectationId: item.expectationId,
+            inclusion: item.inclusion,
+            sourceArtifact: item.sourceArtifact,
+            category: item.category,
+            targetKey,
+            outcome,
+            matchedSourceInstances,
+            matchedSourceFieldPaths
+        };
+    });
+}

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

@@ -0,0 +1,35 @@
+export function buildStageContextExpectationTargetKey(item) {
+    switch (item.category) {
+        case "file":
+        case "test-file":
+        case "fixture":
+        case "factory":
+        case "mock":
+        case "setup-file":
+        case "test-configuration":
+            return `${item.sourceArtifact}|${item.category}|path:${item.match.path}`;
+        case "symbol":
+        case "contract":
+        case "validator":
+        case "constant":
+        case "error":
+        case "schema-or-serializer":
+            return `${item.sourceArtifact}|${item.category}|symbolId:${item.match.symbolId}`;
+        case "source-range":
+            return `context-capsule|source-range|filePath:${item.match.filePath}|startLine:${item.match.startLine}|endLine:${item.match.endLine}`;
+        case "production-responsibility":
+            return `${item.sourceArtifact}|production-responsibility|responsibilityId:${item.match.responsibilityId}`;
+        case "package-script":
+            return `context-capsule|package-script|name:${item.match.name}`;
+        case "test-command":
+            return `context-capsule|test-command|commandText:${item.match.commandText}`;
+        case "workflow":
+        case "stage":
+        case "command":
+        case "rule":
+        case "report-contract":
+            return `${item.sourceArtifact}|${item.category}|id:${item.match.id}`;
+        case "provenance":
+            return `${item.sourceArtifact}|provenance|evidenceId:${item.match.evidenceId}`;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/stageContextSelectors/contextArtifactConsistency.js

@@ -0,0 +1,79 @@
+import { isDeepStrictEqual } from "node:util";
+export function checkMyDevKitContextArtifactConsistency(capsule, audit) {
+    const comparisons = [
+        { fieldPath: "schemaVersion", capsuleValue: capsule.schemaVersion, auditValue: audit.schemaVersion },
+        {
+            fieldPath: "tool",
+            capsuleValue: capsule.tool,
+            auditValue: audit.tool
+        },
+        {
+            fieldPath: "request",
+            capsuleValue: capsule.request,
+            auditValue: audit.request
+        },
+        { fieldPath: "index.indexPath", capsuleValue: capsule.index.indexPath, auditValue: audit.index.indexPath },
+        {
+            fieldPath: "index.manifestPath",
+            capsuleValue: capsule.index.manifestPath,
+            auditValue: audit.index.manifestPath
+        },
+        {
+            fieldPath: "contextAdequacy",
+            capsuleValue: capsule.contextAdequacy,
+            auditValue: audit.contextAdequacy
+        },
+        {
+            fieldPath: "roleContext",
+            capsuleValue: capsule.roleContext,
+            auditValue: audit.roleContext
+        },
+        {
+            fieldPath: "responsibilityMappings",
+            capsuleValue: capsule.responsibilityMappings,
+            auditValue: audit.responsibilityMappings
+        },
+        {
+            fieldPath: "roleAdequacy",
+            capsuleValue: capsule.roleAdequacy,
+            auditValue: audit.roleAdequacy
+        },
+        {
+            fieldPath: "freshness",
+            capsuleValue: capsule.freshness,
+            auditValue: audit.freshness
+        },
+        {
+            fieldPath: "budget",
+            capsuleValue: capsule.budget,
+            auditValue: audit.budget
+        },
+        {
+            fieldPath: "truncation",
+            capsuleValue: capsule.truncation,
+            auditValue: audit.truncation
+        },
+        {
+            fieldPath: "fullFileFallback",
+            capsuleValue: capsule.fullFileFallback,
+            auditValue: audit.fullFileFallback
+        },
+        {
+            fieldPath: "provenance",
+            capsuleValue: capsule.provenance,
+            auditValue: audit.provenance
+        }
+    ];
+    const issues = [];
+    for (const comparison of comparisons) {
+        if (!isDeepStrictEqual(comparison.capsuleValue, comparison.auditValue)) {
+            issues.push({
+                fieldPath: comparison.fieldPath,
+                capsuleValue: comparison.capsuleValue,
+                auditValue: comparison.auditValue,
+                message: `ContextCapsule and RetrievalAuditRecord differ at "${comparison.fieldPath}".`
+            });
+        }
+    }
+    return { consistent: issues.length === 0, issues };
+}