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

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

@@ -0,0 +1,309 @@
+import { selectStageMayRenderNormalPrompt } from "../stageContextSelectors/orchestratorRunIntegritySelectors.js";
+const CONTEXT_SENSITIVE_STAGE_NAMES = ["implementation", "test-implementation"];
+function contradiction(code, fieldPath, expected, observed, reason) {
+    return { code, fieldPath, expected, observed, reason };
+}
+// --- section 19: readiness vs prompt mode ----------------------------------------------
+export function calculateReadinessPromptAgreement(evidence, stageName) {
+    const readinessClassification = evidence.gate.readinessClassification;
+    const stageMayRenderNormalPrompt = selectStageMayRenderNormalPrompt(evidence, stageName) ?? null;
+    if (!CONTEXT_SENSITIVE_STAGE_NAMES.includes(stageName)) {
+        return {
+            availability: "not-applicable",
+            outcome: "not-applicable",
+            readinessClassification,
+            stageMayRenderNormalPrompt,
+            contradictions: [],
+            reason: `Stage "${stageName}" is not a context-sensitive stage; the gate does not attach a prompt-mode decision to it.`
+        };
+    }
+    if (stageMayRenderNormalPrompt === null) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            readinessClassification,
+            stageMayRenderNormalPrompt: null,
+            contradictions: [],
+            reason: "No prompt-mode decision was derivable for this stage."
+        };
+    }
+    const contradictions = [];
+    if (readinessClassification === "ready" && !stageMayRenderNormalPrompt) {
+        contradictions.push(contradiction("READY_BUT_PROMPT_NOT_NORMAL", "gate.readinessClassification", "ready", "refresh-only", "Readiness is ready but this stage may not render its normal prompt."));
+    }
+    if (readinessClassification === "refresh-required" && stageMayRenderNormalPrompt) {
+        contradictions.push(contradiction("REFRESH_REQUIRED_BUT_PROMPT_NORMAL", "gate.readinessClassification", "refresh-required", "normal", "Readiness is refresh-required but this stage may still render its normal prompt."));
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        readinessClassification,
+        stageMayRenderNormalPrompt,
+        contradictions,
+        reason: contradictions.length > 0 ? "Readiness classification and stage prompt-mode evidence disagree." : null
+    };
+}
+// --- section 20: readiness vs expected judge verdict ------------------------------------
+export function calculateReadinessExpectedJudgeAgreement(evidence) {
+    const { contextReady, expectedJudgeVerdict } = evidence.gate;
+    const contradictions = [];
+    if (contextReady && expectedJudgeVerdict !== "PASS") {
+        contradictions.push(contradiction("CONTEXT_READY_BUT_EXPECTED_NOT_PASS", "gate.expectedJudgeVerdict", "PASS", expectedJudgeVerdict, "contextReady is true but expectedJudgeVerdict is not PASS."));
+    }
+    if (!contextReady && expectedJudgeVerdict !== "NEED_CONTEXT") {
+        contradictions.push(contradiction("CONTEXT_NOT_READY_BUT_EXPECTED_NOT_NEED_CONTEXT", "gate.expectedJudgeVerdict", "NEED_CONTEXT", expectedJudgeVerdict, "contextReady is false but expectedJudgeVerdict is not NEED_CONTEXT."));
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        contextReady,
+        expectedJudgeVerdict,
+        contradictions,
+        reason: contradictions.length > 0 ? "The gate's own contextReady/expectedJudgeVerdict invariant does not hold for this evidence." : null
+    };
+}
+// --- section 21: expected vs parsed (actual) judge verdict -------------------------------
+export function calculateExpectedActualJudgeAgreement(evidence) {
+    const judgeIntegrity = evidence.judgeIntegrity;
+    if (judgeIntegrity === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            expectedJudgeVerdict: evidence.gate.expectedJudgeVerdict,
+            authoredJudgeVerdict: null,
+            judgeVerdictParseStatus: null,
+            judgeVerdictAccepted: null,
+            contradictions: [],
+            reason: "No judgeIntegrity evidence was supplied."
+        };
+    }
+    const contradictions = [];
+    const { expectedJudgeVerdict, authoredJudgeVerdict, judgeVerdictParseStatus, judgeVerdictAccepted, judgeVerdictMatchesExpected, blockingCodes } = judgeIntegrity;
+    if (judgeVerdictParseStatus === "unknown-verdict") {
+        contradictions.push(contradiction("JUDGE_VERDICT_UNKNOWN", "judgeIntegrity.judgeVerdictParseStatus", "parsed", "unknown-verdict", "Judge report declares an unrecognized verdict."));
+    }
+    else if (judgeVerdictParseStatus === "missing-verdict") {
+        contradictions.push(contradiction("JUDGE_VERDICT_MISSING", "judgeIntegrity.judgeVerdictParseStatus", "parsed", "missing-verdict", "Judge report does not declare a verdict."));
+    }
+    else if (judgeVerdictParseStatus === "missing-artifact") {
+        contradictions.push(contradiction("JUDGE_REPORT_MISSING", "judgeIntegrity.judgeArtifactPresent", "true", "false", "No judge report artifact exists."));
+    }
+    else if (authoredJudgeVerdict === "PASS" && expectedJudgeVerdict === "NEED_CONTEXT") {
+        // The exact upstream contradiction code (src/judgeIntegrity.ts
+        // JUDGE_VERDICT_CONTRADICTS_RUN_INTEGRITY), preserved verbatim when present.
+        contradictions.push(contradiction(blockingCodes.includes("JUDGE_VERDICT_CONTRADICTS_RUN_INTEGRITY") ? "JUDGE_VERDICT_CONTRADICTS_RUN_INTEGRITY" : "AUTHORED_PASS_CONTRADICTS_EXPECTED_NEED_CONTEXT", "judgeIntegrity.authoredJudgeVerdict", "NEED_CONTEXT", "PASS", 'Judge report authored "PASS" but canonical readiness still requires NEED_CONTEXT.'));
+    }
+    else if (judgeVerdictAccepted && judgeVerdictMatchesExpected === false && authoredJudgeVerdict !== null) {
+        // A syntactically valid, accepted verdict that legitimately differs from the expected
+        // one without being the PASS/NEED_CONTEXT contradiction above (e.g. a correction-route
+        // verdict, or a terminal BLOCKED/SCOPE_VIOLATION verdict) is not itself an integrity
+        // contradiction -- it is the normal correction-required or blocked shape.
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        expectedJudgeVerdict,
+        authoredJudgeVerdict,
+        judgeVerdictParseStatus,
+        judgeVerdictAccepted,
+        contradictions,
+        reason: contradictions.length > 0 ? contradictions[0].reason : null
+    };
+}
+// --- section 22: judge verdict vs correction route ---------------------------------------
+const TERMINAL_BLOCKED_VERDICTS = ["SCOPE_VIOLATION", "BLOCKED"];
+export function calculateJudgeCorrectionAgreement(evidence) {
+    const judgeIntegrity = evidence.judgeIntegrity;
+    if (judgeIntegrity === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            authoredJudgeVerdict: null,
+            correctionRequired: null,
+            acceptedCorrectionStage: null,
+            routedStage: null,
+            contradictions: [],
+            reason: "No judgeIntegrity evidence was supplied."
+        };
+    }
+    const { authoredJudgeVerdict, correctionRequired, correctionBlocked, acceptedCorrectionStage, acceptedCorrectionRoute } = judgeIntegrity;
+    const routedStage = acceptedCorrectionRoute?.routedStage ?? null;
+    const contradictions = [];
+    if (authoredJudgeVerdict === "PASS" && acceptedCorrectionRoute !== null) {
+        contradictions.push(contradiction("PASS_WITH_ACTIVE_CORRECTION_ROUTE", "judgeIntegrity.acceptedCorrectionRoute", "null", "active", "Judge verdict is PASS but an active correction route is present."));
+    }
+    if (authoredJudgeVerdict !== null &&
+        authoredJudgeVerdict !== "PASS" &&
+        !TERMINAL_BLOCKED_VERDICTS.includes(authoredJudgeVerdict) &&
+        !correctionBlocked &&
+        correctionRequired &&
+        acceptedCorrectionRoute === null) {
+        contradictions.push(contradiction("CORRECTIVE_VERDICT_WITHOUT_ROUTE", "judgeIntegrity.acceptedCorrectionRoute", "active", "null", `Judge verdict "${authoredJudgeVerdict}" requires correction but no correction route is present.`));
+    }
+    if (acceptedCorrectionStage !== null && routedStage !== null && acceptedCorrectionStage !== routedStage) {
+        contradictions.push(contradiction("CORRECTION_DESTINATION_MISMATCH", "judgeIntegrity.acceptedCorrectionStage", routedStage, acceptedCorrectionStage, "acceptedCorrectionStage does not match the structured correction route's routedStage."));
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        authoredJudgeVerdict,
+        correctionRequired,
+        acceptedCorrectionStage,
+        routedStage,
+        contradictions,
+        reason: contradictions.length > 0 ? contradictions[0].reason : null
+    };
+}
+// --- section 23: readiness/judge vs final-report eligibility -----------------------------
+export function calculateJudgeFinalEligibilityAgreement(evidence) {
+    const judgeIntegrity = evidence.judgeIntegrity;
+    if (judgeIntegrity === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            authoredJudgeVerdict: null,
+            judgeVerdictAccepted: null,
+            judgeVerdictMatchesExpected: null,
+            finalReportEligible: null,
+            contradictions: [],
+            reason: "No judgeIntegrity evidence was supplied."
+        };
+    }
+    const { authoredJudgeVerdict, judgeVerdictAccepted, judgeVerdictMatchesExpected, finalReportEligible, judgeVerdictParseStatus } = judgeIntegrity;
+    const contradictions = [];
+    if (finalReportEligible && authoredJudgeVerdict !== "PASS") {
+        contradictions.push(contradiction("ELIGIBLE_WITH_NON_PASS_JUDGE", "judgeIntegrity.finalReportEligible", "PASS", authoredJudgeVerdict, "finalReportEligible is true but the authored judge verdict is not PASS."));
+    }
+    if (finalReportEligible && judgeVerdictParseStatus !== "parsed") {
+        contradictions.push(contradiction("ELIGIBLE_WITH_MALFORMED_OR_MISSING_JUDGE", "judgeIntegrity.finalReportEligible", "parsed", judgeVerdictParseStatus, "finalReportEligible is true but the judge verdict was not successfully parsed."));
+    }
+    if (finalReportEligible && !judgeVerdictAccepted) {
+        contradictions.push(contradiction("ELIGIBLE_WITH_UNACCEPTED_JUDGE", "judgeIntegrity.finalReportEligible", "true", "false", "finalReportEligible is true but judgeVerdictAccepted is false."));
+    }
+    if (finalReportEligible && judgeVerdictMatchesExpected === false) {
+        contradictions.push(contradiction("ELIGIBLE_WITH_UNMATCHED_EXPECTED_VERDICT", "judgeIntegrity.finalReportEligible", "true", "false", "finalReportEligible is true but judgeVerdictMatchesExpected is false."));
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        authoredJudgeVerdict,
+        judgeVerdictAccepted,
+        judgeVerdictMatchesExpected,
+        finalReportEligible,
+        contradictions,
+        reason: contradictions.length > 0 ? contradictions[0].reason : null
+    };
+}
+// --- section 24: final eligibility vs final artifact and verdict -------------------------
+export function calculateEligibilityFinalArtifactAgreement(evidence) {
+    const eligibility = evidence.finalReportEligibility;
+    const finalArtifactPresent = evidence.finalArtifactPresent;
+    const finalArtifactVerdict = evidence.finalArtifactVerdict ?? null;
+    if (eligibility === undefined || finalArtifactPresent === undefined) {
+        return {
+            availability: "unavailable",
+            outcome: "insufficient-evidence",
+            eligible: eligibility?.eligible ?? null,
+            finalArtifactPresent: finalArtifactPresent ?? null,
+            finalArtifactVerdict,
+            contradictions: [],
+            reason: eligibility === undefined ? "No finalReportEligibility evidence was supplied." : "No finalArtifactPresent evidence was supplied."
+        };
+    }
+    const { eligible } = eligibility;
+    const contradictions = [];
+    if (eligible && !finalArtifactPresent) {
+        contradictions.push(contradiction("ELIGIBLE_BUT_ARTIFACT_MISSING", "finalArtifactPresent", "true", "false", "The run is final-report eligible but no final artifact is present."));
+    }
+    if (!eligible && finalArtifactPresent) {
+        contradictions.push(contradiction("INELIGIBLE_BUT_ARTIFACT_PRESENT", "finalArtifactPresent", "false", "true", "The run is not final-report eligible but a final artifact is present."));
+    }
+    if (!eligible && finalArtifactVerdict === "PASS") {
+        // The required v0.4.5 failure detection: NEED_CONTEXT (or any other ineligible state)
+        // followed by a normal PASS final report must report an integrity contradiction.
+        const expectedJudge = evidence.gate.expectedJudgeVerdict;
+        contradictions.push(contradiction(expectedJudge === "NEED_CONTEXT" ? "NEED_CONTEXT_FOLLOWED_BY_FINAL_PASS" : "INELIGIBLE_WITH_FINAL_PASS", "finalArtifactVerdict", "not PASS", "PASS", expectedJudge === "NEED_CONTEXT"
+            ? "Canonical readiness required NEED_CONTEXT, yet a final report with verdict PASS exists."
+            : "The run is not final-report eligible, yet a final report with verdict PASS exists."));
+    }
+    if (finalArtifactPresent && evidence.finalArtifactVerdict === undefined) {
+        contradictions.push(contradiction("FINAL_ARTIFACT_MALFORMED_VERDICT", "finalArtifactVerdict", "parsed", "undefined", "A final artifact is present but its verdict was not supplied."));
+    }
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        eligible,
+        finalArtifactPresent,
+        finalArtifactVerdict,
+        contradictions,
+        reason: contradictions.length > 0 ? contradictions[0].reason : null
+    };
+}
+// --- section 25: lifecycle integrity -----------------------------------------------------
+export function calculateLifecycleIntegrityAgreement(evidence) {
+    if (evidence.lifecycle.length === 0) {
+        return { availability: "not-applicable", outcome: "not-applicable", entries: [], contradictions: [], reason: "No lifecycle evidence was supplied." };
+    }
+    const contradictions = [];
+    const entries = evidence.lifecycle.map((entry) => {
+        const completionBasis = entry.resolvedState !== "complete" ? "not-complete" : entry.manualRecord === null ? "artifact-presence-only" : "manual-record";
+        const markCompleteRejected = entry.manualRecord?.state === "complete" && entry.resolvedState !== "complete";
+        const stageContextBlocked = CONTEXT_SENSITIVE_STAGE_NAMES.includes(entry.stageName) &&
+            evidence.gate.blockedStageNames.includes(entry.stageName);
+        const finalReportIneligible = entry.stageName === "final-report" && evidence.finalReportEligibility?.eligible === false;
+        const shouldBeBlocked = stageContextBlocked || finalReportIneligible;
+        const bypassSucceeded = shouldBeBlocked && entry.resolvedState === "complete";
+        if (bypassSucceeded) {
+            contradictions.push(contradiction("MANUAL_MARK_COMPLETE_BYPASS_SUCCEEDED", `lifecycle[${entry.stageName}].resolvedState`, "blocked", "complete", `Stage "${entry.stageName}" should be run-integrity-blocked but resolved to "complete"${completionBasis === "artifact-presence-only" ? " through artifact presence alone" : " despite a manual mark-complete record"}.`));
+        }
+        return { artifactFile: entry.artifactFile, stageName: entry.stageName, resolvedState: entry.resolvedState, completionBasis, markCompleteRejected, bypassSucceeded };
+    });
+    return {
+        availability: "available",
+        outcome: contradictions.length > 0 ? "contradiction" : "agreement",
+        entries,
+        contradictions,
+        reason: contradictions.length > 0 ? "At least one lifecycle entry resolved to complete despite required run-integrity blocking." : null
+    };
+}
+// --- section 26: end-to-end aggregate summary ---------------------------------------------
+function summarize(producerReadinessOutcome, readinessPrompt, readinessExpectedJudge, expectedActualJudge, judgeCorrection, judgeFinalEligibility, eligibilityFinalArtifact, lifecycleIntegrity) {
+    const componentOutcomes = {
+        producerReadiness: producerReadinessOutcome,
+        readinessPrompt,
+        readinessExpectedJudge,
+        expectedActualJudge,
+        judgeCorrection,
+        judgeFinalEligibility,
+        eligibilityFinalArtifact,
+        lifecycleIntegrity
+    };
+    const contradictingComponents = Object.keys(componentOutcomes).filter((key) => componentOutcomes[key] === "contradiction");
+    const category = contradictingComponents.length > 0
+        ? "contradiction-present"
+        : Object.values(componentOutcomes).some((o) => o === "insufficient-evidence")
+            ? "insufficient-evidence"
+            : Object.values(componentOutcomes).some((o) => o === "unsupported-legacy-evidence")
+                ? "unsupported-legacy-evidence"
+                : "full-agreement";
+    return { category, componentOutcomes, contradictingComponents };
+}
+export function evaluateRunIntegrity(evidence, stageName, producerReadinessOutcome = "not-applicable") {
+    const readinessPrompt = calculateReadinessPromptAgreement(evidence, stageName);
+    const readinessExpectedJudge = calculateReadinessExpectedJudgeAgreement(evidence);
+    const expectedActualJudge = calculateExpectedActualJudgeAgreement(evidence);
+    const judgeCorrection = calculateJudgeCorrectionAgreement(evidence);
+    const judgeFinalEligibility = calculateJudgeFinalEligibilityAgreement(evidence);
+    const eligibilityFinalArtifact = calculateEligibilityFinalArtifactAgreement(evidence);
+    const lifecycleIntegrity = calculateLifecycleIntegrityAgreement(evidence);
+    return {
+        readinessPrompt,
+        readinessExpectedJudge,
+        expectedActualJudge,
+        judgeCorrection,
+        judgeFinalEligibility,
+        eligibilityFinalArtifact,
+        lifecycleIntegrity,
+        endToEndSummary: summarize(producerReadinessOutcome, readinessPrompt.outcome, readinessExpectedJudge.outcome, expectedActualJudge.outcome, judgeCorrection.outcome, judgeFinalEligibility.outcome, eligibilityFinalArtifact.outcome, lifecycleIntegrity.outcome)
+    };
+}

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

@@ -3,7 +3,8 @@ function extractRawIdentity(artifact) {
         projectRoot: artifact.index.projectRoot,
         role: artifact.request.role,
         freshnessState: artifact.freshness.state,
-        truncated: artifact.truncation.truncated
+        truncated: artifact.truncation.truncated,
+        requiredEvidenceLost: artifact.truncation.requiredEvidenceLost
     };
 }
 function truncationToYesNo(value) {
@@ -26,7 +27,8 @@ export function calculateSupplementalRawAgreement(supplemental, raw) {
             buildField("canonicalRepositoryIdentity", null, supplemental?.indexIdentity ?? null, reason),
             buildField("role", null, supplemental?.role ?? null, reason),
             buildField("freshness", null, supplemental?.freshness ?? null, reason),
-            buildField("requiredEvidenceTruncated", null, supplemental?.requiredEvidenceTruncated ?? null, reason)
+            buildField("requiredEvidenceTruncated", null, supplemental?.requiredEvidenceTruncated ?? null, reason),
+            buildField("requiredEvidenceLost", null, supplemental?.requiredEvidenceTruncated ?? null, reason)
         ];
         return { fields, contradictions: [], upstreamProducerParityPreserved: null };
     }
@@ -39,6 +41,14 @@ export function calculateSupplementalRawAgreement(supplemental, raw) {
     fields.push(buildField("requiredEvidenceTruncated", truncationToYesNo(rawIdentity.truncated), supplemental.requiredEvidenceTruncated, supplemental.requiredEvidenceTruncated === "unknown"
         ? "The supplemental document declares truncation as \"unknown\", so agreement with the raw boolean cannot be determined."
         : null));
+    // v0.4.5 Batch 2 (section 17): the stricter comparison against the Batch 1
+    // truncation.requiredEvidenceLost rollup, additive to the general "truncated" comparison
+    // above. Absent on legacy raw artifacts, never fabricated.
+    fields.push(buildField("requiredEvidenceLost", rawIdentity.requiredEvidenceLost === undefined ? null : truncationToYesNo(rawIdentity.requiredEvidenceLost), supplemental.requiredEvidenceTruncated, rawIdentity.requiredEvidenceLost === undefined
+        ? "The raw artifact does not declare truncation.requiredEvidenceLost (legacy schema-major-1 evidence)."
+        : supplemental.requiredEvidenceTruncated === "unknown"
+            ? "The supplemental document declares truncation as \"unknown\", so agreement with the raw boolean cannot be determined."
+            : null));
     const contradictions = fields.filter((f) => f.availability === "available" && f.agreement === false);
     return {
         fields,

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

@@ -42,3 +42,103 @@ export function classifyTruncationRecord(record, sourceArtifact, sourceInstance)
 export function classifyTruncationRecords(records, sourceArtifact, sourceInstance) {
     return records.map((record) => classifyTruncationRecord(record, sourceArtifact, sourceInstance));
 }
+// v0.4.5 Batch 2: condition-aware truncation classification. Distinguishes the seven states
+// required by the Batch 2 plan using only explicit upstream evidence (truncation.truncated,
+// truncation.requiredEvidenceLost, ContextCapsule.groupTruncation's required/optional omitted
+// counts, and roleConditionCoverage's lostRequiredCondition/lossReason). Never independently
+// decides that a condition lost its last witness from a raw file count.
+export function classifyConditionAwareTruncation(artifact, sourceArtifact, sourceInstance) {
+    const requiredEvidenceLost = artifact.truncation.requiredEvidenceLost;
+    const roleConditionCoverage = artifact.roleConditionCoverage;
+    const groupTruncation = "groupTruncation" in artifact ? artifact.groupTruncation : undefined;
+    const lostConditions = roleConditionCoverage?.filter((c) => c.lostRequiredCondition) ?? undefined;
+    const lostRequiredConditionIds = lostConditions?.map((c) => c.conditionId) ?? [];
+    const groupsWithBothOmissionFields = groupTruncation?.filter((g) => g.requiredOmittedCount !== undefined && g.optionalOmittedCount !== undefined);
+    const requiredOmittedTotal = groupsWithBothOmissionFields !== undefined && groupsWithBothOmissionFields.length === (groupTruncation?.length ?? -1) && groupTruncation.length > 0
+        ? groupsWithBothOmissionFields.reduce((sum, g) => sum + (g.requiredOmittedCount ?? 0), 0)
+        : null;
+    const optionalOmittedTotal = groupsWithBothOmissionFields !== undefined && groupsWithBothOmissionFields.length === (groupTruncation?.length ?? -1) && groupTruncation.length > 0
+        ? groupsWithBothOmissionFields.reduce((sum, g) => sum + (g.optionalOmittedCount ?? 0), 0)
+        : null;
+    const base = {
+        sourceArtifact,
+        sourceInstance,
+        requiredEvidenceLost: requiredEvidenceLost ?? null,
+        requiredOmittedTotal,
+        optionalOmittedTotal,
+        lostRequiredConditionIds
+    };
+    const hasAnyCurrentDiagnostics = requiredEvidenceLost !== undefined || roleConditionCoverage !== undefined || requiredOmittedTotal !== null;
+    if (!hasAnyCurrentDiagnostics) {
+        return {
+            ...base,
+            availability: "unavailable",
+            state: "unsupported-legacy-diagnostics",
+            contradictionCodes: [],
+            reason: "No v1.10.3/v1.10.4 truncation or condition-coverage diagnostics were supplied (legacy schema-major-1 evidence)."
+        };
+    }
+    const contradictionCodes = [];
+    if (requiredEvidenceLost === false && lostRequiredConditionIds.length > 0) {
+        contradictionCodes.push("REQUIRED_EVIDENCE_LOST_FALSE_BUT_CONDITION_LOSS_REPORTED");
+    }
+    if (requiredEvidenceLost === true &&
+        roleConditionCoverage !== undefined &&
+        lostRequiredConditionIds.length === 0 &&
+        roleConditionCoverage.filter((c) => c.required).every((c) => c.conditionSatisfied) &&
+        (requiredOmittedTotal === null || requiredOmittedTotal === 0)) {
+        contradictionCodes.push("REQUIRED_EVIDENCE_LOST_TRUE_BUT_ALL_REQUIRED_CONDITIONS_RETAINED");
+    }
+    if (contradictionCodes.length > 0) {
+        return {
+            ...base,
+            availability: "available",
+            state: "contradictory-producer-evidence",
+            contradictionCodes,
+            reason: "Producer evidence is internally contradictory; both sides are retained rather than resolved by the lab."
+        };
+    }
+    if (lostRequiredConditionIds.length > 0) {
+        return {
+            ...base,
+            availability: "available",
+            state: "required-condition-or-last-witness-loss",
+            contradictionCodes: [],
+            reason: `Explicit lostRequiredCondition evidence exists for: ${lostRequiredConditionIds.join(", ")}.`
+        };
+    }
+    if (requiredEvidenceLost === true || (requiredOmittedTotal !== null && requiredOmittedTotal > 0)) {
+        return {
+            ...base,
+            availability: "available",
+            state: "required-evidence-loss",
+            contradictionCodes: [],
+            reason: "Required evidence loss is explicitly reported without condition-level detail."
+        };
+    }
+    if (requiredEvidenceLost === undefined && artifact.truncation.truncated) {
+        return {
+            ...base,
+            availability: "available",
+            state: "unknown-criticality",
+            contradictionCodes: [],
+            reason: "General truncation occurred but the rollup requiredEvidenceLost field is absent, so required-versus-optional criticality cannot be determined."
+        };
+    }
+    if (artifact.truncation.truncated) {
+        return {
+            ...base,
+            availability: "available",
+            state: "optional-only-truncation",
+            contradictionCodes: [],
+            reason: "Truncation occurred but no required evidence loss or condition loss was reported."
+        };
+    }
+    return {
+        ...base,
+        availability: "available",
+        state: "no-truncation",
+        contradictionCodes: [],
+        reason: null
+    };
+}

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

@@ -1,9 +1,12 @@
 import { collectSelectedOwnerEvidence, calculateOwnerMetrics } from "./calculateOwnerMetrics.js";
-import { calculateAllocationFactsForGroups } from "./calculateAllocationMetrics.js";
-import { classifyTruncationRecords } from "./calculateTruncationClassification.js";
+import { calculateAllocationFactsForGroups, calculateGroupAllocationMetrics } from "./calculateAllocationMetrics.js";
+import { classifyTruncationRecords, classifyConditionAwareTruncation } from "./calculateTruncationClassification.js";
+import { calculateConditionCoverageMetrics } from "./calculateConditionCoverageMetrics.js";
+import { calculateCapsuleAuditConditionAgreement, calculateProducerConditionAgreement, calculateRequiredEvidenceLossAgreement } from "./calculateProducerConditionAgreement.js";
 import { calculateSupplementalRawAgreement } from "./calculateSupplementalRawAgreement.js";
-import { calculateReadinessAgreementMetrics } from "./calculateReadinessAgreement.js";
+import { calculateReadinessAgreementMetrics, calculateProducerReadinessRelationship } from "./calculateReadinessAgreement.js";
 import { calculateCriticalityMetrics } from "./calculateCriticalityMetrics.js";
+import { evaluateRunIntegrity } from "./calculateRunIntegrityAgreement.js";
 function ownerExpectationsFor(expectations, sourceArtifact) {
     return expectations?.ownerExpectations?.filter((e) => e.sourceArtifact === sourceArtifact);
 }
@@ -36,7 +39,32 @@ function evaluateSide(input, expectations) {
         : [];
     const packetAgreement = input.packet !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.packet, rawForAgreement) : null;
     const reportAgreement = input.report !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.report, rawForAgreement) : null;
-    return { ownerEvaluation, allocationEvaluation, truncationEvaluation, packetAgreement, reportAgreement };
+    // v0.4.5 Batch 2: allocation/condition-coverage evidence, computed once per side and
+    // carried through the result unchanged (never recomputed by a renderer or later batch).
+    const groupAllocationEvaluation = calculateGroupAllocationMetrics(capsule?.groupTruncation, input.role);
+    const conditionAwareTruncationEvaluation = truncationArtifact
+        ? classifyConditionAwareTruncation(truncationArtifact, truncationSourceArtifact, input.role)
+        : null;
+    const roleConditionCoverage = capsule?.roleConditionCoverage ?? input.retrievalAuditRecord?.roleConditionCoverage;
+    const availableEvidenceGroupIds = capsule?.evidenceGroups.map((g) => g.id);
+    const conditionCoverageEvaluation = calculateConditionCoverageMetrics(roleConditionCoverage, availableEvidenceGroupIds);
+    const roleAdequacyStatus = (capsule ?? input.retrievalAuditRecord)?.roleAdequacy.status;
+    const producerConditionAgreement = calculateProducerConditionAgreement(roleAdequacyStatus, conditionCoverageEvaluation);
+    const requiredEvidenceLossAgreement = calculateRequiredEvidenceLossAgreement(truncationArtifact?.truncation.requiredEvidenceLost, conditionCoverageEvaluation, groupAllocationEvaluation.aggregate.totalRequiredOmitted);
+    const capsuleAuditConditionAgreement = calculateCapsuleAuditConditionAgreement(capsule, input.retrievalAuditRecord);
+    return {
+        ownerEvaluation,
+        allocationEvaluation,
+        truncationEvaluation,
+        packetAgreement,
+        reportAgreement,
+        groupAllocationEvaluation,
+        conditionAwareTruncationEvaluation,
+        conditionCoverageEvaluation,
+        producerConditionAgreement,
+        requiredEvidenceLossAgreement,
+        capsuleAuditConditionAgreement
+    };
 }
 // Builds bridge-evaluator input from an already-loaded combined-bounded-stage-context
 // execution payload (Batch 3 section 12.1: "accept already-read raw, supplemental,
@@ -72,7 +100,10 @@ export function buildProducerReadinessBridgeInputFromCombinedPayload(payload, ex
     };
 }
 export function evaluateProducerReadinessBridge(input) {
-    const hasAnyInput = input.implementation !== undefined || input.testImplementation !== undefined || input.readiness !== undefined;
+    const hasAnyInput = input.implementation !== undefined ||
+        input.testImplementation !== undefined ||
+        input.readiness !== undefined ||
+        input.runIntegrityEvidence !== undefined;
     if (!hasAnyInput) {
         return {
             status: "not-applicable",
@@ -81,6 +112,8 @@ export function evaluateProducerReadinessBridge(input) {
             testImplementation: null,
             readinessAgreement: null,
             criticalityEvaluation: null,
+            producerReadinessRelationship: null,
+            runIntegrityEvaluation: null,
             warnings: [],
             evidenceReferences: []
         };
@@ -114,6 +147,42 @@ export function evaluateProducerReadinessBridge(input) {
         input.implementation?.retrievalAuditRecord?.responsibilityMappings.mappings ??
         input.implementation?.contextCapsule?.responsibilityMappings.mappings;
     const criticalityEvaluation = calculateCriticalityMetrics(criticalityMappings, input.expectations.producerReadinessExpectations?.criticalityExpectations);
+    // v0.4.5 Batch 2: producer role adequacy vs supplied orchestrator readiness. Selects the
+    // side input.readiness.kind actually applies to when available, otherwise falls back to
+    // the same test-implementation-preferred precedence as criticalityEvaluation above.
+    const readinessSideRole = input.readiness?.kind === "implementation" || input.readiness?.kind === "test" ? input.readiness.kind : undefined;
+    const readinessSideEvaluation = readinessSideRole === "implementation" ? implementation : readinessSideRole === "test" ? testImplementation : (testImplementation ?? implementation);
+    const readinessSideRawArtifact = readinessSideEvaluation?.role === "implementation"
+        ? (input.implementation?.contextCapsule ?? input.implementation?.retrievalAuditRecord)
+        : readinessSideEvaluation?.role === "test-implementation"
+            ? (input.testImplementation?.contextCapsule ?? input.testImplementation?.retrievalAuditRecord)
+            : undefined;
+    // calculateProducerReadinessRelationship short-circuits before touching this argument
+    // whenever roleAdequacyStatus is undefined, so a placeholder is safe when no side applies.
+    const placeholderProducerConditionAgreement = {
+        availability: "unavailable",
+        outcome: "insufficient-evidence",
+        observedRoleAdequacyStatus: null,
+        contradictionCodes: [],
+        reason: "No producer side applies to the supplied readiness result."
+    };
+    const producerReadinessRelationship = calculateProducerReadinessRelationship(readinessSideRawArtifact?.roleAdequacy.status, readinessSideEvaluation?.producerConditionAgreement ?? placeholderProducerConditionAgreement, input.readiness);
+    // v0.4.5 Batch 3: bounded orchestrator run-integrity evidence and agreement, computed
+    // once here and carried through unchanged. Stage selection follows the same
+    // applicableContextKinds the gate itself declares (implementation preferred, since the
+    // gate blocks implementation before test-implementation in workflow order); the
+    // producerReadinessRelationship outcome already computed above feeds the end-to-end
+    // summary's "producerReadiness" component rather than being recalculated.
+    let runIntegrityEvaluation = null;
+    if (input.runIntegrityEvidence !== undefined) {
+        const gate = input.runIntegrityEvidence.gate;
+        const stageName = gate.applicableContextKinds.includes("implementation")
+            ? "implementation"
+            : gate.applicableContextKinds.includes("test")
+                ? "test-implementation"
+                : gate.mode;
+        runIntegrityEvaluation = evaluateRunIntegrity(input.runIntegrityEvidence, stageName, producerReadinessRelationship.outcome);
+    }
     return {
         status: "evaluated",
         reason: null,
@@ -121,6 +190,8 @@ export function evaluateProducerReadinessBridge(input) {
         testImplementation,
         readinessAgreement,
         criticalityEvaluation,
+        producerReadinessRelationship,
+        runIntegrityEvaluation,
         warnings,
         evidenceReferences
     };

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

@@ -15,3 +15,7 @@ export { calculateSupplementalRawAgreement } from "./calculateSupplementalRawAgr
 export { calculateReadinessStructuralAgreement, calculateReadinessDecisionAgreement, calculateInvalidReady, calculateValidBlocked, calculateReadinessAgreementMetrics } from "./calculateReadinessAgreement.js";
 export { calculateCriticalityMetrics } from "./calculateCriticalityMetrics.js";
 export { evaluateProducerReadinessBridge, buildProducerReadinessBridgeInputFromCombinedPayload } from "./evaluateProducerReadinessBridge.js";
+export { calculateGroupAllocationMetrics } from "./calculateAllocationMetrics.js";
+export { calculateConditionCoverageMetrics } from "./calculateConditionCoverageMetrics.js";
+export { calculateProducerConditionAgreement, calculateRequiredEvidenceLossAgreement, calculateCapsuleAuditConditionAgreement } from "./calculateProducerConditionAgreement.js";
+export { calculateReadinessPromptAgreement, calculateReadinessExpectedJudgeAgreement, calculateExpectedActualJudgeAgreement, calculateJudgeCorrectionAgreement, calculateJudgeFinalEligibilityAgreement, calculateEligibilityFinalArtifactAgreement, calculateLifecycleIntegrityAgreement, evaluateRunIntegrity } from "./calculateRunIntegrityAgreement.js";

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

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

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

@@ -38,6 +38,13 @@ export function checkMyDevKitContextArtifactConsistency(capsule, audit) {
             capsuleValue: capsule.roleContext,
             auditValue: audit.roleContext
         },
+        // Both absent is a compatible legacy pair. One absent and one present is a
+        // contradiction; absence is never normalized to an empty current result.
+        {
+            fieldPath: "roleConditionCoverage",
+            capsuleValue: (capsule.roleConditionCoverage ?? null),
+            auditValue: (audit.roleConditionCoverage ?? null)
+        },
         {
             fieldPath: "responsibilityMappings",
             capsuleValue: capsule.responsibilityMappings,

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

@@ -2,3 +2,4 @@ export * from "./contextCapsuleSelectors.js";
 export * from "./retrievalAuditRecordSelectors.js";
 export * from "./workflowInstructionPacketSelectors.js";
 export * from "./contextArtifactConsistency.js";
+export * from "./orchestratorRunIntegritySelectors.js";