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

package/dist/src/evaluation/ecosystemFixtures/loadContextIntegrityFixture.js

@@ -0,0 +1,102 @@
+// v0.4.5 Batch 4: bounded end-to-end fixture loader (section 22). Loads a frozen
+// context-integrity ecosystem fixture (failed-run or corrected-replay) through the existing
+// Batch 1 producer readers and Batch 3 run-integrity reader, verifies hashes, and rejects
+// path traversal. It never recalculates metrics itself -- evaluation happens through the
+// existing evaluateProducerReadinessBridge, called by the test/consumer, not by this loader.
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { readMyDevKitContextCapsuleV1 } from "../upstreamArtifacts/readMyDevKitContextCapsuleV1.js";
+import { readMyDevKitRetrievalAuditRecordV1 } from "../upstreamArtifacts/readMyDevKitRetrievalAuditRecordV1.js";
+import { readOrchestratorRunIntegrityEvidenceV1 } from "../upstreamArtifacts/readOrchestratorRunIntegrityV1.js";
+import { isSafeFixtureRelativePath, validateEcosystemFixtureManifest } from "./validateManifest.js";
+import { verifyFixtureHashes } from "./verifyFixtureHashes.js";
+function findEntry(manifest, role) {
+    return manifest.artifacts.find((a) => a.role === role && a.evaluationUse);
+}
+export async function loadContextIntegrityFixture(fixtureRoot, manifestPath) {
+    const issues = [];
+    let manifestRaw;
+    try {
+        manifestRaw = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            manifest: null,
+            hashVerification: null,
+            implementationCapsule: null,
+            implementationAudit: null,
+            runIntegrityEvidence: null,
+            issues: [`Manifest at "${manifestPath}" could not be read or parsed: ${error.message}`]
+        };
+    }
+    const manifestResult = validateEcosystemFixtureManifest(manifestRaw);
+    if (!manifestResult.ok) {
+        return {
+            ok: false,
+            manifest: null,
+            hashVerification: null,
+            implementationCapsule: null,
+            implementationAudit: null,
+            runIntegrityEvidence: null,
+            issues: manifestResult.issues.map((i) => `[${i.code}] ${i.fieldPath}: ${i.message}`)
+        };
+    }
+    const manifest = manifestResult.manifest;
+    const hashVerification = await verifyFixtureHashes(manifest, fixtureRoot);
+    if (!hashVerification.ok) {
+        issues.push(...hashVerification.issues.map((i) => `[${i.code}] ${i.fixtureRelativePath}: ${i.message}`));
+    }
+    function resolveSafe(relativePath) {
+        if (!isSafeFixtureRelativePath(relativePath)) {
+            issues.push(`Refused to resolve unsafe fixture-relative path "${relativePath}".`);
+            return null;
+        }
+        return path.resolve(fixtureRoot, relativePath);
+    }
+    let implementationCapsule = null;
+    const capsuleEntry = findEntry(manifest, "context-capsule");
+    if (capsuleEntry) {
+        const resolved = resolveSafe(capsuleEntry.fixtureRelativePath);
+        if (resolved) {
+            const result = await readMyDevKitContextCapsuleV1(resolved);
+            if (result.ok)
+                implementationCapsule = result.artifact;
+            else
+                issues.push(`context-capsule reader failed for "${capsuleEntry.fixtureRelativePath}": [${result.code}] ${result.message}`);
+        }
+    }
+    let implementationAudit = null;
+    const auditEntry = findEntry(manifest, "retrieval-audit-record");
+    if (auditEntry) {
+        const resolved = resolveSafe(auditEntry.fixtureRelativePath);
+        if (resolved) {
+            const result = await readMyDevKitRetrievalAuditRecordV1(resolved);
+            if (result.ok)
+                implementationAudit = result.artifact;
+            else
+                issues.push(`retrieval-audit-record reader failed for "${auditEntry.fixtureRelativePath}": [${result.code}] ${result.message}`);
+        }
+    }
+    let runIntegrityEvidence = null;
+    const runIntegrityEntry = findEntry(manifest, "run-integrity-evidence");
+    if (runIntegrityEntry) {
+        const resolved = resolveSafe(runIntegrityEntry.fixtureRelativePath);
+        if (resolved) {
+            const result = await readOrchestratorRunIntegrityEvidenceV1(resolved);
+            if (result.ok)
+                runIntegrityEvidence = result.artifact;
+            else
+                issues.push(`run-integrity-evidence reader failed for "${runIntegrityEntry.fixtureRelativePath}": [${result.code}] ${result.message}`);
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        manifest,
+        hashVerification,
+        implementationCapsule,
+        implementationAudit,
+        runIntegrityEvidence,
+        issues
+    };
+}

package/dist/src/evaluation/ecosystemFixtures/manifestTypes.js

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

package/dist/src/evaluation/ecosystemFixtures/validateManifest.js

@@ -0,0 +1,82 @@
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Rejects any fixture-relative path that is absolute, empty, or escapes the fixture root
+// via ".." segments (section 22 "rejects path traversal"). Windows and POSIX separators are
+// both checked since fixture manifests are authored on Windows but tests may run on either.
+export function isSafeFixtureRelativePath(candidate) {
+    if (candidate.length === 0)
+        return false;
+    if (candidate.startsWith("/") || candidate.startsWith("\\"))
+        return false;
+    if (/^[a-zA-Z]:[\\/]/.test(candidate))
+        return false;
+    const segments = candidate.split(/[\\/]/);
+    return segments.every((segment) => segment !== "..") && segments.length > 0;
+}
+export function validateEcosystemFixtureManifest(value) {
+    const issues = [];
+    if (!isPlainObject(value)) {
+        return { ok: false, issues: [{ code: "NON_OBJECT_MANIFEST", fieldPath: "", message: "Manifest must be a plain JSON object." }] };
+    }
+    const schemaVersion = value["manifestSchemaVersion"];
+    if (typeof schemaVersion !== "string" || !/^1\./.test(schemaVersion)) {
+        return {
+            ok: false,
+            issues: [
+                {
+                    code: "UNSUPPORTED_MANIFEST_SCHEMA_MAJOR",
+                    fieldPath: "manifestSchemaVersion",
+                    message: `Manifest schema version "${String(schemaVersion)}" is unsupported; expected major version 1.`
+                }
+            ]
+        };
+    }
+    const requiredStringFields = ["fixtureId", "description", "sourceEvidenceRoot", "generatedAt"];
+    for (const field of requiredStringFields) {
+        if (typeof value[field] !== "string" || value[field].length === 0) {
+            issues.push({ code: "MISSING_REQUIRED_FIELD", fieldPath: field, message: `Manifest is missing required non-empty string field "${field}".` });
+        }
+    }
+    const artifacts = value["artifacts"];
+    if (!Array.isArray(artifacts)) {
+        issues.push({ code: "INVALID_FIELD_TYPE", fieldPath: "artifacts", message: 'Manifest field "artifacts" must be an array.' });
+    }
+    else {
+        const seenPaths = new Set();
+        artifacts.forEach((entry, index) => {
+            const fieldPath = `artifacts[${index}]`;
+            if (!isPlainObject(entry)) {
+                issues.push({ code: "INVALID_FIELD_TYPE", fieldPath, message: "Each artifact entry must be an object." });
+                return;
+            }
+            const relPath = entry["fixtureRelativePath"];
+            if (typeof relPath !== "string" || relPath.length === 0) {
+                issues.push({ code: "MISSING_REQUIRED_FIELD", fieldPath: `${fieldPath}.fixtureRelativePath`, message: "Missing fixtureRelativePath." });
+                return;
+            }
+            if (!isSafeFixtureRelativePath(relPath)) {
+                issues.push({
+                    code: "PATH_ESCAPES_FIXTURE_ROOT",
+                    fieldPath: `${fieldPath}.fixtureRelativePath`,
+                    message: `fixtureRelativePath "${relPath}" is absolute or escapes the fixture root.`
+                });
+                return;
+            }
+            if (seenPaths.has(relPath)) {
+                issues.push({ code: "DUPLICATE_ARTIFACT_PATH", fieldPath: `${fieldPath}.fixtureRelativePath`, message: `Duplicate fixtureRelativePath "${relPath}".` });
+                return;
+            }
+            seenPaths.add(relPath);
+            for (const hashField of ["originalSha256", "copiedSha256"]) {
+                const v = entry[hashField];
+                if (typeof v !== "string" || !/^[0-9a-f]{64}$/i.test(v)) {
+                    issues.push({ code: "INVALID_FIELD_TYPE", fieldPath: `${fieldPath}.${hashField}`, message: `${hashField} must be a 64-hex-character SHA-256 digest.` });
+                }
+            }
+        });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    return { ok: true, manifest: value };
+}

package/dist/src/evaluation/ecosystemFixtures/verifyFixtureHashes.js

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { isSafeFixtureRelativePath } from "./validateManifest.js";
+async function sha256OfFile(absolutePath) {
+    const contents = await readFile(absolutePath);
+    return createHash("sha256").update(contents).digest("hex");
+}
+// Section 21: reads the manifest, hashes each tracked fixture file, and reports missing
+// files, hash mismatches, and path-traversal attempts with deterministic (manifest) order.
+// Never rewrites the manifest or the fixture; a mismatch is reported, not repaired.
+export async function verifyFixtureHashes(manifest, fixtureRoot) {
+    const issues = [];
+    let checkedCount = 0;
+    for (const artifact of manifest.artifacts) {
+        const relPath = artifact.fixtureRelativePath;
+        if (!isSafeFixtureRelativePath(relPath)) {
+            issues.push({ code: "PATH_ESCAPES_FIXTURE_ROOT", fixtureRelativePath: relPath, message: `Manifest entry references an unsafe path: "${relPath}".` });
+            continue;
+        }
+        const absolutePath = path.resolve(fixtureRoot, relPath);
+        let actualSha256;
+        try {
+            actualSha256 = await sha256OfFile(absolutePath);
+        }
+        catch (error) {
+            const code = error.code;
+            issues.push({
+                code: code === "ENOENT" ? "MISSING_FILE" : "UNREADABLE_FILE",
+                fixtureRelativePath: relPath,
+                message: code === "ENOENT" ? `Fixture file is missing: "${relPath}".` : `Fixture file could not be read: "${relPath}" (${error.message}).`
+            });
+            continue;
+        }
+        checkedCount += 1;
+        if (actualSha256 !== artifact.copiedSha256) {
+            issues.push({
+                code: "HASH_MISMATCH",
+                fixtureRelativePath: relPath,
+                message: `Fixture file "${relPath}" hash does not match the manifest's recorded copiedSha256 (expected ${artifact.copiedSha256}, got ${actualSha256}).`
+            });
+        }
+    }
+    return { ok: issues.length === 0, checkedCount, issues };
+}

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),