chore: eliminate all compiler warnings (0 warnings, 248 tests pass)

- Remove unused `colored::Colorize` import from main.rs
- Suppress dead_code warnings on API surface prepared for future
  integrations (LLM structs, neural module, BoJ cartridge types)
- Fix `ProverStats` visibility in agent router
- Add `#[allow(unexpected_cfgs)]` for ConceptNet feature gates
- Remove unused imports via cargo fix (77 auto-fixed)
- Restore `Priority` and `Goal` imports in agent test modules
  that cargo fix incorrectly removed
- Add training_data/scripts/ to .gitignore

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

.gitignore

@@ -8,6 +8,9 @@ Thumbs.db
 *.swo
 *~
 .idea/
+
+# Training data scripts (one-off analysis, not part of build)
+training_data/scripts/
 .vscode/
 
 # Build

src/rust/agent/actors.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 
 #![allow(dead_code)]
+#![allow(unexpected_cfgs)]
 
 //! Actor-based Multi-Agent Orchestration
 //!
@@ -10,12 +11,12 @@
 use actix::prelude::*;
 use anyhow::Result;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
-use tracing::{debug, info, warn};
+use std::time::Instant;
+use tracing::{debug, info};
 
 use crate::core::{Goal, ProofState};
 use crate::provers::{ProverBackend, ProverKind};
-use super::{AgenticGoal, GoalResult};
+use super::AgenticGoal;
 
 /// Message types for actor communication
 #[derive(Message)]
@@ -143,7 +144,7 @@ impl Actor for ContextAgent {
 impl Handler<GetRelatedConcepts> for ContextAgent {
     type Result = Vec<String>;
 
-    fn handle(&mut self, msg: GetRelatedConcepts, _ctx: &mut Self::Context) -> Self::Result {
+    fn handle(&mut self, _msg: GetRelatedConcepts, _ctx: &mut Self::Context) -> Self::Result {
         #[cfg(feature = "conceptnet")]
         {
             use actix::AsyncContext;

src/rust/agent/explanations.rs

@@ -11,9 +11,9 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-use crate::core::{Goal, Term};
+use crate::core::Term;
 use crate::provers::ProverKind;
-use super::{AgenticGoal, Priority};
+use super::AgenticGoal;
 
 /// Explanation for a proof attempt
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -301,7 +301,7 @@ impl ExplanationGenerator {
             Term::Let { name, value, body, .. } => {
                 format!("let {} = {} in {}", name, self.format_term(value), self.format_term(body))
             }
-            Term::Match { scrutinee, branches, .. } => {
+            Term::Match { scrutinee, branches: _, .. } => {
                 format!("match {} with ...", self.format_term(scrutinee))
             }
             Term::Fix { name, body, .. } => {
@@ -378,6 +378,8 @@ impl Default for ExplanationGenerator {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::agent::Priority;
+    use crate::core::Goal;
 
     #[test]
     fn test_failure_explanation() {

src/rust/agent/mod.rs

@@ -9,13 +9,12 @@
 //! across multiple provers with neural guidance and symbolic verification.
 
 use anyhow::Result;
-use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::collections::VecDeque;
 use tokio::sync::RwLock;
 use tracing::{debug, info, warn};
 
-use crate::core::{Goal, ProofState, Tactic, TacticResult, Term, Theorem};
+use crate::core::{Goal, ProofState, Tactic, Term};
 use crate::provers::{ProverBackend, ProverKind};
 
 pub mod memory;
@@ -290,7 +289,7 @@ impl AgentCore {
     }
 
     /// Process a single goal
-    async fn process_goal(&self, mut goal: AgenticGoal) -> Result<GoalResult> {
+    async fn process_goal(&self, goal: AgenticGoal) -> Result<GoalResult> {
         // Step 1: Check memory for similar proofs
         if let Some(cached) = self.memory.find_similar(&goal).await? {
             info!("Found similar proof in memory for goal {}", goal.goal.id);
@@ -330,7 +329,7 @@ impl AgentCore {
         };
 
         // Step 5: Try tactics
-        let start = std::time::Instant::now();
+        let _start = std::time::Instant::now();
 
         for tactic in tactics {
             debug!("Trying tactic {:?} for goal {}", tactic, goal.goal.id);

src/rust/agent/planner.rs

@@ -12,7 +12,7 @@ use async_trait::async_trait;
 use tracing::{debug, info};
 
 use crate::core::{Goal, Term};
-use super::{AgenticGoal, Priority};
+use super::AgenticGoal;
 
 /// Trait for goal planning/decomposition
 #[async_trait]
@@ -35,7 +35,7 @@ impl RulePlanner {
     }
 
     /// Check if term is a conjunction (A ∧ B)
-    fn is_conjunction(&self, term: &Term) -> Option<(Term, Term)> {
+    fn is_conjunction(&self, _term: &Term) -> Option<(Term, Term)> {
         // TODO: Implement proper pattern matching for conjunction
         None
     }
@@ -71,7 +71,7 @@ impl Planner for RulePlanner {
         // Rule 1: Decompose implication (A → B) into:
         //   - Assume A
         //   - Prove B
-        if let Some((premise, conclusion)) = self.is_implication(&goal.goal.target) {
+        if let Some((_premise, conclusion)) = self.is_implication(&goal.goal.target) {
             debug!("Decomposing implication");
 
             // Sub-goal 1: Assume premise (this becomes a hypothesis)
@@ -150,6 +150,7 @@ impl Planner for LeanPlanner {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::agent::Priority;
     use crate::core::{Goal, Term};
 
     #[tokio::test]

src/rust/agent/router.rs

@@ -17,7 +17,7 @@ use super::AgenticGoal;
 
 /// Prover performance statistics
 #[derive(Debug, Clone, Serialize, Deserialize)]
-struct ProverStats {
+pub struct ProverStats {
     /// Total attempts
     attempts: u32,
 

src/rust/anomaly_detection.rs

@@ -181,7 +181,7 @@ impl ConsensusChecker {
     /// Check consensus across multiple provers
     pub fn check_consensus(
         &self,
-        goal: &str,
+        _goal: &str,
         prover_results: Vec<(String, bool)>,
     ) -> ConsensusResult {
         let mut voting = HashMap::new();

src/rust/aspect.rs

@@ -789,6 +789,7 @@ impl RuleBasedTagger {
 ///
 /// This integrates with Julia ML components for neural aspect classification.
 /// The neural model is trained on a corpus of tagged theorems.
+#[allow(dead_code)]
 pub struct NeuralTagger {
     /// Confidence threshold for aspect prediction
     threshold: f64,
@@ -821,13 +822,15 @@ impl NeuralTagger {
     }
 
     /// Get embeddings for a term (to be implemented with Julia integration)
+    #[allow(dead_code)]
     async fn get_embeddings(&self, _statement: &Term) -> Vec<f64> {
         // TODO: Implement Julia FFI or HTTP call to Julia ML service
         // For now, return dummy embeddings
         vec![0.0; 128]
     }
 
     /// Classify embeddings into aspects (to be implemented)
+    #[allow(dead_code)]
     async fn classify_embeddings(&self, _embeddings: &[f64]) -> HashMap<Aspect, f64> {
         // TODO: Implement Julia FFI or HTTP call to Julia ML service
         // For now, return empty predictions
@@ -859,6 +862,7 @@ impl AspectTagger for NeuralTagger {
 ///
 /// Maps mathematical concepts to OpenCyc ontology and uses semantic relationships
 /// to infer aspects.
+#[allow(dead_code)]
 pub struct OpenCycTagger {
     /// OpenCyc service URL
     service_url: String,
@@ -877,6 +881,7 @@ impl OpenCycTagger {
     }
 
     /// Query OpenCyc for concept relationships
+    #[allow(dead_code)]
     async fn query_concept(&self, _concept: &str) -> Option<Vec<Aspect>> {
         // TODO: Implement OpenCyc API integration
         // For now, return None

src/rust/dispatch.rs

@@ -13,7 +13,7 @@ use std::time::Instant;
 use tracing::{info, warn};
 
 use crate::integrity::solver_integrity::{IntegrityChecker, IntegrityStatus};
-use crate::llm::{LlmAdvisor, DispatchOptimisation};
+use crate::llm::LlmAdvisor;
 use crate::provers::{ProverConfig, ProverFactory, ProverKind};
 use crate::verification::axiom_tracker::{AxiomTracker, AxiomUsage, DangerLevel};
 use crate::verification::confidence::{compute_trust_level, TrustFactors, TrustLevel};

src/rust/executor/sandbox.rs

@@ -14,7 +14,7 @@
 
 use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Stdio;
 use tokio::io::AsyncWriteExt;
 use tokio::process::Command;