feat: IfExpr + single-expr lambda + dict bare-key + interpreter ergonomics

- ast: add Expression::IfExpr for `if cond { stmts } [else { stmts }]`
  in expression position; add ChainedIndex/ChainedIndexAssignment
- parser: IfExpr in parse_primary; single-expression lambda `fn(p) expr`
  without braces (body becomes [Return(expr)]); dict bare-ident keys
  treated as string keys (JS-style `{foo: val}`)
- interpreter: `to_str` alias for `to_string`; arr_push accepts any
  array-evaluating expression (not just bare Variable); str_concat now
  variadic (was silently dropping args 3+); wrapping_add/sub/mul to
  prevent debug-mode integer overflow panics; IfExpr eval arm
- canonical/compiler/formatter/omnimcode-js: cover new AST variants
- demos: fix agent_swarm, auto_improve_daemon, recursive_loop_demo parse
  errors (reserved keywords, missing braces, IfExpr syntax)
- lib/llm.omc: rename `res` var (reserved), quote `"for"` dict key

All 1126 tests pass.

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

Author: RandomCoder-lab

examples/demos/agent_swarm.omc

@@ -38,13 +38,12 @@ fn decompose_goal(goal, n, model) {
 # ── Worker: execute a single task ─────────────────────────────────────────────
 
 fn worker_execute(task, context, model) {
-    h prompt = if str_len(context) > 0 {
-        str_format(
+    h prompt = str_concat("Your task: ", task, "\n\nProvide a detailed, concrete response.")
+    if str_len(context) > 0 {
+        prompt = str_format(
             "Context:\n{ctx}\n\nYour task: {task}\n\nProvide a detailed, concrete response.",
             {ctx: context, task: task}
         )
-    } else {
-        str_concat("Your task: ", task, "\n\nProvide a detailed, concrete response.")
     }
     return prompt
 }

examples/demos/auto_improve_daemon.omc

@@ -206,11 +206,13 @@ h rounds_env = env_var("OMC_CONTINUOUS")
 if rounds_env == "1" or rounds_env == "true" { CONTINUOUS_MODE = true }
 
 print("=== Auto-Improve Daemon ===")
-print(str_concat("Mode: ", if CONTINUOUS_MODE { "continuous" } else { "single-cycle" }))
+h mode_str = "single-cycle"
+if CONTINUOUS_MODE { mode_str = "continuous" }
+print(str_concat("Mode: ", mode_str))
 print(str_concat("Files: ", to_str(arr_len(FILES_TO_IMPROVE))))
 print(str_concat("Log: ", LOG_FILE))
 print("")
 
 h result = daemon_cycle(FILES_TO_IMPROVE, 2, CONTINUOUS_MODE)
 print(str_concat("\nDaemon ran ", to_str(result["iterations"]), " iteration(s)."))
-print("Check log file for details: ", LOG_FILE)
+print(str_concat("Check log file for details: ", LOG_FILE))

examples/demos/recursive_loop_demo.omc

@@ -179,7 +179,7 @@ h passed = arr_filter(fn(r) r["success"], results)
 print(str_concat("  ", json_stringify(arr_len(passed)), "/3 demos fully solved"))
 
 for demo in results {
-    h status = if demo["success"] "✅" else "⚠️"
+    h status = if demo["success"] { "✅" } else { "⚠️" }
     print(str_concat("  ", status, " solved in ", json_stringify(demo["iterations"]), " iteration(s)"))
 }
 

examples/lib/llm.omc

@@ -43,8 +43,8 @@ fn cot_verify(prompt, n, model) {
     h votes = {}
     h i = 0
     while i < n {
-        h res = cot(prompt, model)
-        h ans = str_trim(res["answer"])
+        h cot_result = cot(prompt, model)
+        h ans = str_trim(cot_result["answer"])
         if dict_has(votes, ans) {
             votes[ans] = votes[ans] + 1
         } else {
@@ -398,7 +398,7 @@ fn debate(topic, rounds, model) {
         ], m)
         arr_push(for_args, both[0])
         arr_push(against_args, both[1])
-        arr_push(transcript, {round: r + 1, for: both[0], against: both[1]})
+        arr_push(transcript, {round: r + 1, "for": both[0], against: both[1]})
         r = r + 1
     }
     h judge_sys = "You are an impartial debate judge. Output JSON: {\"winner\": \"for\" or \"against\", \"reasoning\": \"...\"}"

omnimcode-core/src/ast.rs

@@ -291,6 +291,17 @@ pub enum Expression {
         params: Vec<String>,
         body: Vec<Statement>,
     },
+
+    // `if cond { stmts } else { stmts }` used as an expression.
+    // Value is the last Statement::Expression in whichever branch runs,
+    // or Null if the last statement is not an expression-statement.
+    // Enables `h x = if cond { a } else { b }` and call args like
+    // `fn(if cond { "on" } else { "off" })`.
+    IfExpr {
+        condition: Box<Expression>,
+        then_body: Vec<Statement>,
+        else_body: Option<Vec<Statement>>,
+    },
 }
 
 impl Expression {

omnimcode-core/src/canonical.rs

@@ -399,6 +399,11 @@ fn rename_expr(expr: &Expression, scope: &Scope) -> Expression {
                 .collect();
             Expression::Lambda { params: new_params, body: new_body }
         }
+        Expression::IfExpr { condition, then_body, else_body } => Expression::IfExpr {
+            condition: Box::new(rename_expr(condition, scope)),
+            then_body: then_body.iter().map(|s| rename_stmt(s, &mut scope.child())).collect(),
+            else_body: else_body.as_ref().map(|b| b.iter().map(|s| rename_stmt(s, &mut scope.child())).collect()),
+        },
     }
 }
 

omnimcode-core/src/compiler.rs

@@ -329,6 +329,7 @@ impl Compiler {
             // inference can't see across the call boundary statically,
             // so we don't claim a return-type tag here.
             Expression::Lambda { .. } => None,
+            Expression::IfExpr { .. } => None,
         }
     }
 
@@ -796,6 +797,9 @@ impl Compiler {
                 // scope share the captured Rc.
                 self.emit(Op::Lambda(fn_name));
             }
+            Expression::IfExpr { .. } => {
+                return Err("IfExpr: not supported in bytecode VM — use tree-walk interpreter".to_string());
+            }
         }
         Ok(())
     }

omnimcode-core/src/formatter.rs

@@ -387,6 +387,18 @@ fn format_expr(expr: &Expression, out: &mut String) {
             }
             out.push('}');
         }
+        Expression::IfExpr { condition, then_body, else_body } => {
+            out.push_str("if ");
+            format_expr(condition, out);
+            out.push_str(" {\n");
+            for s in then_body { format_stmt(s, 1, out); }
+            out.push('}');
+            if let Some(eb) = else_body {
+                out.push_str(" else {\n");
+                for s in eb { format_stmt(s, 1, out); }
+                out.push('}');
+            }
+        }
     }
 }
 

omnimcode-core/src/interpreter.rs

@@ -2267,6 +2267,28 @@ impl Interpreter {
                     captured: Some(env),
                 })
             }
+            Expression::IfExpr { condition, then_body, else_body } => {
+                let cond = self.eval_expr(condition)?;
+                let branch: &[Statement] = if cond.to_bool() {
+                    then_body
+                } else {
+                    match else_body {
+                        Some(b) => b,
+                        None => return Ok(Value::Null),
+                    }
+                };
+                // Run all statements; last expression-statement is the value.
+                let mut last = Value::Null;
+                for stmt in branch {
+                    match stmt {
+                        Statement::Expression(e) => {
+                            last = self.eval_expr(e)?;
+                        }
+                        other => { self.execute_stmt(other)?; }
+                    }
+                }
+                Ok(last)
+            }
         }
     }
 
@@ -3423,16 +3445,16 @@ impl Interpreter {
             }
             "str_concat" => {
                 if args.len() < 2 {
-                    return Err("str_concat requires 2 arguments".to_string());
+                    return Err("str_concat requires at least 2 arguments".to_string());
                 }
-                // to_display_string (bare numbers) matches Phase 1's
-                // string-+-concat semantics and Phase 4's vm_fast_dispatch.
-                // Previously used to_string which produced ugly
-                // "HInt(42, φ=..., HIM=...)" output for numeric args —
-                // never what callers wanted.
-                let s1 = self.eval_expr(&args[0])?.to_display_string();
-                let s2 = self.eval_expr(&args[1])?.to_display_string();
-                Ok(Value::String(format!("{}{}", s1, s2)))
+                // Variadic: str_concat(a, b, c...) concatenates all args.
+                // to_display_string produces "42" not "HInt(42, φ=..., ...)"
+                // for numeric args — matches Phase 1 string-+-concat semantics.
+                let mut out = String::new();
+                for a in args {
+                    out.push_str(&self.eval_expr(a)?.to_display_string());
+                }
+                Ok(Value::String(out))
             }
             "str_uppercase" => {
                 if args.is_empty() {

omnimcode-core/src/parser.rs

@@ -1577,12 +1577,19 @@ impl Parser {
                 self.tokens = saved;
             }
         }
-        self.expect(Token::LBrace)?;
-        let mut body: Vec<Statement> = Vec::new();
-        while self.current() != Token::RBrace {
-            body.push(self.parse_statement()?);
-        }
-        self.expect(Token::RBrace)?;
+        // Braced body `fn(p) { stmts }` or single-expr body `fn(p) expr`.
+        let body = if self.current() == Token::LBrace {
+            self.advance();
+            let mut stmts: Vec<Statement> = Vec::new();
+            while self.current() != Token::RBrace {
+                stmts.push(self.parse_statement()?);
+            }
+            self.expect(Token::RBrace)?;
+            stmts
+        } else {
+            let e = self.parse_expression()?;
+            vec![Statement::Return(Some(e))]
+        };
         Ok(Expression::Lambda { params, body })
     }
 
@@ -1886,6 +1893,35 @@ impl Parser {
                 self.expect(Token::RParen)?;
                 Ok(Expression::Call { name: "range".to_string(), args, pos })
             }
+            // `if cond { stmts } else { stmts }` as an expression.
+            // Value is the last expr-statement in the taken branch.
+            Token::If => {
+                self.advance();
+                let condition = self.parse_expression()?;
+                self.expect(Token::LBrace)?;
+                let then_body = self.parse_block()?;
+                self.expect(Token::RBrace)?;
+                let else_body = if self.current() == Token::Else {
+                    self.advance();
+                    // else if → wrap in a nested IfExpr as the else branch
+                    if self.current() == Token::If {
+                        let nested = self.parse_primary()?; // recurse → IfExpr
+                        Some(vec![Statement::Expression(nested)])
+                    } else {
+                        self.expect(Token::LBrace)?;
+                        let body = self.parse_block()?;
+                        self.expect(Token::RBrace)?;
+                        Some(body)
+                    }
+                } else {
+                    None
+                };
+                Ok(Expression::IfExpr {
+                    condition: Box::new(condition),
+                    then_body,
+                    else_body,
+                })
+            }
             other => Err(format!(
                 "at {}: Unexpected token in expression: {}",
                 self.current_pos(),