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

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

@@ -0,0 +1,144 @@
+export function classifyTruncationRecord(record, sourceArtifact, sourceInstance) {
+    const base = {
+        groupId: record.affectedGroup,
+        sourceArtifact,
+        sourceInstance,
+        limit: record.limit,
+        used: record.used,
+        available: record.available,
+        omittedRequiredEvidenceIds: record.requiredEvidenceLost ? record.droppedEvidenceIds : []
+    };
+    if (!record.requiredEvidenceLost) {
+        return {
+            ...base,
+            cause: "none",
+            availability: "available",
+            reason: "No fixture-required evidence was reported lost for this group."
+        };
+    }
+    if (record.limit === null) {
+        return {
+            ...base,
+            cause: "unresolved",
+            availability: "available",
+            reason: "Required evidence was lost but no hard limit is declared for this group, so avoidability cannot be proven either way."
+        };
+    }
+    if (record.used < record.limit) {
+        return {
+            ...base,
+            cause: "avoidable",
+            availability: "available",
+            reason: `Required evidence was lost while used (${record.used}) remained below the declared limit (${record.limit}); compatible headroom existed under the hard limit.`
+        };
+    }
+    return {
+        ...base,
+        cause: "genuine-hard-limit",
+        availability: "available",
+        reason: `Required evidence was lost and used (${record.used}) reached or exceeded the declared limit (${record.limit}); no compatible headroom remained.`
+    };
+}
+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

@@ -0,0 +1,198 @@
+import { collectSelectedOwnerEvidence, calculateOwnerMetrics } from "./calculateOwnerMetrics.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, 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);
+}
+function evaluateSide(input, expectations) {
+    const producerExpectations = expectations?.producerReadinessExpectations;
+    // Owner-selection and allocation-group evidence only exist on ContextCapsule (Batch 1
+    // contract-lock evidence: RetrievalAuditRecord has no selectedOwners/evidenceGroups
+    // fields). Truncation and responsibility-mapping evidence exist on both.
+    const capsule = input.contextCapsule;
+    const truncationArtifact = input.contextCapsule ?? input.retrievalAuditRecord;
+    const rawForAgreement = input.contextCapsule ?? input.retrievalAuditRecord;
+    const selectedOwnerEvidence = capsule ? collectSelectedOwnerEvidence(capsule.selectedOwners, "context-capsule", input.role) : undefined;
+    const ownerEvaluation = calculateOwnerMetrics(selectedOwnerEvidence, ownerExpectationsFor(producerExpectations, "context-capsule"));
+    const allocationFacts = capsule
+        ? calculateAllocationFactsForGroups(capsule.evidenceGroups, "context-capsule", input.role)
+        : { requiredGroupCapacity: [], usedReservation: [], borrowedCapacity: [], unusedCapacity: [] };
+    const allocationEvaluation = {
+        ...allocationFacts,
+        requiredEvidenceOmitted: {
+            availability: "not-applicable",
+            count: null,
+            evidenceKeys: [],
+            reason: "Batch 3 bridge evaluation derives omission from truncation records, not expectation matches; see truncationEvaluation."
+        },
+        requiredEvidenceOmittedEntries: []
+    };
+    const truncationSourceArtifact = input.contextCapsule ? "context-capsule" : "retrieval-audit-record";
+    const truncationEvaluation = truncationArtifact
+        ? classifyTruncationRecords(truncationArtifact.truncation.records, truncationSourceArtifact, input.role)
+        : [];
+    const packetAgreement = input.packet !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.packet, rawForAgreement) : null;
+    const reportAgreement = input.report !== undefined || rawForAgreement !== undefined ? calculateSupplementalRawAgreement(input.report, rawForAgreement) : null;
+    // 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,
+// readiness, and expectation inputs"). Never reads a file itself.
+export function buildProducerReadinessBridgeInputFromCombinedPayload(payload, expectations) {
+    const implementationPair = payload.contextArtifacts.find((p) => p.role === "implementation");
+    const testPair = payload.contextArtifacts.find((p) => p.role === "test-implementation");
+    const hasImplementationSide = implementationPair !== undefined || payload.implementationContextPacket !== undefined || payload.implementationContextRetrievalReport !== undefined;
+    const hasTestSide = testPair !== undefined || payload.testContextPacket !== undefined || payload.testContextRetrievalReport !== undefined;
+    return {
+        implementation: hasImplementationSide
+            ? {
+                role: "implementation",
+                contextCapsule: implementationPair?.contextCapsule,
+                retrievalAuditRecord: implementationPair?.retrievalAuditRecord,
+                packet: payload.implementationContextPacket,
+                packetSourcePath: payload.implementationContextPacketSourcePath,
+                report: payload.implementationContextRetrievalReport
+            }
+            : undefined,
+        testImplementation: hasTestSide
+            ? {
+                role: "test-implementation",
+                contextCapsule: testPair?.contextCapsule,
+                retrievalAuditRecord: testPair?.retrievalAuditRecord,
+                packet: payload.testContextPacket,
+                packetSourcePath: payload.testContextPacketSourcePath,
+                report: payload.testContextRetrievalReport
+            }
+            : undefined,
+        readiness: payload.readiness,
+        expectations
+    };
+}
+export function evaluateProducerReadinessBridge(input) {
+    const hasAnyInput = input.implementation !== undefined ||
+        input.testImplementation !== undefined ||
+        input.readiness !== undefined ||
+        input.runIntegrityEvidence !== undefined;
+    if (!hasAnyInput) {
+        return {
+            status: "not-applicable",
+            reason: "No producer-readiness bridge inputs (supplemental artifacts or readiness result) were supplied.",
+            implementation: null,
+            testImplementation: null,
+            readinessAgreement: null,
+            criticalityEvaluation: null,
+            producerReadinessRelationship: null,
+            runIntegrityEvaluation: null,
+            warnings: [],
+            evidenceReferences: []
+        };
+    }
+    const evidenceReferences = [];
+    const warnings = [];
+    let implementation = null;
+    if (input.implementation !== undefined) {
+        const evaluated = evaluateSide(input.implementation, input.expectations);
+        implementation = { role: "implementation", ...evaluated };
+        if (input.implementation.packetSourcePath)
+            evidenceReferences.push(input.implementation.packetSourcePath);
+    }
+    let testImplementation = null;
+    if (input.testImplementation !== undefined) {
+        const evaluated = evaluateSide(input.testImplementation, input.expectations);
+        testImplementation = { role: "test-implementation", ...evaluated };
+        if (input.testImplementation.packetSourcePath)
+            evidenceReferences.push(input.testImplementation.packetSourcePath);
+    }
+    let readinessAgreement = null;
+    if (input.readiness !== undefined) {
+        const readinessExpectations = input.expectations.producerReadinessExpectations?.readinessExpectations;
+        const matchingExpectation = readinessExpectations?.find((e) => e.kind === input.readiness.kind);
+        const relevantPacket = input.readiness.kind === "implementation" ? input.implementation?.packet : input.testImplementation?.packet;
+        const relevantPacketPath = input.readiness.kind === "implementation" ? input.implementation?.packetSourcePath : input.testImplementation?.packetSourcePath;
+        readinessAgreement = calculateReadinessAgreementMetrics(input.readiness, matchingExpectation, relevantPacket, relevantPacketPath);
+    }
+    const criticalityMappings = input.testImplementation?.retrievalAuditRecord?.responsibilityMappings.mappings ??
+        input.testImplementation?.contextCapsule?.responsibilityMappings.mappings ??
+        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,
+        implementation,
+        testImplementation,
+        readinessAgreement,
+        criticalityEvaluation,
+        producerReadinessRelationship,
+        runIntegrityEvaluation,
+        warnings,
+        evidenceReferences
+    };
+}

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

@@ -8,3 +8,14 @@ export { compareExpectedContextCapsuleState, compareExpectedRetrievalAuditState,
 export { calculateContextCapsuleResponsibilityMappingMetric, calculateRetrievalAuditResponsibilityMappingMetric } from "./calculateResponsibilityMappingMetrics.js";
 export { calculateV043ExecutionContextSize } from "./calculateContextSizeMetrics.js";
 export { evaluateV043StageContextExecution } from "./evaluateV043StageContextExecution.js";
+export { collectSelectedOwnerEvidence, calculateOwnerMetrics } from "./calculateOwnerMetrics.js";
+export { calculateAllocationFactsForGroups, calculateRequiredEvidenceOmitted, findAllocationExpectationForGroup } from "./calculateAllocationMetrics.js";
+export { classifyTruncationRecord, classifyTruncationRecords } from "./calculateTruncationClassification.js";
+export { calculateSupplementalRawAgreement } from "./calculateSupplementalRawAgreement.js";
+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/producerReadinessMetricTypes.js

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

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

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

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

@@ -18,6 +18,16 @@ export function checkMyDevKitContextArtifactConsistency(capsule, audit) {
             capsuleValue: capsule.index.manifestPath,
             auditValue: audit.index.manifestPath
         },
+        {
+            fieldPath: "index.manifestSchemaVersion",
+            capsuleValue: capsule.index.manifestSchemaVersion ?? null,
+            auditValue: audit.index.manifestSchemaVersion ?? null
+        },
+        {
+            fieldPath: "index.projectRoot",
+            capsuleValue: capsule.index.projectRoot ?? null,
+            auditValue: audit.index.projectRoot ?? null
+        },
         {
             fieldPath: "contextAdequacy",
             capsuleValue: capsule.contextAdequacy,
@@ -28,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";

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

@@ -0,0 +1,64 @@
+export function selectReadinessClassification(evidence) {
+    return evidence.gate.readinessClassification;
+}
+export function selectContextReady(evidence) {
+    return evidence.gate.contextReady;
+}
+export function selectBlockingCodes(evidence) {
+    return evidence.gate.blockingCodes;
+}
+export function selectRecommendedCorrectionStage(evidence) {
+    return evidence.gate.recommendedCorrectionStage;
+}
+export function selectExpectedJudgeVerdict(evidence) {
+    return evidence.gate.expectedJudgeVerdict;
+}
+// Prompt mode is not a field the exact v1.2.3 gate contract exposes as a literal string --
+// it is a derived per-stage decision (evaluateStageRunIntegrity()). The lab represents it
+// via the same contextReady/blockedStageNames facts the gate already exposes rather than
+// inventing a separate "promptMode" string the upstream contract does not itself declare.
+export function selectStageMayRenderNormalPrompt(evidence, stageName) {
+    const contextSensitive = evidence.gate.blockedStageNames.length > 0 || stageName === "implementation" || stageName === "test-implementation";
+    if (!contextSensitive)
+        return undefined;
+    return !evidence.gate.blockedStageNames.includes(stageName);
+}
+export function selectJudgeArtifactPresent(evidence) {
+    return evidence.judgeIntegrity?.judgeArtifactPresent;
+}
+export function selectJudgeVerdictParseStatus(evidence) {
+    return evidence.judgeIntegrity?.judgeVerdictParseStatus;
+}
+export function selectAuthoredJudgeVerdict(evidence) {
+    return evidence.judgeIntegrity?.authoredJudgeVerdict;
+}
+export function selectJudgeVerdictMatchesExpected(evidence) {
+    return evidence.judgeIntegrity?.judgeVerdictMatchesExpected;
+}
+export function selectJudgeVerdictAccepted(evidence) {
+    return evidence.judgeIntegrity?.judgeVerdictAccepted;
+}
+export function selectAcceptedCorrectionStage(evidence) {
+    return evidence.judgeIntegrity?.acceptedCorrectionStage;
+}
+export function selectAcceptedCorrectionRoute(evidence) {
+    return evidence.judgeIntegrity?.acceptedCorrectionRoute;
+}
+export function selectJudgeFinalReportEligible(evidence) {
+    return evidence.judgeIntegrity?.finalReportEligible;
+}
+export function selectFinalReportEligible(evidence) {
+    return evidence.finalReportEligibility?.eligible;
+}
+export function selectFinalArtifactPresent(evidence) {
+    return evidence.finalArtifactPresent;
+}
+export function selectFinalArtifactVerdict(evidence) {
+    return evidence.finalArtifactVerdict;
+}
+export function selectLifecycleEntries(evidence) {
+    return evidence.lifecycle;
+}
+export function selectLifecycleEntryForStage(evidence, stageName) {
+    return evidence.lifecycle.find((entry) => entry.stageName === stageName);
+}

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

@@ -1,3 +1,11 @@
 export { readMyDevKitContextCapsuleV1 } from "./readMyDevKitContextCapsuleV1.js";
 export { readMyDevKitRetrievalAuditRecordV1 } from "./readMyDevKitRetrievalAuditRecordV1.js";
 export { readOrchestratorWorkflowInstructionPacketV1 } from "./readOrchestratorWorkflowInstructionPacketV1.js";
+export { ROLE_BY_DOCUMENT_KIND, REQUIRED_METADATA_BY_DOCUMENT_KIND, REQUIRED_SECTIONS_BY_DOCUMENT_KIND, VALID_REPOSITORY_SCOPES, VALID_DECLARED_STATUSES, VALID_FRESHNESS_VALUES, VALID_ADEQUACY_VALUES, VALID_TRUNCATION_VALUES } from "./supplementalContextTypes.js";
+export { readImplementationContextPacketV1 } from "./readImplementationContextPacketV1.js";
+export { readImplementationContextRetrievalReportV1 } from "./readImplementationContextRetrievalReportV1.js";
+export { readTestContextPacketV1 } from "./readTestContextPacketV1.js";
+export { readTestContextRetrievalReportV1 } from "./readTestContextRetrievalReportV1.js";
+export { READINESS_DECISIONS, READINESS_CLASSIFICATIONS, validateOrchestratorContextReadinessResultV1, checkSupplementalReadinessIdentityConsistency } from "./orchestratorContextReadinessResultV1.js";
+export { readOrchestratorRunIntegrityEvidenceV1 } from "./readOrchestratorRunIntegrityV1.js";
+export { validateOrchestratorRunIntegrityEvidenceV1 } from "./validateOrchestratorRunIntegrityV1.js";