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

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

@@ -94,3 +94,172 @@ export function calculateRequiredEvidenceOmitted(matches, sourceArtifactTruncate
 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/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
+    };
+}

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

@@ -2,6 +2,10 @@
 // output (Batch 1) -- this module only compares it against an explicit fixture-declared
 // expectation. It never calls, imports, or reimplements contextReadiness.ts.
 import { checkSupplementalReadinessIdentityConsistency } from "../upstreamArtifacts/index.js";
+const READINESS_ADEQUATE_STATUSES = [
+    "context sufficient for implementation",
+    "context sufficient with listed assumptions"
+];
 function unavailableStructural(field, reason) {
     return { field, expectedValue: null, observedValue: null, agreement: null, availability: "unavailable", reason };
 }
@@ -142,6 +146,62 @@ export function calculateValidBlocked(readiness, expectation) {
     const valid = allowsRefreshRequired && issueCodesMatch && primaryMatches;
     return { availability: "available", validBlocked: valid, validRefreshRequired: valid, observedDecision: readiness.decision, reason: null };
 }
+// v0.4.5 Batch 2 (section 18): compares producer role adequacy (as already reconciled with
+// condition-coverage evidence by calculateProducerConditionAgreement) against the supplied
+// orchestrator readiness decision already accepted by the v0.4.4 bridge. This never decides
+// what readiness "should" have been -- it only reports the observed relationship.
+export function calculateProducerReadinessRelationship(roleAdequacyStatus, producerConditionAgreement, readiness) {
+    if (roleAdequacyStatus === undefined || readiness === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            observedRoleAdequacyStatus: roleAdequacyStatus ?? null,
+            observedReadinessDecision: readiness?.decision ?? null,
+            contradictionCodes: [],
+            reason: roleAdequacyStatus === undefined && readiness === undefined
+                ? "Neither roleAdequacy.status nor a readiness result was supplied."
+                : roleAdequacyStatus === undefined
+                    ? "No roleAdequacy.status was supplied."
+                    : "No readiness result was supplied."
+        };
+    }
+    if (producerConditionAgreement.outcome === "contradiction") {
+        return {
+            availability: "available",
+            outcome: "insufficient-evidence",
+            observedRoleAdequacyStatus: roleAdequacyStatus,
+            observedReadinessDecision: readiness.decision,
+            contradictionCodes: [],
+            reason: "Producer role-adequacy already contradicts its own condition-coverage evidence; the readiness relationship cannot be attributed to either side."
+        };
+    }
+    if (producerConditionAgreement.outcome === "unsupported-legacy-evidence" || producerConditionAgreement.outcome === "insufficient-evidence") {
+        return {
+            availability: "unavailable",
+            outcome: producerConditionAgreement.outcome,
+            observedRoleAdequacyStatus: roleAdequacyStatus,
+            observedReadinessDecision: readiness.decision,
+            contradictionCodes: [],
+            reason: producerConditionAgreement.reason
+        };
+    }
+    const producerAdequate = READINESS_ADEQUATE_STATUSES.includes(roleAdequacyStatus);
+    const readinessReady = readiness.decision === "ready";
+    const contradictionCodes = [];
+    if (producerAdequate && !readinessReady)
+        contradictionCodes.push("PRODUCER_ADEQUATE_BUT_READINESS_NOT_READY");
+    if (!producerAdequate && readinessReady)
+        contradictionCodes.push("PRODUCER_INADEQUATE_BUT_READINESS_READY");
+    const outcome = contradictionCodes.length > 0 ? "contradiction" : "agreement";
+    return {
+        availability: "available",
+        outcome,
+        observedRoleAdequacyStatus: roleAdequacyStatus,
+        observedReadinessDecision: readiness.decision,
+        contradictionCodes,
+        reason: outcome === "contradiction" ? "Producer role adequacy and supplied orchestrator readiness disagree; both sides are retained without a lab-owned verdict." : null
+    };
+}
 export function calculateReadinessAgreementMetrics(readiness, expectation, supplementalPacket, packetSourcePath) {
     return {
         structuralAgreement: calculateReadinessStructuralAgreement(readiness, supplementalPacket, packetSourcePath),