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>

tests/real-world/scrum_applier.ts

@@ -35,7 +35,14 @@ const AUDIT_LOG = `${REPO}/data/_kb/auto_apply.jsonl`;
 const MIN_CONF = Number(process.env.LH_APPLIER_MIN_CONF ?? 90);
 const MAX_FILES = Number(process.env.LH_APPLIER_MAX_FILES ?? 5);
 const COMMIT = process.env.LH_APPLIER_COMMIT === "1";
-const MODEL = process.env.LH_APPLIER_MODEL ?? "kimi-k2:1t";
+// Default patch-emitter model — qwen3-coder:480b is the coding specialist
+// in the scrum ladder (rung 2). Swapped in from kimi-k2:1t after 2026-04-24
+// data showed kimi-k2:1t produces architectural patches that cascade across
+// the file (rename a field → 20 broken call sites). qwen3-coder is tuned
+// for targeted code changes and tends to stay within the mechanical-patch
+// constraint the prompt asks for. LLM Team's /api/run?mode=patch would be
+// the ideal choice but that mode isn't registered in llm_team_ui.py yet.
+const MODEL = process.env.LH_APPLIER_MODEL ?? "qwen3-coder:480b";
 const BRANCH = process.env.LH_APPLIER_BRANCH ?? `scrum/auto-apply-${Date.now().toString(36)}`;
 
 // Deny-list — anything whose path starts with one of these is skipped
@@ -161,14 +168,25 @@ ${review}
 
 The review is high-confidence and the file is eligible for auto-apply. Produce CONCRETE PATCHES as JSON so they can be applied via string replacement.
 
-RULES:
+HARD CONSTRAINTS (violations → patch rejected):
   1. Output ONE JSON object with a "patches" array. NO prose, no markdown fences.
   2. Each patch is {"old_string": "...", "new_string": "...", "rationale": "short", "confidence": 0-100}.
-  3. "old_string" MUST appear EXACTLY ONCE in the file (verbatim, including whitespace). If no unique anchor exists, SKIP that suggestion.
-  4. Mechanical changes only: wire a function call, add a field, remove #[allow(dead_code)], add a missing use import, rename one call-site. NO architectural rewrites. NO new modules.
-  5. Each "new_string" MUST compile in isolation with the same surrounding code. Don't introduce new dependencies.
-  6. If you cannot produce at least one high-confidence mechanical patch, output {"patches": []}.
-  7. Max 3 patches per file.
+  3. "old_string" MUST appear EXACTLY ONCE in the file (verbatim, including whitespace + trailing newlines).
+  4. Max diff size: 6 lines changed per patch (NOT 20). If the change needs >6 lines, emit {"patches": []} — too risky for auto-apply.
+  5. Mechanical-only (the list — nothing else):
+       (a) remove a #[allow(dead_code)] marker on a function now wired elsewhere
+       (b) add a missing 'use' import statement
+       (c) add a single field to a struct (no renames)
+       (d) flip a single boolean/match-arm that doesn't cascade
+       (e) add a fire-and-forget log or tracing call
+  6. FORBIDDEN (automatic reject):
+       • struct field RENAMES (break all call sites)
+       • function signature changes
+       • new modules, new traits, new dependencies
+       • any change that requires editing another file to keep it compiling
+  7. Each "new_string" MUST compile in isolation with the same surrounding code.
+  8. Max 2 patches per file — quality over quantity.
+  9. If you cannot produce at least one high-confidence mechanical patch under these constraints, output {"patches": []}. Don't guess.
 
 ─── SOURCE (${source.length} bytes) ───
 ${source.slice(0, 14000)}
@@ -223,10 +241,12 @@ async function applyPatches(file: string, patches: Patch[]): Promise<{ applied:
     const occurrences = source.split(p.old_string).length - 1;
     if (occurrences === 0) { rejected.push({patch: p, reason: "old_string not found"}); continue; }
     if (occurrences > 1) { rejected.push({patch: p, reason: `old_string appears ${occurrences}× (not unique)`}); continue; }
-    // Size gate — no patch touches > 20 lines (diff discipline).
+    // Size gate — no patch touches > 6 lines (diff discipline; matches prompt).
+    // Raised from 20 to 6 after 2026-04-24 data showed most 10-20 line patches
+    // cascaded and broke the build. Mechanical changes genuinely fit in 6 lines.
     const oldLines = p.old_string.split("\n").length;
     const newLines = p.new_string.split("\n").length;
-    if (Math.max(oldLines, newLines) > 20) { rejected.push({patch: p, reason: `patch too large (${Math.max(oldLines,newLines)} lines)`}); continue; }
+    if (Math.max(oldLines, newLines) > 6) { rejected.push({patch: p, reason: `patch too large (${Math.max(oldLines,newLines)} lines, max 6)`}); continue; }
     source = source.replace(p.old_string, p.new_string);
     applied++;
   }