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

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

@@ -0,0 +1,265 @@
+const NO_BORROW_EVIDENCE_REASON = "The frozen my-dev-kit artifacts do not expose cross-group capacity borrowing evidence.";
+export function calculateAllocationFactsForGroups(evidenceGroups, sourceArtifact, sourceInstance) {
+    const requiredGroupCapacity = [];
+    const usedReservation = [];
+    const borrowedCapacity = [];
+    const unusedCapacity = [];
+    for (const group of evidenceGroups) {
+        requiredGroupCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: group.limit,
+            unit: "items",
+            availability: group.limit === null ? "unavailable" : "available",
+            reason: group.limit === null ? "No hard limit is declared for this evidence group." : null
+        });
+        usedReservation.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: group.usedCount,
+            unit: "items",
+            availability: "available",
+            reason: null
+        });
+        borrowedCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: null,
+            unit: "items",
+            availability: "unavailable",
+            reason: NO_BORROW_EVIDENCE_REASON
+        });
+        if (group.limit === null) {
+            unusedCapacity.push({
+                groupId: group.id,
+                sourceArtifact,
+                sourceInstance,
+                value: null,
+                unit: "items",
+                availability: "unavailable",
+                reason: "No hard limit is declared for this evidence group, so unused capacity cannot be computed."
+            });
+            continue;
+        }
+        const unused = group.limit - group.usedCount;
+        if (unused < 0) {
+            unusedCapacity.push({
+                groupId: group.id,
+                sourceArtifact,
+                sourceInstance,
+                value: null,
+                unit: "items",
+                availability: "unavailable",
+                reason: `Computed unused capacity was negative (used ${group.usedCount} exceeds limit ${group.limit}); treated as a data inconsistency rather than a valid value.`
+            });
+            continue;
+        }
+        unusedCapacity.push({
+            groupId: group.id,
+            sourceArtifact,
+            sourceInstance,
+            value: unused,
+            unit: "items",
+            availability: "available",
+            reason: null
+        });
+    }
+    return { requiredGroupCapacity, usedReservation, borrowedCapacity, unusedCapacity };
+}
+export function calculateRequiredEvidenceOmitted(matches, sourceArtifactTruncated) {
+    const missing = matches.filter((m) => m.inclusion === "required" && m.outcome === "missing");
+    if (missing.length === 0) {
+        return {
+            metric: { availability: "not-applicable", count: null, evidenceKeys: [], reason: "No required expectation is missing from observed evidence." },
+            entries: []
+        };
+    }
+    const entries = missing.map((m) => ({
+        evidenceKey: m.targetKey,
+        groupId: null,
+        truncationReported: sourceArtifactTruncated[m.sourceArtifact] ?? false,
+        sourceArtifact: m.sourceArtifact
+    }));
+    return {
+        metric: { availability: "available", count: entries.length, evidenceKeys: entries.map((e) => e.evidenceKey), reason: null },
+        entries
+    };
+}
+// Not currently consumed by the calculators above, but kept available for callers that
+// want to cross-check allocation expectations directly (bounded, deterministic; the lab
+// still never recalculates the producer's allocation decision).
+export function findAllocationExpectationForGroup(expectations, groupId) {
+    return (expectations ?? []).find((e) => e.groupId === groupId);
+}
+// v0.4.5 Batch 2: per-group/aggregate allocation and spillover evidence, read directly from
+// ContextCapsule.groupTruncation (the Batch 1 mirror of the v1.10.3/v1.10.4 required-first
+// allocator diagnostics). A group entry that lacks every additive allocation field is
+// legacy/unavailable, never fabricated as zero. RetrievalAuditRecord has no groupTruncation
+// field, so this evidence is context-capsule-only (sourceArtifact is always fixed).
+function hasAnyAllocationField(entry) {
+    return (entry.required !== undefined ||
+        entry.reservation !== undefined ||
+        entry.initiallySelectedCount !== undefined ||
+        entry.unusedReservationContributed !== undefined ||
+        entry.borrowedCapacity !== undefined ||
+        entry.requiredOmittedCount !== undefined ||
+        entry.optionalOmittedCount !== undefined ||
+        entry.adequacyAffected !== undefined ||
+        entry.governingHardBound !== undefined ||
+        entry.aggregateCapacityUsed !== undefined ||
+        entry.aggregateCapacityRemaining !== undefined);
+}
+function calculatePerGroupAllocation(entries, sourceInstance) {
+    return entries.map((entry) => {
+        const available = hasAnyAllocationField(entry);
+        return {
+            groupId: entry.groupId,
+            sourceArtifact: "context-capsule",
+            sourceInstance,
+            availability: available ? "available" : "unavailable",
+            required: entry.required ?? null,
+            reservation: entry.reservation ?? null,
+            initiallySelectedCount: entry.initiallySelectedCount ?? null,
+            unusedReservationContributed: entry.unusedReservationContributed ?? null,
+            borrowedCapacity: entry.borrowedCapacity ?? null,
+            governingHardBound: entry.governingHardBound ?? null,
+            requiredOmittedCount: entry.requiredOmittedCount ?? null,
+            optionalOmittedCount: entry.optionalOmittedCount ?? null,
+            droppedCount: entry.droppedCount,
+            droppedEvidenceIds: entry.droppedEvidenceIds ?? [],
+            adequacyAffected: entry.adequacyAffected ?? null,
+            aggregateCapacityUsed: entry.aggregateCapacityUsed ?? null,
+            aggregateCapacityRemaining: entry.aggregateCapacityRemaining ?? null,
+            reason: available ? null : `Group "${entry.groupId}" exposes no v1.10.3/v1.10.4 allocation diagnostics (legacy schema-major-1 evidence).`
+        };
+    });
+}
+function sumIfComplete(entries, field) {
+    if (entries.length === 0)
+        return null;
+    let total = 0;
+    for (const entry of entries) {
+        const value = entry[field];
+        if (typeof value !== "number")
+            return null;
+        total += value;
+    }
+    return total;
+}
+function calculateAggregateAllocation(entries) {
+    if (entries.length === 0) {
+        return {
+            availability: "not-applicable",
+            groupCount: 0,
+            totalReservation: null,
+            totalInitiallySelected: null,
+            totalUnusedReservationContributed: null,
+            totalBorrowedCapacity: null,
+            totalRequiredOmitted: null,
+            totalOptionalOmitted: null,
+            totalDropped: null,
+            groupsContributingUnusedReservation: [],
+            groupsBorrowingCapacity: [],
+            groupsWithRequiredOmission: [],
+            groupsWithOptionalOnlyOmission: [],
+            groupsWithAdequacyAffected: [],
+            partial: false,
+            reason: "No evidence groups were supplied."
+        };
+    }
+    const anyAllocationEvidence = entries.some(hasAnyAllocationField);
+    if (!anyAllocationEvidence) {
+        return {
+            availability: "unavailable",
+            groupCount: entries.length,
+            totalReservation: null,
+            totalInitiallySelected: null,
+            totalUnusedReservationContributed: null,
+            totalBorrowedCapacity: null,
+            totalRequiredOmitted: null,
+            totalOptionalOmitted: null,
+            totalDropped: null,
+            groupsContributingUnusedReservation: [],
+            groupsBorrowingCapacity: [],
+            groupsWithRequiredOmission: [],
+            groupsWithOptionalOnlyOmission: [],
+            groupsWithAdequacyAffected: [],
+            partial: false,
+            reason: "No group exposes v1.10.3/v1.10.4 allocation diagnostics (legacy schema-major-1 evidence)."
+        };
+    }
+    const totalReservation = sumIfComplete(entries, "reservation");
+    const totalInitiallySelected = sumIfComplete(entries, "initiallySelectedCount");
+    const totalUnusedReservationContributed = sumIfComplete(entries, "unusedReservationContributed");
+    const totalBorrowedCapacity = sumIfComplete(entries, "borrowedCapacity");
+    const totalRequiredOmitted = sumIfComplete(entries, "requiredOmittedCount");
+    const totalOptionalOmitted = sumIfComplete(entries, "optionalOmittedCount");
+    const totalDropped = sumIfComplete(entries, "droppedCount");
+    const totals = [
+        totalReservation,
+        totalInitiallySelected,
+        totalUnusedReservationContributed,
+        totalBorrowedCapacity,
+        totalRequiredOmitted,
+        totalOptionalOmitted
+    ];
+    const partial = totals.some((t) => t === null);
+    return {
+        availability: "available",
+        groupCount: entries.length,
+        totalReservation,
+        totalInitiallySelected,
+        totalUnusedReservationContributed,
+        totalBorrowedCapacity,
+        totalRequiredOmitted,
+        totalOptionalOmitted,
+        totalDropped,
+        groupsContributingUnusedReservation: entries.filter((e) => (e.unusedReservationContributed ?? 0) > 0).map((e) => e.groupId),
+        groupsBorrowingCapacity: entries.filter((e) => (e.borrowedCapacity ?? 0) > 0).map((e) => e.groupId),
+        groupsWithRequiredOmission: entries.filter((e) => (e.requiredOmittedCount ?? 0) > 0).map((e) => e.groupId),
+        groupsWithOptionalOnlyOmission: entries
+            .filter((e) => (e.optionalOmittedCount ?? 0) > 0 && (e.requiredOmittedCount ?? 0) === 0)
+            .map((e) => e.groupId),
+        groupsWithAdequacyAffected: entries.filter((e) => e.adequacyAffected === true).map((e) => e.groupId),
+        partial,
+        reason: partial ? "At least one group lacks the full allocation field set; incomplete totals are reported as null rather than partially summed." : null
+    };
+}
+function calculateSpillover(entries) {
+    const anyAllocationEvidence = entries.some(hasAnyAllocationField);
+    if (!anyAllocationEvidence) {
+        return {
+            availability: "unavailable",
+            groupsContributing: [],
+            groupsBorrowing: [],
+            totalContributed: null,
+            totalBorrowed: null,
+            contributionCoversBorrowing: null,
+            reason: "No group exposes v1.10.3/v1.10.4 allocation diagnostics (legacy schema-major-1 evidence)."
+        };
+    }
+    const groupsContributing = entries.filter((e) => (e.unusedReservationContributed ?? 0) > 0).map((e) => e.groupId);
+    const groupsBorrowing = entries.filter((e) => (e.borrowedCapacity ?? 0) > 0).map((e) => e.groupId);
+    const totalContributed = sumIfComplete(entries, "unusedReservationContributed");
+    const totalBorrowed = sumIfComplete(entries, "borrowedCapacity");
+    return {
+        availability: "available",
+        groupsContributing,
+        groupsBorrowing,
+        totalContributed,
+        totalBorrowed,
+        contributionCoversBorrowing: totalContributed !== null && totalBorrowed !== null ? totalContributed >= totalBorrowed : null,
+        reason: null
+    };
+}
+export function calculateGroupAllocationMetrics(groupTruncation, sourceInstance) {
+    const entries = groupTruncation ?? [];
+    return {
+        perGroup: calculatePerGroupAllocation(entries, sourceInstance),
+        aggregate: calculateAggregateAllocation(entries),
+        spillover: calculateSpillover(entries)
+    };
+}

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

@@ -0,0 +1,74 @@
+function unavailableCoverageMetrics(reason) {
+    const unavailableCount = { availability: "unavailable", count: null, evidenceKeys: [], reason };
+    return {
+        availability: "unavailable",
+        requiredConditionsTotal: unavailableCount,
+        requiredConditionsSatisfied: unavailableCount,
+        requiredConditionsMissing: unavailableCount,
+        requiredConditionsLost: unavailableCount,
+        optionalConditionsTotal: unavailableCount,
+        optionalConditionsSatisfied: unavailableCount,
+        optionalConditionsMissing: unavailableCount,
+        witnessEvidence: [],
+        lastWitnessLoss: unavailableCount,
+        conditionToGroupMapping: [],
+        reason
+    };
+}
+function countMetric(ids) {
+    return { availability: "available", count: ids.length, evidenceKeys: ids, reason: null };
+}
+function coverageState(condition) {
+    if (condition.conditionSatisfied)
+        return "satisfied";
+    if (condition.lostRequiredCondition)
+        return "lost-to-allocation";
+    return "missing-evidence";
+}
+export function calculateConditionCoverageMetrics(roleConditionCoverage, availableEvidenceGroupIds) {
+    if (roleConditionCoverage === undefined) {
+        return unavailableCoverageMetrics("No roleConditionCoverage evidence was supplied (legacy schema-major-1 artifact, or the producer did not emit condition-level diagnostics).");
+    }
+    const required = roleConditionCoverage.filter((c) => c.required);
+    const optional = roleConditionCoverage.filter((c) => !c.required);
+    const requiredSatisfied = required.filter((c) => c.conditionSatisfied);
+    const requiredLost = required.filter((c) => c.lostRequiredCondition);
+    const requiredMissing = required.filter((c) => !c.conditionSatisfied && !c.lostRequiredCondition);
+    const optionalSatisfied = optional.filter((c) => c.conditionSatisfied);
+    const optionalMissing = optional.filter((c) => !c.conditionSatisfied);
+    const witnessEvidence = roleConditionCoverage.map((c) => ({
+        conditionId: c.conditionId,
+        role: c.role,
+        required: c.required,
+        witnessPolicy: c.witnessPolicy,
+        requiredWitnessCount: c.requiredWitnessCount,
+        availableWitnessCount: c.availableWitnessCount,
+        retainedWitnessCount: c.retainedWitnessCount,
+        retainedWitnessIds: c.retainedWitnessIds,
+        adequateWitnessRemains: c.conditionSatisfied,
+        coverageState: coverageState(c),
+        lossReason: c.lossReason,
+        evidenceGroupIds: c.evidenceGroupIds
+    }));
+    const conditionToGroupMapping = roleConditionCoverage.map((c) => ({
+        conditionId: c.conditionId,
+        required: c.required,
+        evidenceGroupIds: c.evidenceGroupIds,
+        mapped: c.evidenceGroupIds.length > 0,
+        unknownGroupIds: availableEvidenceGroupIds === undefined ? [] : c.evidenceGroupIds.filter((id) => !availableEvidenceGroupIds.includes(id))
+    }));
+    return {
+        availability: "available",
+        requiredConditionsTotal: countMetric(required.map((c) => c.conditionId)),
+        requiredConditionsSatisfied: countMetric(requiredSatisfied.map((c) => c.conditionId)),
+        requiredConditionsMissing: countMetric(requiredMissing.map((c) => c.conditionId)),
+        requiredConditionsLost: countMetric(requiredLost.map((c) => c.conditionId)),
+        optionalConditionsTotal: countMetric(optional.map((c) => c.conditionId)),
+        optionalConditionsSatisfied: countMetric(optionalSatisfied.map((c) => c.conditionId)),
+        optionalConditionsMissing: countMetric(optionalMissing.map((c) => c.conditionId)),
+        witnessEvidence,
+        lastWitnessLoss: countMetric(requiredLost.map((c) => c.conditionId)),
+        conditionToGroupMapping,
+        reason: null
+    };
+}

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

@@ -0,0 +1,112 @@
+function findMapping(mappings, responsibilityId) {
+    return mappings?.find((m) => m.responsibilityId === responsibilityId);
+}
+export function calculateCriticalityMetrics(mappings, expectations) {
+    const list = expectations ?? [];
+    const overlayAgreement = [];
+    const missingCriticalityResponsibilityIds = [];
+    const conflictingCriticalityResponsibilityIds = [];
+    for (const e of list) {
+        if (!e.applicable) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: findMapping(mappings, e.responsibilityId)?.criticality ?? null,
+                agreement: null,
+                availability: "not-applicable",
+                reason: "Expectation is marked not applicable."
+            });
+            continue;
+        }
+        if (mappings === undefined) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: null,
+                agreement: null,
+                availability: "unavailable",
+                reason: "No raw responsibility-mapping evidence was supplied."
+            });
+            missingCriticalityResponsibilityIds.push(e.responsibilityId);
+            continue;
+        }
+        const mapping = findMapping(mappings, e.responsibilityId);
+        if (mapping === undefined) {
+            overlayAgreement.push({
+                responsibilityId: e.responsibilityId,
+                expectedCriticality: e.expectedCriticality,
+                observedCriticality: null,
+                agreement: null,
+                availability: "unavailable",
+                reason: "No raw mapping entry exists for this responsibility ID."
+            });
+            missingCriticalityResponsibilityIds.push(e.responsibilityId);
+            continue;
+        }
+        const agreement = mapping.criticality === e.expectedCriticality;
+        overlayAgreement.push({
+            responsibilityId: e.responsibilityId,
+            expectedCriticality: e.expectedCriticality,
+            observedCriticality: mapping.criticality,
+            agreement,
+            availability: "available",
+            reason: null
+        });
+        if (!agreement)
+            conflictingCriticalityResponsibilityIds.push(e.responsibilityId);
+    }
+    const unexpectedCriticalityResponsibilityIds = list.length === 0 || mappings === undefined
+        ? []
+        : mappings.filter((m) => !list.some((e) => e.responsibilityId === m.responsibilityId)).map((m) => m.responsibilityId);
+    const fullyMappedCriticalIds = [];
+    const partiallyMappedCriticalIds = [];
+    const unmappedCriticalIds = [];
+    const missingMappingEvidenceCriticalIds = [];
+    for (const e of list) {
+        if (!e.applicable || !e.requiresFullMapping || e.expectedCriticality !== "critical")
+            continue;
+        const mapping = findMapping(mappings, e.responsibilityId);
+        if (mapping === undefined) {
+            missingMappingEvidenceCriticalIds.push(e.responsibilityId);
+            continue;
+        }
+        if (mapping.mappingStatus === "mapped")
+            fullyMappedCriticalIds.push(e.responsibilityId);
+        else if (mapping.mappingStatus === "partially-mapped")
+            partiallyMappedCriticalIds.push(e.responsibilityId);
+        else if (mapping.mappingStatus === "unmapped")
+            unmappedCriticalIds.push(e.responsibilityId);
+        // mapping.mappingStatus === "not-applicable": excluded from the denominator entirely.
+    }
+    const denominator = fullyMappedCriticalIds.length + partiallyMappedCriticalIds.length + unmappedCriticalIds.length;
+    const mappedCriticalCompleteness = denominator === 0
+        ? {
+            availability: "not-applicable",
+            numerator: null,
+            denominator: null,
+            rate: null,
+            matchedExpectationIds: [],
+            missingExpectationIds: [],
+            reason: "No applicable critical responsibility requiring full mapping has resolvable mapping status."
+        }
+        : {
+            availability: "available",
+            numerator: fullyMappedCriticalIds.length,
+            denominator,
+            rate: fullyMappedCriticalIds.length / denominator,
+            matchedExpectationIds: fullyMappedCriticalIds,
+            missingExpectationIds: [...partiallyMappedCriticalIds, ...unmappedCriticalIds],
+            reason: null
+        };
+    return {
+        overlayAgreement,
+        missingCriticalityResponsibilityIds,
+        conflictingCriticalityResponsibilityIds,
+        unexpectedCriticalityResponsibilityIds,
+        mappedCriticalCompleteness,
+        fullyMappedCriticalIds,
+        partiallyMappedCriticalIds,
+        unmappedCriticalIds,
+        missingMappingEvidenceCriticalIds
+    };
+}

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

@@ -0,0 +1,84 @@
+export function collectSelectedOwnerEvidence(selectedOwners, sourceArtifact, sourceInstance) {
+    return selectedOwners.map((item) => ({
+        ownerId: item.id,
+        sourceArtifact,
+        sourceInstance,
+        itemKind: item.itemKind,
+        path: item.path ?? null,
+        symbolId: item.symbolId ?? null,
+        sourceFieldPath: `${sourceInstance}.selectedOwners`
+    }));
+}
+function notApplicableRatio(reason) {
+    return { availability: "not-applicable", numerator: null, denominator: null, rate: null, matchedExpectationIds: [], missingExpectationIds: [], reason };
+}
+function unavailableRatio(reason) {
+    return { availability: "unavailable", numerator: null, denominator: null, rate: null, matchedExpectationIds: [], missingExpectationIds: [], reason };
+}
+function notApplicableCount(reason) {
+    return { availability: "not-applicable", count: null, evidenceKeys: [], reason };
+}
+function unavailableCount(reason) {
+    return { availability: "unavailable", count: null, evidenceKeys: [], reason };
+}
+export function calculateOwnerMetrics(selectedOwnerEvidence, ownerExpectations) {
+    const evidence = selectedOwnerEvidence ?? [];
+    const evidenceUnavailable = selectedOwnerEvidence === undefined;
+    const unavailableReason = "Producer selected-owner evidence was not supplied to this metric.";
+    const requiredIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "required").map((e) => e.ownerId));
+    const allowedIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "allowed").map((e) => e.ownerId));
+    const forbiddenIds = new Set((ownerExpectations ?? []).filter((e) => e.inclusion === "forbidden").map((e) => e.ownerId));
+    const hasClosedSet = requiredIds.size > 0 || allowedIds.size > 0;
+    const observedIds = new Set(evidence.map((e) => e.ownerId));
+    const expectedOwnerPresent = evidenceUnavailable
+        ? unavailableRatio(unavailableReason)
+        : requiredIds.size === 0
+            ? notApplicableRatio("The expectation fixture contains no required owner expectations.")
+            : (() => {
+                const matched = [...requiredIds].filter((id) => observedIds.has(id));
+                const missing = [...requiredIds].filter((id) => !observedIds.has(id));
+                return {
+                    availability: "available",
+                    numerator: matched.length,
+                    denominator: requiredIds.size,
+                    rate: matched.length / requiredIds.size,
+                    matchedExpectationIds: matched,
+                    missingExpectationIds: missing,
+                    reason: null
+                };
+            })();
+    const forbiddenOwnerPresent = evidenceUnavailable
+        ? unavailableRatio(unavailableReason)
+        : forbiddenIds.size === 0
+            ? notApplicableRatio("The expectation fixture contains no forbidden owner expectations.")
+            : (() => {
+                const present = [...forbiddenIds].filter((id) => observedIds.has(id));
+                const absent = [...forbiddenIds].filter((id) => !observedIds.has(id));
+                return {
+                    availability: "available",
+                    numerator: present.length,
+                    denominator: forbiddenIds.size,
+                    rate: present.length / forbiddenIds.size,
+                    matchedExpectationIds: present,
+                    missingExpectationIds: absent,
+                    reason: null
+                };
+            })();
+    const falsePositiveCount = evidenceUnavailable
+        ? unavailableCount(unavailableReason)
+        : !hasClosedSet && forbiddenIds.size === 0
+            ? notApplicableCount("The expectation fixture defines neither a closed owner set nor forbidden owners.")
+            : (() => {
+                const falsePositives = [...observedIds].filter((id) => forbiddenIds.has(id) || (hasClosedSet && !requiredIds.has(id) && !allowedIds.has(id)));
+                return { availability: "available", count: falsePositives.length, evidenceKeys: falsePositives, reason: null };
+            })();
+    const falseNegativeCount = evidenceUnavailable
+        ? unavailableCount(unavailableReason)
+        : requiredIds.size === 0
+            ? notApplicableCount("The expectation fixture contains no required owner expectations.")
+            : (() => {
+                const falseNegatives = [...requiredIds].filter((id) => !observedIds.has(id));
+                return { availability: "available", count: falseNegatives.length, evidenceKeys: falseNegatives, reason: null };
+            })();
+    return { selectedOwnerEvidence: [...evidence], expectedOwnerPresent, forbiddenOwnerPresent, falsePositiveCount, falseNegativeCount };
+}

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

@@ -0,0 +1,113 @@
+import { checkMyDevKitContextArtifactConsistency } from "../stageContextSelectors/contextArtifactConsistency.js";
+const ADEQUATE_STATUSES = [
+    "context sufficient for implementation",
+    "context sufficient with listed assumptions"
+];
+const INADEQUATE_STATUSES = [
+    "context insufficient and more retrieval required",
+    "context conflict found and user or upstream stage decision required"
+];
+export function calculateProducerConditionAgreement(roleAdequacyStatus, conditionCoverage) {
+    if (roleAdequacyStatus === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            observedRoleAdequacyStatus: null,
+            contradictionCodes: [],
+            reason: "No roleAdequacy.status was supplied."
+        };
+    }
+    if (conditionCoverage.availability !== "available") {
+        return {
+            availability: "unavailable",
+            outcome: "unsupported-legacy-evidence",
+            observedRoleAdequacyStatus: roleAdequacyStatus,
+            contradictionCodes: [],
+            reason: conditionCoverage.reason ?? "No condition-coverage evidence was available to compare against roleAdequacy.status."
+        };
+    }
+    const requiredTotal = conditionCoverage.requiredConditionsTotal.count ?? 0;
+    const requiredSatisfied = conditionCoverage.requiredConditionsSatisfied.count ?? 0;
+    const requiredLost = conditionCoverage.requiredConditionsLost.count ?? 0;
+    const allRequiredSatisfied = requiredTotal > 0 && requiredSatisfied === requiredTotal;
+    const producerSaysAdequate = ADEQUATE_STATUSES.includes(roleAdequacyStatus);
+    const producerSaysInadequate = INADEQUATE_STATUSES.includes(roleAdequacyStatus);
+    const contradictionCodes = [];
+    if (producerSaysInadequate && allRequiredSatisfied && requiredLost === 0) {
+        contradictionCodes.push("PRODUCER_INADEQUATE_BUT_ALL_REQUIRED_CONDITIONS_RETAINED");
+    }
+    if (producerSaysAdequate && requiredLost > 0) {
+        contradictionCodes.push("PRODUCER_ADEQUATE_BUT_REQUIRED_CONDITION_LOST");
+    }
+    const outcome = contradictionCodes.length > 0 ? "contradiction" : "agreement";
+    return {
+        availability: "available",
+        outcome,
+        observedRoleAdequacyStatus: roleAdequacyStatus,
+        contradictionCodes,
+        reason: outcome === "contradiction"
+            ? "Producer role-adequacy status contradicts its own explicit condition-coverage evidence; both sides are retained."
+            : null
+    };
+}
+export function calculateRequiredEvidenceLossAgreement(requiredEvidenceLost, conditionCoverage, requiredOmittedCount) {
+    if (requiredEvidenceLost === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            requiredEvidenceLost: null,
+            explicitConditionLossDetected: null,
+            requiredOmittedCount: requiredOmittedCount ?? null,
+            contradictionCodes: [],
+            reason: "No truncation.requiredEvidenceLost rollup was supplied."
+        };
+    }
+    if (conditionCoverage.availability !== "available") {
+        return {
+            availability: "unavailable",
+            outcome: "unsupported-legacy-evidence",
+            requiredEvidenceLost,
+            explicitConditionLossDetected: null,
+            requiredOmittedCount: requiredOmittedCount ?? null,
+            contradictionCodes: [],
+            reason: conditionCoverage.reason ?? "No condition-coverage evidence was available to compare against requiredEvidenceLost."
+        };
+    }
+    const explicitConditionLossDetected = (conditionCoverage.requiredConditionsLost.count ?? 0) > 0;
+    const contradictionCodes = [];
+    if (!requiredEvidenceLost && explicitConditionLossDetected) {
+        contradictionCodes.push("REQUIRED_EVIDENCE_LOST_FALSE_BUT_CONDITION_LOSS_DETECTED");
+    }
+    if (requiredEvidenceLost && !explicitConditionLossDetected && (requiredOmittedCount ?? 0) === 0) {
+        contradictionCodes.push("REQUIRED_EVIDENCE_LOST_TRUE_BUT_NO_CONDITION_OR_GROUP_LOSS_DETECTED");
+    }
+    const outcome = contradictionCodes.length > 0 ? "contradiction" : "agreement";
+    return {
+        availability: "available",
+        outcome,
+        requiredEvidenceLost,
+        explicitConditionLossDetected,
+        requiredOmittedCount: requiredOmittedCount ?? null,
+        contradictionCodes,
+        reason: outcome === "contradiction" ? "truncation.requiredEvidenceLost contradicts explicit condition-loss/required-omission evidence; both sides are retained." : null
+    };
+}
+const RELEVANT_CAPSULE_AUDIT_FIELDS = new Set(["roleConditionCoverage", "truncation", "roleAdequacy"]);
+export function calculateCapsuleAuditConditionAgreement(capsule, audit) {
+    if (capsule === undefined || audit === undefined) {
+        const reason = capsule === undefined && audit === undefined
+            ? "Neither a context capsule nor a retrieval audit record was supplied."
+            : capsule === undefined
+                ? "No context capsule was supplied."
+                : "No retrieval audit record was supplied.";
+        return { availability: "unavailable", consistent: null, contradictingFieldPaths: [], reason };
+    }
+    const result = checkMyDevKitContextArtifactConsistency(capsule, audit);
+    const contradictingFieldPaths = result.issues.filter((issue) => RELEVANT_CAPSULE_AUDIT_FIELDS.has(issue.fieldPath)).map((issue) => issue.fieldPath);
+    return {
+        availability: "available",
+        consistent: contradictingFieldPaths.length === 0,
+        contradictingFieldPaths,
+        reason: null
+    };
+}