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

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

@@ -0,0 +1,212 @@
+// v0.4.4 Batch 2: readiness/raw-evidence agreement. Readiness stays observed consumer
+// 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 };
+}
+export function calculateReadinessStructuralAgreement(readiness, supplementalPacket, packetSourcePath) {
+    const results = [];
+    if (readiness === undefined) {
+        results.push(unavailableStructural("canonicalRepositoryIdentity", "No readiness result was supplied."));
+        results.push(unavailableStructural("packetPath", "No readiness result was supplied."));
+        return results;
+    }
+    if (supplementalPacket === undefined) {
+        results.push(unavailableStructural("canonicalRepositoryIdentity", "No supplemental document was supplied to compare against readiness."));
+    }
+    else {
+        const diagnostic = checkSupplementalReadinessIdentityConsistency(supplementalPacket, readiness);
+        results.push({
+            field: "canonicalRepositoryIdentity",
+            expectedValue: supplementalPacket.indexIdentity,
+            observedValue: readiness.indexIdentity ?? null,
+            agreement: diagnostic === null,
+            availability: readiness.indexIdentity === undefined ? "unavailable" : "available",
+            reason: readiness.indexIdentity === undefined ? "The readiness result does not declare indexIdentity." : diagnostic?.message ?? null
+        });
+    }
+    if (packetSourcePath === undefined) {
+        results.push(unavailableStructural("packetPath", "No packet source path was supplied to compare against readiness.packetPath."));
+    }
+    else {
+        results.push({
+            field: "packetPath",
+            expectedValue: packetSourcePath,
+            observedValue: readiness.packetPath,
+            agreement: packetSourcePath === readiness.packetPath,
+            availability: "available",
+            reason: null
+        });
+    }
+    return results;
+}
+export function calculateReadinessDecisionAgreement(readiness, expectation) {
+    if (expectation === undefined) {
+        return {
+            availability: "not-applicable",
+            observedDecision: readiness?.decision ?? null,
+            allowedDecisions: null,
+            decisionAgreement: null,
+            observedClassification: readiness?.classification ?? null,
+            expectedClassification: null,
+            classificationAgreement: null,
+            observedIssueCodes: readiness?.blockingIssueCodes ?? [],
+            expectedIssueCodes: null,
+            issueCodesAgreement: null,
+            observedPrimaryIssueCode: readiness?.primaryIssue?.code ?? null,
+            expectedPrimaryIssueCode: null,
+            primaryIssueAgreement: null,
+            reason: "The expectation fixture declares no readiness expectation."
+        };
+    }
+    if (readiness === undefined) {
+        return {
+            availability: "unavailable",
+            observedDecision: null,
+            allowedDecisions: expectation.allowedDecisions ?? null,
+            decisionAgreement: null,
+            observedClassification: null,
+            expectedClassification: expectation.expectedClassification ?? null,
+            classificationAgreement: null,
+            observedIssueCodes: [],
+            expectedIssueCodes: expectation.expectedIssueCodes ?? null,
+            issueCodesAgreement: null,
+            observedPrimaryIssueCode: null,
+            expectedPrimaryIssueCode: expectation.expectedPrimaryIssueCode ?? null,
+            primaryIssueAgreement: null,
+            reason: "No readiness result was supplied."
+        };
+    }
+    const decisionAgreement = expectation.allowedDecisions === undefined ? null : expectation.allowedDecisions.includes(readiness.decision);
+    const classificationAgreement = expectation.expectedClassification === undefined ? null : expectation.expectedClassification === readiness.classification;
+    const issueCodesAgreement = expectation.expectedIssueCodes === undefined
+        ? null
+        : expectation.expectedIssueCodes.length === readiness.blockingIssueCodes.length &&
+            expectation.expectedIssueCodes.every((code) => readiness.blockingIssueCodes.includes(code));
+    const primaryIssueAgreement = expectation.expectedPrimaryIssueCode === undefined
+        ? null
+        : expectation.expectedPrimaryIssueCode === (readiness.primaryIssue?.code ?? null);
+    return {
+        availability: "available",
+        observedDecision: readiness.decision,
+        allowedDecisions: expectation.allowedDecisions ?? null,
+        decisionAgreement,
+        observedClassification: readiness.classification,
+        expectedClassification: expectation.expectedClassification ?? null,
+        classificationAgreement,
+        observedIssueCodes: readiness.blockingIssueCodes,
+        expectedIssueCodes: expectation.expectedIssueCodes ?? null,
+        issueCodesAgreement,
+        observedPrimaryIssueCode: readiness.primaryIssue?.code ?? null,
+        expectedPrimaryIssueCode: expectation.expectedPrimaryIssueCode ?? null,
+        primaryIssueAgreement,
+        reason: null
+    };
+}
+export function calculateInvalidReady(readiness, expectation) {
+    if (readiness === undefined) {
+        return { availability: "unavailable", invalidReady: null, observedDecision: null, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "No readiness result was supplied." };
+    }
+    if (expectation === undefined) {
+        return { availability: "not-applicable", invalidReady: null, observedDecision: readiness.decision, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "The expectation fixture declares no readiness expectation." };
+    }
+    const expectsBlocking = (expectation.allowedDecisions !== undefined &&
+        !expectation.allowedDecisions.includes("ready") &&
+        (expectation.allowedDecisions.includes("refresh-required") || expectation.allowedDecisions.length > 0)) ||
+        (expectation.expectedIssueCodes !== undefined && expectation.expectedIssueCodes.length > 0);
+    if (!expectsBlocking) {
+        return { availability: "not-applicable", invalidReady: null, observedDecision: readiness.decision, expectedBlockingDecision: false, missingExpectedIssueCodes: [], reason: "The expectation fixture does not require blocked or refresh-required behavior." };
+    }
+    if (readiness.decision !== "ready") {
+        return { availability: "available", invalidReady: false, observedDecision: readiness.decision, expectedBlockingDecision: true, missingExpectedIssueCodes: [], reason: null };
+    }
+    const expectedCodes = expectation.expectedIssueCodes ?? [];
+    const missing = expectedCodes.filter((code) => !readiness.blockingIssueCodes.includes(code));
+    return { availability: "available", invalidReady: true, observedDecision: readiness.decision, expectedBlockingDecision: true, missingExpectedIssueCodes: missing, reason: null };
+}
+export function calculateValidBlocked(readiness, expectation) {
+    if (readiness === undefined) {
+        return { availability: "unavailable", validBlocked: null, validRefreshRequired: null, observedDecision: null, reason: "No readiness result was supplied." };
+    }
+    if (expectation === undefined) {
+        return { availability: "not-applicable", validBlocked: null, validRefreshRequired: null, observedDecision: readiness.decision, reason: "The expectation fixture declares no readiness expectation." };
+    }
+    if (readiness.decision !== "refresh-required") {
+        return { availability: "available", validBlocked: false, validRefreshRequired: false, observedDecision: readiness.decision, reason: null };
+    }
+    const allowsRefreshRequired = expectation.allowedDecisions === undefined || expectation.allowedDecisions.includes("refresh-required");
+    const issueCodesMatch = expectation.expectedIssueCodes === undefined ||
+        expectation.expectedIssueCodes.every((code) => readiness.blockingIssueCodes.includes(code));
+    const primaryMatches = expectation.expectedPrimaryIssueCode === undefined || expectation.expectedPrimaryIssueCode === (readiness.primaryIssue?.code ?? null);
+    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),
+        decisionAgreement: calculateReadinessDecisionAgreement(readiness, expectation),
+        invalidReady: calculateInvalidReady(readiness, expectation),
+        validBlocked: calculateValidBlocked(readiness, expectation)
+    };
+}

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

@@ -0,0 +1,60 @@
+function extractRawIdentity(artifact) {
+    return {
+        projectRoot: artifact.index.projectRoot,
+        role: artifact.request.role,
+        freshnessState: artifact.freshness.state,
+        truncated: artifact.truncation.truncated,
+        requiredEvidenceLost: artifact.truncation.requiredEvidenceLost
+    };
+}
+function truncationToYesNo(value) {
+    return value ? "yes" : "no";
+}
+function buildField(field, rawValue, supplementalValue, unavailableReason) {
+    if (unavailableReason !== null) {
+        return { field, rawValue, supplementalValue, agreement: null, availability: "unavailable", reason: unavailableReason };
+    }
+    return { field, rawValue, supplementalValue, agreement: rawValue === supplementalValue, availability: "available", reason: null };
+}
+export function calculateSupplementalRawAgreement(supplemental, raw) {
+    if (supplemental === undefined || raw === undefined) {
+        const reason = supplemental === undefined && raw === undefined
+            ? "Neither a supplemental document nor a raw artifact was supplied."
+            : supplemental === undefined
+                ? "No supplemental document was supplied."
+                : "No raw context-capsule or retrieval-audit artifact was supplied.";
+        const fields = [
+            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("requiredEvidenceLost", null, supplemental?.requiredEvidenceTruncated ?? null, reason)
+        ];
+        return { fields, contradictions: [], upstreamProducerParityPreserved: null };
+    }
+    const rawIdentity = extractRawIdentity(raw);
+    const fields = [];
+    fields.push(buildField("canonicalRepositoryIdentity", rawIdentity.projectRoot ?? null, supplemental.indexIdentity, rawIdentity.projectRoot === undefined ? "The raw artifact does not declare index.projectRoot." : null));
+    const roleComparable = rawIdentity.role === "implementation" || rawIdentity.role === "test-implementation";
+    fields.push(buildField("role", rawIdentity.role, supplemental.role, roleComparable ? null : `Raw role "${rawIdentity.role}" has no supplemental-document counterpart in this vocabulary.`));
+    fields.push(buildField("freshness", rawIdentity.freshnessState, supplemental.freshness, null));
+    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,
+        contradictions,
+        // A successfully read raw pair is itself the observed outcome of the frozen
+        // assertRawEvidenceParity() write-time guard; see file header. Never recomputed here.
+        upstreamProducerParityPreserved: true
+    };
+}