fix llm dispatch + add llm_system builtin + multi_agent_debate demo

- Fix: legacy llm_call/llm_chat/llm_embed match arms now cfg-gated with
  #[cfg(feature = "llm-builtins")] so the modern native-llm arms at the
  bottom of the match actually fire in default builds (they were blocked)
- Fix: deduplicate is_known_builtin() LLM pattern list — duplicate arms
  caused "unreachable pattern" warnings in 14 spots; now only listed once
- New: llm_call(prompt, model?, system?) supports optional 3rd system-prompt
  argument (matches usage in examples/lib/llm.omc)
- New: llm_system(prompt, system, model?) convenience builtin for one-shot
  system-prompt calls; llm_call_sys() internal helper shared with llm_system
- New: multi_agent_debate.omc — agents argue FOR/AGAINST via batch_llm_call,
  judge evaluates all rounds and returns winner + confidence via json_extract
- Docs: llm_system entry added to llm_workflow category in docs.rs

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/demos/multi_agent_debate.omc

@@ -0,0 +1,90 @@
+# multi_agent_debate.omc — agents argue a topic, judge selects the winner
+#
+# Pattern:
+#   1. Decompose topic into FOR/AGAINST positions
+#   2. Run N debate rounds via batch_llm_call
+#   3. Judge evaluates all arguments and picks winner
+#   4. Report verdict + confidence
+
+fn build_debater_prompt(position, topic, round, prior_args) {
+    h sys = str_concat("You are a rigorous debater arguing the ", position, " side. Be concise, logical, and make exactly 2 strong points.")
+    h prompt = str_concat(
+        "Topic: ", topic,
+        "\nYour position: ", position,
+        "\nRound: ", to_str(round)
+    )
+    if arr_len(prior_args) > 0 {
+        prompt = str_concat(prompt, "\nPrior arguments:\n", arr_join(prior_args, "\n"))
+    }
+    prompt = str_concat(prompt, "\n\nMake your 2 best arguments for the ", position, " side.")
+    return {prompt: prompt, system: sys}
+}
+
+fn judge_debate(topic, for_args, against_args) {
+    h sys = "You are an impartial judge. Evaluate the quality of arguments on both sides. Respond in JSON: {winner: 'FOR'|'AGAINST', confidence: 1-10, reasoning: '...'}"
+    h combined_for = arr_join(for_args, "\n---\n")
+    h combined_against = arr_join(against_args, "\n---\n")
+    h prompt = str_concat(
+        "Topic: ", topic,
+        "\n\nFOR arguments:\n", combined_for,
+        "\n\nAGAINST arguments:\n", combined_against,
+        "\n\nWho made the stronger case? Reply with JSON only."
+    )
+    h raw = llm_call(prompt, null, sys)
+    return json_extract(raw)
+}
+
+fn run_debate(topic, rounds) {
+    print(str_concat("=== Debate: ", topic, " ==="))
+    print(str_concat("Rounds: ", to_str(rounds)))
+    print("")
+
+    h for_args = []
+    h against_args = []
+
+    h round = 0
+    while round < rounds {
+        print(str_concat("--- Round ", to_str(round + 1), " ---"))
+
+        h for_prompt = build_debater_prompt("FOR", topic, round + 1, against_args)
+        h against_prompt = build_debater_prompt("AGAINST", topic, round + 1, for_args)
+
+        h responses = batch_llm_call([for_prompt, against_prompt])
+
+        h for_arg = responses[0]
+        h against_arg = responses[1]
+
+        arr_push(for_args, str_concat("[FOR R", to_str(round + 1), "] ", for_arg))
+        arr_push(against_args, str_concat("[AGAINST R", to_str(round + 1), "] ", against_arg))
+
+        print(str_concat("FOR: ", str_slice(for_arg, 0, 100), "..."))
+        print(str_concat("AGAINST: ", str_slice(against_arg, 0, 100), "..."))
+        print("")
+
+        round = round + 1
+    }
+
+    print("=== JUDGING ===")
+    h verdict = judge_debate(topic, for_args, against_args)
+    if verdict == null {
+        print("Judge could not parse verdict")
+        return null
+    }
+    h winner = verdict["winner"]
+    h confidence = verdict["confidence"]
+    h reasoning = verdict["reasoning"]
+    print(str_concat("Winner: ", to_str(winner)))
+    print(str_concat("Confidence: ", to_str(confidence), "/10"))
+    print(str_concat("Reasoning: ", to_str(reasoning)))
+    return verdict
+}
+
+# ── Debate 1: AI regulation ──────────────────────────────────────────────────
+h result1 = run_debate("AI systems should be regulated like pharmaceutical drugs", 2)
+print("")
+
+# ── Debate 2: Remote work ────────────────────────────────────────────────────
+h result2 = run_debate("Remote work is better than office work for productivity", 2)
+print("")
+
+print("=== Debate series complete ===")

omnimcode-core/src/docs.rs

@@ -1339,6 +1339,19 @@ pub const BUILTINS: &[BuiltinDoc] = &[
         example: r#"batch_llm_chat([[{"role":"user","content":"hi"}], [{"role":"user","content":"bye"}]])"#,
         unique_to_omc: true,
     },
+    BuiltinDoc {
+        name: "llm_system", category: "llm_workflow",
+        signature: "(prompt: string, system: string, model?: string) -> string",
+        description: concat!(
+            "Convenience wrapper for a single user prompt with a system instruction. ",
+            "Equivalent to `llm_call(prompt, model, system)` or calling `llm_chat` with a system message prepended. ",
+            "Model defaults to the active provider default (claude-3-5-haiku-latest for Anthropic). ",
+            "Reads ANTHROPIC_API_KEY or OPENAI_API_KEY from environment."
+        ),
+        example: r#"h answer = llm_system("List 3 Fibonacci numbers", "You are a concise math tutor. Reply in one sentence.")
+print(answer)"#,
+        unique_to_omc: true,
+    },
     BuiltinDoc {
         name: "llm_tools", category: "llm_workflow",
         signature: "(messages: dict[], tools: dict[], model?: string) -> dict",

omnimcode-core/src/interpreter.rs

@@ -2227,10 +2227,10 @@ impl Interpreter {
             | "re_match" | "re_find" | "re_find_all" | "re_replace" | "re_split"
             | "json_parse" | "json_stringify" | "json_extract" | "str_format"
             | "sha256" | "sha512" | "base64_encode" | "base64_decode"
-            // LLM builtins (Anthropic API)
-            | "llm_call" | "llm_chat" | "llm_embed"
-            | "batch_llm_call" | "batch_llm_chat"
+            // LLM builtins
+            | "llm_call" | "llm_chat" | "llm_embed" | "llm_models" | "llm_system"
             | "llm_tools" | "substrate_embed"
+            | "batch_llm_call" | "batch_llm_chat"
             // HTTP builtins
             | "http_get" | "http_post" | "http_post_json" | "http_put" | "http_delete"
             | "now_iso" | "now_unix" | "format_time" | "parse_time"
@@ -2342,14 +2342,8 @@ impl Interpreter {
             | "arr_enumerate" | "arr_window"
             // Meta-evaluation
             | "eval_omc" | "eval_omc_fresh" | "eval_omc_ctx" | "omc_source"
-            // Native LLM builtins
-            | "llm_call" | "llm_chat" | "llm_embed" | "llm_models"
-            | "batch_llm_call" | "batch_llm_chat"
-            | "llm_tools" | "substrate_embed"
             // Process execution builtins
             | "omc_spawn" | "omc_pipe"
-            // Native HTTP builtins
-            | "http_get" | "http_post" | "http_post_json" | "http_put" | "http_delete"
         )
     }
 
@@ -3632,6 +3626,9 @@ impl Interpreter {
             //   returns the assistant's text reply as a String.
             //   Model defaults to "claude-3-5-haiku-latest".
             //   Reads API key from env var ANTHROPIC_API_KEY.
+            // NOTE: cfg-gated so modern native-llm arms at the bottom fire when
+            //       llm-builtins is not in the feature set (default build).
+            #[cfg(feature = "llm-builtins")]
             "llm_call" => {
                 #[cfg(feature = "llm-builtins")]
                 {
@@ -3687,6 +3684,7 @@ impl Interpreter {
             //   Multi-turn chat. `messages` is an OMC array of dicts, each with
             //   keys "role" ("user" | "assistant") and "content" (String).
             //   Returns the assistant's reply String.
+            #[cfg(feature = "llm-builtins")]
             "llm_chat" => {
                 #[cfg(feature = "llm-builtins")]
                 {
@@ -3767,6 +3765,7 @@ impl Interpreter {
             //   the voyage-3-lite model. If VOYAGE_API_KEY is not set and
             //   ANTHROPIC_API_KEY is not set, returns an error.
             //   Model defaults to "voyage-3-lite".
+            #[cfg(feature = "llm-builtins")]
             "llm_embed" => {
                 #[cfg(feature = "llm-builtins")]
                 {
@@ -9515,11 +9514,22 @@ impl Interpreter {
                 }
                 let prompt = self.eval_expr(&args[0])?.to_display_string();
                 let model = if args.len() > 1 {
-                    Some(self.eval_expr(&args[1])?.to_display_string())
+                    match self.eval_expr(&args[1])? {
+                        Value::Null => None,
+                        v => Some(v.to_display_string()),
+                    }
+                } else {
+                    None
+                };
+                let system = if args.len() > 2 {
+                    match self.eval_expr(&args[2])? {
+                        Value::Null => None,
+                        v => Some(v.to_display_string()),
+                    }
                 } else {
                     None
                 };
-                crate::llm_builtins::llm_call(&prompt, model.as_deref())
+                crate::llm_builtins::llm_call_sys(&prompt, model.as_deref(), system.as_deref())
             }
             #[cfg(feature = "native-llm")]
             "llm_chat" => {
@@ -9549,6 +9559,21 @@ impl Interpreter {
                 let floats = crate::llm_builtins::llm_embed(&text, model.as_deref())?;
                 Ok(floats)
             }
+            // llm_system(prompt, system, model?) -> string
+            //   Convenience: send a user prompt with a system instruction in one call.
+            "llm_system" => {
+                if args.len() < 2 {
+                    return Err("llm_system requires (prompt, system, model?)".to_string());
+                }
+                let prompt = self.eval_expr(&args[0])?.to_display_string();
+                let system = self.eval_expr(&args[1])?.to_display_string();
+                let model = if args.len() > 2 {
+                    Some(self.eval_expr(&args[2])?.to_display_string())
+                } else {
+                    None
+                };
+                crate::llm_builtins::llm_system(&prompt, &system, model.as_deref())
+            }
             // llm_models() -> dict[]
             //   Returns the list of models available from the active provider.
             //   Each element is a dict with at least {"id": string, "provider": string}.

omnimcode-core/src/llm_builtins.rs

@@ -46,9 +46,25 @@ use std::collections::BTreeMap;
 /// `model` overrides `LLM_MODEL` for this call only.
 #[cfg(feature = "native-llm")]
 pub fn llm_call(prompt: &str, model_override: Option<&str>) -> Result<Value, String> {
+    llm_call_sys(prompt, model_override, None)
+}
+
+pub fn llm_call_sys(
+    prompt: &str,
+    model_override: Option<&str>,
+    system: Option<&str>,
+) -> Result<Value, String> {
     let cfg = Config::from_env()?;
     let model = model_override.unwrap_or(&cfg.model).to_string();
-    let reply = cfg.provider.complete_single(&cfg, &model, prompt)?;
+    let reply = if let Some(sys) = system {
+        let msgs = vec![
+            ChatMessage { role: "system".to_string(), content: sys.to_string() },
+            ChatMessage { role: "user".to_string(), content: prompt.to_string() },
+        ];
+        cfg.provider.complete_chat(&cfg, &model, &msgs)?
+    } else {
+        cfg.provider.complete_single(&cfg, &model, prompt)?
+    };
     Ok(Value::String(reply))
 }
 
@@ -65,6 +81,17 @@ pub fn llm_chat(messages: &[ChatMessage], model_override: Option<&str>) -> Resul
     Ok(Value::String(reply))
 }
 
+/// `llm_system(prompt, system, model?) -> string`
+///
+/// Convenience wrapper for llm_call with a system prompt.
+pub fn llm_system(
+    prompt: &str,
+    system: &str,
+    model_override: Option<&str>,
+) -> Result<Value, String> {
+    llm_call_sys(prompt, model_override, Some(system))
+}
+
 /// `batch_llm_call(prompts, model?, concurrency?) -> string[]`
 ///
 /// Send multiple prompts to the LLM sequentially and return all responses in
@@ -805,6 +832,15 @@ pub fn llm_call(_prompt: &str, _model_override: Option<&str>) -> Result<Value, S
     Err("llm_call: recompile with --features native-llm".to_string())
 }
 
+#[cfg(not(feature = "native-llm"))]
+pub fn llm_call_sys(
+    _prompt: &str,
+    _model_override: Option<&str>,
+    _system: Option<&str>,
+) -> Result<Value, String> {
+    Err("llm_call: recompile with --features native-llm".to_string())
+}
+
 /// Stub: `llm_chat` requires the `native-llm` Cargo feature.
 #[cfg(not(feature = "native-llm"))]
 pub fn llm_chat(_messages: &[ChatMessage], _model_override: Option<&str>) -> Result<Value, String> {