feat: brain server v0.2.10 — bug fixes, GET /v1/pages, 9 MCP tools (#234)

* feat: proxy-aware fetch + brain API improvements — publish v0.2.7

Add proxyFetch() wrapper to cli.js and mcp-server.js that detects
HTTPS_PROXY/HTTP_PROXY/ALL_PROXY env vars, uses undici ProxyAgent
(Node 18+) or falls back to curl. Handles NO_PROXY patterns.
Replaced all 17 fetch() call sites with timeouts (15-30s).

Brain server API:
- Search returns similarity scores via ScoredBrainMemory
- List supports pagination (offset/limit), sorting (updated_at/quality/votes), tag filtering
- Transfer response includes warnings, source/target memory counts
- New POST /v1/verify endpoint with 4 verification methods

Co-Authored-By: claude-flow <ruv@ruv.net>

* feat: brain server bug fixes, GET /v1/pages, 9 MCP page/node tools — v0.2.10

Fix proxyFetch curl fallback to capture real HTTP status instead of
hardcoding 200, add 204 guards to brainFetch/fetchBrainEndpoint/MCP
handler, fix brain_list schema (missing offset/sort/tags), fix
brain_sync direction passthrough, add --json to share/vote/delete/sync.

Add GET /v1/pages route with pagination, status filter, sort.
Add 9 MCP tools: brain_page_list/get/create/update/delete,
brain_node_list/get/publish/revoke (previously SSE-only).

Polish: delete --json returns {deleted:true,id} not {}, page get
unwraps .memory wrapper for formatted display.

112 MCP tools, 69/69 tests pass. Published v0.2.10 to npm.

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: ruvnet

crates/mcp-brain-server/src/routes.rs

@@ -5,11 +5,13 @@ use crate::graph::cosine_similarity;
 use crate::types::{
     AddEvidenceRequest, AppState, BetaParams, BrainMemory, ChallengeResponse,
     ConsensusLoraWeights, CreatePageRequest, DriftQuery, DriftReport, HealthResponse,
-    LoraLatestResponse, LoraSubmission, LoraSubmitResponse, PageDelta, PageDetailResponse,
-    PageResponse, PageStatus, PartitionQuery, PartitionResult, PublishNodeRequest,
-    SearchQuery, ShareRequest, ShareResponse, StatusResponse, SubmitDeltaRequest,
-    TemporalResponse, TrainingPreferencesResponse, TrainingQuery, TransferRequest,
-    TransferResponse, VoteDirection, VoteRequest, WasmNode, WasmNodeSummary,
+    ListPagesResponse, ListQuery, ListResponse, ListSort, LoraLatestResponse, LoraSubmission,
+    LoraSubmitResponse, PageDelta, PageDetailResponse, PageResponse, PageStatus, PageSummary,
+    PartitionQuery, PartitionResult, PublishNodeRequest, ScoredBrainMemory, SearchQuery,
+    ShareRequest, ShareResponse,
+    StatusResponse, SubmitDeltaRequest, TemporalResponse, TrainingPreferencesResponse,
+    TrainingQuery, TransferRequest, TransferResponse, VerifyRequest, VerifyResponse,
+    VoteDirection, VoteRequest, WasmNode, WasmNodeSummary,
 };
 use axum::{
     extract::{Path, Query, State},
@@ -224,6 +226,7 @@ pub async fn create_router() -> Router {
         .route("/v1/memories/:id/vote", post(vote_memory))
         .route("/v1/memories/:id", delete(delete_memory))
         .route("/v1/transfer", post(transfer))
+        .route("/v1/verify", post(verify_endpoint))
         .route("/v1/drift", get(drift_report))
         .route("/v1/partition", get(partition))
         .route("/v1/status", get(status))
@@ -235,7 +238,7 @@ pub async fn create_router() -> Router {
         .route("/v1/lora/submit", post(lora_submit))
         .route("/v1/training/preferences", get(training_preferences))
         // Brainpedia (ADR-062)
-        .route("/v1/pages", post(create_page))
+        .route("/v1/pages", get(list_pages).post(create_page))
         .route("/v1/pages/:id", get(get_page))
         .route("/v1/pages/:id/deltas", post(submit_delta))
         .route("/v1/pages/:id/deltas", get(list_deltas))
@@ -622,7 +625,7 @@ async fn search_memories(
     State(state): State<AppState>,
     contributor: AuthenticatedContributor,
     Query(query): Query<SearchQuery>,
-) -> Result<Json<Vec<BrainMemory>>, (StatusCode, String)> {
+) -> Result<Json<Vec<ScoredBrainMemory>>, (StatusCode, String)> {
     if !state.rate_limiter.check_read(&contributor.pseudonym) {
         return Err((StatusCode::TOO_MANY_REQUESTS, "Read rate limit exceeded".into()));
     }
@@ -767,7 +770,7 @@ async fn search_memories(
     // Build scored list: keyword-dominant with embedding + graph + vote signals
     let mut scored: Vec<(f64, BrainMemory)> = raw
         .into_iter()
-        .map(|m| {
+        .map(|(_, m)| {
             let rep = state
                 .store
                 .get_contributor_reputation(&m.contributor_id)
@@ -977,16 +980,16 @@ async fn search_memories(
     // Single final sort after all AGI + midstream scoring layers
     scored.sort_unstable_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
     scored.truncate(limit);
-    let results: Vec<BrainMemory> = scored.into_iter().map(|(_, m)| m).collect();
+    let results: Vec<ScoredBrainMemory> = scored.into_iter().map(|(score, memory)| ScoredBrainMemory { memory, score }).collect();
 
     // ── SONA: Record search trajectory for learning ──
     if state.rvf_flags.sona_enabled && !results.is_empty() {
         let sona = state.sona.read();
         let mut builder = sona.begin_trajectory(query_embedding.clone());
         builder.add_step(
-            results[0].embedding.clone(),
+            results[0].memory.embedding.clone(),
             vec![],
-            results[0].quality_score.mean() as f32,
+            results[0].memory.quality_score.mean() as f32,
         );
         sona.end_trajectory(builder, 0.5);
     }
@@ -997,21 +1000,29 @@ async fn search_memories(
 async fn list_memories(
     State(state): State<AppState>,
     contributor: AuthenticatedContributor,
-    Query(query): Query<SearchQuery>,
-) -> Result<Json<Vec<BrainMemory>>, (StatusCode, String)> {
+    Query(query): Query<ListQuery>,
+) -> Result<Json<ListResponse>, (StatusCode, String)> {
     if !state.rate_limiter.check_read(&contributor.pseudonym) {
         return Err((StatusCode::TOO_MANY_REQUESTS, "Read rate limit exceeded".into()));
     }
 
     let limit = query.limit.unwrap_or(20).min(100);
+    let offset = query.offset.unwrap_or(0);
+    let sort = query.sort.unwrap_or_default();
+    let tags: Option<Vec<String>> = query.tags.map(|t| t.split(',').map(|s| s.trim().to_string()).collect());
 
-    let results = state
+    let (memories, total_count) = state
         .store
-        .list_memories(query.category.as_ref(), limit)
+        .list_memories(query.category.as_ref(), tags.as_deref(), limit, offset, &sort)
         .await
         .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
 
-    Ok(Json(results))
+    Ok(Json(ListResponse {
+        memories,
+        total_count,
+        offset,
+        limit,
+    }))
 }
 
 async fn get_memory(
@@ -1205,6 +1216,14 @@ async fn transfer(
         )
     };
 
+    let mut warnings = Vec::new();
+    if source_memories.is_empty() {
+        warnings.push(format!("No memories found matching source domain '{}'", req.source_domain));
+    }
+    if target_memories.is_empty() {
+        warnings.push(format!("No memories found matching target domain '{}'", req.target_domain));
+    }
+
     Ok(Json(TransferResponse {
         source_domain: req.source_domain,
         target_domain: req.target_domain,
@@ -1214,9 +1233,124 @@ async fn transfer(
             "Transfer initiated by {} (acceleration: {:.2}x, promotable: {})",
             contributor.pseudonym, verification.acceleration_factor, verification.promotable
         ),
+        source_memory_count: source_memories.len(),
+        target_memory_count: target_memories.len(),
+        warnings,
     }))
 }
 
+async fn verify_endpoint(
+    State(state): State<AppState>,
+    contributor: AuthenticatedContributor,
+    Json(req): Json<VerifyRequest>,
+) -> Result<Json<VerifyResponse>, (StatusCode, String)> {
+    if !state.rate_limiter.check_read(&contributor.pseudonym) {
+        return Err((StatusCode::TOO_MANY_REQUESTS, "Read rate limit exceeded".into()));
+    }
+
+    // Method 1: Witness chain steps + hash
+    if let (Some(steps), Some(hash)) = (&req.witness_steps, &req.witness_hash) {
+        let verifier = state.verifier.read();
+        let step_refs: Vec<&str> = steps.iter().map(|s| s.as_str()).collect();
+        return match verifier.verify_witness_chain(&step_refs, hash) {
+            Ok(()) => Ok(Json(VerifyResponse {
+                valid: true,
+                method: "witness_chain".into(),
+                message: "Witness chain verification passed".into(),
+            })),
+            Err(e) => Ok(Json(VerifyResponse {
+                valid: false,
+                method: "witness_chain".into(),
+                message: format!("Witness chain verification failed: {e}"),
+            })),
+        };
+    }
+
+    // Method 2: Memory ID lookup
+    if let Some(memory_id) = req.memory_id {
+        return match state.store.get_memory(&memory_id).await {
+            Ok(Some(mem)) => {
+                // If witness_hash provided, verify it matches
+                if let Some(ref hash) = req.witness_hash {
+                    let equal = subtle::ConstantTimeEq::ct_eq(
+                        mem.witness_hash.as_bytes(),
+                        hash.as_bytes(),
+                    );
+                    if bool::from(equal) {
+                        Ok(Json(VerifyResponse {
+                            valid: true,
+                            method: "memory_id".into(),
+                            message: format!("Memory {} witness hash verified", memory_id),
+                        }))
+                    } else {
+                        Ok(Json(VerifyResponse {
+                            valid: false,
+                            method: "memory_id".into(),
+                            message: format!("Memory {} witness hash mismatch", memory_id),
+                        }))
+                    }
+                } else {
+                    Ok(Json(VerifyResponse {
+                        valid: true,
+                        method: "memory_id".into(),
+                        message: format!("Memory {} exists and is valid", memory_id),
+                    }))
+                }
+            }
+            Ok(None) => Ok(Json(VerifyResponse {
+                valid: false,
+                method: "memory_id".into(),
+                message: format!("Memory {} not found", memory_id),
+            })),
+            Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
+        };
+    }
+
+    // Method 3: Content hash verification
+    if let (Some(hash), Some(data)) = (&req.content_hash, &req.content_data) {
+        let verifier = state.verifier.read();
+        return match verifier.verify_content_hash(data.as_bytes(), hash) {
+            Ok(()) => Ok(Json(VerifyResponse {
+                valid: true,
+                method: "content_hash".into(),
+                message: "Content hash verification passed".into(),
+            })),
+            Err(e) => Ok(Json(VerifyResponse {
+                valid: false,
+                method: "content_hash".into(),
+                message: format!("Content hash verification failed: {e}"),
+            })),
+        };
+    }
+
+    // Method 4: Binary witness chain bytes (base64)
+    if let Some(ref b64) = req.witness_chain_bytes {
+        use base64::Engine as _;
+        let verifier = state.verifier.read();
+        return match base64::engine::general_purpose::STANDARD.decode(b64) {
+            Ok(bytes) => match verifier.verify_rvf_witness_chain(&bytes) {
+                Ok(entries) => Ok(Json(VerifyResponse {
+                    valid: true,
+                    method: "witness_chain_bytes".into(),
+                    message: format!("Binary witness chain valid ({} entries)", entries.len()),
+                })),
+                Err(e) => Ok(Json(VerifyResponse {
+                    valid: false,
+                    method: "witness_chain_bytes".into(),
+                    message: format!("Binary witness chain invalid: {e}"),
+                })),
+            },
+            Err(e) => Ok(Json(VerifyResponse {
+                valid: false,
+                method: "witness_chain_bytes".into(),
+                message: format!("Invalid base64 encoding: {e}"),
+            })),
+        };
+    }
+
+    Err((StatusCode::BAD_REQUEST, "No verification method specified. Provide witness_steps+witness_hash, memory_id, content_hash+content_data, or witness_chain_bytes".into()))
+}
+
 async fn drift_report(
     State(state): State<AppState>,
     _contributor: AuthenticatedContributor,
@@ -1588,6 +1722,68 @@ async fn training_preferences(
 // Brainpedia endpoints (ADR-062)
 // ──────────────────────────────────────────────────────────────────────
 
+/// GET /v1/pages — list Brainpedia pages with pagination
+#[derive(Debug, serde::Deserialize)]
+struct ListPagesQuery {
+    limit: Option<usize>,
+    offset: Option<usize>,
+    status: Option<String>,
+}
+
+async fn list_pages(
+    State(state): State<AppState>,
+    _contributor: AuthenticatedContributor,
+    Query(query): Query<ListPagesQuery>,
+) -> Json<ListPagesResponse> {
+    let limit = query.limit.unwrap_or(20).min(100);
+    let offset = query.offset.unwrap_or(0);
+
+    let (page_ids, total_count) = state.store.list_pages(limit + offset, 0);
+    let status_filter = query.status.as_deref();
+
+    let mut summaries: Vec<PageSummary> = Vec::new();
+    for id in &page_ids {
+        let page_status = match state.store.get_page_status(id) {
+            Some(s) => s,
+            None => continue,
+        };
+        // Apply status filter if provided
+        if let Some(filter) = status_filter {
+            let status_str = page_status.to_string();
+            if status_str != filter {
+                continue;
+            }
+        }
+        if let Ok(Some(mem)) = state.store.get_memory(id).await {
+            let deltas = state.store.get_deltas(id);
+            let evidence = state.store.get_evidence(id);
+            summaries.push(PageSummary {
+                id: *id,
+                title: mem.title,
+                category: mem.category,
+                status: page_status,
+                quality_score: mem.quality_score.mean(),
+                delta_count: deltas.len() as u32,
+                evidence_count: evidence.len() as u32,
+                updated_at: mem.updated_at,
+            });
+        }
+    }
+
+    // Sort by updated_at descending
+    summaries.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));
+
+    let total_filtered = summaries.len();
+    let paginated: Vec<PageSummary> = summaries.into_iter().skip(offset).take(limit).collect();
+
+    Json(ListPagesResponse {
+        pages: paginated,
+        total_count: total_filtered,
+        offset,
+        limit,
+    })
+}
+
 /// POST /v1/pages — create a new Brainpedia page (Draft)
 /// Requires reputation >= 0.5 and contribution_count >= 10 (unless system)
 async fn create_page(