feat: wire alignment scoring into training reward calculation

Coordinators now compute charter↔constitution alignment (via
AlignmentPricing) alongside correctness when verifying solutions.
Both scores flow through Yuma consensus, and solver rewards are
scaled by correctness × alignment.

Changes:
- AutonetLib: add alignmentScore to CoordinatorVote, consensusAlignmentScore
  to YumaConsensusResult, charterCid to SolverSubmission
- ResultsRewards: submitVote accepts alignment score, _processRewardsYuma
  applies alignment factor to solver reward calculation
- TaskContract: commitSolution accepts charterCid so coordinators can
  fetch solver charter text from blob store
- Coordinator node: computes alignment after correctness verification,
  submits both scores in vote
- Solver node: uploads charter to blob store and commits CID with solution
- Python contract bindings: updated for new parameters
- Tests: updated all submitVote/commitSolution calls

Author: EightRice

contracts/core/ResultsRewards.sol

@@ -129,6 +129,7 @@ contract ResultsRewards {
         address _solver,
         bool _isCorrect,
         uint256 _score,
+        uint256 _alignmentScore,
         string calldata _reportCid
     ) external onlyStakedCoordinator {
         AutonetLib.TaskProposal memory proposal = taskContract.getTaskProposal(_taskId);
@@ -159,6 +160,7 @@ contract ResultsRewards {
             coordinator: msg.sender,
             isCorrect: _isCorrect,
             score: _score,
+            alignmentScore: _alignmentScore,
             stake: stakeInfo.amount,
             voteBlock: block.number,
             reportHash: keccak256(abi.encodePacked(_reportCid))
@@ -187,14 +189,15 @@ contract ResultsRewards {
         require(taskVotes.length >= MIN_COORDINATORS, "Insufficient coordinator votes");
 
         // Compute Yuma consensus
-        (bool consensusCorrect, uint256 consensusScore, uint256 totalStake, uint256 correctStake, uint256 clippedCount) =
+        (bool consensusCorrect, uint256 consensusScore, uint256 consensusAlignmentScore, uint256 totalStake, uint256 correctStake, uint256 clippedCount) =
             _computeYumaConsensus(_taskId, taskVotes);
 
         // Store result
         result.taskId = _taskId;
         result.solver = _solver;
         result.consensusCorrect = consensusCorrect;
         result.consensusScore = consensusScore;
+        result.consensusAlignmentScore = consensusAlignmentScore;
         result.totalStake = totalStake;
         result.correctStake = correctStake;
         result.clippedVotes = clippedCount;
@@ -212,35 +215,40 @@ contract ResultsRewards {
         emit YumaConsensusReached(_taskId, _solver, consensusCorrect, consensusScore);
 
         // Process rewards
-        _processRewardsYuma(_taskId, _solver, taskVotes, consensusCorrect, consensusScore);
+        _processRewardsYuma(_taskId, _solver, taskVotes, consensusCorrect, consensusScore, consensusAlignmentScore);
     }
 
     /**
      * @dev Compute Yuma consensus with stake-weighted voting and clipping.
      */
     function _computeYumaConsensus(uint256 _taskId, AutonetLib.CoordinatorVote[] storage taskVotes)
         internal
-        returns (bool consensusCorrect, uint256 consensusScore, uint256 totalStake, uint256 correctStake, uint256 clippedCount)
+        returns (bool consensusCorrect, uint256 consensusScore, uint256 consensusAlignmentScore, uint256 totalStake, uint256 correctStake, uint256 clippedCount)
     {
         uint256 numVotes = taskVotes.length;
 
-        // Calculate total stake and stake-weighted score
+        // Calculate total stake, stake-weighted correctness score, and alignment score
         uint256 weightedScoreSum = 0;
+        uint256 weightedAlignmentSum = 0;
         for (uint256 i = 0; i < numVotes; i++) {
             totalStake += taskVotes[i].stake;
             if (taskVotes[i].isCorrect) {
                 correctStake += taskVotes[i].stake;
             }
             weightedScoreSum += taskVotes[i].score * taskVotes[i].stake;
+            weightedAlignmentSum += taskVotes[i].alignmentScore * taskVotes[i].stake;
         }
 
         // Consensus correct if majority stake agrees
         consensusCorrect = correctStake > totalStake / 2;
 
-        // Calculate stake-weighted average score (before clipping)
+        // Stake-weighted average alignment score (no clipping — alignment is subjective)
+        consensusAlignmentScore = totalStake > 0 ? weightedAlignmentSum / totalStake : 0;
+
+        // Calculate stake-weighted average correctness score (before clipping)
         uint256 avgScore = totalStake > 0 ? weightedScoreSum / totalStake : 0;
 
-        // Apply clipping: scores that deviate too much from average are clipped
+        // Apply clipping: correctness scores that deviate too much from average are clipped
         uint256 clippedWeightedSum = 0;
         uint256 clippedTotalStake = 0;
 
@@ -306,7 +314,8 @@ contract ResultsRewards {
         address _solver,
         AutonetLib.CoordinatorVote[] storage taskVotes,
         bool _isCorrect,
-        uint256 _consensusScore
+        uint256 _consensusScore,
+        uint256 _consensusAlignmentScore
     ) internal {
         require(!rewardsProcessed[_taskId], "Already processed");
 
@@ -340,8 +349,11 @@ contract ResultsRewards {
         }
 
         if (_isCorrect) {
-            // Solver reward scaled by consensus score
-            uint256 scaledSolverReward = (proposal.proposedSolverReward * _consensusScore) / 100;
+            // Solver reward scaled by correctness AND alignment
+            // correctness: 0-100, alignment: 0-10000 (basis points)
+            // Formula: base * (correctness/100) * (alignment/10000)
+            // = base * correctness * alignment / 1_000_000
+            uint256 scaledSolverReward = (proposal.proposedSolverReward * _consensusScore * _consensusAlignmentScore) / 1000000;
             try rpbContract.disburseFromBudget(_solver, scaledSolverReward) returns (bool success) {
                 if (success) {
                     emit RewardsDistributed(_taskId, _solver, scaledSolverReward, "SolverReward");
@@ -350,7 +362,7 @@ contract ResultsRewards {
                 // Continue if disbursement fails
             }
 
-            // Proposer reward
+            // Proposer reward (not alignment-gated — proposers create tasks, not charters)
             try rpbContract.disburseFromBudget(proposal.proposer, proposal.proposedLearnabilityReward) returns (bool success) {
                 if (success) {
                     emit RewardsDistributed(_taskId, proposal.proposer, proposal.proposedLearnabilityReward, "ProposerReward");
@@ -539,6 +551,7 @@ contract ResultsRewards {
         address _solver,
         bool _isCorrect,
         uint256 _score,
+        uint256 _alignmentScore,
         string calldata _reportCid
     ) external onlyStakedCoordinator {
         AutonetLib.TaskProposal memory proposal = taskContract.getTaskProposal(_taskId);

contracts/core/TaskContract.sol

@@ -115,7 +115,7 @@ contract TaskContract {
         _activateTask(_taskId);
     }
 
-    function commitSolution(uint256 _taskId, bytes32 _solutionHash)
+    function commitSolution(uint256 _taskId, bytes32 _solutionHash, bytes32 _charterCid)
         external taskExists(_taskId) onlyStakedSolver
     {
         Task storage t = _tasks[_taskId];
@@ -127,6 +127,7 @@ contract TaskContract {
 
         submissions[_taskId][msg.sender] = AutonetLib.SolverSubmission({
             solutionHash: _solutionHash,
+            charterCid: _charterCid,
             solver: msg.sender,
             submissionBlock: block.number,
             score: 0

contracts/utils/AutonetLib.sol

@@ -93,6 +93,7 @@ library AutonetLib {
 
     struct SolverSubmission {
         bytes32 solutionHash;    // Hash of solution (content hash)
+        bytes32 charterCid;      // Content hash of solver's charter (for alignment scoring)
         address solver;
         uint256 submissionBlock;
         uint256 score;           // Quality score if verified
@@ -166,7 +167,8 @@ library AutonetLib {
     struct CoordinatorVote {
         address coordinator;
         bool isCorrect;
-        uint256 score;           // 0-100
+        uint256 score;           // 0-100 correctness score
+        uint256 alignmentScore;  // 0-10000 charter↔constitution alignment (basis points)
         uint256 stake;           // Coordinator's stake at vote time
         uint256 voteBlock;
         bytes32 reportHash;
@@ -176,7 +178,8 @@ library AutonetLib {
         uint256 taskId;
         address solver;
         bool consensusCorrect;    // Final consensus decision
-        uint256 consensusScore;   // Stake-weighted score
+        uint256 consensusScore;   // Stake-weighted correctness score
+        uint256 consensusAlignmentScore; // Stake-weighted alignment score (basis points)
         uint256 totalStake;       // Total stake that voted
         uint256 correctStake;     // Stake that voted correct
         uint256 clippedVotes;     // Number of votes that were clipped

nodes/common/contracts.py

@@ -245,9 +245,23 @@ def propose_task(
             gas_limit=800000,
         )
 
-    def commit_solution(self, task_id: int, solution_hash: bytes) -> TransactionResult:
-        """Commit a solution hash for a task."""
-        return self.send("TaskContract", "commitSolution", task_id, solution_hash)
+    def commit_solution(self, task_id: int, solution_hash: bytes, charter_cid: bytes = b'\x00' * 32) -> TransactionResult:
+        """Commit a solution hash and charter CID for a task."""
+        return self.send("TaskContract", "commitSolution", task_id, solution_hash, charter_cid)
+
+    def get_submission(self, task_id: int, solver: str) -> dict:
+        """Get a solver's submission for a task."""
+        try:
+            result = self.call("TaskContract", "getSubmission", task_id, solver)
+            return {
+                "solutionHash": result[0],
+                "charterCid": result[1],
+                "solver": result[2],
+                "submissionBlock": result[3],
+                "score": result[4],
+            }
+        except Exception:
+            return {}
 
     def submit_checkpoint(
         self,
@@ -295,12 +309,13 @@ def submit_vote(
         solver: str,
         is_correct: bool,
         score: int,
+        alignment_score: int,
         report_cid: str,
     ) -> TransactionResult:
-        """Submit a coordinator vote."""
+        """Submit a coordinator vote with correctness and alignment scores."""
         return self.send(
             "ResultsRewards", "submitVote",
-            task_id, solver, is_correct, score, report_cid,
+            task_id, solver, is_correct, score, alignment_score, report_cid,
         )
 
     def finalize_voting(self, task_id: int, solver: str) -> TransactionResult:

nodes/coordinator/main.py

@@ -18,6 +18,7 @@
 from ..common.contracts import ContractRegistry
 from ..common.blob_store import BlobStore
 from ..common.governance import GovernanceBridge
+from ..common.alignment_pricing import AlignmentPricing
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -97,6 +98,10 @@ def __init__(
         # Governance bridge for attestation and heartbeat
         self.governance = GovernanceBridge(registry, node_id)
 
+        # Alignment scoring
+        self._alignment_pricing = AlignmentPricing(embedding_mode=False)
+        self._constitution_text: Optional[str] = None
+
         logger.info(
             f"CoordinatorNode initialized: {node_id}"
         )
@@ -262,6 +267,9 @@ def _process_solution_reveal(self, event):
                 ground_truth_cid
             )
 
+            # Compute alignment score (charter ↔ constitution)
+            alignment_score = self._compute_solver_alignment(task_id, solver)
+
             # Create verification report
             report = {
                 "task_id": task_id,
@@ -270,6 +278,7 @@ def _process_solution_reveal(self, event):
                 "ground_truth_cid": ground_truth_cid,
                 "is_correct": is_correct,
                 "score": score,
+                "alignment_score": alignment_score,
                 "coordinator": self.registry.blockchain.account.address,
                 "timestamp": int(time.time()),
                 "node_id": self.node_id,
@@ -285,6 +294,7 @@ def _process_solution_reveal(self, event):
                 solver,
                 is_correct,
                 score,
+                alignment_score,
                 report_cid
             )
 
@@ -673,3 +683,82 @@ def _update_bond_strength(self, success: Optional[bool] = None):
             self.EMA_ALPHA * target +
             (1 - self.EMA_ALPHA) * self.metrics.ema_bond_strength
         )
+
+    # ============ Alignment Scoring ============
+
+    def _get_constitution_text(self) -> str:
+        """Load and cache the jurisdiction constitution text."""
+        if self._constitution_text is not None:
+            return self._constitution_text
+
+        try:
+            from ..core.constitution import DEFAULT_CONSTITUTION
+            self._constitution_text = DEFAULT_CONSTITUTION.get_principle_summary()
+        except Exception as e:
+            logger.warning(f"Failed to load constitution: {e}")
+            self._constitution_text = ""
+
+        return self._constitution_text
+
+    def _compute_solver_alignment(self, task_id: int, solver: str) -> int:
+        """
+        Compute a solver's charter↔constitution alignment score.
+
+        Retrieves the solver's charter text from the blob store (via the
+        charterCid committed with their solution), then computes similarity
+        against the jurisdiction constitution.
+
+        Returns:
+            Alignment score in basis points (0-10000).
+        """
+        constitution = self._get_constitution_text()
+        if not constitution:
+            return 5000  # Neutral default if constitution unavailable
+
+        # Get solver's charter from their submission
+        charter_text = self._get_solver_charter(task_id, solver)
+        if not charter_text:
+            return 5000  # Neutral default if charter unavailable
+
+        try:
+            alignment, breakdown = self._alignment_pricing.compute_alignment(
+                task_description=charter_text,
+                user_standards=charter_text,
+                jurisdiction_standards=constitution,
+            )
+            score_bps = int(alignment * 10000)
+            logger.info(
+                f"Alignment score for solver {solver[:10]}...: "
+                f"{score_bps} bps (breakdown: {breakdown})"
+            )
+            return score_bps
+        except Exception as e:
+            logger.warning(f"Alignment computation failed: {e}")
+            return 5000
+
+    def _get_solver_charter(self, task_id: int, solver: str) -> Optional[str]:
+        """
+        Retrieve the solver's charter text from the blob store.
+
+        The solver commits a charterCid alongside their solution hash.
+        We read it from the on-chain submission and fetch the text.
+        """
+        try:
+            submission = self.registry.get_submission(task_id, solver)
+            charter_cid_bytes = submission.get("charterCid", b'\x00' * 32)
+
+            # Zero hash means no charter submitted
+            if charter_cid_bytes == b'\x00' * 32 or not charter_cid_bytes:
+                return None
+
+            # charterCid is a content hash — fetch from blob store
+            charter_cid = charter_cid_bytes.hex() if isinstance(charter_cid_bytes, bytes) else str(charter_cid_bytes)
+            charter_data = self.store.get_json(charter_cid)
+            if charter_data and isinstance(charter_data, dict):
+                return charter_data.get("charter", "")
+            elif isinstance(charter_data, str):
+                return charter_data
+            return None
+        except Exception as e:
+            logger.warning(f"Failed to get solver charter: {e}")
+            return None

nodes/solver/main.py

@@ -309,8 +309,11 @@ def _train_and_commit(self, task_id: int, task_info: TaskInfo):
 
         logger.info(f"[{self.node_id}] Solution uploaded: {solution_cid}, hash: {solution_hash.hex()[:16]}...")
 
-        # Commit solution hash to blockchain
-        commit_result = self.registry.commit_solution(task_id, solution_hash)
+        # Upload charter for alignment scoring by coordinators
+        charter_cid_bytes = self._upload_charter()
+
+        # Commit solution hash and charter CID to blockchain
+        commit_result = self.registry.commit_solution(task_id, solution_hash, charter_cid_bytes)
 
         if commit_result.success:
             logger.info(f"[{self.node_id}] Solution committed for task {task_id}: {commit_result.tx_hash}")
@@ -327,6 +330,27 @@ def _train_and_commit(self, task_id: int, task_info: TaskInfo):
         else:
             logger.error(f"[{self.node_id}] Failed to commit solution: {commit_result.error}")
 
+    def _upload_charter(self) -> bytes:
+        """Upload this solver's charter to the blob store for alignment scoring.
+
+        Returns:
+            The charter CID as bytes32 (zero bytes if upload fails).
+        """
+        try:
+            from ..core.constitution import DEFAULT_CONSTITUTION
+            charter = {
+                "charter": self.config.charter if hasattr(self.config, 'charter') and self.config.charter else "",
+                "node_id": self.node_id,
+                "constitution_hash": DEFAULT_CONSTITUTION.get_principle_summary()[:64],
+            }
+            cid = self.store.add_json(charter)
+            if cid:
+                from web3 import Web3
+                return Web3.keccak(text=cid)
+        except Exception as e:
+            logger.warning(f"[{self.node_id}] Failed to upload charter: {e}")
+        return b'\x00' * 32
+
     def _train(self, task_id: int, task_spec: Optional[dict] = None) -> tuple:
         """
         Perform real ML training driven by task spec.