observer: fix LLM Team escalation — route to /v1/chat qwen3-coder:480b instead of dead mode

Discovery 2026-04-24: /api/run?mode=code_review returns "Unknown mode"
(error response from llm_team_ui.py). The 2026-04-24 observer escalation
wiring pointed at a dead endpoint and was failing silently. My earlier
claim of "9 registered LLM Team modes" came from GET probes that all
returned 405 — I interpreted that as "POST-only endpoints exist" when
it just means "GET is not allowed for anything, and on POST only `extract`
is registered."

Rewire: observer's escalateFailureClusterToLLMTeam now hits
  POST /v1/chat { provider: "ollama_cloud", model: "qwen3-coder:480b", ... }
which is the same coding-specialist rung 2 of the scrum ladder that
reliably produces substantive reviews. Probe shows 1240 chars of
substantive analysis in ~8.7s.

Also tightens scrum_applier:
  * MODEL default: kimi-k2:1t → qwen3-coder:480b (coding specialist)
  * Size gate: 20 lines → 6 lines (surgical patches only)
  * Max patches per file: 3 → 2
  * Prompt: explicit forbidden-actions list (no struct renames, no
    function-signature changes, no new modules) and mechanical-only
    whitelist

These changes produced the first auto-applied commit (96b46cd), which
landed a 2-line import addition that passed cargo check. Zero-to-one.

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

mcp-server/observer.ts

@@ -159,50 +159,63 @@ const LLM_TEAM_ESCALATIONS = "/home/profit/lakehouse/data/_kb/observer_escalatio
 const ESCALATION_THRESHOLD = 3; // N+ failures on same sig_hash triggers
 
 async function escalateFailureClusterToLLMTeam(sigHash: string, cluster: ObservedOp[]) {
-  // Package the failure cluster as a single context blob for code_review mode.
+  // Package the failure cluster as a single context blob. Originally
+  // I routed this to LLM Team's `code_review` mode at /api/run, but
+  // that mode isn't registered in llm_team_ui.py — it returned
+  // "Unknown mode" on every call. Revised 2026-04-24: route directly
+  // to the gateway's /v1/chat with provider=ollama_cloud + qwen3-coder:480b
+  // (the coding specialist that's rung 2 of the scrum ladder, proven
+  // to produce substantive structured reviews). Fire-and-forget so
+  // downstream failures don't block observer's normal loop.
   const context = cluster.slice(-8).map((o, i) =>
     `[${i + 1}] endpoint=${o.endpoint} input=${o.input_summary} error=${o.error ?? "?"}`
   ).join("\n");
+  const prompt = `sig_hash=${sigHash} · ${cluster.length} failures on the same signature:\n\n${context}\n\nReview this failure cluster. Identify:\n1. Likely root cause (single sentence).\n2. Files most likely responsible (path hints).\n3. Concrete fix direction (under 3 sentences).\n4. Confidence: NN%\n\nBe specific, not generic.`;
 
   try {
-    const resp = await fetch(`${LLM_TEAM}/api/run?mode=code_review`, {
+    const resp = await fetch(`${LAKEHOUSE}/v1/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        input: `sig_hash=${sigHash} · ${cluster.length} failures on same signature:\n\n${context}\n\nReview this failure pattern. What is the root cause? What code change would prevent it? Respond with structured facts + specific file hints.`,
+        provider: "ollama_cloud",
+        model: "qwen3-coder:480b",
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: 800,
+        temperature: 0.2,
       }),
       signal: AbortSignal.timeout(60000),
     });
     if (!resp.ok) {
-      console.error(`[observer] LLM Team code_review ${resp.status}: ${(await resp.text()).slice(0, 200)}`);
+      console.error(`[observer] escalation /v1/chat ${resp.status}: ${(await resp.text()).slice(0, 200)}`);
       return;
     }
     const j: any = await resp.json();
+    const analysis = j?.choices?.[0]?.message?.content ?? "";
 
-    // Write an audit row. Fields are deliberately permissive — LLM
-    // Team's response shape can evolve without breaking this write.
+    // Audit row stays schema-compatible with the prior implementation —
+    // downstream consumers see structured fields regardless of the
+    // review-source change. Facts/entities stay empty (this call is
+    // direct-model, not extract-mode); the raw analysis carries the
+    // signal.
     const row = {
       ts: new Date().toISOString(),
       source: "observer_escalation",
-      mode: "code_review",
+      mode: "direct_chat_qwen3_coder_480b",
       sig_hash: sigHash,
       cluster_size: cluster.length,
       cluster_staffer: cluster[0]?.staffer_id,
       cluster_endpoint: cluster[0]?.endpoint,
-      llm_team_run_id: j.run_id ?? j.llm_team_run_id ?? null,
-      facts: j.facts ?? [],
-      entities: j.entities ?? [],
-      relationships: j.relationships ?? [],
-      raw_response: typeof j.response === "string" ? j.response.slice(0, 2000) : null,
-      recommended_files: j.file_hints ?? j.files ?? [],
+      prompt_tokens: j?.usage?.prompt_tokens ?? 0,
+      completion_tokens: j?.usage?.completion_tokens ?? 0,
+      analysis: analysis.slice(0, 4000),
     };
     const { appendFile } = await import("node:fs/promises");
     await appendFile(LLM_TEAM_ESCALATIONS, JSON.stringify(row) + "\n");
     console.error(
-      `[observer] escalated sig_hash=${sigHash.slice(0, 8)} · cluster=${cluster.length} · facts=${row.facts.length} entities=${row.entities.length}`
+      `[observer] escalated sig_hash=${sigHash.slice(0, 8)} · cluster=${cluster.length} · ${analysis.length} chars`
     );
   } catch (e) {
-    console.error(`[observer] LLM Team escalation failed: ${(e as Error).message}`);
+    console.error(`[observer] escalation failed: ${(e as Error).message}`);
   }
 }