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

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

@@ -7,3 +7,5 @@ export { readImplementationContextRetrievalReportV1 } from "./readImplementation
 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";

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

@@ -0,0 +1,33 @@
+// --- src/judgeParser.ts ---------------------------------------------------------------
+export const JUDGE_VERDICTS = [
+    "PASS",
+    "DESIGN_INCOMPLETE",
+    "PSEUDOCODE_INCOMPLETE",
+    "IMPLEMENTATION_MISMATCH",
+    "TEST_COVERAGE_INCOMPLETE",
+    "ARCHITECTURE_MISMATCH",
+    "NEED_VERIFICATION",
+    "NEED_CONTEXT",
+    "SCOPE_VIOLATION",
+    "BLOCKED"
+];
+// --- src/correctionRouter.ts ----------------------------------------------------------
+export const CORRECTABLE_STAGES = [
+    "architecture-context",
+    "behavior-model",
+    "pseudocode-packet",
+    "test-strategy",
+    "test-implementation",
+    "implementation",
+    "verification",
+    "target-architecture"
+];
+export const ROUTE_STATUSES = ["pass", "correction_required", "blocked", "unknown_verdict", "missing_verdict"];
+// --- src/runIntegrityGate.ts ----------------------------------------------------------
+export const RUN_INTEGRITY_READINESS_CLASSIFICATIONS = ["not-required", "ready", "refresh-required"];
+export const CONTEXT_SENSITIVE_STAGE_NAMES = ["implementation", "test-implementation"];
+// --- src/judgeIntegrity.ts --------------------------------------------------------------
+export const JUDGE_VERDICT_PARSE_STATUSES = ["parsed", "missing-artifact", "missing-verdict", "unknown-verdict"];
+// --- src/artifactLifecycle.ts -----------------------------------------------------------
+export const ARTIFACT_LIFECYCLE_STATES = ["missing", "incomplete", "blocked", "complete", "stale"];
+export const MANUAL_ARTIFACT_LIFECYCLE_STATES = ["incomplete", "blocked", "complete"];

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

@@ -0,0 +1,9 @@
+import { readJsonArtifactFile } from "./readJsonArtifact.js";
+import { validateOrchestratorRunIntegrityEvidenceV1 } from "./validateOrchestratorRunIntegrityV1.js";
+const ARTIFACT_KIND = "orchestrator-run-integrity-evidence-v1";
+export async function readOrchestratorRunIntegrityEvidenceV1(sourcePath) {
+    const loaded = await readJsonArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateOrchestratorRunIntegrityEvidenceV1(loaded.value, loaded.sourcePath);
+}

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

@@ -909,7 +909,7 @@ function validateTestInfrastructureSummary(ctx, value, fieldPath) {
 }
 function validateGroupTruncationEntry(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    const result = {
         groupId: requiredString(ctx, requiredField(ctx, obj, "groupId", joinFieldPath(fieldPath, "groupId")), joinFieldPath(fieldPath, "groupId")),
         limit: requiredNullableNumber(ctx, requiredField(ctx, obj, "limit", joinFieldPath(fieldPath, "limit")), joinFieldPath(fieldPath, "limit")),
         availableCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "availableCount", joinFieldPath(fieldPath, "availableCount")), joinFieldPath(fieldPath, "availableCount")),
@@ -917,6 +917,54 @@ function validateGroupTruncationEntry(ctx, value, fieldPath) {
         truncated: requiredBoolean(ctx, requiredField(ctx, obj, "truncated", joinFieldPath(fieldPath, "truncated")), joinFieldPath(fieldPath, "truncated")),
         droppedCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "droppedCount", joinFieldPath(fieldPath, "droppedCount")), joinFieldPath(fieldPath, "droppedCount"))
     };
+    if (optionalField(obj, "droppedEvidenceIds") !== undefined) {
+        result.droppedEvidenceIds = requiredStringArray(ctx, obj.droppedEvidenceIds, joinFieldPath(fieldPath, "droppedEvidenceIds"));
+    }
+    if (optionalField(obj, "required") !== undefined)
+        result.required = optionalBoolean(ctx, obj.required, joinFieldPath(fieldPath, "required"));
+    if (optionalField(obj, "reservation") !== undefined)
+        result.reservation = optionalNumber(ctx, obj.reservation, joinFieldPath(fieldPath, "reservation"));
+    if (optionalField(obj, "initiallySelectedCount") !== undefined)
+        result.initiallySelectedCount = optionalNumber(ctx, obj.initiallySelectedCount, joinFieldPath(fieldPath, "initiallySelectedCount"));
+    if (optionalField(obj, "unusedReservationContributed") !== undefined)
+        result.unusedReservationContributed = optionalNumber(ctx, obj.unusedReservationContributed, joinFieldPath(fieldPath, "unusedReservationContributed"));
+    if (optionalField(obj, "borrowedCapacity") !== undefined)
+        result.borrowedCapacity = optionalNumber(ctx, obj.borrowedCapacity, joinFieldPath(fieldPath, "borrowedCapacity"));
+    if (optionalField(obj, "requiredOmittedCount") !== undefined)
+        result.requiredOmittedCount = optionalNumber(ctx, obj.requiredOmittedCount, joinFieldPath(fieldPath, "requiredOmittedCount"));
+    if (optionalField(obj, "optionalOmittedCount") !== undefined)
+        result.optionalOmittedCount = optionalNumber(ctx, obj.optionalOmittedCount, joinFieldPath(fieldPath, "optionalOmittedCount"));
+    if (optionalField(obj, "adequacyAffected") !== undefined)
+        result.adequacyAffected = optionalBoolean(ctx, obj.adequacyAffected, joinFieldPath(fieldPath, "adequacyAffected"));
+    if (optionalField(obj, "governingHardBound") !== undefined)
+        result.governingHardBound = optionalNumber(ctx, obj.governingHardBound, joinFieldPath(fieldPath, "governingHardBound"));
+    if (optionalField(obj, "aggregateCapacityUsed") !== undefined)
+        result.aggregateCapacityUsed = optionalNumber(ctx, obj.aggregateCapacityUsed, joinFieldPath(fieldPath, "aggregateCapacityUsed"));
+    if (optionalField(obj, "aggregateCapacityRemaining") !== undefined)
+        result.aggregateCapacityRemaining = optionalNumber(ctx, obj.aggregateCapacityRemaining, joinFieldPath(fieldPath, "aggregateCapacityRemaining"));
+    return result;
+}
+const ROLE_CONDITION_IDS = ["implementation.selected-owner", "implementation.required-contract"];
+const ROLE_CONDITION_WITNESS_POLICIES = ["at-least-one"];
+const ROLE_CONDITION_COVERAGE_LOSS_REASONS = ["bounded-allocation-omitted-required-witnesses"];
+const ROLE_CONDITION_ROLES = ["architecture", "implementation", "test-implementation"];
+export function validateRoleConditionCoverage(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        conditionId: requiredLiteral(ctx, requiredField(ctx, obj, "conditionId", joinFieldPath(fieldPath, "conditionId")), joinFieldPath(fieldPath, "conditionId"), ROLE_CONDITION_IDS),
+        role: requiredLiteral(ctx, requiredField(ctx, obj, "role", joinFieldPath(fieldPath, "role")), joinFieldPath(fieldPath, "role"), ROLE_CONDITION_ROLES),
+        required: requiredBoolean(ctx, requiredField(ctx, obj, "required", joinFieldPath(fieldPath, "required")), joinFieldPath(fieldPath, "required")),
+        evidenceGroupIds: requiredStringArray(ctx, requiredField(ctx, obj, "evidenceGroupIds", joinFieldPath(fieldPath, "evidenceGroupIds")), joinFieldPath(fieldPath, "evidenceGroupIds")),
+        witnessPolicy: requiredLiteral(ctx, requiredField(ctx, obj, "witnessPolicy", joinFieldPath(fieldPath, "witnessPolicy")), joinFieldPath(fieldPath, "witnessPolicy"), ROLE_CONDITION_WITNESS_POLICIES),
+        requiredWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "requiredWitnessCount", joinFieldPath(fieldPath, "requiredWitnessCount")), joinFieldPath(fieldPath, "requiredWitnessCount")),
+        availableWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "availableWitnessCount", joinFieldPath(fieldPath, "availableWitnessCount")), joinFieldPath(fieldPath, "availableWitnessCount")),
+        retainedWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "retainedWitnessCount", joinFieldPath(fieldPath, "retainedWitnessCount")), joinFieldPath(fieldPath, "retainedWitnessCount")),
+        retainedWitnessIds: requiredStringArray(ctx, requiredField(ctx, obj, "retainedWitnessIds", joinFieldPath(fieldPath, "retainedWitnessIds")), joinFieldPath(fieldPath, "retainedWitnessIds")),
+        conditionSatisfied: requiredBoolean(ctx, requiredField(ctx, obj, "conditionSatisfied", joinFieldPath(fieldPath, "conditionSatisfied")), joinFieldPath(fieldPath, "conditionSatisfied")),
+        lostRequiredCondition: requiredBoolean(ctx, requiredField(ctx, obj, "lostRequiredCondition", joinFieldPath(fieldPath, "lostRequiredCondition")), joinFieldPath(fieldPath, "lostRequiredCondition")),
+        lossReason: requiredNullableLiteral(ctx, requiredField(ctx, obj, "lossReason", joinFieldPath(fieldPath, "lossReason")), joinFieldPath(fieldPath, "lossReason"), ROLE_CONDITION_COVERAGE_LOSS_REASONS),
+        evaluationOrder: requiredNumber(ctx, requiredField(ctx, obj, "evaluationOrder", joinFieldPath(fieldPath, "evaluationOrder")), joinFieldPath(fieldPath, "evaluationOrder"))
+    };
 }
 export function validateProvenanceRecord(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
@@ -1040,11 +1088,15 @@ function validateCapsuleTruncationRecord(ctx, value, fieldPath) {
 }
 export function validateTruncationSummary(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    const result = {
         truncated: requiredBoolean(ctx, requiredField(ctx, obj, "truncated", joinFieldPath(fieldPath, "truncated")), joinFieldPath(fieldPath, "truncated")),
         records: requiredArray(ctx, requiredField(ctx, obj, "records", joinFieldPath(fieldPath, "records")), joinFieldPath(fieldPath, "records")).map((item, i) => validateCapsuleTruncationRecord(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "records"), i))),
         warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings"))
     };
+    if (optionalField(obj, "requiredEvidenceLost") !== undefined) {
+        result.requiredEvidenceLost = optionalBoolean(ctx, obj.requiredEvidenceLost, joinFieldPath(fieldPath, "requiredEvidenceLost"));
+    }
+    return result;
 }
 function validateFullFileFallbackRecord(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
@@ -1178,6 +1230,11 @@ export function validateMyDevKitContextCapsuleV1(value, sourcePath) {
             testInfrastructure: validateTestInfrastructureSummary(ctx, requiredField(ctx, value, "testInfrastructure", "testInfrastructure"), "testInfrastructure"),
             unresolvedItems: requiredArray(ctx, requiredField(ctx, value, "unresolvedItems", "unresolvedItems"), "unresolvedItems").map((item, i) => validateUnresolvedEvidenceItem(ctx, item, arrayFieldPath("unresolvedItems", i))),
             groupTruncation: requiredArray(ctx, requiredField(ctx, value, "groupTruncation", "groupTruncation"), "groupTruncation").map((item, i) => validateGroupTruncationEntry(ctx, item, arrayFieldPath("groupTruncation", i))),
+            ...(optionalField(value, "roleConditionCoverage") !== undefined
+                ? {
+                    roleConditionCoverage: requiredArray(ctx, value.roleConditionCoverage, "roleConditionCoverage").map((item, i) => validateRoleConditionCoverage(ctx, item, arrayFieldPath("roleConditionCoverage", i)))
+                }
+                : {}),
             responsibilityMappings: validateResponsibilityMappingSummary(ctx, requiredField(ctx, value, "responsibilityMappings", "responsibilityMappings"), "responsibilityMappings"),
             roleAdequacy: validateRoleAdequacyStatement(ctx, requiredField(ctx, value, "roleAdequacy", "roleAdequacy"), "roleAdequacy"),
             freshness: validateFreshnessSummary(ctx, requiredField(ctx, value, "freshness", "freshness"), "freshness"),

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

@@ -1,6 +1,6 @@
 import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
 import { ArtifactValidationError, arrayFieldPath, joinFieldPath, optionalField, optionalString, requiredArray, requiredField, requiredLiteral, requiredObject, requiredRecord, requiredScalarLike, requiredString, requiredStringArray } from "./runtimeValidation.js";
-import { validateBudgetSummary, validateContextAdequacyStatement, validateContextCapsuleRequest, validateFreshnessSummary, validateFullFileFallbackSummary, validateProvenanceRecord, validateResponsibilityMappingSummary, validateRoleAdequacyStatement, validateRoleContextSummary, validateTruncationSummary } from "./validateMyDevKitContextCapsuleV1.js";
+import { validateBudgetSummary, validateContextAdequacyStatement, validateContextCapsuleRequest, validateFreshnessSummary, validateFullFileFallbackSummary, validateProvenanceRecord, validateResponsibilityMappingSummary, validateRoleAdequacyStatement, validateRoleConditionCoverage, validateRoleContextSummary, validateTruncationSummary } from "./validateMyDevKitContextCapsuleV1.js";
 const ARTIFACT_KIND = "my-dev-kit-retrieval-audit-record-v1";
 const AUDIT_STEP_STATUSES = ["ok", "skipped", "failed"];
 function validateContextCapsuleTool(ctx, value, fieldPath) {
@@ -83,6 +83,11 @@ export function validateMyDevKitRetrievalAuditRecordV1(value, sourcePath) {
             contextAdequacy: validateContextAdequacyStatement(ctx, requiredField(ctx, value, "contextAdequacy", "contextAdequacy"), "contextAdequacy"),
             roleContext: validateRoleContextSummary(ctx, requiredField(ctx, value, "roleContext", "roleContext"), "roleContext"),
             responsibilityMappings: validateResponsibilityMappingSummary(ctx, requiredField(ctx, value, "responsibilityMappings", "responsibilityMappings"), "responsibilityMappings"),
+            ...(optionalField(value, "roleConditionCoverage") !== undefined
+                ? {
+                    roleConditionCoverage: requiredArray(ctx, value.roleConditionCoverage, "roleConditionCoverage").map((item, i) => validateRoleConditionCoverage(ctx, item, arrayFieldPath("roleConditionCoverage", i)))
+                }
+                : {}),
             roleAdequacy: validateRoleAdequacyStatement(ctx, requiredField(ctx, value, "roleAdequacy", "roleAdequacy"), "roleAdequacy"),
             freshness: validateFreshnessSummary(ctx, requiredField(ctx, value, "freshness", "freshness"), "freshness"),
             budget: validateBudgetSummary(ctx, requiredField(ctx, value, "budget", "budget"), "budget"),

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

@@ -0,0 +1,177 @@
+import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, optionalField, optionalString, requiredArray, requiredBoolean, requiredField, requiredLiteral, requiredNullableLiteral, requiredNullableString, requiredObject, requiredString, requiredStringArray } from "./runtimeValidation.js";
+import { validateOrchestratorContextReadinessResultV1 } from "./orchestratorContextReadinessResultV1.js";
+import { ARTIFACT_LIFECYCLE_STATES, CONTEXT_SENSITIVE_STAGE_NAMES, CORRECTABLE_STAGES, JUDGE_VERDICT_PARSE_STATUSES, JUDGE_VERDICTS, MANUAL_ARTIFACT_LIFECYCLE_STATES, ROUTE_STATUSES, RUN_INTEGRITY_READINESS_CLASSIFICATIONS } from "./orchestratorRunIntegrityV1.js";
+const ARTIFACT_KIND = "orchestrator-run-integrity-evidence-v1";
+const EXPECTED_JUDGE_VERDICTS = ["PASS", "NEED_CONTEXT"];
+const APPLICABLE_CONTEXT_KINDS = ["implementation", "test"];
+function validateContextReadinessNested(ctx, value, fieldPath) {
+    const result = validateOrchestratorContextReadinessResultV1(value, `${ctx.sourcePath}#${fieldPath}`);
+    if (!result.ok) {
+        throw new ArtifactValidationError({
+            ok: false,
+            artifactKind: ctx.artifactKind,
+            sourcePath: ctx.sourcePath,
+            code: result.code,
+            message: `Nested readiness field "${fieldPath}" is invalid: ${result.message}`,
+            fieldPath,
+            expected: result.expected,
+            actual: result.actual
+        });
+    }
+    return result.artifact;
+}
+function validateCorrectionRouteResult(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        verdict: requiredNullableLiteral(ctx, requiredField(ctx, obj, "verdict", joinFieldPath(fieldPath, "verdict")), joinFieldPath(fieldPath, "verdict"), JUDGE_VERDICTS),
+        recommendedStage: requiredNullableString(ctx, requiredField(ctx, obj, "recommendedStage", joinFieldPath(fieldPath, "recommendedStage")), joinFieldPath(fieldPath, "recommendedStage")),
+        routedStage: requiredNullableLiteral(ctx, requiredField(ctx, obj, "routedStage", joinFieldPath(fieldPath, "routedStage")), joinFieldPath(fieldPath, "routedStage"), CORRECTABLE_STAGES),
+        routeStatus: requiredLiteral(ctx, requiredField(ctx, obj, "routeStatus", joinFieldPath(fieldPath, "routeStatus")), joinFieldPath(fieldPath, "routeStatus"), ROUTE_STATUSES),
+        warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings")),
+        errors: requiredStringArray(ctx, requiredField(ctx, obj, "errors", joinFieldPath(fieldPath, "errors")), joinFieldPath(fieldPath, "errors")),
+        isBlocked: requiredBoolean(ctx, requiredField(ctx, obj, "isBlocked", joinFieldPath(fieldPath, "isBlocked")), joinFieldPath(fieldPath, "isBlocked")),
+        strictFail: requiredBoolean(ctx, requiredField(ctx, obj, "strictFail", joinFieldPath(fieldPath, "strictFail")), joinFieldPath(fieldPath, "strictFail"))
+    };
+}
+function validateGate(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        schemaVersion: requiredLiteral(ctx, requiredField(ctx, obj, "schemaVersion", joinFieldPath(fieldPath, "schemaVersion")), joinFieldPath(fieldPath, "schemaVersion"), ["1.0.0"]),
+        mode: requiredString(ctx, requiredField(ctx, obj, "mode", joinFieldPath(fieldPath, "mode")), joinFieldPath(fieldPath, "mode")),
+        contextRequired: requiredBoolean(ctx, requiredField(ctx, obj, "contextRequired", joinFieldPath(fieldPath, "contextRequired")), joinFieldPath(fieldPath, "contextRequired")),
+        applicableContextKinds: requiredArray(ctx, requiredField(ctx, obj, "applicableContextKinds", joinFieldPath(fieldPath, "applicableContextKinds")), joinFieldPath(fieldPath, "applicableContextKinds")).map((item, i) => requiredLiteral(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "applicableContextKinds"), i), APPLICABLE_CONTEXT_KINDS)),
+        contextReady: requiredBoolean(ctx, requiredField(ctx, obj, "contextReady", joinFieldPath(fieldPath, "contextReady")), joinFieldPath(fieldPath, "contextReady")),
+        readinessClassification: requiredLiteral(ctx, requiredField(ctx, obj, "readinessClassification", joinFieldPath(fieldPath, "readinessClassification")), joinFieldPath(fieldPath, "readinessClassification"), RUN_INTEGRITY_READINESS_CLASSIFICATIONS),
+        blockedStageNames: requiredArray(ctx, requiredField(ctx, obj, "blockedStageNames", joinFieldPath(fieldPath, "blockedStageNames")), joinFieldPath(fieldPath, "blockedStageNames")).map((item, i) => requiredLiteral(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "blockedStageNames"), i), CONTEXT_SENSITIVE_STAGE_NAMES)),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes")),
+        recommendedCorrectionStage: requiredNullableString(ctx, requiredField(ctx, obj, "recommendedCorrectionStage", joinFieldPath(fieldPath, "recommendedCorrectionStage")), joinFieldPath(fieldPath, "recommendedCorrectionStage")),
+        expectedJudgeVerdict: requiredLiteral(ctx, requiredField(ctx, obj, "expectedJudgeVerdict", joinFieldPath(fieldPath, "expectedJudgeVerdict")), joinFieldPath(fieldPath, "expectedJudgeVerdict"), EXPECTED_JUDGE_VERDICTS),
+        warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings"))
+    };
+    if (optionalField(obj, "implementationContext") !== undefined) {
+        result.implementationContext = validateContextReadinessNested(ctx, obj.implementationContext, joinFieldPath(fieldPath, "implementationContext"));
+    }
+    if (optionalField(obj, "testContext") !== undefined) {
+        result.testContext = validateContextReadinessNested(ctx, obj.testContext, joinFieldPath(fieldPath, "testContext"));
+    }
+    if (optionalField(obj, "primaryBlocker") !== undefined) {
+        // primaryBlocker reuses ContextReadinessBlockerSummary's exact shape (owned by
+        // orchestratorContextReadinessResultV1.ts's blockerSummary field); walked structurally
+        // here rather than re-validated through a second nested-artifact call, since it is not
+        // itself a standalone readiness artifact.
+        const blockerObj = requiredObject(ctx, obj.primaryBlocker, joinFieldPath(fieldPath, "primaryBlocker"));
+        result.primaryBlocker = blockerObj;
+    }
+    return result;
+}
+function validateJudgeIntegrity(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        schemaVersion: requiredLiteral(ctx, requiredField(ctx, obj, "schemaVersion", joinFieldPath(fieldPath, "schemaVersion")), joinFieldPath(fieldPath, "schemaVersion"), ["1.0.0"]),
+        judgeArtifactPresent: requiredBoolean(ctx, requiredField(ctx, obj, "judgeArtifactPresent", joinFieldPath(fieldPath, "judgeArtifactPresent")), joinFieldPath(fieldPath, "judgeArtifactPresent")),
+        judgeVerdictParseStatus: requiredLiteral(ctx, requiredField(ctx, obj, "judgeVerdictParseStatus", joinFieldPath(fieldPath, "judgeVerdictParseStatus")), joinFieldPath(fieldPath, "judgeVerdictParseStatus"), JUDGE_VERDICT_PARSE_STATUSES),
+        authoredJudgeVerdict: requiredNullableLiteral(ctx, requiredField(ctx, obj, "authoredJudgeVerdict", joinFieldPath(fieldPath, "authoredJudgeVerdict")), joinFieldPath(fieldPath, "authoredJudgeVerdict"), JUDGE_VERDICTS),
+        expectedJudgeVerdict: requiredLiteral(ctx, requiredField(ctx, obj, "expectedJudgeVerdict", joinFieldPath(fieldPath, "expectedJudgeVerdict")), joinFieldPath(fieldPath, "expectedJudgeVerdict"), EXPECTED_JUDGE_VERDICTS),
+        judgeVerdictMatchesExpected: requiredBoolean(ctx, requiredField(ctx, obj, "judgeVerdictMatchesExpected", joinFieldPath(fieldPath, "judgeVerdictMatchesExpected")), joinFieldPath(fieldPath, "judgeVerdictMatchesExpected")),
+        judgeVerdictAccepted: requiredBoolean(ctx, requiredField(ctx, obj, "judgeVerdictAccepted", joinFieldPath(fieldPath, "judgeVerdictAccepted")), joinFieldPath(fieldPath, "judgeVerdictAccepted")),
+        correctionRequired: requiredBoolean(ctx, requiredField(ctx, obj, "correctionRequired", joinFieldPath(fieldPath, "correctionRequired")), joinFieldPath(fieldPath, "correctionRequired")),
+        correctionBlocked: requiredBoolean(ctx, requiredField(ctx, obj, "correctionBlocked", joinFieldPath(fieldPath, "correctionBlocked")), joinFieldPath(fieldPath, "correctionBlocked")),
+        acceptedCorrectionStage: requiredNullableString(ctx, requiredField(ctx, obj, "acceptedCorrectionStage", joinFieldPath(fieldPath, "acceptedCorrectionStage")), joinFieldPath(fieldPath, "acceptedCorrectionStage")),
+        finalReportEligible: requiredBoolean(ctx, requiredField(ctx, obj, "finalReportEligible", joinFieldPath(fieldPath, "finalReportEligible")), joinFieldPath(fieldPath, "finalReportEligible")),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes")),
+        acceptedCorrectionRoute: (() => {
+            const routeValue = requiredField(ctx, obj, "acceptedCorrectionRoute", joinFieldPath(fieldPath, "acceptedCorrectionRoute"));
+            return routeValue === null ? null : validateCorrectionRouteResult(ctx, routeValue, joinFieldPath(fieldPath, "acceptedCorrectionRoute"));
+        })()
+    };
+    if (optionalField(obj, "primaryReason") !== undefined) {
+        result.primaryReason = optionalString(ctx, obj.primaryReason, joinFieldPath(fieldPath, "primaryReason"));
+    }
+    return result;
+}
+function validateFinalReportEligibility(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        eligible: requiredBoolean(ctx, requiredField(ctx, obj, "eligible", joinFieldPath(fieldPath, "eligible")), joinFieldPath(fieldPath, "eligible")),
+        contextReady: requiredBoolean(ctx, requiredField(ctx, obj, "contextReady", joinFieldPath(fieldPath, "contextReady")), joinFieldPath(fieldPath, "contextReady")),
+        priorArtifactsValid: requiredBoolean(ctx, requiredField(ctx, obj, "priorArtifactsValid", joinFieldPath(fieldPath, "priorArtifactsValid")), joinFieldPath(fieldPath, "priorArtifactsValid")),
+        judgeIntegrity: validateJudgeIntegrity(ctx, requiredField(ctx, obj, "judgeIntegrity", joinFieldPath(fieldPath, "judgeIntegrity")), joinFieldPath(fieldPath, "judgeIntegrity")),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes"))
+    };
+    if (optionalField(obj, "primaryReason") !== undefined) {
+        result.primaryReason = optionalString(ctx, obj.primaryReason, joinFieldPath(fieldPath, "primaryReason"));
+    }
+    return result;
+}
+function validateArtifactStateRecord(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        state: requiredLiteral(ctx, requiredField(ctx, obj, "state", joinFieldPath(fieldPath, "state")), joinFieldPath(fieldPath, "state"), MANUAL_ARTIFACT_LIFECYCLE_STATES),
+        updatedAt: requiredString(ctx, requiredField(ctx, obj, "updatedAt", joinFieldPath(fieldPath, "updatedAt")), joinFieldPath(fieldPath, "updatedAt"))
+    };
+    if (optionalField(obj, "reason") !== undefined)
+        result.reason = optionalString(ctx, obj.reason, joinFieldPath(fieldPath, "reason"));
+    if (optionalField(obj, "source") !== undefined)
+        result.source = optionalString(ctx, obj.source, joinFieldPath(fieldPath, "source"));
+    return result;
+}
+function validateLifecycleEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const manualRecordValue = requiredField(ctx, obj, "manualRecord", joinFieldPath(fieldPath, "manualRecord"));
+    const result = {
+        artifactFile: requiredString(ctx, requiredField(ctx, obj, "artifactFile", joinFieldPath(fieldPath, "artifactFile")), joinFieldPath(fieldPath, "artifactFile")),
+        stageName: requiredString(ctx, requiredField(ctx, obj, "stageName", joinFieldPath(fieldPath, "stageName")), joinFieldPath(fieldPath, "stageName")),
+        fileExists: requiredBoolean(ctx, requiredField(ctx, obj, "fileExists", joinFieldPath(fieldPath, "fileExists")), joinFieldPath(fieldPath, "fileExists")),
+        manualRecord: manualRecordValue === null ? null : validateArtifactStateRecord(ctx, manualRecordValue, joinFieldPath(fieldPath, "manualRecord")),
+        resolvedState: requiredLiteral(ctx, requiredField(ctx, obj, "resolvedState", joinFieldPath(fieldPath, "resolvedState")), joinFieldPath(fieldPath, "resolvedState"), ARTIFACT_LIFECYCLE_STATES)
+    };
+    if (optionalField(obj, "blockingReason") !== undefined) {
+        result.blockingReason = optionalString(ctx, obj.blockingReason, joinFieldPath(fieldPath, "blockingReason"));
+    }
+    return result;
+}
+export function validateOrchestratorRunIntegrityEvidenceV1(value, sourcePath) {
+    const ctx = { artifactKind: ARTIFACT_KIND, sourcePath };
+    try {
+        const schemaVersionResult = parseSupportedMajorOneSchemaVersion(requiredField(ctx, value, "schemaVersion", "schemaVersion"), ARTIFACT_KIND, sourcePath);
+        if ("ok" in schemaVersionResult)
+            return schemaVersionResult;
+        const evidence = {
+            schemaVersion: requiredString(ctx, value.schemaVersion, "schemaVersion"),
+            runFolder: requiredString(ctx, requiredField(ctx, value, "runFolder", "runFolder"), "runFolder"),
+            gate: validateGate(ctx, requiredField(ctx, value, "gate", "gate"), "gate"),
+            lifecycle: requiredArray(ctx, requiredField(ctx, value, "lifecycle", "lifecycle"), "lifecycle").map((item, i) => validateLifecycleEntry(ctx, item, arrayFieldPath("lifecycle", i)))
+        };
+        if (optionalField(value, "judgeIntegrity") !== undefined) {
+            evidence.judgeIntegrity = validateJudgeIntegrity(ctx, value.judgeIntegrity, "judgeIntegrity");
+        }
+        if (optionalField(value, "finalReportEligibility") !== undefined) {
+            evidence.finalReportEligibility = validateFinalReportEligibility(ctx, value.finalReportEligibility, "finalReportEligibility");
+        }
+        if (optionalField(value, "finalArtifactPresent") !== undefined) {
+            evidence.finalArtifactPresent = requiredBoolean(ctx, value.finalArtifactPresent, "finalArtifactPresent");
+        }
+        if (optionalField(value, "finalArtifactVerdict") !== undefined) {
+            evidence.finalArtifactVerdict = requiredNullableLiteral(ctx, value.finalArtifactVerdict, "finalArtifactVerdict", JUDGE_VERDICTS);
+        }
+        // Per the exact-mirror contract, the returned artifact is always the original parsed
+        // reference, not a rebuilt object. The construction above exists only to walk and
+        // type-check every field.
+        void evidence;
+        return {
+            ok: true,
+            artifactKind: ARTIFACT_KIND,
+            sourcePath,
+            schemaVersion: value.schemaVersion,
+            schemaMajor: 1,
+            artifact: value,
+            rawArtifact: value
+        };
+    }
+    catch (error) {
+        if (error instanceof ArtifactValidationError)
+            return error.failure;
+        throw error;
+    }
+}

package/dist/src/report/experiments/buildContextIntegrityReport.js

@@ -0,0 +1,204 @@
+// v0.4.5 Batch 5: builds the bounded ContextIntegrityReportV1 from already-calculated
+// Batch 1-4 results. Never recalculates allocation, condition coverage, agreement states,
+// hashes, determinism, or immutability -- it only bounds and reshapes values the caller
+// already computed via evaluateProducerReadinessBridge, verifyFixtureHashes, and
+// calculateStageContextDeterminism.
+import { V043_REPORT_DETAIL_LIMIT } from "./contextStrategyComparisonV043ReportModel.js";
+const CORRECTED_REPLAY_LIMITATION = "This corrected-replay fixture is a hand-distilled representation of the exact validated local my-dev-kit v1.10.4 and my-dev-kit-orchestrator v1.2.3 contracts, applied to the same request, target, and active-index identity as the paired failed-run fixture. It is not a live capture of a complete ten-stage AI-authored implementation workflow, and it is not proof that every future run against these contracts will behave identically.";
+function boundItems(source, limit = V043_REPORT_DETAIL_LIMIT) {
+    const items = source.slice(0, limit);
+    return { totalCount: source.length, displayedCount: items.length, omittedCount: source.length - items.length, items };
+}
+function toContradiction(c) {
+    return { code: c.code, fieldPath: c.fieldPath, expected: c.expected, observed: c.observed, reason: c.reason };
+}
+function agreementFromRunIntegrity(component) {
+    return {
+        availability: component.availability,
+        outcome: component.outcome,
+        contradictions: boundItems(component.contradictions.map(toContradiction)),
+        reason: component.reason
+    };
+}
+function unavailableAgreement(reason) {
+    return { availability: "unavailable", outcome: "insufficient-evidence", contradictions: boundItems([]), reason };
+}
+export function buildContextIntegrityReport(input) {
+    const { manifest, hashVerification, capsule, bridgeResult } = input;
+    const side = bridgeResult.implementation ?? bridgeResult.testImplementation;
+    const runIntegrity = bridgeResult.runIntegrityEvaluation;
+    const derivedCount = manifest.artifacts.filter((a) => a.derived).length;
+    const byteExactCount = manifest.artifacts.filter((a) => a.byteExact).length;
+    const allocationAgg = side?.groupAllocationEvaluation.aggregate ?? null;
+    const spillover = side?.groupAllocationEvaluation.spillover ?? null;
+    const conditionCoverage = side?.conditionCoverageEvaluation ?? null;
+    const conditionAwareTruncation = side?.conditionAwareTruncationEvaluation ?? null;
+    const unavailableSections = [];
+    const notes = [];
+    if (!side)
+        unavailableSections.push("producer");
+    if (!runIntegrity)
+        unavailableSections.push("run-integrity");
+    if (conditionCoverage?.availability !== "available")
+        unavailableSections.push("condition-coverage");
+    return {
+        schemaVersion: "1.0.0",
+        detailLimit: V043_REPORT_DETAIL_LIMIT,
+        fixture: {
+            fixtureId: manifest.fixtureId,
+            kind: input.fixtureKind,
+            description: manifest.description,
+            myDevKitCommit: manifest.myDevKit.commit,
+            orchestratorCommit: manifest.orchestrator.commit,
+            targetRepositoryIdentity: manifest.targetRepositoryIdentity,
+            activeIndexIdentity: manifest.activeIndexIdentity,
+            manifestSchemaVersion: manifest.manifestSchemaVersion,
+            trackedArtifactCount: manifest.artifacts.length,
+            derivedArtifactCount: derivedCount,
+            byteExactArtifactCount: byteExactCount,
+            artifacts: boundItems(manifest.artifacts.map((a) => ({
+                fixtureRelativePath: a.fixtureRelativePath,
+                role: a.role,
+                derived: a.derived,
+                byteExact: a.byteExact,
+                provenanceOnly: a.provenanceOnly
+            }))),
+            hashVerification: {
+                ok: hashVerification.ok,
+                checkedCount: hashVerification.checkedCount,
+                issues: boundItems(hashVerification.issues.map((i) => ({ code: i.code, fixtureRelativePath: i.fixtureRelativePath, message: i.message })))
+            },
+            correctedReplayLimitation: input.fixtureKind === "corrected-replay" ? CORRECTED_REPLAY_LIMITATION : ""
+        },
+        producerIdentity: {
+            toolName: capsule?.tool.name ?? null,
+            toolVersion: capsule?.tool.version ?? null,
+            role: capsule?.request.role ?? null,
+            projectRoot: capsule?.index.projectRoot ?? null,
+            indexPath: capsule?.index.indexPath ?? null,
+            roleAdequacyStatus: capsule?.roleAdequacy.status ?? null
+        },
+        allocation: {
+            availability: allocationAgg?.availability ?? "unavailable",
+            groupCount: allocationAgg?.groupCount ?? 0,
+            totalRequiredOmitted: allocationAgg?.totalRequiredOmitted ?? null,
+            totalOptionalOmitted: allocationAgg?.totalOptionalOmitted ?? null,
+            aggregateCapacityUsed: null,
+            aggregateCapacityRemaining: null,
+            groupsWithRequiredOmission: allocationAgg?.groupsWithRequiredOmission ?? [],
+            groupsWithOptionalOnlyOmission: allocationAgg?.groupsWithOptionalOnlyOmission ?? [],
+            perGroup: boundItems((side?.groupAllocationEvaluation.perGroup ?? []).map((g) => ({
+                groupId: g.groupId,
+                availability: g.availability,
+                required: g.required,
+                reservation: g.reservation,
+                initiallySelectedCount: g.initiallySelectedCount,
+                unusedReservationContributed: g.unusedReservationContributed,
+                borrowedCapacity: g.borrowedCapacity,
+                requiredOmittedCount: g.requiredOmittedCount,
+                optionalOmittedCount: g.optionalOmittedCount,
+                adequacyAffected: g.adequacyAffected
+            })))
+        },
+        spillover: {
+            availability: spillover?.availability ?? "unavailable",
+            groupsContributing: spillover?.groupsContributing ?? [],
+            groupsBorrowing: spillover?.groupsBorrowing ?? [],
+            totalContributed: spillover?.totalContributed ?? null,
+            totalBorrowed: spillover?.totalBorrowed ?? null,
+            contributionCoversBorrowing: spillover?.contributionCoversBorrowing ?? null,
+            reason: spillover?.reason ?? null
+        },
+        truncation: {
+            availability: conditionAwareTruncation?.availability ?? "unavailable",
+            state: conditionAwareTruncation?.state ?? "unsupported-legacy-diagnostics",
+            requiredEvidenceLost: conditionAwareTruncation?.requiredEvidenceLost ?? null,
+            requiredOmittedTotal: conditionAwareTruncation?.requiredOmittedTotal ?? null,
+            optionalOmittedTotal: conditionAwareTruncation?.optionalOmittedTotal ?? null,
+            lostRequiredConditionIds: conditionAwareTruncation?.lostRequiredConditionIds ?? [],
+            contradictions: boundItems((conditionAwareTruncation?.contradictionCodes ?? []).map((code) => ({ code, fieldPath: "truncation", expected: null, observed: null, reason: conditionAwareTruncation?.reason ?? "" })))
+        },
+        conditionCoverage: {
+            availability: conditionCoverage?.availability ?? "unavailable",
+            requiredConditionsTotal: conditionCoverage?.requiredConditionsTotal.count ?? null,
+            requiredConditionsSatisfied: conditionCoverage?.requiredConditionsSatisfied.count ?? null,
+            requiredConditionsMissing: conditionCoverage?.requiredConditionsMissing.evidenceKeys ?? [],
+            requiredConditionsLost: conditionCoverage?.requiredConditionsLost.evidenceKeys ?? [],
+            lastWitnessLossCount: conditionCoverage?.lastWitnessLoss.count ?? null,
+            witnessEvidence: boundItems((conditionCoverage?.witnessEvidence ?? []).map((w) => ({
+                conditionId: w.conditionId,
+                required: w.required,
+                coverageState: w.coverageState,
+                retainedWitnessCount: w.retainedWitnessCount,
+                retainedWitnessIds: boundItems(w.retainedWitnessIds),
+                adequateWitnessRemains: w.adequateWitnessRemains,
+                lossReason: w.lossReason,
+                evidenceGroupIds: w.evidenceGroupIds
+            }))),
+            reason: conditionCoverage?.reason ?? null
+        },
+        producerConditionAgreement: side
+            ? {
+                availability: side.producerConditionAgreement.availability,
+                outcome: side.producerConditionAgreement.outcome,
+                contradictions: boundItems(side.producerConditionAgreement.contradictionCodes.map((code) => ({ code, fieldPath: "roleAdequacy", expected: null, observed: null, reason: side.producerConditionAgreement.reason ?? "" }))),
+                reason: side.producerConditionAgreement.reason
+            }
+            : unavailableAgreement("No producer side was supplied."),
+        requiredEvidenceLossAgreement: side
+            ? {
+                availability: side.requiredEvidenceLossAgreement.availability,
+                outcome: side.requiredEvidenceLossAgreement.outcome,
+                contradictions: boundItems(side.requiredEvidenceLossAgreement.contradictionCodes.map((code) => ({ code, fieldPath: "truncation.requiredEvidenceLost", expected: null, observed: null, reason: side.requiredEvidenceLossAgreement.reason ?? "" }))),
+                reason: side.requiredEvidenceLossAgreement.reason
+            }
+            : unavailableAgreement("No producer side was supplied."),
+        capsuleAuditAgreement: side
+            ? {
+                availability: side.capsuleAuditConditionAgreement.availability,
+                consistent: side.capsuleAuditConditionAgreement.consistent,
+                contradictingFieldPaths: side.capsuleAuditConditionAgreement.contradictingFieldPaths
+            }
+            : { availability: "unavailable", consistent: null, contradictingFieldPaths: [] },
+        supplementalRawAgreement: side?.packetAgreement || side?.reportAgreement
+            ? {
+                availability: "available",
+                contradictingFields: [...(side.packetAgreement?.contradictions ?? []), ...(side.reportAgreement?.contradictions ?? [])].map((f) => f.field),
+                upstreamProducerParityPreserved: side.packetAgreement?.upstreamProducerParityPreserved ?? side.reportAgreement?.upstreamProducerParityPreserved ?? null
+            }
+            : null,
+        producerReadinessAgreement: bridgeResult.producerReadinessRelationship
+            ? {
+                availability: bridgeResult.producerReadinessRelationship.availability,
+                outcome: bridgeResult.producerReadinessRelationship.outcome,
+                contradictions: boundItems(bridgeResult.producerReadinessRelationship.contradictionCodes.map((code) => ({ code, fieldPath: "readiness", expected: null, observed: null, reason: bridgeResult.producerReadinessRelationship.reason ?? "" }))),
+                reason: bridgeResult.producerReadinessRelationship.reason
+            }
+            : unavailableAgreement("No producer/readiness relationship was calculated."),
+        readinessPromptAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.readinessPrompt) : unavailableAgreement("No run-integrity evidence was supplied."),
+        readinessExpectedJudgeAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.readinessExpectedJudge) : unavailableAgreement("No run-integrity evidence was supplied."),
+        expectedActualJudgeAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.expectedActualJudge) : unavailableAgreement("No run-integrity evidence was supplied."),
+        judgeCorrectionAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.judgeCorrection) : unavailableAgreement("No run-integrity evidence was supplied."),
+        judgeFinalEligibilityAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.judgeFinalEligibility) : unavailableAgreement("No run-integrity evidence was supplied."),
+        eligibilityFinalArtifactAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.eligibilityFinalArtifact) : unavailableAgreement("No run-integrity evidence was supplied."),
+        lifecycleIntegrityAgreement: runIntegrity ? agreementFromRunIntegrity(runIntegrity.lifecycleIntegrity) : unavailableAgreement("No run-integrity evidence was supplied."),
+        endToEnd: runIntegrity
+            ? { category: runIntegrity.endToEndSummary.category, componentOutcomes: runIntegrity.endToEndSummary.componentOutcomes, contradictingComponents: runIntegrity.endToEndSummary.contradictingComponents }
+            : null,
+        determinism: input.determinism
+            ? {
+                availability: input.determinism.availability,
+                repeatCount: input.determinism.repeatCount,
+                deterministic: input.determinism.deterministic,
+                baselineSha256: input.determinism.baselineSha256,
+                mismatchRunNumbers: input.determinism.mismatchRunNumbers,
+                reason: input.determinism.reason
+            }
+            : { availability: "not-applicable", repeatCount: 1, deterministic: null, baselineSha256: null, mismatchRunNumbers: [], reason: "Determinism was not evaluated for this report." },
+        immutability: {
+            fixtureSelfImmutable: input.fixtureSelfImmutable ?? null,
+            fixtureImmutabilityReason: input.fixtureSelfImmutableReason ?? (input.fixtureSelfImmutable === undefined ? "Fixture self-immutability was not checked for this report." : null)
+        },
+        limitations: { unavailableSections, notes }
+    };
+}

package/dist/src/report/experiments/contextIntegrityReportModel.js

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