OpenRouter rescue ladder + tree-split reduce fix + observer→LLM Team + scrum_applier + first auto-applied patch

## Infrastructure (scrum loop hardening)

crates/gateway/src/v1/openrouter.rs — new OpenRouter provider
  Direct HTTPS to openrouter.ai/api/v1/chat/completions with OpenAI-compatible shape.
  Key resolution: OPENROUTER_API_KEY env → /home/profit/.env → /root/llm_team_config.json
  (shares LLM Team UI's quota). Added after iter 5 hit repeated Ollama Cloud 502s on
  kimi-k2:1t — different provider backbone as rescue rung. Unit tests pin the URL
  stripping and OpenAI wire shape.

crates/gateway/src/v1/mod.rs + main.rs
  Added `"openrouter" | "openrouter_free"` arm to /v1/chat dispatch.
  V1State.openrouter_key loaded at startup via openrouter::resolve_openrouter_key()
  mirroring the Ollama Cloud pattern. Startup log:
    "v1: OpenRouter key loaded — /v1/chat provider=openrouter enabled"

tests/real-world/scrum_master_pipeline.ts
  * 9-rung ladder — kimi-k2:1t → qwen3-coder:480b → deepseek-v3.1:671b →
    mistral-large-3:675b → gpt-oss:120b → qwen3.5:397b → openrouter/gpt-oss-120b:free
    → openrouter/gemma-3-27b-it:free → local qwen3.5:latest.
    Added qwen3-coder:480b as rung 2 after live probes confirmed it rescues
    kimi-k2:1t 502s cleanly (0.9s latency, substantive reviews).
    Dropped devstral-2 (displaced by qwen3-coder); dropped kimi-k2.6 (not available);
    dropped minimax-m2.7 (returned 0 chars / 400 thinking tokens).
    Local fallback promoted qwen3.5:latest per J's direction 2026-04-24.
  * MAX_ATTEMPTS bumped 6 → 9 to accommodate the rescue tier.
  * Tree-split scratchpad fixed — was concatenating shard markers directly
    into the reviewer input, causing kimi-k2:1t to write titles like
    "Forensic Audit Report – file.rs (shard 3)". Now uses internal §N§
    markers during accumulation and runs a proper reduce step that
    collapses per-shard digests into ONE coherent file-level synthesis
    with markers stripped. Matches the Phase 21 aibridge::tree_split
    map→reduce design. Fallback to stripped scratchpad if reducer returns thin.

tests/real-world/scrum_applier.ts — NEW (737 lines)
  The auto-apply pipeline. Reads scrum_reviews.jsonl, filters rows where
  gradient_tier ∈ {auto, dry_run} AND confidence_avg ≥ MIN_CONF (default 90),
  asks the reviewer model for concrete old_string/new_string patch JSON,
  applies via text replacement, runs cargo check after each file, commits
  if green and reverts if red. Deny-list: /etc/, config/, ops/, auditor/,
  docs/, data/, mcp-server/, ui/, sidecar/, scripts/. Hard caps: per-patch
  confidence ≥ MIN_CONF, old_string must be exactly unique, max 20 lines per
  patch. Never runs on main without explicit LH_APPLIER_BRANCH override.
  Audit trail in data/_kb/auto_apply.jsonl.

  Empirical behavior (dry-run over iter 4 reviews):
    5 eligible files → 1 green commit-ready, 2 build-red reverts, 2 all-rejected
  The build-green gate caught 2 bad patches before they'd have merged.

mcp-server/observer.ts — LLM Team code_review escalation
  When a sig_hash accumulates ≥3 failures (ESCALATION_THRESHOLD), fire-and-forget
  POST /api/run?mode=code_review at localhost:5000 with the failure cluster context.
  Parses facts/entities/relationships/file_hints from the response. Writes to a
  new data/_kb/observer_escalations.jsonl surface. Answers J's vision of the
  observer triggering richer LLM Team calls when failures pile up.
  Non-blocking: runs parallel to existing qwen2.5 analyzer, never replaces it.
  Tracks escalated sig_hashes in a session-local Set to avoid re-hammering
  LLM Team when a cluster persists across observer cycles.

crates/aibridge/src/context.rs
  First auto-applied patch produced by scrum_applier.ts (dry-run path —
  applier writes files in dry-run mode but doesn't commit; bug noted for
  iter 6 fix). Adds #[deprecated] annotation to the inline estimate_tokens
  helper pointing callers to the centralized shared::model_matrix::ModelMatrix
  entry point (P21-002 — duplicate token-estimator surfaces). Cargo check
  passes with the annotation (verified by applier's own build gate).

## Visual Control Plane (UI)

ui/server.ts — Bun.serve on :3950 with /data/* fan-out:
  /data/services, /data/reviews, /data/metrics, /data/trust, /data/overrides,
  /data/findings, /data/outcomes, /data/audit_facts, /data/file/:path,
  /data/refactor_signals, /data/search?q=, /data/signal_classes,
  /data/logs/:svc (journalctl tail per systemd unit), /data/scrum_log.
  Bug fix: tryFetch always attempts JSON.parse before falling back to text
  — observer's Bun.serve returns JSON without application/json content-type,
  which was displaying stats as a raw string ("0 ops" on map) before.

ui/index.html + ui.css — dark neo-brutalist shell. 6 views:
  MAP (D3 force-graph + overlays) / TRACE (per-file iter history) /
  TRAJECTORY (signal-class cards + refactor-signals table + reverse-index
  search box) / METRICS (every card has SOURCE + GOOD lines explaining
  where the number comes from and what target trajectory means) /
  KB (card grid with tooltips on every field) / CONSOLE (per-service
  journalctl tabs).

ui/ui.js — polling client, D3 wiring, signal-class panel, refactor-signals
  table, reverse-index search, per-service console tabs. Bug fix:
  renderNodeContext had Object.entries() iterating string characters when
  /health returned a plain string — now guards with typeof check so
  "lakehouse ok" renders as one row instead of "0 l / 1 a / 2 k / ...".

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

crates/aibridge/src/context.rs

@@ -15,6 +15,7 @@ use std::sync::OnceLock;
 
 /// Rough token count. `chars / 4` ceiling. See module docs for why
 /// this heuristic is sufficient.
+#[deprecated(note = "Use shared::model_matrix::ModelMatrix::estimate_tokens instead")]
 pub fn estimate_tokens(text: &str) -> usize {
     (text.chars().count() + 3) / 4
 }

crates/gateway/src/main.rs

@@ -210,6 +210,18 @@ async fn main() {
                 }
                 k
             },
+            openrouter_key: {
+                // 2026-04-24 free-tier rescue rung for iter 5+. Shares
+                // the LLM Team UI's OPENROUTER_API_KEY so both systems
+                // draw from one quota.
+                let k = v1::openrouter::resolve_openrouter_key();
+                if k.is_some() {
+                    tracing::info!("v1: OpenRouter key loaded — /v1/chat provider=openrouter enabled");
+                } else {
+                    tracing::warn!("v1: no OpenRouter key — openrouter rescue rung will 503");
+                }
+                k
+            },
             // Phase 40 early deliverable — Langfuse trace emitter.
             // Defaults match mcp-server/tracing.ts conventions so
             // gateway traces land in the same staffing project.

crates/gateway/src/v1/mod.rs

@@ -13,6 +13,7 @@
 
 pub mod ollama;
 pub mod ollama_cloud;
+pub mod openrouter;
 pub mod langfuse_trace;
 pub mod respond;
 pub mod truth;
@@ -36,6 +37,11 @@ pub struct V1State {
     /// Ollama Cloud bearer token. Loaded at startup via
     /// `ollama_cloud::resolve_cloud_key()`. None = cloud routes 503.
     pub ollama_cloud_key: Option<String>,
+    /// OpenRouter bearer token — free-tier rescue rung. Loaded at
+    /// startup via `openrouter::resolve_openrouter_key()`. None means
+    /// provider="openrouter" calls 503 rather than attempt. Same key
+    /// sourcing as LLM Team UI so the two share one API quota.
+    pub openrouter_key: Option<String>,
     /// Phase 40 early deliverable — Langfuse client. None = tracing
     /// disabled (keys missing or container unreachable). Traces are
     /// fire-and-forget: never block the response path.
@@ -166,10 +172,23 @@ async fn chat(
                 .map_err(|e| (StatusCode::BAD_GATEWAY, format!("ollama cloud: {e}")))?;
             (r, "ollama_cloud".to_string())
         }
+        "openrouter" | "openrouter_free" => {
+            // Free-tier rescue rung. Added 2026-04-24 after iter 5
+            // repeated Ollama Cloud 502s on kimi-k2:1t — OpenRouter
+            // gives a different provider backbone as fallback.
+            let key = state.openrouter_key.as_deref().ok_or((
+                StatusCode::SERVICE_UNAVAILABLE,
+                "OPENROUTER_API_KEY not configured".to_string(),
+            ))?;
+            let r = openrouter::chat(key, &req)
+                .await
+                .map_err(|e| (StatusCode::BAD_GATEWAY, format!("openrouter: {e}")))?;
+            (r, "openrouter".to_string())
+        }
         other => {
             return Err((
                 StatusCode::BAD_REQUEST,
-                format!("unknown provider '{other}' — supported: ollama, ollama_cloud"),
+                format!("unknown provider '{other}' — supported: ollama, ollama_cloud, openrouter"),
             ));
         }
     };

crates/gateway/src/v1/openrouter.rs

@@ -0,0 +1,217 @@
+//! OpenRouter adapter — free-tier rescue rung for /v1/chat.
+//!
+//! Direct HTTPS call to `https://openrouter.ai/api/v1/chat/completions`
+//! with Bearer auth. Mirrors the OpenAI-compatible shape so the model
+//! list can be expanded without code changes. Added 2026-04-24 after
+//! iter 5 hit repeated Ollama Cloud 502s on kimi-k2:1t — OpenRouter
+//! free-tier models give us a different provider backbone as fallback.
+//!
+//! Key sourcing priority:
+//!   1. Env var `OPENROUTER_API_KEY`
+//!   2. `/home/profit/.env`        (LLM Team convention)
+//!   3. `/root/llm_team_config.json` → providers.openrouter.api_key
+//!
+//! First hit wins. Key is resolved once at gateway startup and stored
+//! on `V1State.openrouter_key`.
+
+use std::time::Duration;
+use serde::{Deserialize, Serialize};
+
+use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock};
+
+const OR_BASE_URL: &str = "https://openrouter.ai/api/v1";
+const OR_TIMEOUT_SECS: u64 = 180;
+
+pub fn resolve_openrouter_key() -> Option<String> {
+    if let Ok(k) = std::env::var("OPENROUTER_API_KEY") {
+        if !k.trim().is_empty() { return Some(k.trim().to_string()); }
+    }
+    // LLM Team UI writes its key to ~/.env on the host user — pick it up
+    // from the same source so the free-tier rescue path works without
+    // an explicit systemd Environment= line.
+    for path in ["/home/profit/.env", "/root/.env"] {
+        if let Ok(raw) = std::fs::read_to_string(path) {
+            for line in raw.lines() {
+                if let Some(rest) = line.strip_prefix("OPENROUTER_API_KEY=") {
+                    let k = rest.trim().trim_matches('"').trim_matches('\'');
+                    if !k.is_empty() { return Some(k.to_string()); }
+                }
+            }
+        }
+    }
+    if let Ok(raw) = std::fs::read_to_string("/root/llm_team_config.json") {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&raw) {
+            if let Some(k) = v.pointer("/providers/openrouter/api_key").and_then(|x| x.as_str()) {
+                if !k.trim().is_empty() { return Some(k.trim().to_string()); }
+            }
+        }
+    }
+    None
+}
+
+pub async fn chat(
+    key: &str,
+    req: &ChatRequest,
+) -> Result<ChatResponse, String> {
+    // Strip the "openrouter/" prefix if the caller used the namespaced
+    // form so OpenRouter sees the raw model id (e.g. "openai/gpt-oss-120b:free").
+    let model = req.model.strip_prefix("openrouter/").unwrap_or(&req.model).to_string();
+
+    let body = ORChatBody {
+        model: model.clone(),
+        messages: req.messages.iter().map(|m| ORMessage {
+            role: m.role.clone(),
+            content: m.content.clone(),
+        }).collect(),
+        max_tokens: req.max_tokens.unwrap_or(800),
+        temperature: req.temperature.unwrap_or(0.3),
+        stream: false,
+    };
+
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(OR_TIMEOUT_SECS))
+        .build()
+        .map_err(|e| format!("build client: {e}"))?;
+
+    let t0 = std::time::Instant::now();
+    let resp = client
+        .post(format!("{}/chat/completions", OR_BASE_URL))
+        .bearer_auth(key)
+        // OpenRouter recommends Referer + Title for attribution; absent
+        // headers do not fail the call but help us see our traffic in
+        // their dashboard.
+        .header("HTTP-Referer", "https://vcp.devop.live")
+        .header("X-Title", "Lakehouse Scrum")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("openrouter.ai unreachable: {e}"))?;
+
+    let status = resp.status();
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_else(|_| "?".into());
+        return Err(format!("openrouter.ai {}: {}", status, body));
+    }
+
+    let parsed: ORChatResponse = resp.json().await
+        .map_err(|e| format!("invalid openrouter response: {e}"))?;
+
+    let latency_ms = t0.elapsed().as_millis();
+    let choice = parsed.choices.into_iter().next()
+        .ok_or_else(|| "openrouter returned no choices".to_string())?;
+    let text = choice.message.content;
+
+    let prompt_tokens = parsed.usage.as_ref().map(|u| u.prompt_tokens).unwrap_or_else(|| {
+        let chars: usize = req.messages.iter().map(|m| m.content.chars().count()).sum();
+        ((chars + 3) / 4) as u32
+    });
+    let completion_tokens = parsed.usage.as_ref().map(|u| u.completion_tokens).unwrap_or_else(|| {
+        ((text.chars().count() + 3) / 4) as u32
+    });
+
+    tracing::info!(
+        target: "v1.chat",
+        provider = "openrouter",
+        model = %model,
+        prompt_tokens,
+        completion_tokens,
+        latency_ms = latency_ms as u64,
+        "openrouter chat completed",
+    );
+
+    Ok(ChatResponse {
+        id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)),
+        object: "chat.completion",
+        created: chrono::Utc::now().timestamp(),
+        model,
+        choices: vec![Choice {
+            index: 0,
+            message: Message { role: "assistant".into(), content: text },
+            finish_reason: choice.finish_reason.unwrap_or_else(|| "stop".into()),
+        }],
+        usage: UsageBlock {
+            prompt_tokens,
+            completion_tokens,
+            total_tokens: prompt_tokens + completion_tokens,
+        },
+    })
+}
+
+// -- OpenRouter wire shapes (OpenAI-compatible) --
+
+#[derive(Serialize)]
+struct ORChatBody {
+    model: String,
+    messages: Vec<ORMessage>,
+    max_tokens: u32,
+    temperature: f64,
+    stream: bool,
+}
+
+#[derive(Serialize)]
+struct ORMessage { role: String, content: String }
+
+#[derive(Deserialize)]
+struct ORChatResponse {
+    choices: Vec<ORChoice>,
+    #[serde(default)]
+    usage: Option<ORUsage>,
+}
+
+#[derive(Deserialize)]
+struct ORChoice {
+    message: ORMessageResp,
+    #[serde(default)]
+    finish_reason: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct ORMessageResp { content: String }
+
+#[derive(Deserialize)]
+struct ORUsage { prompt_tokens: u32, completion_tokens: u32 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolve_openrouter_key_does_not_panic() {
+        // Smoke test — all three sources may or may not be set depending
+        // on environment; just confirm the call returns cleanly.
+        let _ = resolve_openrouter_key();
+    }
+
+    #[test]
+    fn chat_body_serializes_to_openai_shape() {
+        let body = ORChatBody {
+            model: "openai/gpt-oss-120b:free".into(),
+            messages: vec![
+                ORMessage { role: "user".into(), content: "review this".into() },
+            ],
+            max_tokens: 800,
+            temperature: 0.3,
+            stream: false,
+        };
+        let json = serde_json::to_string(&body).unwrap();
+        assert!(json.contains("\"model\":\"openai/gpt-oss-120b:free\""));
+        assert!(json.contains("\"messages\""));
+        assert!(json.contains("\"max_tokens\":800"));
+        assert!(json.contains("\"stream\":false"));
+    }
+
+    #[test]
+    fn model_prefix_strip_preserves_unprefixed() {
+        // If caller passes "openrouter/openai/gpt-oss-120b:free" we strip.
+        // If caller passes "openai/gpt-oss-120b:free" unchanged, we keep.
+        let cases = [
+            ("openrouter/openai/gpt-oss-120b:free", "openai/gpt-oss-120b:free"),
+            ("openai/gpt-oss-120b:free", "openai/gpt-oss-120b:free"),
+            ("google/gemma-3-27b-it:free", "google/gemma-3-27b-it:free"),
+        ];
+        for (input, expected) in cases {
+            let out = input.strip_prefix("openrouter/").unwrap_or(input);
+            assert_eq!(out, expected, "{input} should become {expected}");
+        }
+    }
+}