feat: add Baba Is AI demo — knowing-doing gap in spatial puzzles (#38)

* feat: add config and template for baba-is-ai demo

Ollama config with qwen2.5:7b defaults and YAML template documenting
the prompt context for the llm:choose-based action selection.

* feat: add baba-is-ai model with rule engine, push system, and LLM integration

Complete Baba Is You puzzle demo with 3 levels of increasing difficulty:
- Level 1: Navigate (baseline path-finding)
- Level 2: Break the Wall (push STOP word-block to disable wall rule)
- Level 3: Push and Rearrange (rocks + walls + spatial reasoning)

Includes ABM rule engine that scans horizontal/vertical word-block
3-tuples, recursive push chain system, text observation builder for
LLM, and win/defeat detection. Uses llm:choose for constrained
action selection with accumulating history.

* docs: add README for baba-is-ai demo

Covers the BALROG knowing-doing gap experiment context, setup
prerequisites, 3 level descriptions with expected results, provider
swapping instructions, and extension points.

* fix: inject game context, persist history, and safe-place permanent rules

- Add llm:set-history system message in setup so the LLM knows game
  mechanics (push word-blocks, break rules, reach the flag)
- Remove llm:clear-history from go loop so the agent remembers past
  moves and learns from failures
- Move BABA IS YOU and FLAG IS WIN to row 8 (top edge) across all
  levels so the agent never accidentally pushes permanent rules
- Improve observation builder with directional hints, fixed-width grid
  map, loop detection, and explicit blocked-move feedback

* fix: improve system prompt, seal wall gaps, add rate limit handling

- Rewrite system prompt with explicit push mechanics and priority
  (break STOP first, then head to flag)
- Observation now shows exact STOP block coordinates when WALL IS STOP
  is active
- Extend wall columns to y=0-7 in levels 2 and 3 so agent cannot
  navigate around walls — must break the rule
- Cap history to system msg + last 10 exchanges to avoid token bloat
- Handle rate limit errors with 2s wait and retry on next tick

Author: JNK234

demos/baba-is-ai/README.md

@@ -0,0 +1,125 @@
+# Baba Is AI
+
+An LLM agent plays a simplified "Baba Is You" puzzle game where the rules of the world are physical word-block objects on a grid. The agent must push word-blocks to change or break rules in order to reach the goal.
+
+## The Experiment
+
+### Background
+
+Based on findings from the [BALROG benchmark](https://arxiv.org/abs/2411.13543) (Benchmarking Agentic LLM and VLM Reasoning On Games), which found that **all tested LLMs score near 0% on Baba Is You** despite understanding the rules perfectly when quizzed in isolation.
+
+### The Knowing-Doing Gap
+
+LLMs can explain that "rules are pushable objects" and "you need to rearrange word-blocks to change rules." But when given a spatial grid and asked to actually execute moves to push specific blocks in specific directions, they fail consistently. They *know* what to do but *cannot do* it.
+
+### What This Demo Tests
+
+Can an LLM agent, given a text observation of a 9x9 grid, figure out that it needs to:
+1. Navigate to the right word-block
+2. Push it in the right direction
+3. Verify the rule changed
+4. Navigate through the now-passable area to win
+
+This is **meta-rule discovery** -- the agent doesn't just follow rules, it manipulates them.
+
+### Why It Matters for ABM
+
+Agent-based models traditionally have fixed rules. This demo shows agents operating in a world where **the rules themselves are agents** (word-blocks) that can be moved. The rule engine is pure NetLogo ABM; the decision-making is LLM. Together they create a system where rules are emergent from the spatial arrangement of objects.
+
+## Prerequisites
+
+1. **Ollama** running locally with `qwen2.5:7b` pulled:
+   ```bash
+   ollama pull qwen2.5:7b
+   ```
+2. **NetLogo 7.0.3** with the LLM extension JAR installed
+3. Built extension: run `./build.sh` from the extension root if needed
+
+## How to Run
+
+1. Open `baba-is-ai.nlogox` in NetLogo 7.0.3
+2. Select a level from the chooser
+3. Click **Setup** to initialize
+4. Click **Go** to let the LLM agent play autonomously, or **Step** for one move at a time
+5. Toggle **show-observations?** to see the text observation sent to the LLM each turn
+6. Watch the **Active Rules** monitor update as word-blocks are pushed
+
+## Levels
+
+### Level 1: Navigate (baseline)
+```
+Rules: BABA IS YOU, FLAG IS WIN
+Layout: baba on the left, flag on the right, clear path
+Solution: Walk right to the flag (~7 moves)
+Expected: Most LLMs solve this consistently
+```
+
+### Level 2: Break the Wall (medium)
+```
+Rules: BABA IS YOU, WALL IS STOP, FLAG IS WIN
+Layout: Wall column blocking the path to the flag
+Solution: Navigate to the STOP word-block, push it away to break
+          "WALL IS STOP", then walk through walls to the flag
+Expected: Some LLMs occasionally solve this; most get stuck
+```
+
+### Level 3: Push and Rearrange (hard)
+```
+Rules: BABA IS YOU, ROCK IS PUSH, WALL IS STOP, FLAG IS WIN
+Layout: Rocks near the WALL IS STOP rule, wall column, flag behind walls
+Solution: Navigate around rocks, push STOP away, walk through walls
+Expected: Very rarely solved -- demonstrates the knowing-doing gap
+```
+
+## Swapping Providers
+
+Edit `config` to try different LLM providers:
+
+```
+# OpenAI
+provider=openai
+model=gpt-4o-mini
+api_key=YOUR_KEY_HERE
+
+# Anthropic
+provider=anthropic
+model=claude-sonnet-4-20250514
+api_key=YOUR_KEY_HERE
+
+# Gemini
+provider=gemini
+model=gemini-2.0-flash
+api_key=YOUR_KEY_HERE
+```
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `baba-is-ai.nlogox` | Main NetLogo model with rule engine, levels, and LLM integration |
+| `config` | LLM provider configuration (defaults to local Ollama) |
+| `action-template.yaml` | Documents the prompt format (not used at runtime -- `llm:choose` builds its own prompt) |
+| `README.md` | This file |
+
+## How It Works
+
+### Rule Engine
+Three consecutive word-blocks in a horizontal or vertical line form a rule: `[NOUN] IS [PROPERTY]`. The engine scans all possible 3-tuples every tick and rebuilds the active rule set.
+
+### Push System
+Word-blocks are **always pushable**. Other entities (rocks, walls) are pushable only if they have the PUSH property. Push chains propagate: pushing a block into another pushable block pushes both.
+
+### LLM Integration
+Each tick, the agent receives a text observation including the grid layout, active rules, adjacent cell descriptions, and feedback from the last action. It chooses from `["up", "down", "left", "right"]` via `llm:choose`. History accumulates across ticks so the agent can learn from failed moves.
+
+## Extension Points
+
+- **New properties**: Add DEFEAT (touching kills baba), SINK (object + baba both destroyed), MELT/HOT combos
+- **Multiple YOU entities**: What if two things are YOU and must coordinate?
+- **Procedural level generation**: Random placement of word-blocks and obstacles
+- **Rule construction**: Levels where the agent must *build* a rule, not just break one
+
+## Reference
+
+- BALROG paper: [arXiv 2411.13543](https://arxiv.org/abs/2411.13543)
+- Baba Is You (original game): [hempuli.com/baba](https://hempuli.com/baba/)

demos/baba-is-ai/action-template.yaml

@@ -0,0 +1,20 @@
+system: |
+  You are playing Baba Is AI, a puzzle game where the rules of the world are
+  physical word-block objects on a grid. Three consecutive word-blocks in a row
+  or column form a rule: [NOUN] IS [PROPERTY]. For example, "BABA IS YOU" means
+  you control the baba character, "WALL IS STOP" means walls block movement,
+  and "FLAG IS WIN" means reaching a flag wins the level.
+
+  CRITICAL INSIGHT: You can PUSH word-blocks to change or break rules. If you
+  push the STOP block away from "WALL IS STOP", walls become passable. Rules
+  are not fixed -- they are objects you can physically manipulate.
+
+  Your goal: reach an entity that has the WIN property.
+
+  Respond with exactly one of: up, down, left, right
+
+template: |
+  {observation}
+
+  Think about which rules you need to change to reach the goal.
+  Choose your move.