diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..e02fcb0
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,23 @@
+name: tests
+on:
+ push:
+ branches: [main]
+ pull_request:
+
+jobs:
+ pytest:
+ runs-on: ubuntu-latest
+ timeout-minutes: 30
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive # maze corpus + maze-family tests live in the submodule
+ - uses: actions/setup-python@v5
+ with:
+ python-version: '3.10'
+ - run: pip install -e ".[dev,visual]"
+ - run: pytest -q # addopts already excludes ogbench collection and slow benchmarks
+ - name: wheel must not ship mazes/ or deploy/
+ run: |
+ pip wheel --no-deps --no-build-isolation -w /tmp/wheelcheck .
+ python -m zipfile -l /tmp/wheelcheck/*.whl | grep -E '(^|/)(mazes|deploy)/' && exit 1 || echo "wheel clean"
diff --git a/.gitignore b/.gitignore
index 8837513..baf1e1c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,8 +39,6 @@ interface/smoke_tests/results/
# Generated evaluation outputs
mazes/results/*_results.json
mazes/results/*.progress.json
-# Generated maze render PNGs (regenerated from the maze JSONs; keep README.md)
-mazes/exp_maze_images/**/*.png
# Bare-bones run pipeline artifact tree (regenerated locally)
artifacts/
# Artifacts pulled off coordinators by the cost-safety monitor (run output)
@@ -54,6 +52,25 @@ deploy/*.log
# Dev planning docs (specs/plans) - kept out of the pushed/release branch
docs/superpowers/
+# Local release-audit kickoff prompt + agent-authored reports (never commit these)
+docs/release_cleanup_reviews/
+docs/RELEASE_CLEANUP.md
+
+# Editor swap/backup files
+*.sw[a-p]
+*~
+
+# Agent/tool local working state (never release content)
+.claude/
+.superpowers/
+scratchpad/
+
+# Generated prompt previews (regenerate: multinet-preview-prompts)
+prompting_experiments/prompts.txt
+
+# Local R1 analysis planning note (operator-owned, not release content)
+docs/MultiNet v2 0 R1 Analysis Guide.md
+
#AI configuration files
CLAUDE.md
AGENTS.md
diff --git a/.gitmodules b/.gitmodules
index a4247e2..daa5245 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +1,4 @@
[submodule "ogbench"]
path = ogbench
url = https://github.com/ManifoldRG/ogbench.git
- branch = master
+ branch = fix/d3-goal
diff --git a/MANIFEST.in b/MANIFEST.in
index fd432fa..73cb685 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,3 +1 @@
recursive-include gridworld/tasks *.json
-recursive-include mazes/validation_10 *.json
-prune mazes/ogbench_procgen_mazes
diff --git a/README.md b/README.md
index c568c42..b3d5797 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,200 @@
-# Multinet-v2.0
+
+
+ 
+ An early preview into MultiNet v2.0: Benchmarking Long-Horizon Action Taking and Causal Reasoning Capabilities in Frontier Vision-Language Models
+
+
-Benchmark for evaluating multimodal perception and action-taking capabilities
-across gridworld and multigrid domains.
+
+ 
+ 
+ 
+ 
+
+
-- Setup and commands: [RUNME.md](./RUNME.md)
-- Documentation: [docs/README.md](./docs/README.md)
-- Interface reference: [docs/interfaces.md](./docs/interfaces.md)
+### MultiNet is a collaborative initiative with contributions from leading research teams at institutions like:
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+ Claude Opus 4.8, Kimi K2.6 and Qwen 3.6 27B models failing on 2D mazes.
+
+
+## π’ News
+
+- ποΈ 2026-08-18: An early preview into Multinet v2.0 - We evaluate 3 frontier VLMs on 50 2D mazes to understand how, where, and why they break in an environment that requires exploration, planning, action taking, and reasoning. Read our technical report [here](https://metarch.ai/blog).
+- π 2026-04-03: Paper accepted at CVPR 2026! Our work has been accepted at the [MMFM Workshop](https://mmfm-workshop.github.io/) at CVPR 2026! Read our paper [here](https://openaccess.thecvf.com/content/CVPR2026W/MMFM5/papers/Guruprasad_Do_Multimodal_Foundation_Models_Truly_Generalize_Exposing_Failure_Modes_Across_CVPRW_2026_paper.pdf).
+- π 2025-10-13: Multinet v1.0 - We release our most comprehensive benchmark yet - evaluating a SoTA VLM, VLA, and generalist model on a wide variety of multimodal understanding and action datasets. Read more [here](https://multinet.ai/static/pages/Multinetv1.html)
+- π
2025-06-10: Paper accepted at ICML 2025! Our paper detailing the Open-Source contributions of Multinet that benefit the AI community has been accepted at the [CodeML Workshop](https://codeml-workshop.github.io/codeml2025/) at ICML 2025! Read our paper [here](https://multinet.ai/static/pdfs/An%20Open-Source%20Software%20Toolkit%20&%20Benchmark%20Suite%20for%20the%20Evaluation%20and%20Adaptation%20of%20Multimodal%20Action%20Models.pdf).
+- π 2025-05-22: Multinet v0.2 - We systematically profile state-of-the-art VLAs and VLMs to understand how they perform in procedurally generated OOD game environments! Read more about our release [here](https://multinet.ai/static/pages/Multinetv02.html)
+- π 2024-11-08: We release the first version of MultiNet where we profiled SoTA VLMs and VLAs on real-world robotics tasks - Multinet v0.1! Check our [release page](https://multinet.ai/static/pages/Multinetv01.html) for more details.
+- π 2024-03-22: Introducing Multinet! A new generalist benchmark to evaluate Vision-Language & Action models. Learn more [here](https://multinet.ai)
+
+## π An early preview into a new kind of agentic benchmark
+
+This release is an early preview into MultiNet v2.0, where we evaluated 3 frontier VLMs on 50 2D mazes. Through this evaluation we try and understand how, where, and why a frontier VLM breaks in an environment that requires exploration, planning, action taking, and reasoning.
+
+## 𧩠What we built
+
+- **The environment:** 8Γ8 to 14Γ14 [MiniGrid](https://github.com/Farama-Foundation/Minigrid) mazes with an action space containing 6 valid actions: turn left, turn right, move forward, pickup, toggle, and done. The agent must navigate corridors, dead ends, distractors and decoys, operate mechanisms in the right order and reach a goal tile.
+- **A validator and BFS oracle:** every maze is confirmed solvable, with checks for mechanism necessity, chain ordering, and distractor safety. The oracle yields the exact optimal action sequence from any reachable state, giving objective difficulty, partial credit, and the ability to label a single move as strictly wrong.
+- **An evaluation harness:** a config-driven episode runner (prompt assembly, strict action parsing, per-episode artifact logging, a progress-stall watchdog, difficulty-relative step caps), model adapters behind one interface, mechanism-aware scoring, and the distributed run infrastructure that executed the evaluation across a fleet of VMs and GPUs.
+- **An ablation-derived protocol:** extensive experiments were run across 540 episodes to finalize the evaluation protocol for the final run on 50 mazes.
+
+## π A peek into the results
+
+We evaluated **Claude Opus 4.8** (xhigh thinking), **Kimi k2.6** (thinking), and **Qwen3.6-27B** (thinking) on 50 difficulty-balanced mazes, with an equal 64k output-token budget.
+
+
+
+
+
+ |
+ Claude Opus 4.8 |
+ Kimi k2.6 |
+ Qwen3.6-27B |
+
+
+
+
+ | Mazes solved (/50) |
+ 4 |
+ 1 |
+ 1 |
+
+
+ | Mean action progress |
+ 0.19 |
+ 0.23 |
+ 0.23 |
+
+
+
+
+ 
+
+ Progress per maze (columns) per model (rows); stars mark the six solves.
+
+
+For a deeper dive, read our [technical report](https://metarch.ai/blog).
+
+## π Quickstart
+
+```bash
+git clone https://github.com/ManifoldRG/MultiNet-v2.0.git
+cd MultiNet-v2.0
+
+conda create -n multinet-v2 python=3.10 && conda activate multinet-v2
+# (or: python -m venv .venv && source .venv/bin/activate)
+pip install -e ".[dev,visual]"
+```
+
+Mazes are declarative JSON task specifications. Validate every example spec in the repo and rank them by difficulty:
+
+```bash
+python -m gridworld.task_validator
+```
+
+```
+ [PASS] tier3_key_switch_001: optimal=30 steps, mechanisms=4, score=70.61
+ ...
+=== Summary: 16/16 tasks beatable ===
+```
+
+To build your own maze, copy a spec from `gridworld/tasks/`, edit the layout and mechanisms, then validate and render it:
+
+```python
+from PIL import Image
+
+from gridworld.task_spec import TaskSpecification
+from gridworld.task_validator import compute_difficulty
+from gridworld.backends.minigrid_backend import MiniGridBackend
+
+spec = TaskSpecification.from_json("gridworld/tasks/tier3/key_switch_001.json")
+
+report = compute_difficulty(spec)
+print(report.is_beatable, report.optimal_steps, report.mechanism_count)
+
+backend = MiniGridBackend()
+backend.configure(spec)
+backend.reset(seed=0)
+Image.fromarray(backend.render()).save("maze.png")
+```
+
+`compute_difficulty` runs the BFS oracle: if your maze is unsolvable, has a decorative mechanism, or has a distractor that can strand the agent, it will tell you.
+
+## πΊοΈ Repository structure
+
+| Path | Contents |
+|---|---|
+| `gridworld/` | task specification, maze validator, BFS oracle, MiniGrid + MultiGrid backends |
+| `interface/` | episode runner, prompt assembly, action parsing, model adapters |
+| `prompting_experiments/` | every prompt template used in the protocol sweep |
+| `scorer/` | static and runtime scoring, mechanism-aware progress |
+| `demo/` | the playable maze demo embedded on the website |
+| `scripts/` | evaluation pipeline entrypoints and run tooling |
+| `deploy/` | distributed run infrastructure: VM and GPU fleet provisioning, teardown, and cost-safety rails |
+
+## π MultiNet archive
+
+Our previous research with MultiNet v1.0 and earlier versions all live in the [MultiNet v1.0 repository](https://github.com/ManifoldRG/MultiNet): evaluations of VLMs, VLAs, and generalist models across a wide variety of domains such as robotics, multimodal understanding, game play, and tool-calling to understand their cross-domain generalization capabilities.
+
+## π Citation
+
+If you use MultiNet v2.0 in your research, please cite:
+
+```bibtex
+@misc{guruprasad2026multinetv2,
+ title={Frontier Vision-Language Models Fail Simple 2D Mazes: Benchmarking
+ Long-Horizon Action Taking and Causal Reasoning Capabilities},
+ author={Pranav Guruprasad and Sean Rivera and Helen Lu and Arushi Jain
+ and Hangliang Ren and Harshvardhan Sikka},
+ year={2026},
+ note={TODO: arXiv link},
+ }
+```
+
+
+## π€ Work with us!
+
+**Can your model or agent generalize across modalities?**
+
+This release is an early preview of the MultiNet v2.0 benchmark, the full version of which will contain the same underlying task of a maze projected in multiple domains such as 3D simulation and pure language. Are models capable of taking actions in any environment? Or do they just overfit to a specific interface? With v2.0 we aim to quantify this.
+
+If you work on building models and agents, or benchmarking and evaluation, we would love to hear from you, whether that means getting your model on the benchmark, contributing to the environments, or working with us on what comes after.
+
+
+ Work with us
+ ·
+ Join the Discord
+
+
+Released under the [MIT License](./LICENSE).
diff --git a/RUNME.md b/RUNME.md
index 30c2705..f1c8326 100644
--- a/RUNME.md
+++ b/RUNME.md
@@ -1,320 +1,137 @@
-# Multinet-v2.0 - How to Run
+# MultiNet v2.0 β Operator Guide
-## Prerequisites
+How to install, run, and score evaluations. The public front page is
+[README.md](./README.md); design docs are indexed in [docs/](./docs/README.md).
-```bash
-# Activate your environment (conda or venv)
-conda activate multinet # or source .venv/bin/activate
-
-# Install the standalone package in editable mode
-pip install -e ".[dev,visual]"
-
-# Optional Hugging Face / transformers adapter support
-pip install -e ".[hf]"
-```
-
----
-
-## 1. Run the Test Suite
+## 1. Setup
```bash
-# All tests collected on this branch: 261. This command excludes perf tests.
-python -m pytest tests/ -v --ignore=tests/test_performance.py
+git clone --recurse-submodules https://github.com/ManifoldRG/MultiNet-v2.0.git
+cd MultiNet-v2.0
+# already cloned without submodules? run: git submodule update --init
-# Specific test files
-python -m pytest tests/test_teleporters.py -v # Teleporter mechanics
-python -m pytest tests/test_exotic_tilings.py -v # Archimedean tilings
-python -m pytest tests/test_model_interface.py -v # Model interface + cross-domain
-python -m pytest tests/test_tiling_generation.py -v # Core tiling tests
+conda create -n multinet-v2 python=3.10 && conda activate multinet-v2
+# (or: python -m venv .venv && source .venv/bin/activate)
+pip install -e ".[dev,visual]"
```
----
+The `ogbench` submodule (~50 MB) supplies the evaluation maze corpus; the
+test suite and the R1 manifests both resolve mazes from it.
-## 2. Validate All Tasks (Beatable Path Check)
-
-Proves every task JSON has a valid solution using BFS:
+## 2. Verify the install
```bash
-python -c "
-import sys, os
-_sd = os.path.abspath('.')
-if _sd in sys.path: sys.path.remove(_sd)
-try: import gymnasium
-except ImportError: pass
-for k in [k for k in sys.modules if k == 'minigrid' or k.startswith('minigrid.')]: del sys.modules[k]
-sys.path.insert(0, _sd)
-from gridworld.task_validator import validate_all_tasks
-validate_all_tasks()
-"
+pytest # full suite; load-sensitive perf benchmarks are excluded
+pytest -m slow # opt-in: performance/scalability benchmarks
```
-Expected output: `16/16 tasks beatable`
-
----
+The full suite needs no API keys, GPU, or network.
-## 3. Play Tasks Interactively (Pygame) β Playable Human Demo
+## 3. Run an evaluation (canonical pipeline)
-Play any task with keyboard controls. This player is hooked into the same
-`interface/` code the LLM pipeline uses to build observations, so you can
-mirror exactly what a model would see (e.g. image-only, text-only, or with a
-`text_summary` of prior activity) via `ExperimentConfig`-style flags:
+Every run is a **run-config** (models + conditions) over a **manifest**
+(task list). Fixtures live in `gridworld/fixtures/`.
```bash
-# Default (small validation_10 maze, image-only view -- today's plain grid)
-python play_task.py
+export ANTHROPIC_API_KEY=... # only for the providers you actually run
-# Specific task file
-python play_task.py mazes/validation_10/V04_single_key.json
-
-# With trajectory recording
-python play_task.py mazes/exp_maze_jsons/S1/8x8_empty_room_0.json --record
-
-# Browse a whole directory of task files with [ / ] (non-recursive: point
-# at the leaf directory that directly contains the task JSONs)
-python play_task.py --tasks-dir mazes/exp_maze_jsons/S1
-
-# Browse a manifest task catalog with [ / ] instead of a directory -- rows can
-# point at files in different folders (e.g. test3's corridor pairs live under
-# gridworld/fixtures/test3/, not mazes/). The info panel shows each row's
-# experiment/condition/expected_mechanisms, mirroring the task selection
-# scripts/run_pipeline.py uses for real runs.
-python play_task.py --manifest gridworld/fixtures/manifest.json --experiment test1
-python play_task.py --manifest gridworld/fixtures/manifest.json --experiment test3
-
-# Play under the same information constraints as the model in text-only
-# mode with a text_summary of prior activity instead of raw history
-python play_task.py mazes/validation_10/V06_chain_ks.json \
- --observation text_only --context-window text_summary
-
-# Play with the model's cardinal (absolute N/S/E/W) action space instead of
-# egocentric turn/forward controls
-python play_task.py mazes/validation_10/V01_empty_room.json --action-space cardinal
+# Smoke run: 1 Claude model, 3 mazes, 4k token cap β verifies the whole
+# loop (prompt assembly -> parsing -> stepping -> scoring -> artifacts)
+# at minimal cost. Not for measurement.
+python -m scripts.run_pipeline \
+ --run-config gridworld/fixtures/run_config.smoke_claude_sonnet.json \
+ --manifest gridworld/fixtures/manifest.smoke_eval.json \
+ --seeds 0
```
-Settings can also be toggled live in-app via the `Tab` overlay, without
-restarting. Press `M` at any time to see the exact text the model would
-receive given the current settings.
+Always pass an explicit `--run-config` and `--manifest`: the default
+`gridworld/fixtures/manifest.json` is a browse catalog for the demo and now
+includes the 42-maze R1 panel.
-**Controls:**
-| Key | Action |
-|-----|--------|
-| Up/Down/Left/Right, W/A/S/D | Move forward/turn (egocentric) or N/S/W/E (cardinal action space) |
-| Space | Pick up item |
-| T / E | Toggle (doors, switches) / Interact (cardinal) |
-| X | Drop item (human-only -- not in the model's action space) |
-| Backspace | Wait (no-op) |
-| R | Reset current task |
-| [ / ] | Previous / next task in the current directory / manifest |
-| Tab | Toggle settings overlay (observation, context window, action space, ...) |
-| M | Toggle full-screen view of the exact model-facing text |
-| Q | Quit |
+Artifacts land under
+`artifacts/runs////seed_//episode.json`
+(git-ignored) and aggregate into `episode_runs.jsonl` with a per-run
+`run_score.json` written by `scorer/`.
----
+### Reproduce the R1 evaluation (paid)
-## 4. Visualize Tilings
-
-Generate PNG images of all supported tilings:
+The R1 cell runs three models over the 50-maze balanced panel β Claude and
+Kimi at 64k output caps, the served Qwen tier starting at an 8k cap with a
+phase-2 widen for cap-hitters (see the run-config's inline notes) β and it
+requires an Anthropic key (Opus 4.8), a Moonshot key, and a locally served
+Qwen3.6-27B vLLM endpoint (A100-class GPU), and it spends real money. Read
+the run-config before launching.
```bash
-# All 5 tilings (square, hex, triangle, 3-4-6-4, 4-8-8)
-python visualize_all_tilings.py
-
-# Original 3 tilings only
-python visualize_grids_proper.py
+export ANTHROPIC_API_KEY=... MOONSHOT_API_KEY=...
+python -m scripts.run_pipeline \
+ --run-config gridworld/fixtures/run_config.r1.json \
+ --manifest gridworld/fixtures/manifest.r1_balanced_03.json \
+ --seeds 0
```
----
-
-## 5. Run Model Evaluation
+## 4. Scoring
-### Backend/Frontend Selection
+Scoring runs inside the pipeline (`scorer/`): static maze/difficulty scores
+plus runtime episode scoring. To re-score an existing episode JSON:
```bash
-# Default: MiniGrid backend + discrete actions
-python run_eval.py --model random --benchmark validation_10
-
-# MultiGrid backend with hexagonal tiling
-python run_eval.py --model random --benchmark tiers --tier 1 --backend multigrid --tiling hex
-```
-
-### Random Baseline
+multinet-score-json --help
+```
+
+## 5. Distributed / fleet runs (GCP)
+
+`scripts/distributed_run_pipeline.py` provides coordinator/worker jobs;
+`sweep_run.sh` drives fleets (provision / next-batch / run-massive /
+finalize-batch / publish / teardown) with `lib/cost_safety.sh` rails.
+Batch-starting subcommands **require** `BATCH_CAP` and `MAX_RUN_DURATION` β
+they have no defaults by design. STOP VMs rather than deleting them, and
+pull artifacts before spindown.
+
+## 6. Evaluate your own model
+
+Implement an agent in `interface/agents/` exposing
+`generate(messages) -> Reply` (see `interface/agents/claude.py` and
+`interface/agents/reply.py`), add a provider branch for it in
+`scripts/run_pipeline.py`'s `_build_agent_from_spec`, register that
+provider name in a run-config's `models` block, and run the pipeline. The
+harness handles prompting, parsing, stepping, scoring, and artifacts.
+
+## 7. Playable human demo (pygame)
+
+`play_task.py` is a human-playable client wired into the same `interface/`
+code the LLM pipeline uses to build observations. It fixes its
+`ExperimentConfig` to the R1 cell (`image_only` observation,
+`text_summary_and_last3` context window, `egocentric` action space) so a
+human run mirrors what the R1 models actually saw β `Tab` opens a read-only
+settings overlay showing that config, `M` shows the exact model-facing text,
+and `[ / ]` steps through the current task list. When an R1 results table is
+available, task browsing can be restricted to mazes that appear in it β
+point it at the R1 corpus (`ogbench/ogbench/procgen/maze_jsons/` or
+the manifest's `r1` experiment) to get the end-of-episode comparison against
+Claude/Kimi/Qwen. Without a table (e.g. a fresh clone with no
+`Multinet-v2-results` checkout), any maze still plays, just without that
+comparison.
```bash
-# Evaluate random agent on all tiers
-python run_eval.py --model random --benchmark tiers --tier all
-
-# Single tier
-python run_eval.py --model random --benchmark tiers --tier 1
-
-# Range of tiers
-python run_eval.py --model random --benchmark tiers --tier 1-3
-
-# Save results to file
-python run_eval.py --model random --benchmark tiers --tier all --output results/random_baseline.json
+python play_task.py ogbench/ogbench/procgen/maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json
+python play_task.py --tasks-dir ogbench/ogbench/procgen/maze_jsons/M1 # browse a family with [ / ]
+python play_task.py --manifest gridworld/fixtures/manifest.json --experiment r1
+python play_task.py --record ogbench/ogbench/procgen/maze_jsons/S4/10x10_dense_1.json
```
-### Ollama VLM (e.g., Qwen2.5-VL-7B)
-
-```bash
-# First: install and start Ollama, pull a vision model
-ollama pull qwen2.5vl:7b
+## Appendix: legacy local/VLM demo harness
-# Run evaluation
-python run_eval.py --model ollama --ollama-model qwen2.5vl:7b --benchmark tiers --tier 1
-
-# Or use a different model
-python run_eval.py --model ollama --ollama-model llava:7b --benchmark tiers --tier 1-3
-```
-
-### LM Studio VLM
+An earlier single-machine harness predates the canonical pipeline and
+remains usable for local exploration with Ollama / LM Studio VLMs and
+exotic tilings. It is **not** the stack behind any published number.
```bash
-# Start LM Studio with a vision model loaded
-
-python run_eval.py --model lmstudio --lmstudio-model local-model --benchmark tiers --tier 1
-```
-
-### File-Based Protocol (Any External Model)
-
-```bash
-# The file-based protocol writes observations to a directory
-# and waits for action responses. See model_interface.py FileBasedModelInterface.
-
-python run_eval.py --model file_based --benchmark tiers --tier 1
-```
-
----
-
-## 6. VLM Vision Sanity Check
-
-Verify that a VLM can see and identify objects in the gridworld before running action evaluation:
-
-```bash
-# Run sanity check with Ollama VLM
-python -m scripts.vlm_sanity_check --model ollama --ollama-model qwen2.5vl:7b
-
-# Specific task
-python -m scripts.vlm_sanity_check --model ollama --ollama-model qwen2.5vl:7b --task gridworld/tasks/tier3/key_switch_001.json
-
-# All tiers (one representative task per tier)
-python -m scripts.vlm_sanity_check --model ollama --ollama-model qwen2.5vl:7b --all-tiers --output results/sanity_check.json
-```
-
-Tests two categories:
-- **Object Identification**: Can the VLM identify agents, goals, keys, doors, switches, hazards?
-- **Spatial Reasoning**: Can the VLM describe grid dimensions, agent direction, relative positions?
-
----
-
-## 7. Manual Web-Chat Smoke Tests
-
-Use this when you want to drive ChatGPT, Claude, or Gemini through the normal web UI instead of the API.
-
-```bash
-# One action per chat turn with short visual history
-python -m scripts.chat_smoke_test \
- --task mazes/validation_10/V01_empty_room.json \
- --query-interval 1 \
- --history-images 2
-
-# Multi-action turns plus optional LOOK
-python -m scripts.chat_smoke_test \
- --task mazes/validation_10/V04_single_key.json \
- --query-interval 3 \
- --allow-look \
- --history-images 2 \
- --history-text-window 4
-```
-
-Each turn writes a packet directory under `/tmp/chat_smoke_/` containing:
-- `current.png`
-- optional `prior_*.png`
-- `prompt.txt`
-- `user_message.md`
-- `state.json`
-
-Attach the images in the packet to the chat UI, paste `user_message.md`, then paste the model's reply back into the terminal.
-
----
-
-## 8. Partial Observability
-
-Some tier 5 tasks use partial observability. Two modes are supported:
-
-| Mode | Description | Example Task |
-|------|------------|--------------|
-| `full` | Agent sees entire grid (default) | All tier 1-4 tasks |
-| `view_cone` | Agent sees only a cone in front (walls block vision) | `tier5/hidden_switch_001.json` |
-| `fog_of_war` | Grid starts invisible, revealed as explored | `tier5/memory_003.json` |
-
-Set in task JSON under `rules.observability`:
-```json
-{
- "rules": {
- "observability": "view_cone",
- "view_size": 5
- }
-}
-```
-
----
-
-## 9. Task Structure
-
-Tasks are organized by difficulty tier in `gridworld/tasks/`:
-
-```
-gridworld/tasks/
- tier1/ Pure navigation (maze solving)
- maze_simple_001.json
- maze_corridor_002.json
- maze_rooms_003.json
- tier2/ Key-door puzzles
- single_key_001.json
- multi_key_002.json
- colored_doors_003.json
- tier3/ Switches and gates
- key_switch_001.json
- gates_switches_002.json
- complex_deps_003.json
- tier4/ Pushable blocks and resource management
- push_block_001.json
- blocked_path_002.json
- consumable_003.json
- tier5/ Inference, multi-mechanism, teleporters
- hidden_switch_001.json
- infer_color_002.json
- memory_003.json
- teleporter_004.json
+python run_eval.py --model random --benchmark tiers --tier 1 # random baseline on tier tasks
+python run_eval.py --model ollama --backend multigrid --tiling hex
+python visualize_all_tilings.py
+python -m scripts.vlm_sanity_check --model ollama # VLM vision sanity check
```
----
-
-## 10. MultiGrid Tilings
-
-Supported tiling types for the MultiGrid backend:
-
-| Tiling | Directions | Description |
-|--------|-----------|-------------|
-| `square` | 4 (N,E,S,W) | Standard grid |
-| `hex` | 6 (N,NE,SE,S,SW,NW) | Hexagonal grid |
-| `triangle` | 3 (edge_0, edge_1, edge_2) | Triangular subdivision of hexagons |
-| `3464` | up to 6 | Rhombitrihexagonal (mixed triangles, squares, hexagons) |
-| `488` | up to 8 | Truncated square (octagons and squares) |
-
----
-
-## 11. Architecture Summary
-
-```
-Task JSON --> TaskParser --> CustomMiniGridEnv
- |
- MiniGridBackend (square grids)
- MultiGridBackend (exotic tilings)
- |
- GridRunner (episode execution)
- |
- EvaluationHarness + ModelInterface
- |
- Adapters: File-Based | Ollama | LMStudio
-```
+Task tiers for this harness live in `gridworld/tasks/tier1..tier5/`;
+`gridworld.task_validator.validate_all_tasks()` checks beatability.
diff --git a/analysis/README.md b/analysis/README.md
index 4ea45d8..75055b4 100644
--- a/analysis/README.md
+++ b/analysis/README.md
@@ -1,10 +1,6 @@
-# Analysis has moved
+# Analysis lives with the results
-Data analysis lives with the data (team decision, 2026-07-24):
-
-- R1 post-hoc analysis β `Multinet-v2-results/r1-20260717/analysis/`
-- Exp3 / conditional-sweep analysis package (+ its pytest files) β
- `Multinet-v2-results/analysis-exp3/`
-
-Scripts there still expect to run from this repo's root with
-`Multinet-v2-results/` checked out as a sibling.
+Results loading, figure generation, and the R1 post-hoc analysis are
+published alongside the results, not in this implementation repository.
+The scripts there expect to run from this repo's root with the results
+checkout as a sibling directory.
diff --git a/assets/fig_logo.png b/assets/fig_logo.png
new file mode 100644
index 0000000..4c5218d
Binary files /dev/null and b/assets/fig_logo.png differ
diff --git a/assets/gt_logo.png b/assets/gt_logo.png
new file mode 100644
index 0000000..f883ab9
Binary files /dev/null and b/assets/gt_logo.png differ
diff --git a/assets/manifold_logo.png b/assets/manifold_logo.png
new file mode 100644
index 0000000..4241f12
Binary files /dev/null and b/assets/manifold_logo.png differ
diff --git a/assets/multinet_logo.png b/assets/multinet_logo.png
new file mode 100644
index 0000000..fcfd7ad
Binary files /dev/null and b/assets/multinet_logo.png differ
diff --git a/assets/r1_failure_reel.gif b/assets/r1_failure_reel.gif
new file mode 100644
index 0000000..a4b8e2f
Binary files /dev/null and b/assets/r1_failure_reel.gif differ
diff --git a/assets/r1_failure_reels.gif b/assets/r1_failure_reels.gif
new file mode 100644
index 0000000..fad5b51
Binary files /dev/null and b/assets/r1_failure_reels.gif differ
diff --git a/assets/r1_progress_grid.png b/assets/r1_progress_grid.png
new file mode 100644
index 0000000..9f8f727
Binary files /dev/null and b/assets/r1_progress_grid.png differ
diff --git a/assets/tufts_logo.jpg b/assets/tufts_logo.jpg
new file mode 100644
index 0000000..0029075
Binary files /dev/null and b/assets/tufts_logo.jpg differ
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 0000000..4d7b947
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,14 @@
+"""Pytest bootstrap: make repo-root packages importable in any invocation.
+
+Several test modules import repo-root packages that are deliberately not
+packaged/installed (e.g. `deploy` β operator tooling excluded from the wheel
+in v2.0.0). Bare `pytest` does not put the rootdir on sys.path, so without
+this the suite only collects when an alphabetically-early test module happens
+to insert it first.
+"""
+import sys
+from pathlib import Path
+
+_REPO_ROOT = str(Path(__file__).resolve().parent)
+if _REPO_ROOT not in sys.path:
+ sys.path.insert(0, _REPO_ROOT)
diff --git a/demo/__init__.py b/demo/__init__.py
index bd2c864..306bb84 100644
--- a/demo/__init__.py
+++ b/demo/__init__.py
@@ -16,8 +16,9 @@
chimes), best-effort and silent when audio isn't available.
- ``demo.fx``: display-only motion feedback (wall bounce, cell flash/fade,
goal pulse) composited on the rendered frame -- never mutates the env.
-- ``demo.compare``: R1 results lookup (requires sibling Multinet-v2-results).
- The demo only plays mazes present in that table.
+- ``demo.compare``: R1 results lookup (sibling checkout or nested
+ Multinet-v2-results directory; degrades gracefully when neither is
+ present). Any maze plays; the table only gates the comparison card.
- ``demo.r1_config`` / ``demo.r1_tasks``: shared R1 experiment config and
allowlist helpers used by both the desktop UI and the web API.
- ``demo.api``: FastAPI HTTP surface for the web player
diff --git a/demo/compare.py b/demo/compare.py
index ecc0c00..56939fe 100644
--- a/demo/compare.py
+++ b/demo/compare.py
@@ -1,7 +1,9 @@
"""R1 model-comparison lookup for the human-play demo's end screen.
-Reads the sibling Multinet-v2-results canonical metrics table so a finished
-episode can show human steps vs BFS optimal vs Claude / Kimi / Qwen.
+Reads the Multinet-v2-results canonical metrics table (sibling checkout, or
+nested inside this repo -- see ``_find_default_csv``) so a finished episode
+can show human steps vs BFS optimal vs Claude / Kimi / Qwen. If no table is
+found, the catalog is empty and comparison is simply unavailable.
"""
from __future__ import annotations
@@ -31,15 +33,27 @@
"solved": "solved",
}
-# Sibling checkout next to MultiNet-v2.0.
-_DEFAULT_CSV = (
- Path(__file__).resolve().parents[1].parent
- / "Multinet-v2-results"
- / "r1-20260717"
- / "analysis"
- / "metrics"
- / "canonical_results_table.csv"
-)
+_RESULTS_TABLE_TAIL = Path("r1-20260717") / "analysis" / "metrics" / "canonical_results_table.csv"
+
+
+def _find_default_csv() -> Path | None:
+ """Locate the R1 canonical results table.
+
+ Prefers a ``Multinet-v2-results`` checkout sibling to this repo (the
+ layout the demo was originally written against); falls back to a
+ ``Multinet-v2-results/`` directory nested inside this repo (this
+ machine's actual layout -- see CLAUDE.md's Layout section). Returns
+ ``None`` if neither exists, so callers can degrade to an empty/absent
+ catalog instead of crashing the demo at launch.
+ """
+ repo_root = Path(__file__).resolve().parents[1]
+ sibling = repo_root.parent / "Multinet-v2-results" / _RESULTS_TABLE_TAIL
+ if sibling.is_file():
+ return sibling
+ nested = repo_root / "Multinet-v2-results" / _RESULTS_TABLE_TAIL
+ if nested.is_file():
+ return nested
+ return None
def r1_task_id(task_path: Path) -> str:
@@ -94,16 +108,24 @@ class TaskComparison:
class R1ResultCatalog:
- """Index of R1 canonical results, keyed by ``r1_*`` task_id."""
+ """Index of R1 canonical results, keyed by ``r1_*`` task_id.
+
+ When ``csv_path`` isn't given explicitly, the table is auto-discovered
+ via ``_find_default_csv`` (sibling checkout, then nested). If neither
+ location has it, the catalog is constructed empty rather than raising --
+ ``__contains__`` is always False and ``lookup`` always raises ``KeyError``
+ -- so the demo can still launch with the R1-comparison feature disabled.
+ An explicitly-passed ``csv_path`` that doesn't exist still raises: that's
+ a deliberate ask, not auto-discovery.
+ """
def __init__(self, csv_path: Path | None = None):
- self.csv_path = Path(csv_path) if csv_path else _DEFAULT_CSV
- if not self.csv_path.is_file():
- raise FileNotFoundError(
- f"R1 results CSV not found at {self.csv_path}. "
- "Expected sibling Multinet-v2-results checkout."
- )
+ self.csv_path = Path(csv_path) if csv_path else _find_default_csv()
self._by_task: dict[str, list[dict]] = {}
+ if self.csv_path is None:
+ return
+ if not self.csv_path.is_file():
+ raise FileNotFoundError(f"R1 results CSV not found at {self.csv_path}.")
with open(self.csv_path, newline="", encoding="utf-8") as f:
for row in csv.DictReader(f):
tid = row["task_id"].strip()
@@ -115,6 +137,11 @@ def __contains__(self, task_id: str) -> bool:
def lookup(self, task_id: str) -> TaskComparison:
rows = self._by_task.get(task_id)
if rows is None:
+ if self.csv_path is None:
+ raise KeyError(
+ f"No R1 results table is available (no Multinet-v2-results "
+ f"checkout found); cannot look up {task_id!r}."
+ )
raise KeyError(f"Task {task_id!r} not in R1 results table ({self.csv_path})")
return self._build(task_id, rows)
diff --git a/demo/overlays.py b/demo/overlays.py
index 3f646c7..fd4fdb4 100644
--- a/demo/overlays.py
+++ b/demo/overlays.py
@@ -137,10 +137,106 @@ def render_episode_overlay(ui: "MiniGridPlayerUI") -> None:
if session.episode_success and not ui.fx.success_overlay_ready():
return
- comparison = ui.r1_catalog.lookup(r1_task_id(session.task_path))
+ task_id = r1_task_id(session.task_path)
+ if task_id not in ui.r1_catalog:
+ # No results table at all (e.g. a fresh clone with no
+ # Multinet-v2-results checkout), or this task simply isn't an R1
+ # maze -- either way there's no TaskComparison to draw the
+ # model-comparison rows from. Never raise out of the render path:
+ # show a plain end card instead.
+ render_plain_result_overlay(ui)
+ return
+ comparison = ui.r1_catalog.lookup(task_id)
render_r1_result_overlay(ui, comparison)
+def render_plain_result_overlay(ui: "MiniGridPlayerUI") -> None:
+ """Non-comparison end card: steps + success/failure only.
+
+ Used whenever ``render_episode_overlay`` finds no R1 catalog entry for
+ the finished task. Mirrors ``render_r1_result_overlay``'s header /
+ description / difficulty / steps-line layout (computed locally from the
+ session, same as that function); omits the BFS-optimal/score-vs-models
+ rows since there is no ``TaskComparison`` to draw them from.
+ """
+ session = ui.session
+ state = session.state
+ human_steps = state.step_count
+ max_steps = state.max_steps
+ success = session.episode_success
+ spec = session.task_spec
+ desc = (spec.description or "").strip() if spec else ""
+ tier = spec.difficulty_tier if spec else 0
+
+ veil = pygame.Surface((GRID_DISPLAY_SIZE, GRID_DISPLAY_SIZE), pygame.SRCALPHA)
+ veil.fill((8, 9, 13, 210))
+ ui.screen.blit(veil, (LEFT_RAIL_W, TOP_BAR_H))
+
+ pad = 28
+ card_w = GRID_DISPLAY_SIZE - 2 * pad
+ card_h = GRID_DISPLAY_SIZE - 2 * pad
+ card_x = LEFT_RAIL_W + pad
+ card_y = TOP_BAR_H + pad
+ card = pygame.Surface((card_w, card_h), pygame.SRCALPHA)
+ pygame.draw.rect(card, (22, 24, 34, 250), card.get_rect(), border_radius=16)
+ accent = ACCENT_GREEN if success else (255, 110, 110)
+ pygame.draw.rect(card, accent, pygame.Rect(0, 0, 7, card_h), border_radius=3)
+
+ cx = card_w // 2
+ content_w = card_w - 56
+ items: list[tuple[pygame.Surface | None, int]] = []
+ gap = 18
+
+ headline = "YOU SOLVED IT" if success else (
+ "STALLED" if session.end_reason == "stalled" else "OUT OF STEPS"
+ )
+ items.append((ui.font_overlay.render(headline, True, accent), gap + 6))
+
+ if desc:
+ desc_surfs = _wrap_text_surfs(desc, ui.font_small, COLOR_TEXT, content_w, max_lines=4)
+ for i, surf in enumerate(desc_surfs):
+ after = gap if i == len(desc_surfs) - 1 else 8
+ items.append((surf, after))
+
+ if tier:
+ diff = f"Maze difficulty: {tier} / {MAX_DIFFICULTY_TIER}"
+ items.append((ui.font_small_bold.render(diff, True, difficulty_color(tier)), gap + 4))
+
+ if success:
+ line = f"Completed in {human_steps} steps"
+ else:
+ line = f"Used {human_steps} / {max_steps} steps"
+ items.append((ui.font_main_bold.render(line, True, COLOR_TEXT_TITLE), gap - 2))
+
+ score_pct = int(round(session.display_reward * 100))
+ score_line = _compose_colored_line(
+ ui.font_main_bold,
+ [(f"Score: {score_pct}%", _score_color(score_pct))],
+ )
+ items.append((score_line, gap + 4))
+
+ items.append((
+ ui.font_small_bold.render("R reset [ ] switch task Q quit", True, COLOR_TEXT_DIM),
+ 0,
+ ))
+
+ total_h = sum((2 if surf is None else surf.get_height()) + after for surf, after in items)
+ y = max(24, (card_h - total_h) // 2)
+
+ for surf, after in items:
+ if surf is None:
+ pygame.draw.line(
+ card, COLOR_SEPARATOR,
+ (cx - content_w // 2, y + 1), (cx + content_w // 2, y + 1),
+ )
+ y += 2 + after
+ else:
+ card.blit(surf, surf.get_rect(midtop=(cx, y)))
+ y += surf.get_height() + after
+
+ ui.screen.blit(card, (card_x, card_y))
+
+
def render_r1_result_overlay(ui: "MiniGridPlayerUI", comparison: TaskComparison) -> None:
session = ui.session
state = session.state
diff --git a/demo/r1_tasks.py b/demo/r1_tasks.py
index 0aeee73..1bb43ea 100644
--- a/demo/r1_tasks.py
+++ b/demo/r1_tasks.py
@@ -23,10 +23,15 @@ def restrict_to_r1_tasks(
session: MiniGridPlaySession,
catalog: R1ResultCatalog | None = None,
) -> None:
+ """Narrow browsing to mazes present in the R1 results table, when any of
+ the current selection is. If none are -- a non-R1 experiment/directory
+ was requested, or no results table is available at all -- leave the
+ task list alone; R1-comparison is just unavailable for this session
+ rather than a reason to refuse to launch."""
catalog = catalog or R1ResultCatalog()
r1_tasks = [p for p in session.task_list if r1_task_id(p) in catalog]
if not r1_tasks:
- raise ValueError("No tasks in the current selection appear in the R1 results table.")
+ return
session.task_list = r1_tasks
session.task_list_locked = True
if session.task_path not in r1_tasks:
diff --git a/demo/session.py b/demo/session.py
index 8afab2e..d5ddfd4 100644
--- a/demo/session.py
+++ b/demo/session.py
@@ -200,7 +200,7 @@ def __init__(
task_path = str(self.task_list[0])
if task_path is None:
- task_path = "mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json"
+ task_path = "ogbench/ogbench/procgen/maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json"
# Backend for environment logic
self.backend = MiniGridBackend(render_mode="rgb_array")
@@ -258,11 +258,19 @@ def _load_task(self, path: str) -> None:
raw_spec = TaskSpecification.from_json(str(resolved))
manifest_row = self.manifest_row_by_path.get(resolved)
task_id = manifest_row["task_id"] if manifest_row else r1_task_id(resolved)
- self.optimal_steps = self._r1_catalog.lookup(task_id).optimal_steps
- cap = max(1, self.optimal_steps * 3)
- self.task_spec = (
- raw_spec if raw_spec.max_steps <= cap else dataclasses.replace(raw_spec, max_steps=cap)
- )
+ try:
+ self.optimal_steps = self._r1_catalog.lookup(task_id).optimal_steps
+ except KeyError:
+ # Not an R1 task, or no results table is available at all --
+ # R1-comparison is simply off for this task; keep the maze's own
+ # max_steps rather than crashing the whole load.
+ self.optimal_steps = 0
+ self.task_spec = raw_spec
+ else:
+ cap = max(1, self.optimal_steps * 3)
+ self.task_spec = (
+ raw_spec if raw_spec.max_steps <= cap else dataclasses.replace(raw_spec, max_steps=cap)
+ )
if self.task_list_locked:
if resolved not in self.task_list:
diff --git a/deploy/smoke_qwen.py b/deploy/smoke_qwen.py
index 17b6072..5565178 100644
--- a/deploy/smoke_qwen.py
+++ b/deploy/smoke_qwen.py
@@ -30,7 +30,7 @@ def format_verdict(tok_per_s: float, target: float = TARGET_TOK_S) -> str:
status = "MEETS" if tok_per_s >= target else "BELOW"
return (
f"[{status} target] {tok_per_s:.1f} tok/s vs {target:.0f} "
- f"(single-stream HF generate; see docs/future_directions.md for the vLLM path)"
+ f"(single-stream HF generate; the served-vLLM pipeline is the production path)"
)
diff --git a/docs/README.md b/docs/README.md
index 7412e6e..deaf42d 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,482 +1,29 @@
-# Multinet-v2.0 Documentation
-
-This directory contains the current documentation for the Multinet-v2.0 gridworld,
-multigrid, model-adapter, and evaluation interfaces.
-
-## Quick Navigation
-
-### Core Components
-
-1. **[Canonical System Design](./system_design.md)** - Target architecture for the full MultiNet v2.0 benchmark pipeline
-2. **[Immediate System Design for Tests 1-3](./immediate_system_design_tests_1_3.md)** - Reduced merge-scope design for the first scoring experiments
-3. **[Interfaces](./interfaces.md)** - Public task, backend, runner, model, and evaluation contracts
-4. **[Task Parser](./task_parser.md)** - Transforms JSON task specifications into executable MiniGrid environments
-5. **[MiniGrid Backend](./minigrid_backend.md)** - Default square-grid backend
-6. **[MultiGrid Backend](./multigrid_backend.md)** - Custom backend for square, hex, triangle, 3-4-6-4, and 4-8-8 tilings
-7. **[Backend Reference](./gridworld_backends.md)** - Cross-backend behavior and feature matrix
-
-## Overview
-
-The framework provides a complete pipeline for defining task specs, rendering
-grid observations, running policies, and scoring multimodal model behavior.
-
-```
-βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
-β Complete Framework Architecture β
-βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
-
-Task JSON
- -> TaskSpecification
- -> Backend.configure(task_spec)
- -> Backend.reset(seed)
- -> GridRunner / EvaluationHarness
- -> ModelInterface adapters
- -> EpisodeResult / benchmark metrics
-```
-
-## Getting Started
-
-### Basic Usage
-
-```python
-from gridworld.backends import MiniGridBackend
-from gridworld.task_spec import TaskSpecification
-
-# 1. Load task specification
-spec = TaskSpecification.from_json("mazes/validation_10/V01_empty_room.json")
-
-# 2. Create and configure backend
-backend = MiniGridBackend(render_mode="rgb_array")
-backend.configure(spec)
-
-# 3. Run episode
-obs, state, info = backend.reset(seed=42)
-done = False
-
-while not done:
- action = my_policy(obs) # Your agent
- obs, reward, terminated, truncated, state, info = backend.step(action)
- done = terminated or truncated
-
-# 4. Check results
-print(f"Success: {state.goal_reached}")
-print(f"Steps: {state.step_count}")
-```
-
-### Quick Examples
-
-#### Navigation Task
-```python
-# Simple navigation from start to goal
-from gridworld.task_parser import load_task_from_file
-
-env = load_task_from_file("gridworld/tasks/tier1/maze_simple_001.json")
-obs, info = env.reset()
-# ... run episode
-```
-
-#### Key-Door Puzzle
-```python
-# Task requiring key collection and door unlocking
-spec = TaskSpecification.from_json("gridworld/tasks/tier2/single_key_001.json")
-backend = MiniGridBackend()
-backend.configure(spec)
-
-obs, state, info = backend.reset()
-# Agent must: find key β pickup key β unlock door β reach goal
-```
-
-#### Switch-Gate Mechanism
-```python
-# Task with remote-controlled barriers
-spec = TaskSpecification.from_json("gridworld/tasks/tier3/gates_switches_002.json")
-backend = MiniGridBackend()
-backend.configure(spec)
-
-obs, state, info = backend.reset()
-# Agent must: find switch β toggle switch β pass through gate β reach goal
-```
-
-## Documentation Structure
-
-### Task Parser Documentation (`task_parser.md`)
-
-**Topics Covered**:
-- Architecture and design philosophy
-- Three-phase parsing (validate, create, populate)
-- Object placement order and dependencies
-- Usage examples and common patterns
-- Integration with backends
-- Performance considerations
-- Troubleshooting guide
-
-**Key Sections**:
-- Why reset() is called inside the parser
-- Object placement rules (gates before switches!)
-- Validation constraints
-- Convenience functions
-
-**Best For**: Understanding how JSON tasks become runnable environments
-
-### MiniGrid Backend Documentation (`minigrid_backend.md`)
-
-**Topics Covered**:
-- Backend abstraction layer
-- GridState extraction
-- Complete API reference
-- Action space (0-6 actions)
-- Reward structure
-- Feature support matrix
-- Performance benchmarks
-
-**Key Sections**:
-- Why we don't call env.reset() in backend.reset()
-- GridState extraction algorithm
-- Multi-seed evaluation patterns
-- Mechanism state tracking
-- Video recording
-
-**Best For**: Production evaluation setup, understanding backend interface
-
-### MultiGrid Backend Documentation (`multigrid_backend.md`)
-
-**Topics Covered**:
-- Exotic tiling support (hex, triangle)
-- Coordinate system translation (integer β normalized)
-- Task specification conversion
-- Action space translation
-- Feature limitations
-- Cross-backend comparison
-
-**Key Sections**:
-- Why normalize coordinates?
-- Object type unification
-- Square vs hex vs triangle comparison
-- Known limitations and workarounds
-- Future enhancements
-
-**Best For**: Research on spatial topology, exotic grid experiments
-
-## Task Specification Format
-
-Tasks are defined in JSON format with the following structure:
-
-```json
-{
- "task_id": "unique_identifier",
- "seed": 42,
- "difficulty_tier": 2,
- "max_steps": 100,
- "description": "Human-readable description",
-
- "maze": {
- "dimensions": [8, 8],
- "start": [1, 1],
- "goal": [6, 6],
- "walls": [[3, 3], [3, 4], [4, 3]]
- },
-
- "mechanisms": {
- "keys": [
- {"id": "key1", "position": [2, 2], "color": "red"}
- ],
- "doors": [
- {"id": "door1", "position": [4, 4],
- "requires_key": "red", "initial_state": "locked"}
- ],
- "switches": [
- {"id": "sw1", "position": [2, 5],
- "controls": ["gate1"], "switch_type": "toggle"}
- ],
- "gates": [
- {"id": "gate1", "position": [5, 5], "initial_state": "closed"}
- ],
- "blocks": [
- {"id": "block1", "position": [3, 5], "color": "grey"}
- ],
- "hazards": [
- {"id": "lava1", "position": [4, 6], "hazard_type": "lava"}
- ]
- },
-
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle"
- },
-
- "goal": {
- "type": "reach_position",
- "target": [6, 6]
- }
-}
-```
-
-See individual documentation files for detailed schema definitions.
-
-## Difficulty Tiers
-
-Tasks are organized into 5 difficulty tiers based on complexity:
-
-| Tier | Name | Features | Example |
-|------|------|----------|---------|
-| 1 | Navigation | Basic pathfinding | Empty maze, shortest path |
-| 2 | Linear Dependencies | Sequential tasks | Collect key β unlock door β reach goal |
-| 3 | Multi-Mechanism | Parallel mechanisms | Multiple keys, switches, gates |
-| 4 | Irreversibility | One-way actions | One-shot switches, consumed keys |
-| 5 | Hidden Information | Partial observability | Hidden keys, memory requirements |
-
-## Backend Comparison
-
-| Feature | MiniGrid Backend | MultiGrid Backend |
-|---------|------------------|-------------------|
-| **Status** | Default backend | Experimental but integrated |
-| **Tilings** | Square only | `square`, `hex`, `triangle`, `3464`, `488` |
-| **Mechanisms** | Keys, doors, switches, gates, blocks, hazards, teleporters | Keys, doors, switches, gates, blocks, hazards, teleporters |
-| **Partial Obs** | `full`, `view_cone`, `fog_of_war` | `full`, `view_cone`, `fog_of_war` |
-| **Rendering** | MiniGrid RGB rendering | Custom polygon renderer |
-| **Use Case** | Standard square-grid evaluation | Tiling and topology generalization |
-
-**Recommendation**: use **MiniGridBackend** for default square-grid evaluation.
-Use **MultiGridBackend** when the experiment depends on non-square tilings.
-
-## Common Patterns
-
-### Pattern 1: Multi-Seed Evaluation
-
-```python
-def evaluate_with_seeds(backend, task_spec, num_seeds=10):
- backend.configure(task_spec)
- results = []
-
- for seed in range(num_seeds):
- obs, state, info = backend.reset(seed=seed)
- # ... run episode
- results.append({"seed": seed, "success": state.goal_reached})
-
- return results
-```
-
-### Pattern 2: Task Suite Evaluation
-
-```python
-def evaluate_task_suite(backend, task_dir):
- results = {}
-
- for task_file in Path(task_dir).glob("*.json"):
- spec = TaskSpecification.from_json(task_file)
- backend.configure(spec)
- # ... run evaluation
- results[spec.task_id] = metrics
-
- return results
-```
-
-### Pattern 3: Observation Collection
-
-```python
-def collect_dataset(backend, task_spec, num_episodes=100):
- backend.configure(task_spec)
- dataset = []
-
- for episode_id in range(num_episodes):
- obs, state, info = backend.reset(seed=episode_id)
- trajectory = {"observations": [obs], "actions": [], "rewards": []}
-
- done = False
- while not done:
- action = expert_policy(obs)
- obs, reward, terminated, truncated, state, info = backend.step(action)
-
- trajectory["observations"].append(obs)
- trajectory["actions"].append(action)
- trajectory["rewards"].append(reward)
- done = terminated or truncated
-
- dataset.append(trajectory)
-
- return dataset
-```
-
-## Performance Tips
-
-### 1. Reuse Parser and Backend
-```python
-# GOOD: Reuse instances
-parser = TaskParser()
-backend = MiniGridBackend()
-
-for task_file in task_files:
- spec = TaskSpecification.from_json(task_file)
- backend.configure(spec)
- # ... evaluate
-
-# AVOID: Creating new instances each time
-for task_file in task_files:
- parser = TaskParser() # Wasteful!
- backend = MiniGridBackend() # Wasteful!
- # ...
-```
-
-### 2. Choose Appropriate Render Mode
-```python
-# For headless evaluation
-backend = MiniGridBackend(render_mode="rgb_array")
-
-# For interactive debugging
-backend = MiniGridBackend(render_mode="human")
-
-# For fastest execution (no visuals needed)
-backend = MiniGridBackend(render_mode=None)
-```
-
-### 3. Close Environments
-```python
-# Always close when done
-try:
- backend.reset()
- # ... run episodes
-finally:
- backend.close() # Cleanup resources
-```
-
-## Troubleshooting
-
-### Common Issues
-
-1. **RuntimeError: Backend must be configured before reset**
- - Solution: Call `backend.configure(spec)` before `backend.reset()`
-
-2. **Objects not appearing in environment**
- - Check task JSON has mechanisms defined
- - Validate spec: `spec.validate()`
-
-3. **Switch references non-existent gate**
- - Ensure gate IDs in task spec match switch.controls
-
-4. **Agent spawns in wrong position**
- - Check for position conflicts in task spec
- - Parser places agent last to handle conflicts
-
-5. **Unexpected reward values**
- - Check if agent stepped on hazard (reward=0, terminated=True)
- - vs reaching goal (reward>0, terminated=True)
-
-See individual documentation files for detailed troubleshooting guides.
-
-## API Quick Reference
-
-### TaskParser
-- `TaskParser(render_mode=None)`: Create parser
-- `.parse(spec, seed=None)`: Parse TaskSpecification β environment
-- `.parse_file(path)`: Load and parse JSON file
-- `.parse_dict(data)`: Parse dictionary
-
-### Backend Interface (MiniGrid and MultiGrid)
-- `.__init__(...)`: Initialize backend
-- `.configure(task_spec)`: Set task to use
-- `.reset(seed=None)`: Reset to initial state
-- `.step(action)`: Execute action
-- `.render()`: Get RGB image
-- `.get_mission_text()`: Get goal description
-- `.get_state()`: Get GridState
-- `.close()`: Cleanup
-
-### TaskSpecification
-- `.from_json(path)`: Load from file
-- `.from_dict(data)`: Load from dictionary
-- `.validate()`: Check consistency
-- `.to_json(path)`: Save to file
-- `.get_mission_text()`: Generate description
-
-## File Locations
-
-```
-.
-βββ gridworld/
-β βββ task_spec.py
-β βββ task_parser.py
-β βββ custom_env.py
-β βββ task_validator.py
-β βββ actions.py
-β βββ tasks/
-β β βββ tier1/
-β β βββ tier2/
-β β βββ tier3/
-β β βββ tier4/
-β β βββ tier5/
-β βββ backends/
-β β βββ base.py
-β β βββ minigrid_backend.py
-β β βββ multigrid_backend.py
-β βββ runner/grid_runner.py
-βββ mazes/validation_10/
-βββ multigrid/
-βββ cross_domain/
-βββ adapters/
-βββ scripts/
-βββ model_interface.py
-βββ evaluation_harness.py
-βββ run_eval.py
-βββ play_task.py
-```
-
-## Related Resources
-
-### Code Files
-- `gridworld/task_spec.py`: Complete TaskSpecification schema with validation
-- `gridworld/custom_env.py`: Custom MiniGrid environment with all mechanisms
-- `gridworld/backends/base.py`: Backend interface and `GridState` definition
-- `model_interface.py`: model adapter interface
-- `evaluation_harness.py`: model evaluation bridge and metrics
-- `gridworld/runner/grid_runner.py`: episode execution and trajectory data
-
-### Example Tasks
-- `gridworld/tasks/tier1/`: Navigation tasks
-- `gridworld/tasks/tier2/`: Key-door puzzles
-- `gridworld/tasks/tier3/`: Switch-gate mechanisms
-- `gridworld/tasks/tier4/`: Irreversible actions and push blocks
-- `gridworld/tasks/tier5/`: Partial observability, inference, and teleporters
-- `mazes/validation_10/`: Default validation benchmark for `run_eval.py`
-
-### Evaluation Scripts
-- `run_eval.py`: benchmark runner
-- `play_task.py`: interactive Pygame player
-- `scripts/vlm_sanity_check.py`: visual sanity checks
-- `scripts/chat_smoke_test.py`: manual web-chat action loop
-- `scripts/probe_vlm.py`: VLM orientation and action probes
-
-## Contributing
-
-When adding new features to the framework:
-
-1. **Update inline documentation**: Add comprehensive docstrings and comments
-2. **Update markdown docs**: Reflect changes in relevant .md files
-3. **Add examples**: Include usage examples in documentation
-4. **Update comparison tables**: Keep feature matrices current
-5. **Note limitations**: Document known issues and workarounds
-
-## Version History
-
-- **v2.0**: Current version
- - MiniGrid Backend: default square-grid backend
- - MultiGrid Backend: experimental backend for square, hex, triangle, 3-4-6-4, and 4-8-8 tilings
- - Shared task schema for keys, doors, switches, gates, blocks, hazards, teleporters, and partial observability
- - Public interfaces documented in `docs/interfaces.md`
-
-- **v1.0**: Initial release
- - Basic task specification
- - MiniGrid backend only
- - Limited documentation
-
-## Contact and Support
-
-For issues, questions, or contributions:
-- See the repository [README.md](../README.md)
-- Check individual documentation files for detailed troubleshooting
-- Review inline code comments for implementation details
-
----
-
-**Last Updated**: 2026-05-09
-
-**Documentation Status**: Complete and ready for production use
+# MultiNet v2.0 β Documentation Index
+
+MultiNet v2.0 is a gridworld benchmark harness: VLM/LLM agents navigate
+procedurally generated mazes (keys, doors, switches, gates) under controlled
+prompt, observation, and query conditions. Start with the repository
+[README](../README.md) and [RUNME](../RUNME.md); this directory holds the
+design references.
+
+## Architecture & design
+
+| Doc | What it covers |
+|---|---|
+| [system_design.md](system_design.md) | System architecture: pipeline stages, backend Γ adapter axes, artifact DAG |
+| [technical_design.md](technical_design.md) | Detailed technical design of the harness |
+| [task_parser.md](task_parser.md) | Task specification format and the spec β runtime env parser |
+| [gridworld_backends.md](gridworld_backends.md) | Backend overview |
+| [minigrid_backend.md](minigrid_backend.md) | MiniGrid backend reference |
+| [multigrid_backend.md](multigrid_backend.md) | MultiGrid backend reference (exotic tilings) |
+| [interfaces.md](interfaces.md) | Model-interface contracts (note: describes the legacy `ModelInterface` stack; the canonical agent contract is `interface/agents/` β `generate(messages) -> Reply`) |
+| [batch-api-lockstep-runner-design.md](batch-api-lockstep-runner-design.md) | Batch-API lockstep runner design |
+| [qwen-two-tier-rerun-design.md](qwen-two-tier-rerun-design.md) | Two-tier token-cap design for served-vLLM runs |
+
+## Where everything else lives
+
+- **Operator guide** (install, runs, scoring, fleet): [RUNME.md](../RUNME.md)
+- **Results & analysis**: published separately with the R1 results β not in
+ this repository.
+- **Historical campaign runbooks** (run preparation, cost projections,
+ rollout checklists): relocated to the results repository's archive.
diff --git a/docs/batch-api-lockstep-runner-design.md b/docs/batch-api-lockstep-runner-design.md
index 5b98f92..d72c383 100644
--- a/docs/batch-api-lockstep-runner-design.md
+++ b/docs/batch-api-lockstep-runner-design.md
@@ -214,9 +214,9 @@ Each **round** (one tick):
## Validation smoke
-- **Mazes (selected 2026-07-16 from `analysis/candidate_mazes/all_maze_features.csv`;
- all beatable, none in balanced_03, none length-risk, 5 distinct mechanism
- signatures):**
+- **Mazes (selected 2026-07-16 from the candidate-maze feature table, maintained
+ with the results; all beatable, none in balanced_03, none length-risk, 5
+ distinct mechanism signatures):**
| slot | maze | optimal actions | signature |
|---|---|---:|---|
diff --git a/docs/conditional_experiments_launch_checklist.md b/docs/conditional_experiments_launch_checklist.md
deleted file mode 100644
index 61694bd..0000000
--- a/docs/conditional_experiments_launch_checklist.md
+++ /dev/null
@@ -1,132 +0,0 @@
-# Conditional Experiments β Launch Checklist
-
-Single source of truth for the conditional-experiments launch. Check items off as
-they land. β οΈ marks a decision needed before the dependent work is correct.
-
-## 0. Naming (agreed terms)
-
-| Term | Maze set | Manifest |
-|---|---|---|
-| **Phase 1 full run** | OGBench 50 (S/M/B/D selection) | `manifest.ogbench_50_smbd.json` |
-| **Conditional evaluation** | validation_10 + 5 (1 S, 1 M, 1 B, 2 D) = 15, incl. the blind probe maze | `manifest.conditional_eval.json` (NEW) |
-| **Smoke eval** | 3 mazes, orchestration only | `manifest.smoke_eval.json` (NEW) |
-
-## 1. Experiment matrix β 6 condition sets β 14 variants
-
-Per the new spec. "Baseline" = the no-op variant (== default `ExperimentConfig`);
-the baseline is shared across all sets, so the 14 slots are **9 unique configs**.
-
-| # | Set (`--conditions`) | Variants (target) | Baseline | Implemented today | Gap |
-|---|---|---|---|---|---|
-| 1 | Prompt | minimal, **standard**, verbose (3) | standard | standard, verbose | add `minimal` (PR #23) |
-| 2 | Observation format | image_text, **image_only** (2) | image_only | image_only, text_only, image_text | **D1**: run image_only + image_text; keep `text_only` implemented but omit from the launch rollout (no code change) |
-| 3 | Context window | **current**, last3, text_summary (3) | current | current, last3 (text_summary = not impl) | wire `text_summary` (PR #23 history summary) |
-| 4 | **Action space** (NEW) | **egocentric**, cardinal (2) | egocentric | none β no config knob | add `action_space` knob + cardinal translation + new condition set; re-introduce cardinal (removed in 410f5f7) |
-| 5 | Querying strategy | **step_by_step**, subgoal, full_trajectory (3) | step_by_step | step_by_step, subgoal, full_trajectory | **D2**: run all 3 β no code change |
-| 6 | In-context learning | **zero_shot**, 1-shot (2) | zero_shot | set marked not-impl; one_shot not-impl | enable set; wire `one_shot` (PR #23); add ICL example trajectories |
-
-**Counts** (3 models = qwen[local] + kimi + claude; 15 mazes):
-- Variant-slots: 3+2+3+2+3+2 = **15**; unique configs after baseline dedup: **10**.
-- Episode-cells (dedup): 10 Γ 3 Γ 15 = **450** (paid = kimi+claude only: 10 Γ 2 Γ 15 = **300**).
-- Without dedup: 15 Γ 3 Γ 15 = 675 (paid 450). Use `--prompt-variant` dedup (see
- `docs/validation10_condition_sweep_rollout.md`).
-
-## 2. Dependencies to merge (into `Distributed-run-pipeline`, never main)
-
-- [x] Merge **PR #23** (`history_summary`): minimal prompt (Set 1), history/text
- summary (Set 3 `text_summary`), one-shot example (Set 6 `one_shot`).
- Merged into `Distributed-run-pipeline`; resolved a same-cell-pickup
- runtimeβsolver conflict (see [[same-cell-key-pickup-invariant]]).
-- [x] Confirm S/M/B/D fixture mazes exist for the conditional set. S/M/D pulled
- from ogbench (all sources verified on disk); the **B** maze is the
- hand-authored held-out blind probe (see Β§4).
-
-## 3. Code implementation
-
-- [x] **Set 1**: `minimal` variant registered in `condition_set_1_prompt.py`
- (delivered by PR #23).
-- [x] **Set 2** (D1 = run 2): no registry change; `text_only` stays implemented,
- omitted from the launch rollout (handled via `--prompt-variant` in the
- rollout doc, not the run-config).
-- [x] **Set 3**: `text_summary` implemented in `condition_set_3_context_window.py`
- and wired to `ExperimentConfig.context_window="text_summary"` (PR #23).
-- [x] **Set 4 (NEW Action space)**: added `action_space` knob; cardinal vocabulary
- (MOVE_NORTH/SOUTH/EAST/WEST, PICKUP, INTERACT, DONE) in
- `interface/action_space.py` with facing-relative expansion in the runner
- (each primitive = 1 step; `cardinal_action` provenance recorded);
- `condition_set_4_action_space.py` registered in `CONDITION_SETS`.
-- [x] **Set 5** (D2 = run all 3): no code change; all three querying variants run.
-- [x] **Set 6**: ICL set enabled with `one_shot` (PR #23); disjointness test added
- (`tests/test_one_shot_solution.py`) asserting the example uses no eval maze.
-- [x] Update `CONDITION_SETS` registry + `condition_variant_names` so all 6 sets /
- 15 variant-slots resolve; `variant.name` globally unique (locked by tests).
-- [x] Update `docs/validation10_condition_sweep_rollout.md` for 6 sets / new counts
- and the conditional_eval manifest, and the dedup coverage tests.
-
-## 4. Mazes & manifests
-
-- [x] **Generate the blind box probe maze**: hand-authored held-out 11th B
- (blind) maze `mazes/conditional/blind_probe_B_holdout.json` β keys/doors
- uniform grey, switches uniform white (no white key/door in the MiniGrid
- palette), 4 doors / 2 keys / 2 switches with positional+consumption decoys.
- Genuine wrong-keys/doors deferred (see [[blind-mazes-and-wrong-key-refactor]]).
-- [x] **Render the blind maze in 2D** β `mazes/maze_image/conditional/blind_probe_B_holdout.png`.
-- [x] **D3 = the blind probe maze is one of the 5 (S/M/B/D/D); conditional set stays 15.**
- It is the held-out **B** maze.
-- [x] Create `manifest.conditional_eval.json` = validation_10 + S/M/B/D/D (B = the
- blind probe) = 15 total; all 5 added mazes disjoint from the 50-maze run.
-- [x] Create `manifest.smoke_eval.json` = 3 mazes.
-- [ ] Confirm/alias `manifest.ogbench_50_smbd.json` as the "Phase 1 full run".
-
-## 5. Run configs (3 models, with the H1/H2 manifest+conditions guard)
-
-- [x] One run-config per condition set against `manifest.conditional_eval.json`,
- each declaring `manifest` + `conditions` (new
- `run_config.conditional_*_claude_kimi_qwen.json` files; H1/H2 guard tested).
-- [x] Action space and In-context learning run-configs added.
-- [x] Variant trimming (Set 2 omits `text_only`) is handled in the rollout via
- `--prompt-variant`, not the run-config.
-- [x] Smoke run-config `run_config.smoke_eval_qwen_kimi.json`: qwen
- `worker_count: 2`, kimi `worker_count: 1`.
-
-## 6. Smoke / orchestration test
-
-- [x] 3-maze `manifest.smoke_eval.json` + `run_config.smoke_eval_qwen_kimi.json`
- validating **2 parallel Qwen runners + 1 Kimi runner** and the coordinator
- handing the next maze to a runner as soon as one finishes (work-stealing).
- Covered by `test_smoke_coordinator_work_steals_across_two_qwen_and_one_kimi`
- (note: Qwen `max_in_flight` must be β₯2 or the two Qwen runners serialize).
-- [ ] Decide if other coordinator capabilities need exercising (e.g. stale
- reassignment, GCS mirror, finalize) and extend the smoke if so.
-
-## 7. Cost estimate
-
-- [ ] Local weekend Qwen run over the 15-maze conditional set (10 unique configs Γ
- 15 = 150 local episodes) to get rough tokens/episode.
-- [ ] Extrapolate to paid models (kimi+claude) for conditional eval (300 paid
- episodes) and to Phase 1 full run (50 mazes).
-
-## 8. Outstanding Medium items (from the launch review)
-
-- [x] **M5**: Kimi `enable_thinking` is now forwarded by the agent factory
- (`run_pipeline._build_agent_from_spec` kimi branch); test in
- `tests/test_kimi_k26_agent.py`.
-- [~] **M6**: the 4096 `max_tokens` budget is asserted on every conditional
- run-config model (test), but the live truncation/parse check is an operator
- step requiring API keys. Before the full run, run a 1-task API smoke, e.g.:
- `multinet-run-pipeline --run-config gridworld/fixtures/run_config.conditional_prompt_claude_kimi_qwen.json --manifest gridworld/fixtures/manifest.conditional_eval.json --conditions "Prompt" --prompt-variant standard --seeds 0 --artifacts-root artifacts/m6_smoke --run-set-id m6_smoke --difficulty-max-static-score `
- and confirm Kimi/Claude replies parse without 4096-token truncation.
-- [x] **M4**: `_jsonable` now raises `TypeError` instead of stringifying an
- unknown type, so a non-primitive cannot poison the cross-machine cache hash;
- test in `tests/test_run_pipeline.py`.
-
-## 9. Decisions (resolved)
-
-- **D1** β
Set 2: run `image_only` + `image_text`; keep `text_only` implemented but
- omit from the launch rollout.
-- **D2** β
Set 5: run all 3 (`step_by_step`, `subgoal`, `full_trajectory`) β Set 5 is
- 3 variants, total 15 variant-slots / 10 unique configs.
-- **D3** β
Blind probe maze is one of the S/M/B/D/D 5; conditional set stays 15.
-- **D4** β
The per-set decision rules (deltas: <5% / >5% / >15%) live in the **final
- results doc**, which flags the chosen number for easy reference. This is **external
- to the run** β not encoded in the pipeline or monitoring.
diff --git a/docs/conditional_run_cost_projection.md b/docs/conditional_run_cost_projection.md
deleted file mode 100644
index 92d7575..0000000
--- a/docs/conditional_run_cost_projection.md
+++ /dev/null
@@ -1,205 +0,0 @@
-# Conditional-Eval Cost & Time Projection (Kimi K2.6 / Sonnet 4.6 / Opus 4.6 / Qwen 3.6)
-
-Projection for the **6-set conditional sweep** = **10 unique prompt-variant configs Γ 15 mazes Γ 1 seed**
-(`manifest.conditional_eval.json`), built from the Qwen3.5-27B validation-10 run data in
-`docs/qwen35_hf_local_pipeline_notes.md` and `artifacts/qwen35_27b_hf_validation10/partial_results_summary/`.
-
-> "A single run of the full 15" = **one variant run across the 15 mazes**.
-> "All 10 experiments" = **the 10 deduplicated unique configs** (baseline + 9 distinct variants;
-> the baseline is shared across all six condition sets and is paid once β per
-> `docs/validation10_condition_sweep_rollout.md`).
-
----
-
-## 1. Method & data sources
-
-| Quantity | Source |
-|---|---|
-| Per-turn **text** input/output tokens (by obs format) | Qwen3.5 fresh rows, `fresh_rows.csv` (19 episodes, 1.75M tokens) |
-| Per-call **latency** (by obs format) | Qwen3.5 `llm_latency_s` (666 min total recorded) |
-| **Optimal path length** per maze | canonical BFS in `tasks/*/canonical_paths.json` (v01βv10 exact; 5 held-out estimated) |
-| **Maze pixel size** | MiniGrid `TILE_PIXELS = 32` Γ maze (W,H); images sent full-res (no resize in `claude.py`/`kimi_k26.py`) |
-| **Image β tokens** | Claude `(wΒ·h)/750`; Kimi MoonViT β `(wΒ·h)/784` (14px patch + 2Γ2 merge) |
-| **Pricing** | Opus 4.6 $5/$25; Sonnet 4.6 $3/$15; Kimi K2.6 $0.95(miss)/$0.16(hit) in, $4.00 out β all per 1M tok |
-
-**Per-turn text-token profile measured from Qwen3.5 (images excluded from these counts):**
-
-| Obs format | text in / call | out / call | latency / call |
-|---|---:|---:|---:|
-| `image_only` (baseline) | 386 | 173 | 13.3 s |
-| `image_text` | 987 | 467 | 30.7 s |
-| `text_only` | 942 | 500 | 33.0 s |
-
-**Turns-per-episode (capable API model):** `step_by_step` β `turns β 1.5 Γ optimal` (step caps don't bind).
-Querying-strategy variants override this (`subgoal` β 0.4Γoptimal calls; `full_trajectory` β 3 calls total).
-
----
-
-## 2. The image cost that was NOT in the token metrics β οΈ
-
-The Qwen metrics recorded **text tokens only** β proof: `image_only` logged *fewer* input tokens
-(386/call) than `text_only` (942/call), because the rendered frame contributed **0** to the count.
-Every turn ships one PNG; on the API models that PNG **is** billed as input tokens.
-
-| Maze | WΓH | Pixels | Img tok (Claude) | Img tok (Kimi) |
-|---|---|---|---:|---:|
-| v01 empty_room | 8Γ8 | 256Γ256 | 87 | 84 |
-| v02 winding_corridor | 20Γ8 | 640Γ256 | 218 | 209 |
-| v03 multi_path | 12Γ12 | 384Γ384 | 197 | 188 |
-| v04βv08 (14Γ12) | 14Γ12 | 448Γ384 | 229 | 219 |
-| v09βv10 (16Γ12) | 16Γ12 | 512Γ384 | 262 | 251 |
-| S 14Γ14 | 14Γ14 | 448Γ448 | 268 | 256 |
-| M / D1 / D3 10Γ10 | 10Γ10 | 320Γ320 | 137 | 131 |
-| B blind 15Γ9 | 15Γ9 | 480Γ288 | 184 | 176 |
-| **Average / maze** | | | **β202** | **β194** |
-
-**At the baseline (`image_only`), image tokens are β35% of all input tokens.** Omitting them
-understates input by roughly a third β and for the cheap-output Kimi model, input is the majority of spend.
-
----
-
-## 3. Cost per experiment (one variant Γ 15 mazes Γ 1 seed)
-
-Input = text + image tokens. Output assumes the terse one-line `FINAL_OUTPUT` contract
-(Qwen ran `enable_thinking=False`). All USD.
-
-| Experiment (unique config) | LLM calls | Input (M) | Output (M) | **Opus 4.6** | **Sonnet 4.6** | **Kimi K2.6** | Kimi (cache-hit) |
-|---|---:|---:|---:|---:|---:|---:|---:|
-| standard (baseline) | 624 | 0.373 | 0.108 | **4.57** | **2.74** | **0.78** | 0.49 |
-| minimal (Prompt) | 624 | 0.325 | 0.108 | 4.32 | 2.59 | 0.74 | 0.48 |
-| verbose (Prompt) | 624 | 0.458 | 0.119 | 5.26 | 3.15 | 0.90 | 0.55 |
-| image_text (Obs format) | 624 | 0.748 | 0.291 | 11.03 | 6.62 | 1.87 | 1.28 |
-| last3 (Context window) | 624 | 0.349 | 0.108 | 4.44 | 2.67 | 0.76 | 0.49 |
-| text_summary (Context) | 624 | 0.349 | 0.108 | 4.44 | 2.67 | 0.76 | 0.49 |
-| cardinal (Action space) | 624 | 0.373 | 0.108 | 4.57 | 2.74 | 0.78 | 0.49 |
-| subgoal (Querying) | 166 | 0.099 | 0.086 | 2.65 | 1.59 | 0.44 | 0.36 |
-| full_trajectory (Querying) | 45 | 0.026 | 0.019 | 0.61 | 0.36 | 0.10 | 0.08 |
-| one_shot (In-context learning) | 624 | 0.904 | 0.108 | 7.22 | 4.33 | 1.28 | 0.58 |
-
-Cost drivers worth noting: **`image_text` β 2.4Γ baseline** (full text grid *plus* image every turn);
-**`one_shot` β 1.6Γ** (worked example in every prompt); **`full_trajectory` β 0.13Γ** and
-**`subgoal` β 0.58Γ** (far fewer LLM calls).
-
----
-
-## 4. TOTALS β all 10 experiments (15 mazes, 1 seed each)
-
-| Model | 10-experiment total | Per the rollout (Kimi + one Claude tier) |
-|---|---:|---|
-| **Opus 4.6** | **$49.10** | Opus + Kimi = **$57.51** ($54.39 w/ Kimi cache) |
-| **Sonnet 4.6** | **$29.46** | Sonnet + Kimi = **$37.87** ($34.75 w/ Kimi cache) |
-| **Kimi K2.6** | **$8.41** (miss) / **$5.29** (cache-hit) | β |
-| **Qwen 3.6 (local)** | **$0** (compute/time only) | β |
-
-The doc's rollout runs **Claude + Kimi + local Qwen**. So a realistic full sweep is one of the
-"Kimi + one Claude tier" lines above, **plus the Qwen wall-clock** below. Per seed.
-
----
-
-## 5. Qwen 3.6 wall-clock (local, 6 parallel runners)
-
-Qwen runs on local hardware (RTX 4090, 4-bit) β **no token cost**, only time. Latency basis = Qwen3.5
-per-call latencies; **assumes 3.6 generates at a similar speed** (scale up if 3.6 is materially larger).
-
-| Scenario | Sequential model-time | **6 runners (ideal)** | + ~15% orchestration |
-|---|---:|---:|---:|
-| 3.6 navigates near-optimally (1.5Γopt calls) | ~24 h | **~4.0 h** | ~4.6 h |
-| 3.6 truncates/loops like 3.5 (~35 min/episode measured) | ~88 h | **~14.6 h** | ~17 h |
-
-**Plan for Β½β1 day** of local Qwen time on 6 runners for the full 10Γ15 suite (1 seed).
-The driver is truncation: Qwen3.5 hit step caps (140β220 calls/episode) on hard mazes; if 3.6
-solves more it lands near the 4 h end.
-
----
-
-## 6. Sensitivities (what could move these numbers)
-
-- **Extended/adaptive thinking (biggest risk for Claude).** Output is ~55β60% of Opus/Sonnet spend.
- The estimate assumes terse one-line outputs. If adaptive thinking is left **on**, output tokens can
- rise 2β4Γ β Opus 10-exp total could move from ~$49 toward **$90β130**. Keep effort low / thinking
- constrained to hold the projection.
-- **Prompt caching (biggest savings).** `step_by_step` turns share a growing prefix.
- Claude cache-read β0.1Γ input; Kimi cache-hit $0.16 vs $0.95 (~6Γ). Input is 35β77% of cost, so
- caching can cut totals materially (Kimi 10-exp already shown: $8.41 β $5.29). Not assumed on by
- default β the simple HTTP agents don't set `cache_control`/context caching yet.
-- **Seeds.** All figures are **1 seed**. Costs and time scale linearly with seed count.
-- **API-model truncation (upside risk).** If Claude/Kimi loop instead of solving (the Qwen failure
- mode), calls/episode rise toward the step cap and costs scale ~3β4Γ. Capable models shouldn't, but
- watch parse-failure / no-`FINAL_OUTPUT` loops.
-- **Held-out maze optimals** (S/M/B/D, 5 of 15) are estimated; they're ~β
of mazes and small, so the
- effect on totals is minor.
-
----
-
-## 7. Thinking-enabled projection
-
-Assumption: **a 70%-thinking pipeline** β reasoning is ~70% of generated tokens, the answer ~30% β
-so **output tokens Γ 3.33** (input unchanged). Applied uniformly to all variants.
-
-### 7a. API cost with thinking (one variant Γ 15 mazes Γ 1 seed, USD)
-
-| Experiment | out (M) | Opus 4.6 | Sonnet 4.6 | Kimi K2.6 | Kimi (cache) |
-|---|---:|---:|---:|---:|---:|
-| standard (baseline) | 0.360 | 10.86 | 6.52 | 1.79 | 1.50 |
-| minimal (Prompt) | 0.360 | 10.62 | 6.37 | 1.74 | 1.49 |
-| verbose (Prompt) | 0.396 | 12.18 | 7.31 | 2.01 | 1.66 |
-| image_text (Obs) | 0.971 | 28.03 | 16.82 | 4.59 | 4.00 |
-| last3 (Context) | 0.360 | 10.74 | 6.45 | 1.77 | 1.49 |
-| text_summary (Context) | 0.360 | 10.74 | 6.45 | 1.77 | 1.49 |
-| cardinal (Action) | 0.360 | 10.86 | 6.52 | 1.79 | 1.50 |
-| subgoal (Querying) | 0.287 | 7.68 | 4.61 | 1.24 | 1.16 |
-| full_trajectory (Querying) | 0.063 | 1.71 | 1.03 | 0.28 | 0.26 |
-| one_shot (ICL) | 0.360 | 13.51 | 8.11 | 2.29 | 1.58 |
-
-### 7b. Totals β all 10 experiments, thinking enabled (1 seed)
-
-| Model | No-thinking | **Thinking (70%)** | Uplift |
-|---|---:|---:|---:|
-| **Opus 4.6** | $49.10 | **$116.94** | 2.38Γ |
-| **Sonnet 4.6** | $29.46 | **$70.17** | 2.38Γ |
-| **Kimi K2.6** | $8.41 | **$19.27** | 2.29Γ |
-| **Kimi (cache-hit input)** | $5.29 | **$16.14** | 3.05Γ |
-
-Uplift is below 3.33Γ because thinking scales **output only** (input is unchanged). The cheaper the
-model's output relative to input β and the more input is cached β the closer the uplift gets to 3.33Γ.
-Realistic dual sweep with thinking (Kimi + one Claude tier): **Sonnet+Kimi β $89.4** ($86.3 w/ Kimi
-cache); **Opus+Kimi β $136.2** ($133.1 w/ Kimi cache). Per seed.
-
-**Does the 4096-output cap change these?** No. Under the 70%-thinking model the **per-call** output is
-577β2,293 tokens (max = `full_trajectory` on the largest maze) β all below 4096, so the cap never
-binds and the totals above stand. The cap is a per-call *ceiling*: the absolute max if every one of the
-~5,200 calls hit 4096 output would be ~$553 Opus / ~$332 Sonnet / ~$89 Kimi (β9Γ the modeled output β
-not a reachable regime here). The only way the cap raises cost is *indirectly*: if a call's reasoning
-alone exceeds ~3,900 tokens it truncates before `FINAL_OUTPUT` β parse-failure retry β extra calls. If
-that shows up on the hardest mazes, raise the API `max_tokens` to 8192 (currently 4096 for the paid
-models per the M6 budget-parity invariant; only local Qwen is at 8192).
-
-### 7c. Qwen 3.6 wall-clock with thinking (local, 6 runners)
-
-Effective rate from Qwen3.5 = **14.6 output tok/s/runner** (583,219 output tok Γ· 666 min). Total
-suite output (no-think) Γ 3.33 Γ· rate Γ· 6 runners:
-
-| Turn regime | Suite output (no-think β thinking) | No-thinking | **Thinking** |
-|---|---|---:|---:|
-| Near-optimal (1.5Γopt) | 1.16M β 3.88M tok | ~3.7 h | **~12.3 h** |
-| Truncates/loops like Qwen3.5 | 4.60M β 15.35M tok | ~14.6 h | **~48.7 h** |
-
-So with thinking on, **budget ~Β½ day if Qwen 3.6 navigates well, up to ~2 days if it truncates like
-3.5.** Thinking roughly triples local generation time. (The 14.6 tok/s is *effective* β it bundles
-prefill β so the thinking figure is mildly conservative for the added pure-decode reasoning tokens.)
-
----
-
-## 8. Implementation changes shipped with this projection
-
-- **Prompt caching wired for Claude** (`interface/agents/claude.py`): `cache_control` breakpoints on
- the system prompt and the last block of the latest turn (`enable_prompt_cache=True` by default), so
- each step reads the prior step's prefix. **Telemetry fixed** (`interface/telemetry.py`) to fold
- `cache_read_input_tokens` + `cache_creation_input_tokens` back into `input_tokens` β otherwise
- caching would silently undercount prompt tokens (Anthropic reports `input_tokens` as the *uncached
- remainder* only). Moonshot/Kimi caches identical prefixes automatically (no per-message field).
-- **Qwen thinking enabled for the full conditional sweep**: the six
- `run_config.conditional_*_claude_kimi_qwen.json` set `enable_thinking: true` + `max_tokens: 8192`
- for the local Qwen model (mirrors the `ogbench_50` thinking precedent; the larger budget leaves room
- for chain-of-thought *plus* the trailing `FINAL_OUTPUT` line). API models stay at 4096; the M6
- budget-parity test was refined to enforce 4096 for the paid models and 8192 for local Qwen.
diff --git a/docs/design-proposals-2026-07.md b/docs/design-proposals-2026-07.md
deleted file mode 100644
index ca5f000..0000000
--- a/docs/design-proposals-2026-07.md
+++ /dev/null
@@ -1,188 +0,0 @@
-# Design proposals β post-sweep iteration (2026-07)
-
-Three designs requested after the conditional sweep, **not yet implemented**.
-Each section says what the feature is, the design decision points, the
-recommendation, and exactly which code changes it needs. Data citations are
-from `analysis/FINDINGS.md` (540 episodes, 3 models, 15 mazes, 1 seed).
-
-Related work already landed on `fix/run-bugfixes` (not proposals β done):
-resolved-goal consistency + executable-action difficulty counts, the
-FINAL_OUTPUT-anchored parser, lean multiturn history turns, the equal-token-cap
-guard (`allow_unequal_max_tokens` opt-out), and BATCH_CAP required-no-default.
-
----
-
-## 1. New context mode: `summary_last3` (text_summary + rolling 3 images)
-
-**What:** one condition combining the two context mechanisms that each helped
-different models: the cumulative `text_summary` sentence ("You picked up the
-yellow key, then opened the yellow door, thenβ¦") plus the last-3
-decision-frame images (`last3`'s visual half). Today `context_window` is a
-single enum β the two are mutually exclusive.
-
-**Why:** `ctx_text_summary` beat `ctx_current` for Claude/Kimi (50 vs 47%) but
-starved image-reliant behavior; `last3` carries recency but forgets mechanism
-history past 3 steps. The combination tests whether "long-horizon events as
-text + short-horizon dynamics as pixels" is additive.
-
-**Design:** add a `ContextWindow` value `"summary_last3"` that composes the two
-existing builders rather than introducing a new pathway:
-
-- `history_text(...)` returns `text_summary_history(...)` for both
- `"text_summary"` and `"summary_last3"`.
-- `history_content_blocks(...)` / `recent_history_steps(...)` return the last-3
- image blocks for both `"last3"` and `"summary_last3"`.
-
-That is deliberately it β both builders are already pure functions of the
-transcript, so composition is a membership test on the enum, no new state.
-
-**Code changes:**
-
-| file | change |
-|---|---|
-| `interface/observation.py` | `ContextWindow` literal + the two membership tests (`recent_history_steps`: `context_window in ("last3", "summary_last3")`; `history_text`: summary branch matches both) |
-| `interface/config.py` | accept the new value in `ExperimentConfig.context_window` validation (if enumerated) |
-| `gridworld/fixtures/run_config.conditional_context_window_*.json` | add the cell to the Context-window condition set |
-| `tests/` | unit: a transcript with a pickup + 5 moves yields BOTH the summary block and exactly 3 image blocks; e2e (pattern of `tests/test_history_dedup.py`): stateless episode carries both sections, rolling episode carries neither (lean-turn rule) |
-| `analysis/data.py` | config-name mapping for the new cell |
-
-**Interaction rule (already enforced):** with `chat_history != stateless` the
-embedded history sections are disabled (`with_context_history=False` in
-`interface/runner.py`) β `summary_last3` composes with multiturn chat the same
-way `last3` does: the chat carries it.
-
-**Landed alongside (2026-07-10, `fix/run-bugfixes`):** the summary itself is
-now additive β mechanism events *plus* the movement trail since the last
-event β instead of events-XOR-waypoints. The old form carried zero spatial
-information from the first pickup onward (29/45 sweep episodes), which is the
-likely driver of `ctx_text_summary`'s weak showing; an audit found the
-generation itself bug-free (4054/4054 sent summaries regenerate identically;
-0 phantom/missed events). β οΈ Future `text_summary` cells are therefore not
-directly comparable to the sweep's β rank them within the next run.
-
-**Cost note:** ~3 extra images per query on top of `text_summary`'s flat text;
-expect `ctx_last3`-like token profiles (~146-159k median/episode), not
-`obs_image_only`'s 195k.
-
----
-
-## 2. New condition: full context at every step
-
-**What:** every query carries the complete episode so far (all observations /
-actions / feedback), not a 3-step window.
-
-**Two possible constructions β recommend (a):**
-
-- **(a) `chat_history: "full"` (multiturn, no trim) β already implemented.**
- The runner supports `rolling` (trimmed to `chat_turns_max`) and `full`
- (untrimmed); `hist_multiturn` ran `rolling`+3. A "full context" cell is a
- **run-config change, zero code**: `chat_history: "full"`,
- `context_window: "current"`. Provider prompt caching makes append-only
- multiturn the cheap construction (each query re-reads the prefix from
- cache), and the lean-turn rule keeps turns non-duplicative.
-- **(b) `context_window: "all"` (stateless, in-prompt replay).** New enum value
- where `recent_history_steps` returns `history_steps(transcript)` unsliced.
- Costs O(nΒ²) tokens over an episode with NO cache reuse (the prompt is
- rebuilt each step), and re-renders every historical frame for image modes.
- Only worth building if the experiment explicitly wants "full context without
- chat structure" as its own axis (i.e. to separate "information" from
- "conversation shape").
-
-**Caps interaction:** a 90-step episode Γ step-by-step querying means the last
-queries carry ~90 turns. With images this can exceed `max_model_len` for local
-Qwen (16384) long before the step cap β (a) needs either `text_only`, image
-stripping from old turns (keep the text label, drop the pixels past N turns β
-small change in `interface/runner.py` before append), or a documented
-Qwen exclusion. Flag this in the run config description rather than silently
-truncating.
-
-**Code changes (a):** new fixture run_config cell + analysis config-name only.
-**Code changes (b):** `interface/observation.py` (`"all"` in `ContextWindow` +
-unsliced branch), config validation, fixture, tests mirroring the last3 ones.
-
----
-
-## 3. Step-cap redesign: from global 3Γ to a progress watchdog
-
-**Today:** `_runtime_capped_spec` (`scripts/run_pipeline.py:341`) clamps
-`max_steps` to `3 Γ canonical optimal`. Episodes that fail overwhelmingly
-grind to exactly this cap (81-100% of failures by model), and in failed
-episodes ~46% of output tokens are spent thrashing after the last new-cell
-visit (~7.7M tokens across the sweep).
-
-**The user-floated options and their problems:**
-
-1. **"20 steps without stepping on a new tile."** If "new" means
- never-visited-before, mazes that require backtracking (key β return through
- the same corridor β door) impose a design constraint we don't want: a long
- legal backtrack reads as zero progress. FINDINGS supports the concern β
- a *no-new-cell* watchdog "kills key-backtrackers".
-2. **"BFS solution as a list; 20 steps that neither touch a new tile nor
- advance the BFS state."** Problems: (i) the BFS path is *one* optimal
- route; `multi_path` and any alternate-route solve legitimately leaves the
- list and would never "advance" it; (ii) after the resolved-goal fix there
- is still no guarantee the model's strategy tracks BFS order (subgoal mode
- demonstrably re-plans); (iii) it couples the runtime to a solver artifact,
- which we just finished decoupling for correctness reasons.
-
-**Recommendation: progress = novel *runtime state*, not novel tile.**
-Define a step as progress iff it produces a never-seen episode signature:
-
-```
-signature = (agent_pos, frozenset(inventory), frozenset(open_doors),
- frozenset(active_switches), frozenset(open_gates))
-```
-
-- Loop-backs are handled naturally: re-walking a corridor after picking up
- the key is a **new** signature for every cell (inventory changed) β one
- free traversal per mechanism state change, which is exactly the legal
- backtrack budget a keyed maze needs.
-- Facing is deliberately excluded so spin-in-place doesn't count as progress.
-- Wall-bangs, toggle-jams, and oscillation (the three failure clusters:
- wall-banger 68, wanderer 116, toggle-jammer 8) all stop producing novel
- signatures within a handful of steps.
-
-**Watchdog rule:** end the episode with `end_reason="stalled"` after
-`K = 20` consecutive steps with no novel signature. Keep the global cap as a
-backstop at **3Γ** β do NOT tighten it to 2Γ: 27/200 sweep successes (13.5%)
-land between 2Γ and 3Γ, and the pain is concentrated on Kimi (24% of its
-wins). The empirical trade at K=20 (measured on the frozen-in-place variant,
-the closest proxy): ~23% of failed-episode output tokens recovered for a ~2%
-success loss.
-
-**Comparability warning (why this is NOT a drop-in change):** any watchdog
-changes the success/steps distribution vs the completed sweep. Ship it as a
-new config knob defaulting OFF; enable per-run-config. Per
-`per-tile-step-cap-next-iteration` this belongs to the next iteration, not a
-patch of the current one.
-
-**Code changes:**
-
-| file | change |
-|---|---|
-| `interface/config.py` | `progress_stall_k: int \| None = None` (None = off) |
-| `interface/runner.py` | track `seen_signatures: set` + `stall_count` in the step loop (state is already snapshotted per step); `break` with `end_reason="stalled"` |
-| `gridworld/backends/base.py` | nothing β `GridState` already exposes position/inventory/doors/switches/gates |
-| `scorer` / `episode_metrics` | count `stalled` as a failure end_reason (alongside `truncated`/`exhausted`) |
-| `analysis/data.py` | `end_reason` vocabulary + `is_clean` unaffected (stalled is a legitimate outcome, not a bug) |
-| `tests/` | scripted-agent e2e (pattern of `tests/test_cardinal_runner.py`): oscillating agent stalls at exactly K; key-backtrack agent does NOT stall while re-walking a corridor post-pickup; K=None keeps today's behavior byte-identical |
-
-**Rejected variant worth recording:** per-tile budget (`3-5Γ BFS` *per tile*,
-from the earlier brainstorm). It punishes revisit-heavy but progressing
-strategies (wanderers that eventually solve β Kimi's signature win mode) and
-needs per-tile bookkeeping the signature set gives us for free.
-
----
-
-## Follow-ups that fall out of the bug fixes (not designs, just do next)
-
-1. **ogbench submodule data fix:** `D3/10x10_dense_deadend_ky_dy_1.json` and
- `S4/10x10_dense_1.json` have `maze.goal β goal.target`; this repo now
- fail-closes on them at validation. Fix upstream (set `maze.goal :=
- goal.target`, the as-run value) and bump the submodule.
-2. **baseline_thinking re-run** with one equal cap β₯16384 for all three models
- (the guard now forces the choice to be explicit).
-3. **d3 difficulty artifacts:** stored `optimal_steps=31` / `max_steps=93` for
- d3 were computed against the wrong goal (true optimum 23 β cap would be
- 69). Analysis already uses stored eval-time values consistently; regenerate
- canonical paths before any re-run of that maze.
diff --git a/docs/future_directions.md b/docs/future_directions.md
deleted file mode 100644
index 2d67a7f..0000000
--- a/docs/future_directions.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# Future Directions
-
-Deferred work intentionally kept out of the current scope. Each item records the
-"why now" trigger so we can pick it up without re-deriving context.
-
-## Inference engine: offline vLLM first, server later
-
-The Qwen runner currently uses in-process HuggingFace `model.generate()`
-(`interface/agents/qwen35_vl.py`). Single-stream HF generate on a 27B dense
-hybrid (Gated DeltaNet + gated attention) will likely land **below** the
-~100 tok/s A100 target even with `flash-attn` + `flash-linear-attention` +
-`causal-conv1d` and bf16. `deploy/smoke_qwen.py` measures and reports the actual
-rate so this is visible rather than assumed.
-
-The in-process offline vLLM agent (`interface/agents/qwen_vllm.py`) now runs
-**`Qwen/Qwen3.6-27B` (FP16) on A100-80GB** β we moved off the FP8 checkpoint (see
-the decision record below). This keeps the pipeline contract simple for the
-current target of **one Qwen worker per VM**: the worker process owns one vLLM
-engine and no localhost server is required.
-
-If we later need multiple local worker processes per GPU, or want external
-clients to share one hot model, switch the same provider to **vLLM/SGLang
-serving** via an OpenAI-compatible localhost API. A local server gives
-continuous batching, prefix caching, paged KV, and (SGLang) multi-token
-prediction (~3-5x decode), but it adds process supervision and health checks.
-
-KTransformers remains a fallback to evaluate if vLLM/SGLang cannot hit the
-required throughput or memory envelope on the A100 40GB worker shape.
-
-## Decision (2026-07): moved off Qwen3.6-27B-FP8 β FP16 on A100-80GB
-
-**We moved the Qwen runner off the `Qwen/Qwen3.6-27B-FP8` checkpoint to FP16/BF16
-on the A100-80GB (`a2-ultragpu-1g`, the `qwen-fp16-80` image).** The 2026-06-30
-distributed smokes ran FP8 through the offline vLLM agent on `a2-highgpu-1g`
-(A100 40GB) and showed that **vLLM alone does not make FP8-on-A100-40GB fast
-enough**. Both failure modes trace back to the A100 lacking native FP8 compute:
-
-- **`enforce_eager: true` (no CUDA graphs):** loads (~14 min: 66 shards + engine
- init) and runs, but decode is slow. In smoke `qwen-smoke-eager-20260630-172236`
- the navigation maze (`v01_empty_room`) verified in ~18 min (~32 agent steps),
- but the harder mazes (`v04` key-door, `v05` switch-gate) ground at **~4-5
- min/step** β only ~25-27 steps in ~2 h, i.e. ~6-7 h for a single unit. FP8
- weights run through non-native Marlin weight-only kernels on A100 ("Your GPU
- does not have native support for FP8 computation ... may degrade performance"),
- which is the throughput ceiling.
-- **`enforce_eager: false` (CUDA graphs β the speed lever):** OOMs at startup in
- vLLM's cudagraph memory profiling (`profile_cudagraph_memory ->
- _init_minimal_kv_cache_for_profiling -> torch.zeros`, +1.53 GiB) because at
- `gpu_memory_utilization=0.88` only ~498 MiB is free on the 40GB card. CUDA-graph
- capture needs headroom the 40GB shape does not have for a 27B model.
-
-So FP8 bought memory but not speed on A100-40GB, and the CUDA-graph speed path
-did not fit. The throughput path we adopted is **FP16/BF16 on A100-80GB
-(`a2-ultragpu-1g`)**: native A100 compute plus headroom for CUDA graphs and a
-large KV cache β shipped as the `qwen-fp16-80` image running `Qwen/Qwen3.6-27B`
-with `enforce_eager: false`. (INT8 W8A8 on A100-40GB β A100 has native INT8 β
-remains a cheaper alternative worth a test, per the section below.)
-
-This is purely a model-throughput finding. The distributed pipeline itself β
-coordinator work-stealing / queue hand-off to the next maze, and the
-progress-aware stall detector β was validated end-to-end in the same smoke and is
-not blocked by this (the smoke's actual goal: the freed worker correctly stole
-the 3rd unit, and the monitor never false-stalled while `progress_total` climbed
-for ~2 h with the verified count frozen at 1).
-
-## Qwen INT8 and A100 80GB rental checkpoint
-
-As of 2026-06-29, the `a100-qwen-vllm` boot disk is 150 GB (`/dev/root`: 145G
-size, 70G used, 75G available). The existing Hugging Face cache is 29G, pip
-cache is 6.4G, and the checked-out repo plus `.venv-qwen-vllm` is about 8.5G.
-The candidate `Avesed/Qwen3.6-27B-INT8-W8A8` checkpoint is about 31.2 GB of
-safetensors, close to the current `Qwen/Qwen3.6-27B-FP8` footprint of about
-30.9 GB. It should fit on the image alongside the FP8 checkpoint without
-deleting the existing model cache, leaving roughly 40 GB free after download.
-If a future download needs extra temporary headroom, the pip cache is a safe
-first cleanup target; deleting the FP8 checkpoint should not be necessary.
-
-Current recommendation: test INT8 W8A8 on the existing A100 40GB worker before
-renting an 80GB A100. A100 has native INT8 Tensor Cores, while the current FP8
-checkpoint runs through non-native FP8 weight-only kernels on A100, so INT8 may
-be competitive without changing GPU shape.
-
-If we later need to test full BF16/FP16, or want more KV-cache margin, use
-`a2-ultragpu-1g`: 1 NVIDIA A100 80GB, 12 vCPU, 170 GB RAM, and 1 bundled local
-SSD. GCP zones found for this shape: `us-central1-a`, `us-central1-c`,
-`us-east4-c`, `us-east5-a`, `us-east5-b`, `europe-west4-a`, and
-`asia-southeast1-c`.
-
-Pricing basis: Cloud Billing Catalog API for Compute Engine SKUs queried on
-2026-06-29. Source docs: [Cloud Billing `services.skus.list`][billing-skus] and
-[Compute Engine accelerator-optimized machines][a2-machines]. Hourly total below
-is GPU + 12 A2 core-hours + 170 GiB A2 RAM-hours. This excludes boot persistent
-disk, snapshots/images, network egress, taxes, and any committed-use/reservation
-effects.
-
-| Region | Example zone(s) | On-demand USD/h | Spot/preemptible USD/h |
-| --- | --- | ---: | ---: |
-| `us-central1` | `us-central1-a`, `us-central1-c` | 5.028 | 2.738 |
-| `us-east5` | `us-east5-a`, `us-east5-b` | 5.524 | 1.656 |
-| `europe-west4` | `europe-west4-a` | 5.536 | 2.601 |
-| `us-east4` | `us-east4-c` | 5.663 | 2.272 |
-| `asia-southeast1` | `asia-southeast1-c` | 6.202 | 3.130 |
-
-For comparison, the current Tokyo `a2-highgpu-1g` A100 40GB shape is about
-4.050 USD/h on-demand and 2.228 USD/h spot/preemptible using the same SKU
-calculation.
-
-[billing-skus]: https://docs.cloud.google.com/billing/docs/reference/rest/v1/services.skus/list
-[a2-machines]: https://docs.cloud.google.com/compute/docs/accelerator-optimized-machines
-
-## Other deferred items
-
-- **SSH auto-launcher** for the cluster (read `deploy/cluster.example.json` and
- start each node's role over SSH). Today we print the commands instead.
-- **FP8 / quantized serving** as a throughput/VRAM lever (explicitly avoided now).
-- **Multi-GPU tensor parallelism** for larger checkpoints.
-- **systemd units** generated from the cluster inventory for unattended runners.
-- **Pre-release cleanup action** to keep `docs/superpowers/**` and generated
- artifacts out of the release repo on merge (tracked separately).
diff --git a/docs/gridworld_backends.md b/docs/gridworld_backends.md
index 34d33c0..58a02d3 100644
--- a/docs/gridworld_backends.md
+++ b/docs/gridworld_backends.md
@@ -563,8 +563,6 @@ gridworld/
β βββ multigrid_backend.py # MultiGrid adapter
βββ runner/
β βββ grid_runner.py # Episode execution
-βββ envs/
-β βββ tier_envs.py # Pre-configured environments
βββ tasks/ # Sample task JSON files
βββ tier1/
βββ tier2/
diff --git a/docs/immediate_system_design_tests_1_3.md b/docs/immediate_system_design_tests_1_3.md
deleted file mode 100644
index 74b36ce..0000000
--- a/docs/immediate_system_design_tests_1_3.md
+++ /dev/null
@@ -1,388 +0,0 @@
-# MultiNet v2.0 Immediate System Design for Tests 1-3
-
-| Field | Value |
-|---|---|
-| Status | Draft for merge planning |
-| Date | 2026-05-17 |
-| Branch basis | `origin/reporting-and-examples` |
-| Scope | Minimal system needed to run Experimental Evaluation Draft tests 1, 2, and 3 |
-| Companion target design | `docs/system_design.md` (read first for canonical architecture) |
-
-This document narrows the canonical target design to the system needed for the
-current merge stack and the first scoring experiments. The canonical document
-remains the long-term architecture; this is a merge and execution plan for the
-immediate slice.
-
-The source experiment plan is
-`/home/sean/AI_training/Manifold/MultiNet/docs/plans/EXPERIMENTAL_EVALUATION_DRAFT.md`.
-Tests 1-3 are:
-
-1. Scoring calibration over the existing task set.
-2. Complexity-vs-distance validation with short mechanistic and long open paths.
-3. Mechanism-ordering consistency checks over matched task pairs.
-
-## 1. Executive Summary
-
-The tests 1-3 pipeline is roughly 80-90% present across merged foundation work
-and open PRs. The remaining work is integration shape, not research code:
-emitting standard artifacts, splitting the curated fixture generator, cleaning
-the NLP backend and baseline-agent branches, and adding thin aggregation
-reports.
-
-**Status at a glance:**
-
-- Foundation (task schema, validator, BFS, static scoring): merged to `main`.
-- Runtime backend, model adapters, reporting/docs scaffolding: in PRs #3, #4,
- #5 β awaiting land.
-- Baselines, NLP backend, maze generator: in PRs #10, #8, #1 β need cleanup
- before they fit the standard.
-
-**Remaining effort:** <1 week of scoring/integration work, plus 2-3 days per
-API endpoint across five adapters β about 2-3 weeks of active engineering once
-the merges land.
-
-**Headline:** once the next push of merges (#3, #4, #5) lands, we'll be ready
-to start the final buildout for tests 1-3.
-
-**Decisions needing leadership input** (see Β§7):
-
-1. Whether `greedy_solvability` is a separate canonical-agent feature or part
- of the calibration vector.
-2. Whether PR #10's generated validation result JSON files are committed.
-3. The implementation shape of the NLP backend.
-4. Whether OGBench is part of the current merge basis.
-
-**Merge order:** #3 β #4 β #5, then revise #8, then rebase #10. Details in Β§6.
-
-## 2. Goal and Non-goals
-
-### 2.1 Immediate Goal
-
-The immediate system must answer one question:
-
-> Can we produce reliable task, solver, run, and report artifacts for the first
-> three scoring experiments without merging the full target DAG?
-
-The merge slice therefore needs:
-
-- A canonical `TaskSpecification` for every fixture.
-- A BFS validator/solver that emits correct optimal plans.
-- Static scoring rows for the draft's 12 dimensions.
-- Optional canonical-agent features such as greedy solvability, kept separate
- until calibration decides whether they belong in the point vector.
-- A MiniGrid runtime whose termination/reward semantics match the validator.
-- Baseline/model episode rows with success, steps, optimality, path choice,
- mechanism interaction order, and failure point.
-- JSON/CSV summaries simple enough to inspect and stable enough to feed
- notebooks or later report scripts.
-
-### 2.2 Explicit Non-goals
-
-These remain part of the canonical target design but should not block the
-current merge slice:
-
-- A full content-hash DAG runner.
-- Production procedural generation for live benchmark tasks.
-- MultiGrid parity across exotic tilings.
-- Public leaderboard hosting or dashboard UI.
-- Final runtime composite scoring.
-- Final static point weights and tier thresholds.
-- Cross-domain physics/GUI revival.
-
-The NLP/text backend is a desired backend axis, but the current open PR needs
-revision before it should join this merge basis.
-
-## 3. Minimal Pipeline
-
-The canonical design has five DAG stages. For tests 1-3, use the same concepts
-but implement them as simple, inspectable artifact steps. Full artifact field
-schemas are in Appendix A.
-
-### 3.1 Fixture Selection and Generation
-
-Inputs:
-
-- Existing task set for test 1.
-- Curated shortcut-maze variants for test 2.
-- Curated mechanism-ordering pairs for test 3.
-
-Outputs:
-
-- `task.json` files in the existing `TaskSpecification` schema.
-- A manifest with `task_id`, `experiment`, `condition`, `variant`, `source`,
- `expected_mechanisms`, and `notes`.
-
-Required behavior:
-
-- Every fixture must pass `TaskSpecification.validate()`.
-- Fixture IDs encode the experiment and variant, for example
- `T2_short_mech_open`, `T2_long_open_only`, `T3_A1_key_switch`.
-- Test 2 must make path choice measurable when both routes are open.
-- Test 3 must hold path length and layout topology constant within each pair.
-
-### 3.2 Static Solve and Score
-
-Inputs: `task.json`.
-
-Outputs: `canonical_paths.json` (BFS trace) and `scored_static.json` (12
-calibration dimensions, beatable flag, validation messages, optional
-canonical-agent features). See Appendix A for field shapes.
-
-Required behavior:
-
-- The BFS path must be replayable in the runtime backend.
-- Switch activation semantics must match between validator and runtime. The
- validator activates switches from the agent's current cell, so the runtime
- must check the agent cell for switches.
-- Non-`reach_position` goals must terminate in runtime when complete and
- return a positive reward so downstream success detection works.
-
-The draft uses 12 scoring dimensions. The canonical target design
-adds `greedy_solvability` as a 13th dimension. For the immediate experiments,
-keep the 12 draft dimensions as the calibration vector and record greedy/random
-baseline outcomes as separate canonical-agent features. After test 1, decide
-whether `greedy_solvability` becomes a calibrated dimension.
-
-### 3.3 Runtime Runs
-
-Inputs: `task.json`, `canonical_paths.json`, backend choice, adapter or
-baseline agent, seed.
-
-Default immediate backend: `MiniGridBackend`.
-
-Default immediate agents/adapters:
-
-- BFS canonical replay.
-- Greedy baseline, once PR #10 is cleaned up.
-- Random baseline, once PR #10 is cleaned up.
-- Ollama/LM Studio VLM adapters from PR #4 for model runs.
-
-Outputs: `episode_runs.jsonl`, one row per `(task, backend, agent_or_model,
-seed)`. See Appendix A for required row fields.
-
-`path_choice` is required for test 2. `mechanism_interaction_order` and
-`failure_point` are required for test 3.
-
-### 3.4 Runtime Metrics and Reports
-
-Inputs: `scored_static.json`, `canonical_paths.json`, `episode_runs.jsonl`.
-
-Outputs:
-
-- `scoring_calibration_summary.json` for test 1.
-- `complexity_distance_summary.json` for test 2.
-- `mechanism_ordering_pairs.json` for test 3.
-- Optional CSV mirrors for notebooks.
-
-Required report fields:
-
-- Success rate by task, condition, and agent/model.
-- Mean and median optimality ratio.
-- Path choice counts for test 2.
-- Paired success deltas for test 3.
-- Scoring dimension correlation matrix for test 1.
-- Draft 12-dimension point-weight candidates and tier-boundary candidates.
-
-These reports do not claim a final MultiNet score. They are calibration
-evidence used to update the scoring system.
-
-## 4. Readiness Assessment
-
-The tests 1-3 pipeline is roughly 80-90% present in tree and open PRs.
-
-**Binary readiness:** not ready. The pipeline cannot run end-to-end today
-because the runtime, adapter, and reporting layers (PRs #3, #4, #5) have not
-landed.
-
-**Effort to ready, post-merge:** <1 week of scoring/integration work, plus
-2-3 days per API endpoint across five adapters β about 2-3 weeks of active
-engineering once the basis merges land.
-
-**Blocker:** review and merge cadence on the basis stack (#3 β #4 β #5). Once
-those merge, the remaining work is integration shape rather than new research.
-
-**What is already close:**
-
-- Task schema, validation, BFS solving, and static scoring are largely in
- `main` via the merged foundation work.
-- MiniGrid runtime and backend support are largely in #3.
-- Model adapters and run harness concepts are largely in #4.
-- Documentation, examples, and reporting scaffolding are largely in #5.
-- NLP/text backend and maze-generation ideas exist in #8/#1, though they need
- reshaping before joining the standard pipeline.
-- Baseline-agent work exists in #10 and should become the canonical-agent
- suite extension after cleanup.
-
-**Remaining 10-20% (integration shape, not missing research code):**
-
-- Emit standard artifacts or rows for `canonical_paths`, `scored_static`, and
- `episode_runs`.
-- Build or split the curated fixture generator for tests 2-3.
-- Clean and rebase #8 so text/NLP uses the same task/backend/adapter contracts.
-- Clean and rebase #10 so BFS/greedy/random baselines are code, not generated
- result dumps.
-- Add thin aggregation reports for the three experiment deliverables.
-
-**Scope assumption:** the immediate scope stays MiniGrid-first and does not
-require full MultiGrid parity, public dashboards, final runtime composite
-scoring, or the full DAG runner before tests 1-3.
-
-Per-test readiness detail is in Appendix B.
-
-## 5. PR Status β Consolidated
-
-GitHub PR state is the source of truth for ownership and assignment. The
-tables below consolidate component role, current GitHub state, landing effort,
-and must-fix items.
-
-### 5.1 Basis PRs (critical path for tests 1-3)
-
-| PR | Branch | State | Role | Effort | Must-fix |
-|---|---|---|---|---|---|
-| #3 | `maze-realization-and-backends` | `CHANGES_REQUESTED` | MiniGrid runtime, MultiGrid code, backend abstractions, task parser | Medium | Confirm MiniGrid switch/goal-completion fixes in `2b82e81`; resolve duplicate-files/scope concern; clarify MultiGrid is not critical path for tests 1-3; rerun focused backend/runtime tests. |
-| #4 | `model-scaffolding-and-runs` | `CHANGES_REQUESTED` | Model adapters, evaluation harness, runner scripts | Medium | Rebase onto current #3 without losing runtime fixes; keep release-1 adapter exposure consistent; align run output with `episode_runs.jsonl` fields. |
-| #5 | `reporting-and-examples` | `REVIEW_REQUIRED` | Canonical docs, examples, render/reporting scripts | Small-to-medium | Rebase onto #4; add this immediate design; scrub removed release-1 adapter docs; preserve canonical target design; avoid making scripts/docs the source of truth for schemas. |
-
-### 5.2 Related PRs
-
-| PR | Branch | State | Role | Effort | Must-fix |
-|---|---|---|---|---|---|
-| #1 | `maze_gen_and_interface` | `REVIEW_REQUIRED` | Historical large drop: generator, NLU code, 200 generated mazes, PNGs, smoke outputs, terminal logs | Do not land as-is | Extract generator ideas into a small standards-based PR that emits `TaskSpecification` fixtures/manifests for tests 2-3. |
-| #6 | `ogbench` | `CHANGES_REQUESTED` | Older OGBench submodule attempt | Replace/close | Prefer #11 or a successor with a clear submodule update policy. |
-| #8 | `pr1/nlu-interfacing-minimal-mazegen` | `CHANGES_REQUESTED` | NLP/text runner plus maze-generation ideas; parallel to the standard system (custom env, custom maze dataclasses, no `TaskSpecification`, differing switch semantics) | Large | Rebase after #5; split generator from NLP backend; use `TaskSpecification`; implement as `TextBackend` or adapter-compatible runner; remove generated PNG/log artifacts from source. |
-| #9 | `pr/benchmark-solver-artifacts` | Clean against #8 | Solver PNG/CSV artifacts for #8 review | Do not land independently | Wait for #8 rewrite; move artifacts to ignored/generated outputs unless explicitly promoted to fixtures. |
-| #10 | `baseline-agents` | `DIRTY`, approved | BFS/greedy/random baseline code; dirty against #5 (removes reporting docs, resurrects a removed release-1 adapter, commits large generated result JSON; forward-cell switch semantics conflict with #3) | Medium-to-large | Clean rebase after #8/#5; keep only baseline code/tests; remove generated result dumps; update switch semantics to match validator/runtime; avoid resurrecting removed adapter files. |
-| #11 | `codex/add-ogbench-submodule` | `REVIEW_REQUIRED` | Cleaner OGBench submodule PR (`.gitmodules` plus `ogbench` only) | Small | Define ownership/update policy before merge; confirm tests do not require recursive submodule checkout surprises. |
-| #12 | `prompts` | `REVIEW_REQUIRED` | Prompt condition definitions for later protocol experiments | Small-to-medium | Remove generated/editor files (`__pycache__`, `.vscode`) and unrelated submodule changes; rebase after the core stack; clarify which prompt conditions are required before tests 1-3. |
-
-## 6. Merge Order
-
-Recommended order for the immediate merge slice:
-
-1. Land #3 first as the runtime/backend layer on top of the merged task schema,
- validator, and scorer foundation. This is where runtime/validator parity and
- duplicate-file scope are settled.
-2. Land #4 second as the model-adapter and run-harness layer. It should rebase
- onto #3 and align run outputs with the immediate row schema.
-3. Land #5 third as the reporting/docs/examples layer. It should preserve the
- canonical design while adding this immediate merge-scope design.
-4. Revise and land #8 fourth as the NLP/text backend and minimal maze-generation
- follow-up. It should rebase onto #5, move into the backend/adapter standards,
- use `TaskSpecification`, and stop committing build/render artifacts.
-5. Rebase and land #10 fifth as the baseline-agent suite. The baseline code is
- needed before running test 1 at scale, but generated validation result
- artifacts should be separated from the code review unless the team decides
- they are committed fixtures.
-6. Split or revise any remaining maze-generator work after the core stack. The
- generator should produce canonical `TaskSpecification` fixtures and manifests
- for tests 2-3 without pulling in the full historical #1 drop.
-7. Decide between #6 and #11 for OGBench handling. Prefer one maintained
- submodule PR, not both.
-8. Clean #12 and merge prompts when prompt sensitivity/protocol experiments
- become active.
-
-## 7. Open Decisions
-
-1. Should `greedy_solvability` remain a separate canonical-agent feature during
- test 1, or be promoted immediately into the calibration vector?
-2. Should PR #10's generated validation result JSON files be committed, or
- regenerated as local artifacts during calibration runs?
-3. Should the NLP backend be implemented as a `TextBackend`, an adapter layer
- around MiniGrid, or a separate smoke-test package that feeds the canonical
- runner?
-4. Do tests 1-3 require any OGBench dependency now, or can OGBench be kept out
- of the current merge basis?
-
-## 8. Mapping to Canonical Design
-
-Traceability against `docs/system_design.md`. Useful for cross-checking
-component intent against the long-term architecture; not status-critical for
-leadership.
-
-| Canonical component | Immediate tests 1-3 version | Current source |
-|---|---|---|
-| Stage 1 Generate | Curated fixtures plus existing task set | Merged foundation + future cleaned generator work |
-| Stage 2 Solve and Score-static | BFS validation, replayable path, 12-dimension score rows | Merged foundation + PR #10 for extra canonical agents |
-| Canonical agent suite | BFS validator now; greedy/random after cleanup | Merged foundation, PR #10 |
-| Stage 3 Render-and-Run | MiniGrid runtime plus model/baseline runners | PR #3, PR #4, PR #10 |
-| Stage 4 Score-runtime | Per-run metric rows, no final composite yet | PR #4 plus small reporting code |
-| Stage 5 Aggregate | JSON/CSV summaries for tests 1-3 | PR #5 plus immediate doc work |
-| Backend axis | MiniGrid only for this slice | PR #3 |
-| MultiGrid backend | Present but not critical path | PR #3 |
-| Text/NLP backend | Desired follow-up, needs revision | PR #8 |
-| Prompt condition system | Useful later; not blocking tests 1-3 | PR #12 |
-| OGBench submodule | External dataset/input dependency; needs ownership decision | PR #11 or successor |
-
-## Appendix A. Artifact Field Reference
-
-Full field schemas for the per-stage artifacts referenced in Β§3.
-
-### A.1 `canonical_paths.json` (Stage 3.2)
-
-- `bfs.success`
-- `bfs.actions`
-- `bfs.positions`
-- `bfs.optimal_steps`
-- `bfs.states_explored`
-
-### A.2 `scored_static.json` (Stage 3.2)
-
-- `is_beatable`
-- `dimensions_12`
-- `static_score_unweighted`
-- Validation messages and structural warnings
-- Optional `canonical_agent_features`
-
-### A.3 `episode_runs.jsonl` row fields (Stage 3.3)
-
-- `task_id`
-- `experiment`
-- `condition`
-- `backend`
-- `agent_or_model`
-- `seed`
-- `success`
-- `terminated`
-- `truncated`
-- `reward`
-- `steps`
-- `optimal_steps`
-- `optimality_ratio`
-- `path_choice`
-- `mechanism_interaction_order`
-- `failure_point`
-- `tokens`
-- `raw_output_ref`
-
-`path_choice` is required for test 2. `mechanism_interaction_order` and
-`failure_point` are required for test 3.
-
-## Appendix B. Per-Test Readiness Detail
-
-The binary readiness call in Β§4 hides per-test variation. For engineers
-planning execution:
-
-**Test 1 β Scoring calibration over existing task set**
-
-- Closest to ready. The task set exists; no new fixture generation required.
-- Blocked on: #3 (runtime), #4 (adapters), #5 (reporting), #10 (greedy/random
- baselines for calibration runs).
-- Remaining engineering after merges: thin calibration summary report and
- correlation-matrix output.
-
-**Test 2 β Complexity-vs-distance validation**
-
-- Requires curated shortcut-maze variants where both routes are open and path
- choice is measurable.
-- Blocked on: basis merges plus a small fixture generator (split out of #1/#8).
-- Remaining engineering: fixture authoring/generation, `path_choice` recording
- in runs, complexity/distance summary report.
-
-**Test 3 β Mechanism-ordering consistency**
-
-- Requires curated mechanism-ordering pairs with path length and topology held
- constant within each pair.
-- Blocked on: basis merges plus the same fixture generator work as test 2.
-- Remaining engineering: paired-pair fixture authoring,
- `mechanism_interaction_order` and `failure_point` recording, paired-delta
- report.
diff --git a/docs/implementation_summary.md b/docs/implementation_summary.md
deleted file mode 100644
index 35fdb73..0000000
--- a/docs/implementation_summary.md
+++ /dev/null
@@ -1,192 +0,0 @@
-# Multinet-v2.0 Implementation Summary
-
-## Completion Status: Current
-
-The current branch contains the gridworld backend stack, the custom multigrid
-backend, model adapters, evaluation harnesses, validation task specs, and
-documentation. Test collection currently finds 261 tests.
-
-## What Was Implemented
-
-### 1. Core Architecture
-- β
`Cell` dataclass with adjacency information
-- β
`Tiling` abstract base class
-- β
`TilingGraph` for representing world topology
-- β
Canonical coordinate system ([0,1] normalization)
-
-### 2. Tiling Implementations
-
-#### Square Tiling (`multigrid/tilings/square.py`)
-- 4 directions: north, east, south, west
-- Manhattan distance metric
-- Row/column coordinate system
-- Covered by tiling tests
-
-#### Hexagonal Tiling (`multigrid/tilings/hex.py`)
-- 6 directions: N, NE, SE, S, SW, NW
-- Axial coordinate system (Red Blob Games implementation)
-- Hex distance metric
-- Pointy-top orientation
-- Covered by tiling tests
-
-#### Triangular Tiling (`multigrid/tilings/triangle.py`)
-- 3 edges per triangle
-- Alternating up/down triangle orientation
-- BFS-based distance computation
-- Covered by tiling tests
-
-#### Archimedean Tilings
-- `multigrid/tilings/archimedean_3464.py`
-- `multigrid/tilings/archimedean_488.py`
-- Registered as `3464` and `488` in `multigrid.env.TilingRegistry`
-
-### 3. Object System
-- β
`WorldObj` abstract base class
-- β
`ObjectRegistry` for extensible types
-- β
Built-in objects:
- - `MovableObj` - can be picked up and pushed
- - `Wall` - blocks movement
- - `Zone` - overlappable goal regions
- - `Key`, `Door`, `Switch`, `Gate`, `Hazard`, `Teleporter`
-- β
Physics properties stub for future expansion
-
-### 4. Agent & Actions
-- β
`AgentState` dataclass (position, facing, holding)
-- β
9 discrete actions:
- - FORWARD - move in facing direction
- - BACKWARD - move opposite to facing
- - TURN_LEFT - rotate counter-clockwise
- - TURN_RIGHT - rotate clockwise
- - PICKUP - pick up object (from current or adjacent cell)
- - DROP - drop held object
- - TOGGLE - interact with doors and switches
- - PUSH - push object in facing direction
- - WAIT - no-op
-- β
Invalid action detection and handling
-
-### 5. Environment
-- β
`MultiGridEnv` class (Gymnasium-compatible)
-- β
Task specification from JSON
-- β
`reset()` and `step()` methods
-- β
State export via `get_state_dict()`
-- β
Multiple tiling support via `TilingRegistry`
-
-### 6. World State
-- β
`WorldState` class managing agents and objects
-- β
`from_task_spec()` constructor
-- β
Collision detection (`can_move_to()`)
-- β
Object queries (`get_object_at()`)
-- β
Goal predicates in `multigrid/goals.py`
-
-### 7. Rendering (Basic Implementation)
-- β
`Renderer` abstract interface
-- β
`MinimalRenderer` with basic drawing
-- β
Visualization script with matplotlib
-- β οΈ Note: Rendering is simplified (sufficient for testing)
-
-### 8. Test Suite
-
-`python -m pytest --collect-only -q` collects 261 tests. Coverage includes:
-
-- core tiling generation, coordinates, distance, and action execution
-- exotic tilings (`3464`, `488`)
-- MiniGrid and MultiGrid backend integration
-- partial observability in both backend families
-- teleporter mechanics
-- task-spec validation and beatability scoring
-- model interface and evaluation harness behavior
-- NL action parsing and cross-domain canonical round trips
-- VLM sanity-check helpers and chat smoke-test parsing
-
-## Test Results
-
-```
-============================= test session starts ==============================
-platform linux -- Python 3.10.14, pytest-8.2.2, pluggy-1.5.0
-collected 261 items
-
-261 tests collected
-```
-
-## Visualizations Generated
-
-The user can render and view grids using:
-
-```bash
-python visualize_grid.py
-```
-
-Generated files:
-- β
`grid_visualization_square.png` - Shows 10Γ10 square grid structure
-- β
`grid_visualization_hex.png` - Shows 10Γ10 hexagonal grid structure
-- β
`grid_visualization_triangle.png` - Shows 10Γ10 triangular grid structure
-- β
`environment_comparison.png` - Side-by-side comparison of the original three tilings with agent and objects
-- `visualize_all_tilings.py` renders square, hex, triangle, 3-4-6-4, and 4-8-8 tilings
-
-## File Structure
-
-```
-.
-βββ multigrid/
-β βββ __init__.py
-β βββ base.py # Tiling abstract base
-β βββ core.py # Cell and TilingGraph
-β βββ agent.py # AgentState and Action enum
-β βββ world.py # WorldState and action execution
-β βββ env.py # MultiGridEnv environment
-β βββ rendering.py # Renderer interface and MinimalRenderer
-β βββ tilings/
-β β βββ __init__.py
-β β βββ square.py
-β β βββ hex.py
-β β βββ triangle.py
-β β βββ archimedean_3464.py
-β β βββ archimedean_488.py
-β βββ objects/
-β βββ __init__.py
-β βββ base.py # WorldObj and ObjectRegistry
-β βββ builtin.py # Built-in object types
-βββ tests/ # Pytest suite for backends, interfaces, tasks, VLM helpers
-βββ gridworld/tasks/ # Tiered task specs
-βββ mazes/validation_10/ # Default validation benchmark specs
-βββ visualize_grid.py # Visualization script
-βββ README.md # Usage documentation
-βββ docs/implementation_summary.md
-
-See `docs/README.md` for the current full file map.
-```
-
-## Code Quality
-
-- **Style**: Follows repository conventions (type hints, docstrings)
-- **Testing**: Current suite is discovered with `python -m pytest --collect-only -q`
-- **Documentation**: Comprehensive docstrings and README
-- **Architecture**: Clean separation of concerns
-- **Extensibility**: Easy to add new tilings and objects
-
-## Known Limitations
-
-1. **MultiGrid maturity**: newer than the MiniGrid backend; add focused regressions for new benchmark mechanics.
-2. **Rendering**: custom renderer is functional but still experimental for publication visuals.
-3. **Backend parity**: the same high-level spec can differ subtly across MiniGrid and MultiGrid because the engines are different.
-
-These limitations are documented and don't affect the core functionality tested in the test suite.
-
-## Next Iteration Priorities
-
-If continuing implementation:
-1. Keep documentation and examples aligned with `gridworld/tasks` and `mazes/validation_10`.
-2. Add focused backend parity tests for any new mechanism or tiling.
-3. Improve publication-quality rendering for exotic tilings.
-4. Extend benchmark reporting around optimality and point scoring.
-
-## Conclusion
-
-**Status**: current tests are collected from `tests/` and `multigrid/test_multigrid.py`; tests are the source of truth for this branch.
-
-**Verification**: User can run:
-- `python -m pytest --collect-only -q` - Confirm test discovery
-- `python -m pytest tests/ -v --ignore=tests/test_performance.py` - Run the main suite without performance tests
-- `python visualize_grid.py` - Generate and view grid visualizations
-
-The implementation successfully provides a tiling-agnostic grid environment framework with square, hexagonal, and triangular tilings, following the design specifications exactly.
diff --git a/docs/qwen-served-vllm-concurrency.md b/docs/qwen-served-vllm-concurrency.md
deleted file mode 100644
index 0bdd728..0000000
--- a/docs/qwen-served-vllm-concurrency.md
+++ /dev/null
@@ -1,75 +0,0 @@
-# Qwen served-vLLM concurrency β change log & pain points
-
-How the Qwen distributed eval went from "can't complete a single multi-batch run" to
-running at ~13Γ via a served-vLLM continuous-batching architecture. Written 2026-07-06.
-
-## Outcome
-
-Qwen (`Qwen/Qwen3.6-27B`, 3Γ A100-80GB) now runs the conditional sweep with each GPU
-worker driving a **persistent `vllm serve`** (OpenAI server, continuous batching) and
-running **16 episodes in parallel**, so the server batches their (expensive multimodal)
-prefills. Validated live: 42 units in flight, servers batching 16/10/15 concurrent
-requests, **1.33 gen-steps/s fleet-wide (13Γ the serial 0.10)**.
-
-**Throughput caveat (important):** aggregate throughput is 13Γ, but a *batch's* wall
-time is bounded by its **longest single episode**, because an episode's steps are
-sequential and each step is ~31 s (batched per-request latency for a multimodal prompt).
-Hard mazes run to 3Γ optimal β `s5_corridor` β 267 steps β 2.3 h as one episode β so each
-batch is ~2.5 h and the 10-batch sweep is ~20β25 h (~$375), NOT the ~5β6 h I first
-(wrongly) estimated. Concurrency cannot shorten a single long episode. (Next-iteration
-fix: per-tile step budget β see the `per-tile-step-cap-next-iteration` memory.)
-
-## The chain of fixes (in order, each caught the next)
-
-| # | commit | bug | fix |
-|---|---|---|---|
-| 1 | `795d0b1` | next-batch teardown left vLLM's separate `EngineCore` process orphaned holding ~70 GiB β new `LLM()` OOMed ("Engine core initialization failed") | `lib/gpu_teardown.sh`: SIGTERM the worker + every GPU compute-app, poll `nvidia-smi` until free, fail-closed; never SIGKILL (that wedges CUDA) |
-| 2 | `fa788fd` | teardown's gpu-branch called `worker_field` before `TOPO_JSON` was exported β silent fall-through to the old broken pkill | move topo derivation above the teardown loop |
-| 3 | `f133658` | `prepare_job` kept a same-job's stale `job_state`, so a prior run's units failed-at-attempt-cap were never retried β coordinator dispatched nothing, workers idled | `_reset_state_for_rerun`: keep only verified/uploaded units, reset the rest to pending on re-prepare |
-| 4 | `c6a8598` | configs ran thinking-ON with `max_tokens=8192` β ~2125 output tok/step (~5 min/step) AND a confound vs the thinking-OFF API baseline | thinking OFF + `max_tokens=4096` for all Qwen batches except `baseline_thinking` |
-| 5 | `a632ef8` | in-process offline `LLM.chat()` is prefill-bound at batch=1 (~30 s/step) and NOT thread-safe β concurrency impossible | served architecture: persistent `vllm serve` per worker + `qwen_vllm_api` agent + `run_worker_loop(concurrency=N)` thread pool; teardown keeps the server (no reload/orphan) |
-| 6 | `c41de78` | served vLLM showed "Running: 16 reqs" but only ONE distinct maze β coordinator `assign` re-returned the worker's single active unit, so 16 threads ran the same episode | `assign` is concurrency-aware (worker sends `worker_concurrency`; may hold that many DISTINCT active units); also parallel `start_worker` (3 servers load at once) + `pgrep vllm serve` guard |
-
-Config: providers `qwen_vllm` β `qwen_vllm_api` (base_url `127.0.0.1:8000/v1`), `max_in_flight`
-32 β 64 (coordinator cap must exceed 3 workers Γ 16). Knob `WORKER_CONCURRENCY` (default 16).
-
-## Pain points / gotchas (what actually cost time)
-
-1. **vLLM v1 runs `EngineCore` as a separate process.** Killing the worker by cmdline
- (`pkill -f 'distributed-role worker'`) never touched it. `vllm==0.19/0.24` v1 engine.
-2. **The 02:22 "Engine core init failed" WAS the OOM** (fix #1), not a config bug β vLLM
- wraps an init-time OOM in that generic message; "root cause above" was in lost stderr.
-3. **Deterministic `job_id`** (hash of run_config+manifest): a reused fleet re-prepares the
- *same* job_id, which is why stale-state preservation (#3) silently stranded every unit.
-4. **Empty `worker.log` was buffering, not silence** β block-buffered stdout on an idle
- process. The real failure reason was on the *coordinator* (`job_state.json.failure_reason`),
- readable by starting only the cheap n2 coord VM.
-5. **`max_in_flight` is a COORDINATOR throttle, not per-worker concurrency.** Bumping 3β32
- did nothing for throughput; the worker loop was serial. This misled the first fix attempt.
-6. **Throughput measured from a 93 s `progress_total` delta was garbage** (long thinking-on
- generations finish in bursts β undersampled β false 15 tok/s). Measure over minutes and
- cross-check against verified-unit rate + the server's own throughput log lines.
-7. **vLLM v1 (0.19/0.24) does NOT emit the old "Avg prompt/generation throughput" log lines
- for the offline engine** β but the *served* engine's `APIServer` logger DOES (that's how
- the 2280 tok/s prompt / 200 tok/s gen batching was confirmed).
-8. **Sequential server loads:** `start_worker` blocks until its server is up, so a serial
- loop loaded 3 servers back-to-back (~42 min). Fixed to parallel `start_worker` (#6).
-9. **Long-blocking `next-batch` background tasks get killed.** The first served-vLLM run
- (14-min server wait) was killed mid-`start_worker`; nohup'd VM processes survived, leaving
- a confusing half-started fleet. Run `next-batch` only once servers are up so it returns fast.
-10. **Live validation caught two bugs that unit tests + code review missed** (#5 offline
- thread-safety, #6 coordinator 1-unit-per-worker). Cheap live smokes earn their keep.
-
-## Ops runbook
-
-```
-# relight the stopped fleet, sync the committed sha, run a batch
-gcloud compute instances start <3 workers> --zone us-central1-a
-# sync HEAD to all VMs (git archive | ssh tar -x + verify .deployed_sha)
-# first next-batch loads servers (~14 min, now parallel); run it AFTER servers are up so
-# the call returns fast, or expect the long-blocking process to be killable
-SWEEP_TOPO=qwen QWEN_WORKER_COUNT=3 WORKER_CONCURRENCY=16 ZONE=us-central1-a \
- SWEEP_ID=cond-sweep-20260704-qwen ... bash sweep_run.sh next-batch
-# per batch: finalize-batch N -> summarize_run --model Qwen -> publish -> next-batch N+1
-# servers persist across batches (no reload). STOP (not delete) to preserve disks.
-```
diff --git a/docs/qwen-two-tier-rerun-design.md b/docs/qwen-two-tier-rerun-design.md
index bd24f56..cf3d809 100644
--- a/docs/qwen-two-tier-rerun-design.md
+++ b/docs/qwen-two-tier-rerun-design.md
@@ -18,7 +18,7 @@ The served-vLLM path **ignores the run-config's `max_model_len` /
in-process `qwen_vllm` provider. The server is launched with hard-coded args in
`lib/distributed_start.sh:150-157`
(`--max-model-len 16384 --max-num-seqs 64 --gpu-memory-utilization 0.9`), with
-twin copies in `run_qwen_backfill.sh:50` and `launch_qwen_smoke.sh:171`. A
+twin copies in the backfill launcher (kept with the run records) and `launch_qwen_smoke.sh:171`. A
reuse guard (`distributed_start.sh:150`) skips relaunch when a server is already
up. Consequences:
@@ -33,8 +33,8 @@ up. Consequences:
- The phase-2 **reload** uses the existing teardown primitive
`stop_gpu_worker` / `lib/gpu_teardown.sh` (`lib/distributed_start.sh:215-222`,
fail-closed GPU-free polling), then relaunches with phase-2 args. Serve-args
- cannot change at runtime; this is a real ~14-min reload (see
- `docs/qwen-served-vllm-concurrency.md`).
+ cannot change at runtime; this is a real ~14-min reload (see the earlier
+ served-vLLM concurrency investigation).
## Scope
@@ -144,8 +144,9 @@ to retry forever).
## Documentation (explicit requirement β clear & replicable)
-- Runbook `docs/qwen-two-tier-rerun.md`: what/why/how, the KV-vs-parallelism
- rationale, the exact reload step and phase-2 serve args, how to re-run.
+- The operational runbook lives with the run records: what/why/how, the
+ KV-vs-parallelism rationale, the exact reload step and phase-2 serve args,
+ how to re-run.
- Inline comments at the phase-transition points in the run scripts
(`launch_distributed.sh` / `lib/distributed_start.sh` / the sweep driver).
- Phase-labeled artifacts (above) as self-documenting output.
diff --git a/docs/qwen-two-tier-rerun.md b/docs/qwen-two-tier-rerun.md
deleted file mode 100644
index 39937aa..0000000
--- a/docs/qwen-two-tier-rerun.md
+++ /dev/null
@@ -1,262 +0,0 @@
-# Qwen two-tier rerun β operator runbook
-
-Reproduce the Qwen phase-1/phase-2 truncation-requeue flow end to end from the
-files. **Qwen-only:** Claude and Kimi are API models with no KV-cache constraint
-and run the full 64k cap from the start (via the batch lockstep runner) β they
-are never two-tiered. Design and rationale:
-[`docs/qwen-two-tier-rerun-design.md`](qwen-two-tier-rerun-design.md);
-launch context and footguns:
-[`docs/r1-run-preparation.md`](r1-run-preparation.md); served-vLLM reload
-mechanics and the ~14-min reload:
-[`docs/qwen-served-vllm-concurrency.md`](qwen-served-vllm-concurrency.md).
-
-## What & why (KV-vs-parallelism)
-
-Qwen3.6-27B runs locally on A100 via **served** vLLM. A large output budget is
-expensive in KV cache: `max_model_len=96000` (needed to fit a 64k output cap)
-collapses concurrency from ~13-16 episodes/server to ~2-3, wrecking the
-"~4-5 hour, wide-parallel" plan. But Qwen's *observed* output demand is tiny
-(median 142, p90 ~2815, max ~4921 tokens; only ~4.8% of image_only queries hit
-the old buggy 4k cap). So: **run wide at a small cap, then re-run only the few
-mazes that actually truncate, at 64k.**
-
-| Phase | `max_model_len` (serve env) | `max_tokens` | timeout / attempts | concurrency | mazes | run config |
-|---|---|---|---|---|---|---|
-| 1 (fast/wide) | 16384 | 8000 | 1800 s / 3 | full (~13-16/server) | all | `gridworld/fixtures/run_config.r1.json` |
-| 2 (deep/narrow) | 96000 | 64000 | 2400 s / 2 | reduced (~2-3/server, `--max-num-seqs 3`) | flagged only | `gridworld/fixtures/run_config.r1.qwen_phase2.json` |
-
-Two facts that force the shape of this flow (both verified against the code):
-
-- **Serve args are hard-coded, not config-driven.** The served-vLLM path
- ignores the run-config's `max_model_len` / `gpu_memory_utilization` /
- `enforce_eager`. The KV tradeoff is set at the serve line in
- `lib/vllm_serve_args.sh` from env knobs: `QWEN_MAX_MODEL_LEN` (default 16384),
- `QWEN_MAX_NUM_SEQS` (default 64), `QWEN_GPU_MEMORY_UTILIZATION` (default 0.9).
- **Unset env reproduces the exact phase-1 string** β phase 1 needs no env.
- Switching to phase-2 args is a real server reload (~14 min), not a runtime
- toggle.
-- **Two run configs, not one toggle.** `max_tokens` is baked into the run config
- and into the episode/unit hash, so phase-2 units are legitimately distinct
- from phase-1 units (the intended re-pay). Phase 1 mixes caps (Qwen 8k vs
- Claude/Kimi 64k), so it declares `"allow_unequal_max_tokens": true` (the
- documented exception to the equal-caps invariant); phase 2 is Qwen-only, so
- the caps guard auto-passes. Phase 2's `manifest` key points at the generated
- rerun manifest β which does not exist until phase 1 has run and been scanned.
-
-Placeholder conventions (as in the other runbooks): `$SWEEP_ID` is the fleet /
-artifacts namespace; `` / `.runs//β¦` are the phase-labeled artifacts
-roots; angle-bracketed tokens are yours to fill.
-
----
-
-## The freeze rule (read first β money-critical)
-
-**`SCORER_VERSION`, `PIPELINE_VERSION`, and the scorer weights MUST NOT change
-between the smoke, phase 1, and phase 2 of one campaign.** Unit identity folds
-these in; bumping any of them on a re-prepare churns `unit_id`s, orphans already
-verified (paid) units, and makes fresh workers re-pay episodes. Verify before
-each phase that these are untouched:
-
-- `scorer/config.py::SCORER_VERSION` (currently `0.3.0`) and the scorer weights.
-- `scripts/run_pipeline.py::PIPELINE_VERSION` (currently `0.1.2`).
-
-The phase change carries its own hash difference (the `max_tokens` cap); nothing
-else about scoring may move. The `phase`/`pass` provenance fields are additive
-and deliberately *excluded* from the hash (`_phase_episode_provenance` in
-`scripts/run_pipeline.py`), so labeling a phase never churns a cached episode.
-
----
-
-## End-to-end command sequence
-
-Set the namespace once, from a single value, so the artifacts path and the
-fleet id can never diverge:
-
-```bash
-export RUN=r1-YYYYMMDD # artifacts namespace (.runs/$RUN/β¦)
-export SWEEP_ID="$RUN" # fleet id (reload-qwen-phase2 RUN_ID default); same value
-```
-
-### 1. Phase 1 β run all mazes wide at 8k
-
-Serve env **unset** = phase-1 defaults (16384 / 64 / 0.9). Qwen episodes land
-under a phase-labeled artifacts root `.runs/$RUN/qwen_phase1/`. `run_pipeline`
-is a *client* β it does not start a model server, and the Qwen block points at
-`http://127.0.0.1:8000/v1`, so a `vllm serve` must already be healthy before it
-runs. Pick the path that matches your setup; each is complete on its own.
-
-**(a) Fleet path (normal).** Phase 1 is the standard R1 distributed launch: the
-coordinator/worker driver (`sweep_run.sh provision`, then `next-batch` for the
-following batches β see
-[`docs/r1-run-preparation.md`](r1-run-preparation.md) Β§Launch sequence step 5 and
-[`docs/sequential_sweep_runbook.md`](sequential_sweep_runbook.md)) SSHes each
-A100 VM and `start_worker` (`lib/distributed_start.sh`) launches `vllm serve`
-with the phase-1 defaults from `lib/vllm_serve_args.sh` (env unset), blocking on
-`/v1/models` readiness before any episode is dispatched. This same launch carries
-Claude/Kimi at 64k. **Do not export any `QWEN_*` serve env for phase 1** β the
-worker reproduces the phase-1 serve string verbatim when the knobs are unset.
-
-> **Lockstep API groups (Claude/Kimi):** start the coordinator
-> (`coordinator-serve`) with `--stale-after-seconds 9000` (β₯ `batch_deadline_s`
-> + `batch_cancel_grace_s` + slack; R1 default 7200 + 300), and run **exactly
-> one** `lockstep-worker` per API model group. The lockstep worker only
-> heartbeats between rounds, and one batch round can run for the full 2 h
-> deadline with no heartbeat, so the default `stale_after_seconds=300` would
-> flip every held unit stale mid-round; with two workers per group a stale unit
-> is re-assigned to the other worker β double-run β double-pay. See
-> [`docs/r1-run-preparation.md`](r1-run-preparation.md) Β§Launch sequence step 5.
-
-**(b) Local / single-VM path.** Start the phase-1 server yourself first, wait for
-it to answer `/v1/models`, then run the client. The serve line is the exact
-phase-1 default string rendered by `lib/vllm_serve_args.sh` (env unset):
-
-```bash
-# 1. Launch the phase-1 vLLM server (background). Serve args == vllm_serve_args() defaults.
-source lib/vllm_serve_args.sh
-vllm serve Qwen/Qwen3.6-27B --served-model-name Qwen/Qwen3.6-27B $(vllm_serve_args) &
-# expands to: --port 8000 --gpu-memory-utilization 0.9 --max-model-len 16384 \
-# --max-num-seqs 64 --dtype bfloat16 --trust-remote-code
-
-# 2. Wait until the server is healthy (must return 200 before step 3).
-until curl -fsS http://127.0.0.1:8000/v1/models >/dev/null; do sleep 5; done
-
-# 3. Run the phase-1 client against the healthy server.
-python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.r1.json \
- --manifest gridworld/fixtures/manifest.r1_balanced_03.json \
- --artifacts-root .runs/$RUN/qwen_phase1
-```
-
-The config's `phase` block (`{"pass": 1, "label": "phase1"}`) stamps `pass` and
-the caps onto every `episode.json`.
-
-### 2. Scan β emit the phase-2 rerun manifest
-
-Flags episodes where any query record hit the cap (`usage.output_tokens >= cap`
-or `finish_reason == "length"`; the cap is read per-run from
-`run_inputs.json β model_config.max_tokens`, or override with `--cap`). Writes a
-verbatim subset of the source manifest. **`--out` must be exactly the path the
-phase-2 config declares as its `manifest`** β otherwise the phase-2
-manifest-match guard fails:
-
-```bash
-python -m scripts.scan_truncations \
- --artifacts-root .runs/$RUN/qwen_phase1 \
- --source-manifest gridworld/fixtures/manifest.r1_balanced_03.json \
- --out gridworld/fixtures/manifest.r1_qwen_phase2.json \
- --model Qwen_Qwen3.6-27B
-```
-
-`--model` is the **sanitized `` run-dir segment**, not the run-config key
-`qwen36_27b_vllm`. For R1's qwen block (`"model": "Qwen/Qwen3.6-27B"`) that
-segment is `Qwen_Qwen3.6-27B` (run `python -c "from scripts.run_pipeline import
-_sanitize; print(_sanitize('Qwen/Qwen3.6-27B'))"` to confirm). Fail-closed: the
-scanner exits non-zero if `--model` matches ZERO run dirs (a typo must never
-emit an empty rerun manifest), and also if any run's cap is unresolvable, unless
-you pass `--allow-unresolved` (it is a money-deciding tool). Runnable live as
-phase-1 episodes complete, or post-hoc on the finished root β functionally
-equivalent, because the reload forces a phase boundary regardless. If nothing
-truncated, the manifest has zero tasks and phase 2 is a no-op β you are done.
-
-### 3. Reload β switch the fleet to phase-2 serve args
-
-On the already-running fleet, per GPU VM: `stop_gpu_worker` (fail-closed until
-the GPU is free), kill any lingering `vllm serve` with a bounded wait, relaunch
-with `QWEN_MAX_MODEL_LEN=96000 QWEN_MAX_NUM_SEQS=3`, drop worker concurrency, and
-health-check `/v1/models`. `BATCH_CAP` is required (cost-safety parity). This is
-the ~14-min reload:
-
-```bash
-BATCH_CAP=9h \
-RUN_CONFIG=gridworld/fixtures/run_config.r1.qwen_phase2.json \
-RUN_ID=$SWEEP_ID \
-./sweep_run.sh reload-qwen-phase2
-```
-
-`reload-qwen-phase2` exports the phase-2 `QWEN_*` env itself β you do not set the
-serve knobs by hand. It re-arms the on-VM watchdog at `BATCH_CAP` and aborts
-fail-closed if any GPU does not free or a server does not answer `/v1/models`.
-
-### 4. Phase 2 β rerun the flagged mazes deep at 64k
-
-Qwen-only, against the generated rerun manifest, into a **separate**
-phase-labeled root `.runs/$RUN/qwen_phase2/`:
-
-```bash
-python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.r1.qwen_phase2.json \
- --manifest gridworld/fixtures/manifest.r1_qwen_phase2.json \
- --artifacts-root .runs/$RUN/qwen_phase2
-```
-
-The config's `phase` block (`{"pass": 2, "label": "qwen_phase2"}`) stamps
-`pass=2` and the 64k cap. Separate roots are mandatory: a shared run-dir would
-silently clobber phase-1 episodes, and merging must be explicit (next step)
-rather than relying on an accidental same-path overwrite.
-
-### 5. Merge β later-pass-wins
-
-Phase-2 episodes overwrite phase-1 per unit (keyed by
-`task_id / agent_or_model / seed / condition / prompt_variant`); unflagged mazes
-keep their phase-1 episodes. Provenance (`pass`, caps, `truncated_at_ceiling`) is
-stamped on the **copies** written into the out root β the two source roots are
-never mutated:
-
-```bash
-python -m scripts.merge_two_tier \
- --phase1 .runs/$RUN/qwen_phase1 \
- --phase2 .runs/$RUN/qwen_phase2 \
- --out .runs/$RUN/qwen_merged \
- --expected-rerun-manifest gridworld/fixtures/manifest.r1_qwen_phase2.json
-```
-
-`--expected-rerun-manifest` fail-closes if any `task_id` the scan flagged is
-missing from phase 2 (a dropped rerun). The merge writes a
-`.runs/$RUN/qwen_merged/two_tier_merge.json` summary:
-`{"total", "from_phase2", "truncated_at_ceiling": [β¦], "cap_unresolved": [β¦]}`.
-If a phase-2 winner's ceiling status is unresolvable it fails closed by default;
-`--allow-unresolved-cap` downgrades that to a stderr WARN + a `cap_unresolved`
-entry (mirrors the scanner's policy).
-
----
-
-## Where every artifact lands
-
-| Artifact | Path |
-|---|---|
-| Phase-1 Qwen episodes | `.runs/$RUN/qwen_phase1/runs////seed_//episode.json` (each stamped `pass=1`, `max_tokens=8000`) |
-| Phase-2 rerun manifest | `gridworld/fixtures/manifest.r1_qwen_phase2.json` (subset of `manifest.r1_balanced_03.json`; the phase-2 config's `manifest` key) |
-| Phase-2 Qwen episodes | `.runs/$RUN/qwen_phase2/runs/β¦/episode.json` (each stamped `pass=2`, `max_tokens=64000`) |
-| Merged results | `.runs/$RUN/qwen_merged/` (episode copies, later-pass-wins) |
-| Merge summary | `.runs/$RUN/qwen_merged/two_tier_merge.json` |
-
-The phase-labeled roots are self-documenting: `qwen_phase1` / `qwen_phase2` in
-the path is the phase, and each `episode.json` records its `pass` + caps.
-
-## Terminal case: `truncated_at_ceiling`
-
-**64k is the ceiling β there is no third tier.** If a maze *still* hits
-`output_tokens >= 64000` (or `finish_reason == "length"`) in phase 2, the merge
-keeps the episode and marks it `truncated_at_ceiling: true` rather than looping.
-These `task_id`s are listed in `two_tier_merge.json` β **report them, do not
-retry**: a genuinely unbounded Qwen thinking loop is a finding, not a bug to
-retry forever. The name is distinct on purpose β `truncated` /
-`end_reason == "truncated"` already mean *environment* truncation.
-
----
-
-**Verified against** commit `0367b0d` (`feature/early_terminate`): both
-`gridworld/fixtures/run_config.r1.json` and
-`gridworld/fixtures/run_config.r1.qwen_phase2.json` read as quoted (phase blocks,
-caps, timeouts, `allow_unequal_max_tokens`, `max_in_flight`); `--help` exits 0
-for `scripts.scan_truncations`, `scripts.merge_two_tier`, and
-`scripts.run_pipeline`, and every flag shown above is present in their argparse;
-`sweep_run.sh reload-qwen-phase2` exists (dispatch + `cmd_reload_qwen_phase2`,
-requires `BATCH_CAP` + `RUN_CONFIG`, health-checks `/v1/models`);
-`lib/vllm_serve_args.sh` renders the serve line from `QWEN_MAX_MODEL_LEN` /
-`QWEN_MAX_NUM_SEQS` / `QWEN_GPU_MEMORY_UTILIZATION` (defaults 16384 / 64 / 0.9);
-the `--out` value this runbook passes to the scan and the phase-2 config's
-`manifest` key both equal `gridworld/fixtures/manifest.r1_qwen_phase2.json`
-(`--out` has no argparse default β omitting it makes the scan a summary-only dry
-run that writes no manifest); `SCORER_VERSION` (`scorer/config.py`)
-and `PIPELINE_VERSION` (`scripts/run_pipeline.py`) exist as named.
diff --git a/docs/qwen35_hf_local_pipeline_notes.md b/docs/qwen35_hf_local_pipeline_notes.md
deleted file mode 100644
index 9398c3e..0000000
--- a/docs/qwen35_hf_local_pipeline_notes.md
+++ /dev/null
@@ -1,344 +0,0 @@
-# Qwen3.5 HF Local Pipeline Notes
-
-These notes capture the local setup changes discovered while running the
-`feature/run-pipeline` validation-10 test pass with the Hugging Face
-Transformers-backed Qwen agent.
-
-## Target
-
-- Agent path: `interface/agents/qwen35_vl.py`
-- Model: `Qwen/Qwen3.5-27B`
-- Run config: `gridworld/fixtures/run_config.qwen35_27b_hf_validation10.json`
-- Validation generation budget: `max_tokens=4096`
-- Manifest: `gridworld/fixtures/manifest.json`
-- Prompt variants: `Observation format` (`text_only`, `image_text`, `image_only`)
-- Artifacts root: `artifacts/qwen35_27b_hf_validation10`
-
-## Local Environment Requirements
-
-The stock environment could not load Qwen3.5 because `transformers==4.44.0`
-did not know the `qwen3_5` architecture. `transformers==5.10.2` recognizes the
-model, but it requires a newer Torch than the original `torch==2.3.1`.
-
-Working local versions after setup:
-
-- Python: `/home/sean/mosaic/bin/python` (`Python 3.10.14`)
-- `transformers==5.10.2`
-- `torch==2.9.1+cu128`
-- `torchvision==0.24.1+cu128`
-- `torchaudio==2.9.1+cu128`
-- `bitsandbytes==0.49.2`
-- NVIDIA driver supports CUDA 12.9, so use CUDA 12.8 PyTorch wheels rather than
- CUDA 13 wheels.
-
-An intermediate `torch==2.12.0+cu130` install pulled CUDA 13 wheels. Those were
-removed because this driver reports CUDA 12.9 and PyTorch CUDA 13 could not
-initialize. The final Python CUDA package set should contain only `*-cu12`
-NVIDIA packages, not no-suffix CUDA 13 packages such as `cuda-toolkit`,
-`nvidia-cublas`, or `nvidia-cudnn-cu13`.
-
-Install command used for the driver-compatible Torch stack:
-
-```bash
-python -m pip install -U --index-url https://download.pytorch.org/whl/cu128 \
- "torch==2.9.1+cu128" "torchvision==0.24.1+cu128" "torchaudio==2.9.1+cu128"
-```
-
-Install command used for Qwen3.5 Transformers support:
-
-```bash
-python -m pip install -U "transformers>=5.10.2" "accelerate>=1.8.0" bitsandbytes
-```
-
-Note: this may conflict with `sentence-transformers==3.0.1`, which requires
-`transformers<5.0.0`. The run-pipeline path used here does not depend on
-`sentence-transformers`.
-
-## Model Cache
-
-The existing cache had only Qwen metadata and tokenizer files. The weight shards
-had to be downloaded once:
-
-```bash
-hf download Qwen/Qwen3.5-27B \
- --include "*.safetensors" \
- --include "*.index.json" \
- --include "*.json" \
- --include "*.jinja" \
- --include "*.txt" \
- --max-workers 16
-```
-
-After download, the local cache was about 53 GB and contained 11 safetensors
-shards.
-
-## Runtime Config Notes
-
-The 4-bit load path needs the model forced onto GPU:
-
-```json
-"device_map": {
- "": 0
-},
-"load_in_4bit": true
-```
-
-Using `"device_map": "auto"` caused bitsandbytes to reject CPU/disk-dispatched
-modules. On the RTX 4090, the forced 4-bit load used about 22-23 GB VRAM and fit
-with little headroom.
-
-Qwen3.5 spent the output budget on chain-of-thought-style map analysis and did
-not emit `FINAL_OUTPUT` until the chat template thinking mode was disabled. The
-agent now passes:
-
-```python
-enable_thinking=False
-```
-
-The prompt template was also tightened to request no explanation before
-`FINAL_OUTPUT`. After the first out-of-sandbox validation pass reached
-`validation_10_v02_winding_corridor`, Qwen again spent the full 512 output
-tokens on path analysis during `text_only` and failed all parse retries. The
-per-step user prompt and parse-failure feedback now repeat the one-line output
-contract at the decision point:
-
-```text
-Reply exactly as one line: FINAL_OUTPUT:
-```
-
-Stage-3 episode cache keys now include the condition set, prompt variant,
-resolved `ExperimentConfig`, and runtime model config such as `provider`,
-`model`, `temperature`, `max_tokens`, `enable_thinking`, quantization, and
-attention settings. The sidecar at each `run_inputs.json` records both the full
-model config and the runtime subset used in the hash. This prevents an old
-episode from being silently reused after changing the prompt contract or the
-generation budget. For the validation run, keep `max_tokens=4096`.
-
-## Fast Attention Kernels
-
-Transformers emitted this warning during Qwen3.5 loading:
-
-```text
-The fast path is not available because one of the required library is not installed.
-Falling back to torch implementation.
-```
-
-It specifically points to:
-
-- `flash-linear-attention`
-- `causal-conv1d`
-
-Without these kernels, Qwen3.5 generation can be impractically slow even after
-the model loads successfully. Dedicated-hardware runs should install the
-versions of these packages compatible with the active Torch/CUDA stack before
-starting the full suite.
-
-Dedicated-hardware setup should include:
-
-```bash
-python -m pip install -U flash-linear-attention causal-conv1d
-```
-
-If `causal-conv1d` imports with an undefined Torch/CUDA symbol after a normal
-install, rebuild it against the active Torch wheel:
-
-```bash
-python -m pip install --force-reinstall --no-build-isolation --no-cache-dir --no-deps causal-conv1d==1.6.2.post1
-```
-
-Verify the imports before starting the full pipeline:
-
-```bash
-python -c "import fla; import causal_conv1d; print('fast kernels ok')"
-```
-
-If bitsandbytes emits a separate `kernels` package warning while all model
-modules are resident on GPU, treat that as secondary. The blocking performance
-warning for this run is the missing Qwen fast attention path above.
-
-## Current Local Run Status
-
-Completed locally:
-
-- Fast-kernel install and verification:
-
-```text
-flash-linear-attention==0.5.0
-causal-conv1d==1.6.2.post1
-import fla; import causal_conv1d -> fast kernels ok
-```
-
-- Static scoring for all 16 manifest rows (`all`: tests 1-3) under
- `artifacts/qwen35_27b_hf_validation10/tasks`.
-- Focused pipeline tests:
-
-```bash
-python -m pytest tests/test_run_pipeline.py tests/test_interface_token_usage.py -q
-```
-
-Result: `28 passed`.
-
-- Qwen smoke run on `validation_10_v01_empty_room` for all three observation
- variants:
-
-```bash
-python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.qwen35_27b_hf_smoke.json \
- --manifest gridworld/fixtures/manifest.json \
- --artifacts-root artifacts/qwen35_27b_hf_smoke \
- --run-set-id qwen35_27b_hf_smoke \
- --seeds 0 \
- --conditions "Observation format" \
- --force
-```
-
-Result: 3/3 successful runs over V01:
-
-- `text_only`: success, 11 steps, optimality ratio 1.0
-- `image_text`: success, 12 steps, optimality ratio 0.9167
-- `image_only`: success, 12 steps, optimality ratio 0.9167
-
-An out-of-sandbox validation pass was later started from the same artifact root
-and killed manually after a long run. It did not finish the full suite or write
-the top-level aggregate reports, but it did write per-episode `episode.json`,
-`run_inputs.json`, and `run_score.json` files for 19 fresh completed rows. The
-run directory still also contains 21 older pre-fix rows, so the partial summary
-below explicitly separates fresh rows from stale rows.
-
-Partial summary artifacts:
-
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/summary.md`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/summary.json`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/fresh_rows.csv`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/coverage_audit.csv`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/run_config.remaining_tasks.json`
-
-Fresh-only aggregate report artifacts regenerated from existing `episode.json`
-and `run_score.json` files without model calls:
-
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/episode_runs.fresh.jsonl`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/partial_report_metadata.json`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/reports/qwen35_27b_hf_validation10_partial_fresh/scoring_calibration_summary.json`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/reports/qwen35_27b_hf_validation10_partial_fresh/complexity_distance_summary.json`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/reports/qwen35_27b_hf_validation10_partial_fresh/mechanism_ordering_pairs.json`
-- `artifacts/qwen35_27b_hf_validation10/partial_results_summary/partial_fresh_reports/reports/qwen35_27b_hf_validation10_partial_fresh/models/Qwen_Qwen3.5-27B.json`
-
-Fresh partial results:
-
-```text
-fresh_completed_rows: 19
-fresh_coverage_needed_rows: 29
-stale_rows: 21
-physically_missing_rows: 8
-successes: 3
-parse_failed: 7
-truncated: 9
-input_tokens: 1,167,145
-output_tokens: 583,219
-total_tokens: 1,750,364
-recorded_llm_latency: 665.96 minutes
-```
-
-All fresh successes were on `validation_10_v01_empty_room`; the run reached
-through `validation_10_v07_chain_sk/text_only` before it was killed. Episode
-files do not record full wall-clock duration, only per-query `llm_latency_s`, so
-the timing above is summed model-call latency rather than total process runtime.
-The remaining fresh coverage is split across `test1` (11 rows), `test2` (6
-rows), and `test3` (12 rows). All 16 manifest tasks already have
-`canonical_paths.json` and `scored_static.json`; every existing episode file has
-a `run_score.json` sidecar.
-The generated remaining-tasks config keeps `max_tokens=4096` and targets the 10
-tasks that still have stale or missing rows. The current `0.1.1` Stage-3 cache
-key includes the prompt/observation config and runtime model config, so patched
-non-`--force` runs should invalidate older `0.1.0` sidecars. Keep `--force`
-when writing into this mixed artifact root if you want the overwrite to be
-explicit.
-
-Earlier, inside the sandboxed Codex environment, fresh PyTorch processes
-reported:
-
-```text
-CUDA initialization: CUDA driver initialization failed
-torch 2.9.1+cu128, torch.cuda.is_available() == False
-```
-
-On June 18, 2026, this sandboxed shell still reported:
-
-```text
-Can't initialize NVML
-torch 2.9.1+cu128, torch.cuda.is_available() == False, device_count == 0
-```
-
-The fast attention kernel imports still succeeded in the same shell:
-
-```text
-import fla; import causal_conv1d -> fast kernels ok
-```
-
-At the same time `nvidia-smi` still saw the RTX 4090. This appears to be a
-local CUDA runtime/driver state issue rather than a pipeline artifact issue.
-Additional diagnostics on June 11, 2026:
-
-```text
-ctypes CDLL("libcuda.so.1") loaded /usr/lib/x86_64-linux-gnu/libcuda.so.575.57.08
-cuInit(0) -> 100
-cuDeviceGetCount(...) -> 3, count=0
-```
-
-Recent kernel logs also showed repeated NVIDIA driver allocation failures:
-
-```text
-NVRM: Check failed: Out of memory [NV_ERR_NO_MEMORY]
-NVRM: sysmemConstruct_IMPL: *** Cannot allocate sysmem through fb heap
-```
-
-After removing the stray CUDA 13 Python wheels and force-reinstalling the CUDA
-12.8 wheel libraries, Torch imported correctly again, but CUDA initialization
-still failed because the direct driver API still failed.
-
-An attempted targeted reset also failed because the RTX 4090 is the primary
-display GPU:
-
-```text
-nvidia-smi --gpu-reset -i 0
-GPU Reset couldn't run because GPU 00000000:01:00.0 is the primary GPU.
-```
-
-The next full run should be started on dedicated hardware, or after a driver/GPU
-reset or reboot on this machine. Do not start the full Qwen suite until both
-checks pass:
-
-```bash
-python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"
-python -c "import fla; import causal_conv1d; print('fast kernels ok')"
-```
-
-Expected result: CUDA is available, the device name prints `NVIDIA GeForce RTX
-4090` or the dedicated hardware GPU, and both fast-kernel imports succeed.
-
-## Full Run Command
-
-Once CUDA initialization is healthy and the fast kernels are installed, run:
-
-```bash
-python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.qwen35_27b_hf_validation10.json \
- --manifest gridworld/fixtures/manifest.json \
- --artifacts-root artifacts/qwen35_27b_hf_validation10 \
- --run-set-id qwen35_27b_hf_validation10 \
- --seeds 0 \
- --conditions "Observation format" \
- --force
-```
-
-Expected report outputs:
-
-- `artifacts/qwen35_27b_hf_validation10/episode_runs.jsonl`
-- `artifacts/qwen35_27b_hf_validation10/reports/qwen35_27b_hf_validation10/scoring_calibration_summary.json`
-- `artifacts/qwen35_27b_hf_validation10/reports/qwen35_27b_hf_validation10/complexity_distance_summary.json`
-- `artifacts/qwen35_27b_hf_validation10/reports/qwen35_27b_hf_validation10/mechanism_ordering_pairs.json`
-- `artifacts/qwen35_27b_hf_validation10/reports/qwen35_27b_hf_validation10/models/Qwen_Qwen3.5-27B.json`
-
-The current `artifacts/qwen35_27b_hf_validation10/runs` directory contains
-episodes from aborted/pre-fix attempts. Use `--force` for the next full run if
-you want to overwrite those attempts explicitly.
diff --git a/docs/r1-run-preparation.md b/docs/r1-run-preparation.md
deleted file mode 100644
index a0a4bbd..0000000
--- a/docs/r1-run-preparation.md
+++ /dev/null
@@ -1,265 +0,0 @@
-# R1 run preparation β preflight verification, footguns, launch checklist
-
-**Date:** 2026-07-16. **Scope:** the R1 fixed-cell run (`gridworld/fixtures/run_config.r1.json`
-on `manifest.r1_balanced_03.json`, 50 mazes Γ 1 seed Γ 3 models), its 5-maze
-validation smoke, and the two supporting designs:
-`docs/batch-api-lockstep-runner-design.md` (Claude/Kimi batch lockstep) and
-`docs/qwen-two-tier-rerun-design.md` (Qwen phase-1/phase-2). Both specs were
-verified line-by-line against the codebase and provider docs on 2026-07-16;
-corrections are integrated into the specs themselves. This document holds
-everything else: verification results, the footgun catalog, and the launch
-sequence.
-
-## Preflight verification results (all clean unless noted)
-
-- **Manifest β panel:** `manifest.r1_balanced_03.json` matches
- `analysis/candidate_mazes/sets/balanced_03/SUMMARY.md` **exactly 1:1** β 50
- tasks, every source path and `optimal_steps` value matches the walkthrough,
- strictly ascending 23β106, provenance recorded in the manifest's `selection`
- block. The other three R1 manifests (long_tail_02, mechanism_rich_01,
- pairwise_01) exist and parse at 50 tasks each.
-- **Submodule-path safety:** all R1 manifests point into the `ogbench`
- submodule. Safe since commit `36ebf73`: `launch_distributed.sh` ships each
- submodule tree at the superproject-pinned sha and **fail-closes** if a
- submodule is missing/empty on a VM. Vendoring into `mazes/` is no longer
- required. The S4 goal defect is fixed at the pinned sha (`31a0549`).
-- **Beatability/validation:** all 50 mazes audit clean (beatable, BFS-solvable,
- `optimal_steps` consistent). Re-validate any new/edited manifest with
- `python scripts/validate_fixtures.py --manifest `.
-- **Provider batch APIs:** both confirmed real and sufficient (Anthropic 50%
- off, Moonshot 40% off, thinking + images supported, results carry
- `stop_reason`/`finish_reason`). Details and request-shape requirements live in
- the batch-runner spec.
-
-## Footgun catalog
-
-Each item: the trap, and where the mitigation lives.
-
-1. **Stale Qwen block in `run_config.r1.json`** (user-flagged). The committed
- config had qwen at `max_tokens=64000 / max_model_len=96000` β phase-2 values
- with no two-tier mechanism. Worse: on the served path `max_model_len` (and
- `gpu_memory_utilization`, `enforce_eager`) are **inert** β `vllm serve` args
- are hard-coded in `lib/distributed_start.sh:150-157` at 16384 context, so the
- old config would have requested 64k outputs from a 16k-context server.
- *Mitigation:* two-tier implementation parameterizes the serve line; config
- carries phase-1 values (`max_tokens=8000`, `allow_unequal_max_tokens: true`);
- phase 2 gets its own config. See the two-tier spec.
-2. **Uncommitted working tree vs fail-closed code-sync.** The early-terminate
- branch has ~728 uncommitted lines (runner stall-K hardening, coordinator
- inputs-hash verification, tests) plus untracked candidate-maze tooling. VM
- code-sync pushes the **committed** sha and fail-closes on mismatch β nothing
- runs until this work is committed. *Mitigation:* commit (including
- implementation work) before any smoke/run; verify `git status` clean and the
- ogbench submodule pointer pushed.
-3. **`max_in_flight=1` for Claude/Kimi vs the lockstep working set.**
- `max_in_flight` is a fleet-wide per-group throttle checked at `assign`; at 1
- it would starve the batch runner to a single active maze. *Mitigation:* R1
- config raises Claude/Kimi `max_in_flight` to β₯ 50 (= MAX_BATCHES /
- `worker_concurrency`). Invariant documented in the batch-runner spec.
-4. **No kill layer between unit staleness and VM shutdown.** A wedged batch
- round is kept "alive" by our own heartbeats; the only backstop is the
- `BATCH_CAP` VM shutdown (the 6h-watchdog incident, amplified by 24h batch
- expiry). *Mitigation:* per-round deadline in the batch runner (spec), and
- size `MAX_RUN_DURATION`/`BATCH_CAP` from smoke-measured round latency β
- batch rounds have minutes-to-unbounded variance, not sync-API latency.
-5. **Unit-hash churn re-pays paid units.** `unit_id` folds in scorer identity
- (`SCORER_VERSION`, scorer weights, `PIPELINE_VERSION`, task rows). Bumping
- any of these between prepare calls of the same campaign orphans
- verified/uploaded units; fresh workers re-pay. *Mitigation:* **freeze
- scorer/pipeline versions and weights for the entire R1 campaign** (smoke β
- phase 1 β phase 2). The deeper design question (should unit identity cover
- scoring inputs at all) stays open but is explicitly deferred past R1.
-6. **Phase collision / double-count.** Same run-dir for both Qwen phases would
- silently clobber; separate roots double-count in finalize and
- `analysis/data.py`. *Mitigation:* phase-labeled artifacts roots + `pass`
- field + later-pass-wins dedup at aggregation (two-tier spec).
-7. **Truncation trigger reads the wrong field if implemented naively.** Usage
- is on **query records** (`transcript[kind=="query"].usage.output_tokens`),
- not step records; `episode_runs.jsonl`'s `tokens` is a total-tokens sum and
- can't drive the trigger; the cap lives in `run_inputs.json`, not
- `episode.json`. *Mitigation:* spelled out in the two-tier spec; unit tests
- pin it.
-8. **`truncated` name collision.** `truncated`/`end_reason=="truncated"` mean
- *environment* truncation today. Token-cap truncation uses distinct names
- (`token_truncated`, `truncated_at_ceiling`, recorded `stop_reason`).
-9. **Kimi specifics.** (a) `max_tokens` defaults to 32768 if unset β always
- explicit; (b) sampling params are mode-forced (thinkingβ1.0) β omit or match,
- anything else 400s; (c) Kimi thinking-runaway truncated 5.6% of queries at
- 16k with **empty content** β rate at 64k unknown; the smoke measures it and
- `stop_reason` capture makes it visible. Kimi remains the likeliest
- parse-fail artifact source; judge from smoke data before the full run.
-10. **Claude Opus 4.8 request shape.** `thinking: {"type":"adaptive"}` +
- `output_config.effort`; `budget_tokens`/`temperature`/`top_p`/`top_k` are
- hard 400s; thinking display defaults to omitted (set `summarized` to log
- traces; billing identical). Already honored by the sync agent; batch
- implementation must match.
-11. **Batch-runner uploads must reuse the run-inputs machinery.** Upload
- verification rejects archives whose `run_inputs.json` `inputs_hash` β the
- unit's `episode_inputs_hash` (new check on this branch). The lockstep worker
- goes through the same `run_inputs` writer as `pipeline._run_one_unit`.
-12. **last3 + text-summary prompt comparability.** The reworked last3 history
- (`FINAL_OUTPUT:` + Position-after/Feedback shape) AND the new persistent
- start-pose anchor in the text summary (`"You started at (r, c) facing DIR."`,
- added 2026-07-17 to ground image_only) mean R1's `text_summary_and_last3`
- data is **not prompt-comparable** with previously-collected corpora (incl.
- the kimictx run). Deliberate. Never pool old and new arms silently in analysis.
-13. **Panel interpretation caveats** (from the balanced_03 SUMMARY, restated so
- they survive into analysis): mechanism comparisons begin at 26 actions (no
- shorter mechanism fixtures exist); the single D3 maze's BFS estimate may be
- inflated vs legal runtime execution; matched pairs/triplets are the causal
- units, not the marginal curve.
-14. **Cosmetic:** the balanced_03 walkthrough PNG for `S4/10x10_dense_1` still
- renders the pre-fix goal position. Re-render + re-package when convenient;
- does not affect runs (runtime reads `goal.target` via `resolved_goal()`).
-15. **Kimi transcripts now include thinking traces.** The Reply-based agents
- capture Kimi's `reasoning_content` (previously discarded), so paid Kimi
- runs record `thinking` on every query record β intended (it's how
- truncation-vs-runaway is diagnosed) but transcript/artifact size grows
- accordingly.
-16. **Order-dependent test flake:**
- `tests/test_launch_distributed.py::test_sync_ships_and_verifies_submodule_content`
- failed once in full-suite order (passes in isolation and in most full
- runs). Not caused by the feature work; diagnose before treating a red
- full-suite as a launch blocker.
-
-## Launch sequence (in order; nothing runs before its predecessor)
-
-Steps 1β2 are **DONE** (2026-07-16, commits `d1196a6..00757f3` on
-`feature/early_terminate`): both designs implemented with per-task review
-(batch lockstep runner incl. Anthropic/Moonshot batch clients, `EpisodeStepper`
-extraction, query-boundary checkpoint/resume, `lockstep-worker` coordinator
-role; two-tier serve-arg env knobs + `reload-qwen-phase2`, truncation scanner,
-phase provenance, later-pass-wins merge, both run configs, operator runbook
-`docs/qwen-two-tier-rerun.md`); full suite green (1006+ tests); smoke fixtures
-validated. Remaining steps are operator-run (paid).
-
-1. ~~Implement~~ **DONE.** Fixtures: `manifest.r1_smoke_batch.json` +
- `run_config.r1_smoke_batch.json`; validate any edited manifest with
- `python -m scripts.validate_fixtures --manifest ` (must be invoked
- with `-m`; bare-path invocation lacks sys.path).
-2. ~~Commit everything~~ **DONE** (submodule pointer at the S4-fixed sha).
-3. **Validation smoke** (5 mazes, Claude + Kimi via `generate_batch`, plus a
- serial sync control; ~$5β25):
- `SMOKE_BUDGET_ACK=1 python -m scripts.run_batch_smoke --models claude_opus,kimi_k26 --max-batches 5 --control-episodes 1 --max-usd 25 --artifacts-root .runs/r1_smoke_batch`
- (use `--dry-run` first). Verifies custom_id mapping, ragged termination,
- checkpoint/resume, price delta; **measures queries/episode, output/query,
- per-round batch latency, and Kimi/Claude truncation rates at 64k** into
- `smoke_report.json`. Also the first live confirmation of the Moonshot batch
- wire shapes (implemented from docs, unverified against the live endpoint).
-4. **Re-budget from smoke numbers** (prior central ~$435 sync β ~$229 with
- batch discounts; smoke collapses the $200β1025 range). Set
- `MAX_RUN_DURATION` / `BATCH_CAP` from measured round latency β count the
- full worst-case round: `round_deadline_s` (default 2h) **+ cancel grace
- (default 5 min)**, times a multi-round tail. **Decision gate:** proceed /
- adjust caps / Kimi thinking-off fallback if its 64k truncation rate is
- still pathological.
-5. **Full run, phase 1:** Claude + Kimi through the lockstep batch worker β
- fleet-launched by exporting `API_WORKER_ROLE=lockstep-worker
- API_WORKER_CONCURRENCY=50` before starting the API workers
- (`lib/distributed_start.sh::start_worker`; defaults unchanged = old serial
- role), or manually via `--distributed-role lockstep-worker
- --worker-concurrency 50`. Exactly ONE lockstep worker per API model group;
- coordinator serves with `--stale-after-seconds 9000` (default 300 is wrong
- for batch rounds); the model groups' `max_in_flight` is already 64 β₯
- MAX_BATCHES. Qwen runs wide at 8k on the A100 fleet (serve env unset =
- phase-1 defaults). Cost-safety env vars are required-no-default; STOP VMs,
- never delete; pull artifacts before spindown.
- - **Coordinator staleness for lockstep groups:** start `coordinator-serve`
- with `--stale-after-seconds 9000` (must be β₯ `batch_deadline_s` +
- `batch_cancel_grace_s` + slack; R1 default 7200 + 300). The lockstep
- worker only heartbeats between rounds (`on_round`), and a single batch
- round can run for the whole 2 h deadline with no heartbeat β the default
- `stale_after_seconds=300` would flip every held unit stale mid-round.
- - **Exactly ONE lockstep worker per API model group.** With one worker,
- a stale bounce is harmless (the coordinator re-hands the same worker's
- units and refill dedups them, costing only an `attempts` increment). With
- two workers on a group, a stale unit is re-assigned to the *other* worker
- β double-run β double-pay. Size `MAX_RUN_DURATION` / `BATCH_CAP` to the
- same worst-case round (`batch_deadline_s` + `batch_cancel_grace_s`) Γ the
- multi-round tail (see step 4).
-6. **Scan β phase 2 β merge:** exact commands in `docs/qwen-two-tier-rerun.md`
- (scanner is fail-closed on unresolvable caps; `reload-qwen-phase2` requires
- `BATCH_CAP`; merge is fail-closed on missing flagged tasks and stamps
- `pass`/`truncated_at_ceiling` on merged copies only).
-7. **Finalize + analysis:** merged `episode_runs.jsonl`, `run_score.json`,
- budget/actuals reconciliation, `truncated_at_ceiling` cases reported
- explicitly. Analysis note: rows now carry additive `pass`/`max_tokens`
- columns; query records carry additive `stop_reason`/`token_truncated`.
-
-## Budget (smoke-measured, 2026-07-17)
-
-The pre-smoke central estimate (~\$229 batch across all 3 models) assumed higher
-queries/episode than reality: under image_only the episodes **stall at ~30β80
-steps** (stall-K=30), well below a solve, so Claude comes in far cheaper than the
-old \$165 line. Smoke-measured (Claude, 50 mazes Γ 1 seed):
-
-| Model | R1 batch | R1 sync | Basis |
-|---|--:|--:|---|
-| **Claude Opus 4.8** | **~\$23.4** | ~\$46.8 | measured: 49.8 q/episode Γ 50, mean 574 out-tok/step (`smoke_report.json`) |
-| **Kimi k2.6** | ~\$50β100 (uncertain) | ~\$85β170 | single-round datapoint only: ~16.5k reasoning tok/step β measure with a Kimi smoke before trusting |
-| **Qwen** | \$0/token | \$0/token | local vLLM |
-
-Full tables + provenance: `analysis/r1_smoke_batch_findings.md`. `token_truncated`
-was 0/249 for Claude at 64k. Cost lever ranking unchanged: output cap runaway
-tail > batch discount > prompt caching (input minor at xhigh). **Kimi is the cost
-*and* wall-clock long pole** (heavy per-step thinking + Moonshot's ~17 min/round).
-
-## Lessons learned from the batch smoke (2026-07-17)
-
-The 5-maze Claude batch smoke (`analysis/r1_smoke_batch_findings.md` has the full
-tables) surfaced several things that will bite the live R1 launch if not checked.
-
-### Smoke result summary (Claude, image_only, thinking-on, batch)
-- All 5 mazes **stalled** (0 solved) at exactly `stall_gap = 30` β stall-K=30 is
- the terminator. Queries/episode 32β83 (mean 49.8). `token_truncated = 0`.
-- Per-step tokens: output mean **574** / median 252 / max 21426; input mean 886.
-- **Cost:** batch $2.34 vs sync-equiv $4.68 (**50% discount confirmed**). Official
- projection: **Claude batch ~$23.4 / sync ~$46.8** for 50 mazes Γ 1 seed.
-- **Latency:** Anthropic batch **median 6β7 min/round** (max 31); Moonshot batch
- **median 17 min/round** (max 67) β Kimi-via-Moonshot is the wall-clock long pole.
-
-### Pre-launch checks (do these on the LIVE coordinator run, early)
-1. **Confirm thinking is actually ON** β the #1 trap. The smoke driver built its
- batch agent from the stripped `plan["models"][key]` (no `enable_thinking`/
- `effort`) and silently ran **thinking-OFF** (uniform ~24-token outputs, all
- stalled). The real `run_lockstep_worker` uses `unit["model_config"]` and is
- correct, **but verify it live**: within the first 1β2 rounds, pull a query
- record's `usage.output_tokens`. **~24 tokens = thinking-OFF (STOP, investigate);
- hundredsβthousands = thinking-ON.** Also check `thinking` non-empty on Claude
- (display=summarized) and `reasoning_content` on Kimi.
-2. **Check token use early** to catch runaway before it burns budget β median is
- ~250β570 out-tok/step for Claude; Kimi thinks *heavily* (~16.5k tok for one
- step in the confirmation). A first-round spot check bounds the projection.
-3. **Qwen is slow to start β don't panic.** Qwen's first solve takes **~15β20 min**
- (vLLM load + first decode on the served A100 path); an early "no progress" is
- startup, not a hang (see the qwen-fp8 smoke-stall note). Check after ~20 min.
-
-### If the batch coordinator breaks
-- **At launch (first ~hour, no real work done):** kill the job, fix the bug,
- relaunch clean. Cheap β nothing to salvage.
-- **After ~an hour (real batches in flight / episodes on workers):** **monkeypatch
- live** rather than restart. Completed episodes live on the workers as
- `episode.json`; a coordinator restart risks mid-flight batches and re-pays. The
- lockstep worker checkpoints per round (`checkpoint.json` in the run dir) and the
- Anthropic/Moonshot batch history is queryable directly (`GET /v1/messages/batches`
- / `GET /v1/batches`) to inspect in-flight state without touching the process.
-
-### Known behaviors / gotchas
-- **Two config sources:** `plan["models"]` is a routing/topology view (stripped of
- runtime params); `unit["model_config"]` carries `enable_thinking`/`effort`/
- `temperature`. Always build agents from the unit config (the smoke fix + the
- worker both do).
-- **image_only gives NO action-outcome feedback by design** ("PNGs + inventory/
- action labels, no text history"). The model can't tell a move was BLOCKED, so it
- repeats it until stall-K β this is the fast-stall mechanism, not a bug. The
- text-summary now carries a persistent **"You started at (r,c) facing DIR."**
- anchor to partially ground it.
-- **Temperature:** Claude Opus 4.8 **rejects** `temperature`/`top_p`/`top_k` (400) β
- never send it; it samples via adaptive thinking. Kimi is mode-forced to 1.0.
- Qwen raised 0.6 β 1.0 to match Kimi (0.6 was Kimi's *non-thinking* value).
-- **Batch API honors thinking** for both providers (verified by direct sync-vs-batch
- A/Bs: Anthropic text+image; Moonshot single round, no 64k truncation) β but this
- is a per-run-path property, so item (1) above still applies to the live coordinator.
-- **Smoke β worker on checkpoints:** the smoke driver runs the lockstep runner
- WITHOUT a checkpoint path (episodes flush only at leg end); the real worker
- checkpoints per round. Don't infer worker resume behavior from smoke disk state.
diff --git a/docs/sequential_sweep_runbook.md b/docs/sequential_sweep_runbook.md
deleted file mode 100644
index 2066daa..0000000
--- a/docs/sequential_sweep_runbook.md
+++ /dev/null
@@ -1,196 +0,0 @@
-# Sequential Supervised Sweep β Operator Runbook
-
-Runs the **11-batch** conditional sweep (smoke + 10 conditional configs) as one
-supervised sequence on a **single reused fleet** β 3 Qwen (A100-80GB) + 1 Kimi +
-1 Claude + 1 coordinator (n2). The fleet is provisioned once; each batch is
-(re)started on the same VMs. VMs are **STOPped, never deleted**; artifacts live on
-the coordinator's 500 GB disk and are egressed to the operator before each advance.
-
-The sequencer (`sweep_run.sh`) only orchestrates β all cost-safety logic lives in
-the tested `lib/cost_safety.sh`, `lib/distributed_start.sh`, and `launch_distributed.sh`.
-
----
-
-## Two duration caps (do NOT conflate)
-
-| knob | meaning | value | enforced by |
-|---|---|---|---|
-| `MAX_RUN_DURATION` | GCP provision ceiling (backstop; every VM STOPs at this age) | `120h` | `--max-run-duration` at create |
-| `BATCH_CAP` | per-batch on-VM watchdog, re-armed each `next-batch` | `6h` | `arm_watchdog β¦ 0` (fail-closed) |
-
-`provision` passes `MAX_RUN_DURATION` to the launcher. `next-batch` re-arms the
-watchdog with `MAX_RUN_DURATION="$BATCH_CAP"` scoped to that call only. Never set
-the GCP ceiling to `BATCH_CAP`.
-
-## The 11 batches
-
-`n=0` smoke β then 10 conditional batches. Each ablates one variable DOWN from the
-fair default baseline (image_text Β· last3 single-message Β· egocentric Β· one_shot;
-see `docs/validation10_condition_sweep_rollout.md`). Order and weights (relative
-runtime, for the live-calibrated ETA) are in `scripts/sweep_state.py::BATCHES`:
-
-| n | run_id | conditions / variant | weight |
-|---|---|---|---:|
-| 0 | smoke | 3-model fleet smoke (non-conditional) | 0.1 |
-| 1 | cond_prompt | Prompt (standard baseline + minimal + verbose) | 3.0 |
-| 2 | cond_obs_image_only | Observation format / image_only | 1.0 |
-| 3 | cond_ctx_current | Context window / current (0-history) | 1.0 |
-| 4 | cond_ctx_text_summary | Context window / text_summary | 1.0 |
-| 5 | cond_act_cardinal | Action space / cardinal | 1.0 |
-| 6 | cond_qry_subgoal | Querying strategy / subgoal | 1.0 |
-| 7 | cond_qry_full_trajectory | Querying strategy / full_trajectory | 1.0 |
-| 8 | cond_icl_zero_shot | In-context learning / zero_shot | 1.0 |
-| 9 | cond_hist_multiturn | History mechanism / multiturn | 1.3 |
-| 10 | cond_baseline_thinking | Prompt / standard (thinking ON) | 3.0 |
-
-(`text_only` is deferred to a future point β variant stays implemented, not run.)
-
-**Batch 0 (smoke) is started by `provision` itself** (the launcher always starts a
-run; we make that run the cheap 3-model smoke). Batches 1β10 are each started by
-`next-batch N`. Batch 0 validates all three workers on the real fleet before any
-paid conditional batch.
-
-**Batch 10 (`cond_baseline_thinking`) runs Kimi in thinking-ON mode** β the Kimi
-agent pins its temperature to **1.0** (thinking-off batches use 0.6); this is forced
-in `interface/agents/kimi_k26.py`, not the config. Thinking-ON Kimi can spend its
-whole token budget on reasoning and truncate on hard mazes even at `max_tokens
-16384` β expect some Kimi `parse_failed` on batch 10 and do not mistake it for a
-fleet fault.
-
----
-
-## 1. Preflight
-
-```bash
-set -a; source .env; set +a # .env is NOT auto-sourced
-: "${ANTHROPIC_API_KEY:?}"; : "${MOONSHOT_API_KEY:?}" # fail fast if unset
-python -m pytest tests/test_sweep_run.py tests/test_sweep_state.py \
- tests/test_summarize_run.py tests/test_distributed_topology.py -q
-git diff --quiet && git diff --cached --quiet || echo "COMMIT FIRST: a paid run needs a clean sha"
-```
-
-- All four test files green.
-- Working tree clean (the launcher's `require_clean_tree` gate refuses a dirty run;
- the on-VM code is verified to match the committed sha).
-- Coordinator image disk has headroom for 10 batches of artifacts (500 GB is ample;
- each batch is egressed + can be pruned).
-- The results repo (`Multinet-v2-results/`) is a **separate** initialized git repo
- with an `origin` remote you can push to (it is gitignored from the code repo).
-
-## 2. Provision (brings the fleet UP; starts batch 0 only)
-
-```bash
-export SWEEP_ID=cond-sweep-YYYYMMDD
-export ZONE=asia-northeast1-a
-export ZONES="asia-northeast1-a asia-northeast1-c us-central1-a us-central1-b us-central1-c us-central1-f us-east1-b us-east4-c europe-west4-a europe-west4-b asia-southeast1-b asia-southeast1-c me-west1-b me-west1-c"
-export DEST="artifacts-pulled/$SWEEP_ID"
-export MAX_RUN_DURATION=120h # GCP ceiling (required)
-export BATCH_CAP=6h # per-batch watchdog
-export QWEN_WORKER_COUNT=3
-export DIFFICULTY_MAX=1000
-
-./sweep_run.sh provision
-```
-
-`provision` hunts the `$ZONES` for A100-80GB capacity (NE-Asia first), code-syncs
-the committed sha, applies the cost-safety net, starts the fleet running the smoke,
-and writes `.runs/$SWEEP_ID/{manifest.json,sweep_state.json}`. **It does not start
-any conditional batch** β stop here and wrap the loop.
-
-Check state any time: `./sweep_run.sh status`.
-
-## 3. The `/loop` kickoff prompt (paste into `/loop`, self-paced)
-
-> You are supervising the conditional sweep `$SWEEP_ID` on the already-provisioned
-> reused fleet (`.runs/$SWEEP_ID/manifest.json`). Work one batch at a time, disk-first,
-> egress-before-advance. NEVER delete a VM. NEVER push to the code repo's `main`.
->
-> Per-batch cycle (batch 0 is already running from provision; batches 1β9 you start):
-> 1. **Poll** the current batch until terminal. Read live counts with:
-> `Z=$(python3 -c 'import json;d=json.load(open(".runs/'"$SWEEP_ID"'/manifest.json"));print(d["zone"])'); C=$(python3 -c 'import json;d=json.load(open(".runs/'"$SWEEP_ID"'/manifest.json"));print(d["coordinator"]["name"])'); gcloud compute ssh "$C" --zone "$Z" --command 'curl -fsS http://127.0.0.1:8765/status'`
-> Terminal = `verified==unit_count` (complete) OR `running==0 && pending==0`
-> (partial). Watch `progress_total` to tell a slow batch from a stalled one; if it
-> is frozen past ~`BATCH_CAP` the on-VM watchdog will STOP the fleet (fail-closed).
-> 2. **Egress + record:** only once the batch is genuinely terminal (all
-> `verified==unit_count`, or an accepted partial per Β§6 β never a still-running
-> batch), run `./sweep_run.sh finalize-batch N`. A non-empty egress means "data
-> landed", NOT "batch complete" β you own the completeness check (step 1). If
-> finalize exits **40** (nothing landed) the fleet is left UP on purpose β
-> investigate; do NOT advance.
-> 3. **Summaries:** dispatch three summary subagents (template in Β§4), one per model
-> (Qwen / Kimi / Claude), against `$DEST//episode_runs.jsonl`.
-> 4. **Publish:** `./sweep_run.sh publish ` (mirrors to the results repo
-> minus PNGs, commits, pushes β results repo only).
-> 5. **Cycle the API VMs (optional cost save):** once a batch's Kimi + Claude units
-> are all verified but Qwen is still finishing, `./sweep_run.sh stop-apis`
-> (STOPs only the e2 API runners). `next-batch` STARTs them back.
-> 6. **Advance:** `./sweep_run.sh next-batch $((N+1))` (restarts coordinator + workers
-> for the next batch, re-arms the watchdog @ `BATCH_CAP`).
-> 7. Update your running notes; `./sweep_run.sh status` shows the progress table + ETAs.
->
-> Failure policy: see Β§6. **Confirm-gate:** before starting batch 10
-> (`cond_baseline_thinking`), STOP and get explicit human go (Β§7).
-
-## 4. Summary-subagent prompt template (one per model)
-
-> Run: `python -m scripts.summarize_run $DEST//episode_runs.jsonl --model
-> --batch --out artifacts/summaries/__.md` (the `__` key MUST
-> match `publish`'s copy glob `artifacts/summaries/__*.md`; `` is only the
-> markdown heading). M β {`Qwen`, `Kimi` (or
-> `kimi`), `claude`} β match the `agent_or_model` substring). Then read the produced
-> `.md` and add 2β3 sentences of qualitative read: loops/truncations? which mazes
-> failed? token/cost surprises? Stage the 3rd backup: `mkdir -p
-> Multinet-v2-results/$SWEEP_ID//summaries && cp your `.md` there. Do **NOT**
-> run git and do **NOT** modify any source artifact β the loop publishes.
-
-## 5. API cycling
-
-The e2 API runners (Kimi + Claude) finish well before Qwen on most batches. Once
-their units all verify they can `stop-apis` (STOP only, disks preserved) to save cost
-while Qwen's tail runs; `next-batch` STARTs them again at the next batch. The
-coordinator (n2) and the three Qwen (A100) VMs are **never** in the stop-apis set.
-
-## 6. Failure runbook
-
-Classify from the terminal counts (`verified V / total T / failed F`):
-
-- **Light-partial** (`V β₯ ~0.8Β·T`, a few `failed`/truncated): accept the batch β
- `finalize-batch` (egress the partial), publish, note the failures, advance. Model
- truncation (esp. Kimi thinking-ON on batch 10) is expected, not a fleet fault.
-- **Heavy-fail** (`V < ~0.5Β·T`, or `finalize-batch` exits 40, or a stall STOPped the
- fleet): do **not** advance. Retry the batch **once** β if the fleet is up, re-run
- `next-batch N`; if a watchdog/hardcap STOPped it, `./sweep_run.sh provision` reuses
- the STOPped disks (data intact) then resume at N. On the **second** failure:
- `./sweep_run.sh teardown` (STOP all, preserve disks) and escalate to the human with
- the coordinator + worker logs.
-- **Egress fail-closed (exit 40):** the batch's artifacts did not land at
- `$DEST/`. The fleet is intentionally left UP (data on the coordinator disk).
- Fix the egress (disk/quota/ssh) and re-run `finalize-batch N` before advancing.
-
-`teardown` never deletes; `provision` after a teardown reattaches the same disks, so
-no data is lost across a stop/restart.
-
-## 7. Confirm-gate before batch 10
-
-Batch 10 (`cond_baseline_thinking`, weight 3.0, Kimi thinking-ON) is the most
-expensive batch. Before `next-batch 10`, STOP the loop and get an explicit human
-go-ahead, presenting: batches 0β9 all egressed + published, cumulative token/cost so
-far, and the calibrated ETA for batch 10 from `./sweep_run.sh status`.
-
----
-
-## Known live-path risk (read before the first advance)
-
-The **reused-fleet per-batch flow (`next-batch` / `finalize-batch`) has never run
-live** β only the single-run provisionβsuperviseβpull path was validated in the
-smoke. Two things to watch on the **first** `next-batch` (0β1 transition):
-
-1. `next-batch` `pkill`s the prior coordinator-serve and worker processes to free
- port 8765, then restarts everything. On the Qwen workers this drops the in-process
- vLLM engine β a **model reload (~14 min per GPU VM)** at every batch boundary. This
- is safe but adds ~15 min of idle GPU time per transition (Γ9). If a future
- run_pipeline worker tolerates a coordinator restart without exiting, the Qwen
- workers could be left warm β an optimization, not needed for correctness.
-2. Confirm the new coordinator binds `:8765` cleanly (the port-free check aborts
- `next-batch` if the old serve did not die) and that the workers re-attach and pull
- the new batch's units. Watch the 0β1 transition end-to-end before trusting the loop.
diff --git a/docs/system_design.md b/docs/system_design.md
index 6f1dad3..c8d3022 100644
--- a/docs/system_design.md
+++ b/docs/system_design.md
@@ -41,8 +41,6 @@ This document is the single canonical source of truth for how the MultiNet v2.0
### 1.2 Two-axis backend / inference decomposition
-
-
```
Spatial+Modality Backend Inference Adapter
(implements AbstractGridBackend) (talks to a model)
@@ -60,8 +58,6 @@ Each evaluation run is a 2-tuple `(backend, adapter)` plus a task. Same task acr
## 2. Pipeline DAG: stages, artifacts, invalidation
-
-
The pipeline is a five-stage DAG. Each stage has declared inputs and outputs and is keyed by a content hash so re-runs only touch stages whose inputs actually changed.
### 2.1 Stages
@@ -98,9 +94,6 @@ Stages 1β2 are per-task and produce the **task artifact bundle**. Stage 3 is p
### 2.2 Artifact layout
-
-
-
```
artifacts/
βββ tasks//
diff --git a/docs/test_implementation_summary.md b/docs/test_implementation_summary.md
deleted file mode 100644
index 2ddc417..0000000
--- a/docs/test_implementation_summary.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Test Implementation Summary
-
-## Overview
-
-This document summarizes the current test suite for the Multinet-v2.0 gridworld
-and multigrid framework. Tests are the source of truth for this branch.
-
-## Test Coverage
-
-### Collected Test Suite (261 tests)
-
-#### 1. Core Tiling Tests (`tests/test_tiling_generation.py`)
-- **Direction count tests**: Validates correct number of directions for each tiling type
- - Square: 4 directions (N, E, S, W)
- - Hexagonal: 6 directions (N, NE, SE, S, SW, NW)
- - Triangular: 3 directions
-- **Cell count tests**: Verifies correct grid cell generation
- - Square: width Γ height cells
- - Hex: width Γ height cells (rectangular layout)
- - Triangle: 480 cells for 10Γ8 grid (6 triangles per hex)
-- **Boundary detection**: Edge cells have fewer neighbors than interior cells
-- **Adjacency symmetry**: If A neighbors B, then B neighbors A (bidirectional)
-- **Determinism**: Same seed produces identical graphs
-
-#### 2. Coordinate Conversion Tests (`tests/test_coordinates.py`)
-- **Roundtrip conversion**: Canonical [0,1] β cell ID β canonical preserves position
-- **Corner mapping**: Corner positions map to boundary cells correctly
-- **Position uniqueness**: Each cell has a unique canonical position
-- Validates across all three tiling types (square, hex, triangle)
-
-#### 3. Distance Computation Tests (`tests/test_distance.py`)
-- **Manhattan distance**: Square grid uses Manhattan metric
-- **Hex metric**: Hexagonal grid uses appropriate hex distance
-- **Zero distance**: Distance from cell to itself is 0
-- **Symmetry**: Distance(A, B) = Distance(B, A)
-- Validates across all three tiling types
-
-#### 4. Action Execution Tests (`tests/test_actions.py`)
-- **Forward movement**: Agent moves in facing direction
-- **Turn actions**: Facing changes without position change
-- **Boundary collision**: Invalid move into wall/boundary returns error
-- **Object pickup**: Agent can pick up adjacent objects
-
-#### 5. Edge Case Tests (`tests/test_edge_cases.py`)
-- **Corner behavior**: Agents at corners have exactly 2 movement options
-- **Edge behavior**: Agents at edges have 3 movement options
-- **Deterministic reset**: Seed 0 produces identical observations
-- **Max steps truncation**: Episodes truncate at max_steps limit
-- **Deterministic across tilings**: All tilings produce deterministic results
-- **Boundary movement**: Cannot move off grid edges
- - North edge test
- - East edge test
- - All boundary directions for all tilings
-
-#### 6. Performance Tests (`tests/test_performance.py`)
-- **Reset time benchmarks**:
- - Small grids (10Γ10): < 200ms average
- - Medium grids (25Γ25): < 200ms average
- - Large grids (50Γ50): < 700ms average
- - Tests all three tiling types
-- **Step throughput**:
- - Square/Hex: > 700 steps/second
- - Triangle: > 100 steps/second (more cells = slower)
-- **Large grid scalability**:
- - 100Γ100 grids: reset < 2s, 100 steps < 2s
-- **Memory efficiency**:
- - Environment instances use < 10MB each (requires psutil)
-- **Rapid reset**: > 50 episodes/second
-- **Scalability tests**:
- - Many objects (1, 10, 50): performance scales reasonably
- - Concurrent environments: multiple envs maintain independent state
-
-## Performance Benchmarks (Measured)
-
-| Tiling | Grid Size | Reset Time (avg) | Throughput |
-|----------|-----------|------------------|--------------|
-| Square | 10Γ10 | 0.4 ms | ~2500 steps/s|
-| Square | 25Γ25 | 2.5 ms | ~2000 steps/s|
-| Square | 50Γ50 | 12.4 ms | ~1500 steps/s|
-| Hex | 10Γ10 | 0.9 ms | ~1300 steps/s|
-| Hex | 25Γ25 | 5.6 ms | ~1200 steps/s|
-| Hex | 50Γ50 | 24.8 ms | ~900 steps/s |
-| Triangle | 10Γ10 | 8.5 ms | ~200 steps/s |
-| Triangle | 25Γ25 | 42.4 ms | ~150 steps/s |
-| Triangle | 50Γ50 | 186.7 ms | ~135 steps/s |
-
-**Note**: Triangle tiling has 6Γ more cells than square/hex for same grid dimensions, explaining slower performance.
-
-## Regression Coverage
-
-Current regression tests cover:
-
-1. **Random policy seeding** in `gridworld/runner/grid_runner.py`.
-2. **Block position extraction** in `gridworld/backends/minigrid_backend.py`.
-3. **Gymnasium plugin isolation** in `gridworld/bootstrap.py`.
-4. **Canonical gridworld round trips** in `cross_domain/`.
-5. **Backend conversion fidelity** for doors, gates, switches, hazards, and teleporters.
-
-## Visualization
-
-Grid visualization scripts confirmed working:
-- `visualize_grid.py` generates:
- - `grid_visualization_square.png` (43 KB)
- - `grid_visualization_hex.png` (312 KB)
- - `grid_visualization_triangle.png` (640 KB)
- - `environment_comparison.png` (284 KB)
-
-Visualization checks cover square, hex, triangle, and the newer Archimedean
-tilings through targeted rendering tests.
-
-## Test Execution
-
-```bash
-# Run all tests
-python -m pytest tests/ -v
-
-# Run specific test suite
-python -m pytest tests/test_edge_cases.py -v
-python -m pytest tests/test_performance.py -v
-
-# Run with performance output
-python -m pytest tests/test_performance.py -v -s
-```
-
-## Files Covered
-
-**Runtime and interface test files include**:
-- `tests/test_backend_integration.py`
-- `tests/test_model_interface.py`
-- `tests/test_partial_observability.py`
-- `tests/test_multigrid_partial_obs.py`
-- `tests/test_teleporters.py`
-- `tests/test_task_spec_validation.py`
-- `tests/test_vlm_sanity_check.py`
-- `tests/test_chat_smoke_test.py`
-- `tests/test_probe_vlm.py`
-- `tests/test_standalone_surface.py`
-
-**Core multigrid test files include**:
-- `multigrid/test_multigrid.py`
-- `tests/test_tiling_generation.py`
-- `tests/test_coordinates.py`
-- `tests/test_distance.py`
-- `tests/test_actions.py`
-- `tests/test_exotic_tilings.py`
-- `tests/test_edge_cases.py`
-- `tests/test_performance.py`
-
-## Coverage Areas
-
-- Tiling generation, coordinate conversion, and distance metrics
-- Action execution and boundary behavior
-- Object interactions, zones, hazards, switches, gates, and teleporters
-- MiniGrid/MultiGrid backend conversion fidelity
-- Partial observability and fog-of-war rendering
-- Task-spec validation and beatability scoring
-- Evaluation harness metrics and serialization
-- Model adapters for random, file-based, Ollama, LM Studio, and NL modes
-
-## Next Steps (Future Work)
-
-1. Keep task-file tests synchronized with `gridworld/tasks` and `mazes/validation_10`.
-2. Add backend-parity tests whenever a mechanism is extended.
-3. Add full-run benchmark smoke tests for any new CLI mode.
-
-## Conclusion
-
-The test suite provides coverage of core Multinet-v2.0 functionality across:
-- Graph generation and topology
-- Coordinate systems and conversions
-- Distance metrics
-- Action execution
-- Edge cases and boundary conditions
-- Performance benchmarks
-
-Use `python -m pytest --collect-only -q` to verify discovery and
-`python -m pytest tests/ -v --ignore=tests/test_performance.py` for the main
-non-performance suite.
diff --git a/docs/validation10_condition_sweep_rollout.md b/docs/validation10_condition_sweep_rollout.md
deleted file mode 100644
index b708045..0000000
--- a/docs/validation10_condition_sweep_rollout.md
+++ /dev/null
@@ -1,171 +0,0 @@
-# Conditional condition-sweep rollout
-
-How to launch the **7-set** condition sweep across **Qwen3.6-27B (local,
-FP16/vLLM), Kimi, and Claude** over the 15-maze conditional evaluation, covering
-every prompt variable **once** without re-paying for the shared baseline in every
-condition set.
-
-## Fair default baseline (2026-07-04 rebase)
-
-The sweep ablates **down** from a baseline the models can actually perform in, so
-that changing one dependent variable measures signal, not noise off a floored
-baseline (an earlier stateless/image-only default made every model loop to the
-step cap β see the 2026-07-03 smoke). The default `ExperimentConfig` is:
-
-```
-prompting=standard Β· observation=image_text (+ current-observation description) Β·
-context_window=last3 (single-message history, chat_history=stateless) Β·
-action_space=egocentric Β· querying=step_by_step Β· in_context_learning=one_shot
-```
-
-Every set's **baseline variant is the one that equals this default**, so it is
-run once (under `Prompt/standard`) and reused as the comparison cell for all
-axes:
-
-```
-standard β‘ image_text β‘ last3 β‘ egocentric β‘ step_by_step β‘ one_shot β‘ single_message (= default ExperimentConfig)
-```
-
-Each condition set then runs only the variants that **differ** from this default.
-
-**History is two coupled knobs.** *Amount* is `context_window`
-(`current`/`last3`/`text_summary`, all rendered in one stateless message) β set 3.
-*Mechanism* is the new **History mechanism** set (set 7): the single-message
-default vs a multi-turn rolling chat (`chat_history=rolling`, one image per prior
-turn). The two are coupled in the variant overrides so history is never
-double-counted (in-prompt **and** as turns).
-
-**Models & thinking (as configured in the run-configs):**
-
-- **Claude = Opus 4.8** (`claude-opus-4-8`, key `claude_opus`). The agent omits
- `temperature` for the Opus-4.7+ family (it 400s otherwise). The experimental
- configs run **adaptive thinking at `effort: low`**; paid `max_tokens` stays 4096.
-- **Kimi = `enable_thinking: false`, `temperature: 0.6`** on the experimental
- configs (thinking-on truncates before FINAL_OUTPUT at 4096; Moonshot rejects
- temp < 0.6).
-- **Qwen = Qwen3.6-27B, FP16 via vLLM** on the `qwen-fp16-80` A100-80GB image,
- `enable_thinking: true` (local). **Deferred for now** β single-stream decode of
- a 27B FP16 model on A100 is ~20β35 tok/s, so a thinking maze takes hours; the
- Qwen leg waits on a batched-rollout throughput fix (tracked separately). The
- API leg (Kimi + Claude) runs first on API-only infra (`SWEEP_TOPO=api`, no
- A100s) via `run_config.conditional__claude_kimi.json`.
-- **The thinking probe** (`run_config.conditional_baseline_thinking_*`): the
- shared baseline re-run with Opus `effort: xhigh` and all models thinking-on,
- paid `max_tokens` raised to 8192 β isolates reasoning-depth value vs the
- `effort: low` sweep.
-
-## Variant inventory
-
-Each set's **baseline** variant builds the default `ExperimentConfig` above (its
-`config_overrides` resolve to the default values); the baselines are
-byte-identical prompts and (at `temperature 0.0`) the *same run*.
-
-| Condition set (`--conditions`) | Variant (run-dir name) | Kind | Run in sweep |
-|---|---|---|---|
-| `Prompt` | `standard` | **baseline** | yes (batch 1) |
-| `Prompt` | `minimal` | distinct | yes |
-| `Prompt` | `verbose` | distinct | yes |
-| `Observation format` | `image_text` | baseline (β‘ standard) | as baseline |
-| `Observation format` | `image_only` | distinct | yes |
-| `Observation format` | `text_only` | distinct | **deferred (future point)** |
-| `Context window` | `last3` | baseline (β‘ standard) | as baseline |
-| `Context window` | `current` | distinct (0-history) | yes |
-| `Context window` | `text_summary` | distinct | yes |
-| `Action space` | `egocentric` | baseline (β‘ standard) | as baseline |
-| `Action space` | `cardinal` | distinct | yes |
-| `Querying strategy` | `step_by_step` | baseline (β‘ standard) | as baseline |
-| `Querying strategy` | `subgoal` | distinct | yes |
-| `Querying strategy` | `full_trajectory` | distinct | yes |
-| `In-context learning` | `one_shot` | baseline (β‘ standard) | as baseline |
-| `In-context learning` | `zero_shot` | distinct | yes |
-| `History mechanism` | `single_message` | baseline (β‘ standard) | as baseline |
-| `History mechanism` | `multiturn` | distinct | yes |
-
-Unique configs after baseline dedup = **12** (the shared baseline plus `minimal`,
-`verbose`, `image_only`, `text_only`, `current`, `text_summary`, `cardinal`,
-`subgoal`, `full_trajectory`, `zero_shot`, `multiturn`). `text_only` is deferred,
-so **11 unique effort-low configs run**, plus the thinking probe.
-
-Coverage + the dedup invariant are locked by tests in
-`tests/test_run_pipeline.py`
-(`test_launch_condition_sets_expose_expected_variants`,
-`test_baseline_variant_of_every_launch_set_is_the_default_config`,
-`test_dedup_rollout_covers_every_unique_variant_config_once`,
-`test_conditional_run_configs_pair_conditional_eval_with_all_six_sets`) and the
-batch list in `tests/test_sweep_state.py`.
-
-## Deduplicated rollout (the sweep BATCHES)
-
-Run the **shared baseline once** (free with the `Prompt` set, which also gives
-`minimal` + `verbose`), then run only the **non-baseline** variants of the other
-sets via `--prompt-variant`. Encoded in `scripts/sweep_state.py::BATCHES`
-(batch 0 = smoke):
-
-| Batch | `--conditions` | `--prompt-variant` | run_id |
-|---|---|---|---|
-| 1 | `Prompt` | _(none β all)_ β standard(baseline), minimal, verbose | `cond_prompt` |
-| 2 | `Observation format` | `image_only` | `cond_obs_image_only` |
-| 3 | `Context window` | `current` | `cond_ctx_current` |
-| 4 | `Context window` | `text_summary` | `cond_ctx_text_summary` |
-| 5 | `Action space` | `cardinal` | `cond_act_cardinal` |
-| 6 | `Querying strategy` | `subgoal` | `cond_qry_subgoal` |
-| 7 | `Querying strategy` | `full_trajectory` | `cond_qry_full_trajectory` |
-| 8 | `In-context learning` | `zero_shot` | `cond_icl_zero_shot` |
-| 9 | `History mechanism` | `multiturn` | `cond_hist_multiturn` |
-| 10 | `Prompt` | `standard` (thinking probe) | `cond_baseline_thinking` |
-
-Batch 10 uses `run_config.conditional_baseline_thinking_*`: the baseline re-run
-with Opus `effort: xhigh` + all models thinking-on.
-
-## The configs at a glance
-
-Configs 1β11 are the deduplicated `effort: low` sweep; config 12 is the thinking
-probe. Thinking columns are **Opus effort / Kimi / Qwen**.
-
-| # | Config (run-dir) | Axis it varies | Batch | Opus | Kimi | Qwen |
-|---|---|---|---|---|---|---|
-| 1 | `standard` | baseline (default `ExperimentConfig`) | 1 | low | off | on |
-| 2 | `minimal` | Prompt | 1 | low | off | on |
-| 3 | `verbose` | Prompt | 1 | low | off | on |
-| 4 | `image_only` | Observation format | 2 | low | off | on |
-| 5 | `current` | Context window (amount) | 3 | low | off | on |
-| 6 | `text_summary` | Context window (amount) | 4 | low | off | on |
-| 7 | `cardinal` | Action space | 5 | low | off | on |
-| 8 | `subgoal` | Querying strategy | 6 | low | off | on |
-| 9 | `full_trajectory` | Querying strategy | 7 | low | off | on |
-| 10 | `zero_shot` | In-context learning | 8 | low | off | on |
-| 11 | `multiturn` | History mechanism | 9 | low | off | on |
-| 12 | `standard` **+ thinking** | baseline re-run β reasoning-depth probe | 10 | **xhigh** | **on** | on |
-
-> `text_only` (Observation format) is intentionally not in the rollout right now
-> (future point). The variant stays implemented and registry-covered; to run it
-> later, add one batch `Observation format --prompt-variant text_only`.
-
-### Analysis note
-
-The baseline rollout lives in **batch 1** under the `standard/` run dir. When you
-compare *within* the `Observation format`, `Context window`, `Action space`,
-`Querying strategy`, `In-context learning`, or `History mechanism` axes, use that
-`standard/` rollout as the baseline cell β there is no `image_text/`, `last3/`,
-`egocentric/`, `step_by_step/`, `one_shot/`, or `single_message/` directory in
-batches 2β9 by design.
-
-## Split: API-only first, Qwen later
-
-`SWEEP_TOPO=api` selects the `run_config.conditional__claude_kimi.json`
-fixtures (Kimi + Claude only, no qwen model). The topology derives 0 GPU workers,
-so `provision` skips the A100 hunt and brings up only the coordinator + 2 e2 API
-VMs. Run the API leg today (`QWEN_WORKER_COUNT=0`); add Qwen back via the full
-`_claude_kimi_qwen` configs once the throughput fix lands.
-
-## Manifest / difficulty
-
-- Manifest: `gridworld/fixtures/manifest.conditional_eval.json` (15 mazes).
-- Use `DIFFICULTY_MAX=1000` across all batches (launcher default) so runtime
- normalization is comparable.
-
-## Smoke first (orchestration only)
-
-Before the paid sweep, validate coordinator work-stealing with the smoke job
-(`run_config.smoke_qwen36_kimi_claude.json` over `manifest.smoke_eval.json`,
-3 mazes). It is for orchestration only, not measurement.
diff --git a/example_usage.py b/example_usage.py
deleted file mode 100644
index 0c74235..0000000
--- a/example_usage.py
+++ /dev/null
@@ -1,240 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example usage of the MultiGrid environment.
-
-This script demonstrates the basic functionality of the MultiGrid system.
-"""
-
-import sys
-import os
-
-# Add parent directory to path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-from multigrid.env import MultiGridEnv
-from multigrid.agent import Action
-
-
-def basic_example():
- """Basic example: Create environment and execute actions."""
- print("=" * 60)
- print("BASIC EXAMPLE: Square Grid Navigation")
- print("=" * 60)
-
- # Create a simple task
- task_spec = {
- "task_id": "example_001",
- "seed": 42,
- "scene": {
- "bounds": {"width": 1.0, "height": 1.0},
- "objects": [
- {
- "id": "cube_red",
- "type": "movable",
- "color": "red",
- "position": {"x": 0.7, "y": 0.7},
- "size": 0.1
- }
- ],
- "agent": {
- "position": {"x": 0.2, "y": 0.2},
- "facing": 0 # Facing north
- }
- },
- "goal": {
- "predicate": "object_in_zone",
- "object_id": "cube_red",
- "zone_id": "zone_blue"
- },
- "limits": {"max_steps": 100},
- "tiling": {"type": "square", "grid_size": {"width": 10, "height": 10}}
- }
-
- # Create environment
- env = MultiGridEnv(task_spec, tiling="square")
- obs, info = env.reset(seed=42)
-
- print(f"\nInitial state:")
- state = env.get_state_dict()
- print(f" Agent position: {state['agent']['cell_id']}")
- print(f" Agent facing: {state['agent']['facing_direction']}")
- print(f" Agent holding: {state['agent']['holding']}")
-
- # Execute some actions
- actions = [
- (Action.FORWARD, "Move forward"),
- (Action.TURN_RIGHT, "Turn right"),
- (Action.FORWARD, "Move forward"),
- (Action.FORWARD, "Move forward"),
- ]
-
- print(f"\nExecuting {len(actions)} actions:")
- for action, description in actions:
- obs, reward, terminated, truncated, info = env.step(action)
- state = env.get_state_dict()
-
- print(f"\n Action: {description}")
- print(f" New position: {state['agent']['cell_id']}")
- print(f" Facing: {state['agent']['facing_direction']}")
- print(f" Reward: {reward:.2f}")
- if info.get('invalid_action'):
- print(f" β οΈ Invalid action!")
-
-
-def multi_tiling_example():
- """Demonstrate the same task on different tilings."""
- print("\n" + "=" * 60)
- print("MULTI-TILING EXAMPLE: Same Task, Different Grids")
- print("=" * 60)
-
- task_spec = {
- "task_id": "example_002",
- "seed": 42,
- "scene": {
- "bounds": {"width": 1.0, "height": 1.0},
- "objects": [],
- "agent": {
- "position": {"x": 0.5, "y": 0.5},
- "facing": 0
- }
- },
- "goal": {},
- "limits": {"max_steps": 100},
- "tiling": {"type": "square", "grid_size": {"width": 10, "height": 10}}
- }
-
- for tiling_name in ["square", "hex", "triangle"]:
- print(f"\n{tiling_name.upper()} TILING:")
-
- env = MultiGridEnv(task_spec, tiling=tiling_name)
- obs, info = env.reset()
-
- tiling = env.tiling
- print(f" Directions: {tiling.directions}")
- print(f" Direction count: {len(tiling.directions)}")
- print(f" Total cells: {len(tiling.cells)}")
-
- # Check a cell's neighbors
- first_cell_id = list(tiling.cells.keys())[50] # Pick a middle cell
- cell = tiling.cells[first_cell_id]
- print(f" Sample cell {first_cell_id} has {len(cell.neighbors)} neighbors")
-
-
-def object_interaction_example():
- """Demonstrate object interaction (pickup, drop, push)."""
- print("\n" + "=" * 60)
- print("OBJECT INTERACTION EXAMPLE")
- print("=" * 60)
-
- task_spec = {
- "task_id": "example_003",
- "seed": 42,
- "scene": {
- "bounds": {"width": 1.0, "height": 1.0},
- "objects": [
- {
- "id": "cube_red",
- "type": "movable",
- "color": "red",
- "position": {"x": 0.4, "y": 0.2},
- "size": 0.1
- }
- ],
- "agent": {
- "position": {"x": 0.2, "y": 0.2},
- "facing": 1 # Facing east
- }
- },
- "goal": {},
- "limits": {"max_steps": 100},
- "tiling": {"type": "square", "grid_size": {"width": 10, "height": 10}}
- }
-
- env = MultiGridEnv(task_spec, tiling="square")
- obs, info = env.reset()
-
- print(f"\nInitial state:")
- state = env.get_state_dict()
- print(f" Agent: {state['agent']['cell_id']} (facing {state['agent']['facing_direction']})")
- print(f" Red cube: {state['objects']['cube_red']['cell_id']}")
- print(f" Holding: {state['agent']['holding']}")
-
- # Move to object and pick it up
- print(f"\n1. Moving forward to object...")
- obs, reward, _, _, info = env.step(Action.FORWARD)
- state = env.get_state_dict()
- print(f" Agent: {state['agent']['cell_id']}")
-
- print(f"\n2. Picking up object...")
- obs, reward, _, _, info = env.step(Action.PICKUP)
- state = env.get_state_dict()
- print(f" Holding: {state['agent']['holding']}")
- if state['agent']['holding']:
- print(f" β Successfully picked up {state['agent']['holding']}!")
-
- print(f"\n3. Moving with object...")
- obs, reward, _, _, info = env.step(Action.FORWARD)
- state = env.get_state_dict()
- print(f" Agent: {state['agent']['cell_id']} (still holding {state['agent']['holding']})")
-
- print(f"\n4. Dropping object...")
- obs, reward, _, _, info = env.step(Action.DROP)
- state = env.get_state_dict()
- print(f" Holding: {state['agent']['holding']}")
- print(f" β Object dropped at agent's location!")
-
-
-def distance_calculation_example():
- """Demonstrate distance calculations on different tilings."""
- print("\n" + "=" * 60)
- print("DISTANCE CALCULATION EXAMPLE")
- print("=" * 60)
-
- for tiling_name in ["square", "hex", "triangle"]:
- from multigrid.tilings import SquareTiling, HexTiling, TriangleTiling
-
- tiling_class = {
- "square": SquareTiling,
- "hex": HexTiling,
- "triangle": TriangleTiling
- }[tiling_name]
-
- tiling = tiling_class()
- tiling.generate_graph(10, 10, seed=0)
-
- # Calculate distance between two cells
- cell_ids = list(tiling.cells.keys())
- cell_a = cell_ids[10]
- cell_b = cell_ids[50]
-
- distance = tiling.distance(cell_a, cell_b)
-
- print(f"\n{tiling_name.upper()} TILING:")
- print(f" Distance from {cell_a} to {cell_b}: {distance} hops")
-
- # Get coordinates
- pos_a = tiling.cell_to_canonical(cell_a)
- pos_b = tiling.cell_to_canonical(cell_b)
- print(f" Canonical positions: {pos_a} -> {pos_b}")
-
-
-def main():
- """Run all examples."""
- print("\n" + "#" * 60)
- print("# MultiGrid-v2.0 - Usage Examples")
- print("#" * 60)
-
- basic_example()
- multi_tiling_example()
- object_interaction_example()
- distance_calculation_example()
-
- print("\n" + "#" * 60)
- print("# All examples completed successfully!")
- print("#" * 60)
- print("\nTo run tests: python -m pytest tests/ -v")
- print("To visualize: python visualize_grid.py")
-
-
-if __name__ == "__main__":
- main()
diff --git a/gridworld/baselines.py b/gridworld/baselines.py
index a0dc255..64a5639 100644
--- a/gridworld/baselines.py
+++ b/gridworld/baselines.py
@@ -63,8 +63,9 @@ class PlannedPath:
class TaskPlanningContext:
"""Fast lookup tables derived from a ``TaskSpecification``."""
- def __init__(self, spec: TaskSpecification):
+ def __init__(self, spec: TaskSpecification, *, drop_available: bool = False):
self.spec = spec
+ self.drop_available = drop_available
self.width, self.height = spec.maze.dimensions
self.goal = spec.resolved_goal()
self.start = spec.maze.start.to_tuple()
@@ -253,6 +254,39 @@ def _successors(ctx: TaskPlanningContext, state: PlannerState) -> Iterable[Trans
),
)
+ # DROP exists in the planner graph only when the episode's harness exposed
+ # it to the model. R1 had no DROP, so a decoy-key pickup was terminal; the
+ # 2026-07-30 rerun did, so the same state is recoverable. The dropped key
+ # stays in collected_keys here β it leaves the world rather than becoming
+ # re-acquirable β but the runtime disagrees: custom_env.py's DROP handler
+ # does `self.collected_keys.discard(key_id)` (custom_env.py:549), so the
+ # agent CAN walk back and re-pick up a key it dropped. That mismatch makes
+ # this model "conservative" for escapability (it never claims a state is
+ # winnable when it isn't) but WRONG, in the over-reporting direction, for
+ # doomedness: on the D2 spec, with drop_available=True, this model reports
+ # 456 doomed states, of which 304 are false β every state where the agent
+ # dropped a key it still needs and could still retrieve. No row in the
+ # current corpus is affected (both drop_available=True primary/
+ # supplementary episodes are doomed=False), but this MUST be revisited
+ # before scoring any future episode that actually emits DROP, or a
+ # recoverable state will be scored "mechanically unwinnable" when it is
+ # not.
+ if ctx.drop_available and state.carrying_key is not None:
+ yield Transition(
+ action=int(MiniGridActions.DROP),
+ label=f"drop:{state.carrying_key}",
+ next_state=PlannerState(
+ agent_pos=state.agent_pos,
+ agent_dir=state.agent_dir,
+ carrying_key=None,
+ collected_keys=state.collected_keys,
+ active_switches=state.active_switches,
+ used_switches=state.used_switches,
+ open_gates=state.open_gates,
+ open_doors=state.open_doors,
+ ),
+ )
+
switch = ctx.switches_by_pos.get(state.agent_pos)
if switch and switch["switch_type"] != "hold":
toggled = _apply_switch(ctx, state, switch)
@@ -454,8 +488,10 @@ def _bfs_actions(spec: TaskSpecification) -> list[int]:
return actions
-def _bfs_actions_with_stats(spec: TaskSpecification) -> tuple[list[int], int]:
- ctx = TaskPlanningContext(spec)
+def _bfs_actions_with_stats(
+ spec: TaskSpecification, *, drop_available: bool = False
+) -> tuple[list[int], int]:
+ ctx = TaskPlanningContext(spec, drop_available=drop_available)
actions, _, states_explored = _shortest_plan(
ctx,
ctx.initial_state(),
@@ -487,9 +523,11 @@ def _greedy_actions(spec: TaskSpecification) -> list[int]:
return actions
-def trace_planned_actions(spec: TaskSpecification, actions: list[int]) -> PlannedPath:
+def trace_planned_actions(
+ spec: TaskSpecification, actions: list[int], *, drop_available: bool = False
+) -> PlannedPath:
"""Replay planner actions through the planner graph without running a backend."""
- ctx = TaskPlanningContext(spec)
+ ctx = TaskPlanningContext(spec, drop_available=drop_available)
state = ctx.initial_state()
positions = [state.agent_pos]
executed_actions: list[int] = []
@@ -533,10 +571,10 @@ def plan_greedy_actions(spec: TaskSpecification) -> list[int]:
return _greedy_actions(spec)
-def plan_bfs_path(spec: TaskSpecification) -> PlannedPath:
+def plan_bfs_path(spec: TaskSpecification, *, drop_available: bool = False) -> PlannedPath:
"""Return the BFS baseline plan plus replayed positions."""
- actions, states_explored = _bfs_actions_with_stats(spec)
- path = trace_planned_actions(spec, actions)
+ actions, states_explored = _bfs_actions_with_stats(spec, drop_available=drop_available)
+ path = trace_planned_actions(spec, actions, drop_available=drop_available)
return PlannedPath(
success=path.success,
actions=path.actions,
diff --git a/gridworld/demo.py b/gridworld/demo.py
deleted file mode 100644
index 7e2f8dd..0000000
--- a/gridworld/demo.py
+++ /dev/null
@@ -1,479 +0,0 @@
-#!/usr/bin/env python3
-"""
-MiniGrid Backend Demo
-
-Demonstrates the MiniGridBackend (gymnasium-based) for standard square grid tasks.
-Shows loading tasks, running episodes, using policies, and saving visualizations.
-
-Usage:
- python gridworld/demo.py # Run all demos
- python gridworld/demo.py --visual # Save PNG images of each demo
- python gridworld/demo.py --play # Interactive play mode
- python gridworld/demo.py --play --task tier2/single_key_001 # Play specific task
-"""
-
-import sys
-import argparse
-from pathlib import Path
-import numpy as np
-
-# Ensure imports work from the repository root
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from gridworld.task_spec import TaskSpecification
-from gridworld.backends import get_backend, MiniGridBackend
-from gridworld.backends.base import GridState
-from gridworld.runner.grid_runner import GridRunner
-from gridworld.actions import MiniGridActions, ACTION_NAMES
-from gridworld.envs.tier_envs import list_available_envs
-
-
-def interactive_play(task_path: str = None):
- """
- Interactive play mode - control the agent with keyboard.
-
- Controls:
- Arrow Keys: Move/Turn (Up=forward, Left/Right=turn)
- Space: Pickup
- D: Drop
- T or Enter: Toggle (open door, activate switch)
- R: Reset episode
- Q or Escape: Quit
- """
- import pygame
-
- # Default to a tier 2 task for interesting gameplay
- if task_path is None:
- task_path = Path(__file__).parent / "tasks" / "tier2" / "single_key_001.json"
- else:
- # Handle relative paths like "tier2/single_key_001"
- if not Path(task_path).exists():
- task_path = Path(__file__).parent / "tasks" / f"{task_path}.json"
-
- spec = TaskSpecification.from_json(str(task_path))
-
- print("\n" + "=" * 60)
- print("Interactive Play Mode")
- print("=" * 60)
- print(f"\nTask: {spec.task_id}")
- print(f"Description: {spec.description}")
- print(f"\nControls:")
- print(" Arrow Up : Move forward")
- print(" Arrow Left : Turn left")
- print(" Arrow Right : Turn right")
- print(" Space : Pickup")
- print(" D : Drop")
- print(" T / Enter : Toggle (doors, switches)")
- print(" R : Reset")
- print(" Q / Escape : Quit")
- print("\n" + "-" * 60)
-
- # Create backend with rgb_array mode (we'll display via pygame)
- backend = get_backend("minigrid", render_mode="rgb_array")
- backend.configure(spec)
- obs, state, info = backend.reset(seed=42)
-
- # Initialize pygame
- pygame.init()
-
- # Scale up for visibility
- scale = 2
- display_size = (obs.shape[1] * scale, obs.shape[0] * scale)
- screen = pygame.display.set_mode(display_size)
- pygame.display.set_caption(f"MiniGrid: {spec.task_id}")
-
- # Key mapping
- key_to_action = {
- pygame.K_UP: MiniGridActions.MOVE_FORWARD,
- pygame.K_LEFT: MiniGridActions.TURN_LEFT,
- pygame.K_RIGHT: MiniGridActions.TURN_RIGHT,
- pygame.K_SPACE: MiniGridActions.PICKUP,
- pygame.K_d: MiniGridActions.DROP,
- pygame.K_t: MiniGridActions.TOGGLE,
- pygame.K_RETURN: MiniGridActions.TOGGLE,
- }
-
- clock = pygame.time.Clock()
- running = True
- step_count = 0
-
- def render_frame():
- # Convert numpy array to pygame surface
- surf = pygame.surfarray.make_surface(obs.swapaxes(0, 1))
- surf = pygame.transform.scale(surf, display_size)
- screen.blit(surf, (0, 0))
- pygame.display.flip()
-
- def print_status():
- carrying = state.agent_carrying if state.agent_carrying else "nothing"
- print(f" Step {step_count}: pos={state.agent_position}, carrying={carrying}")
-
- render_frame()
- print(f"\nStarting at {state.agent_position}")
-
- while running:
- for event in pygame.event.get():
- if event.type == pygame.QUIT:
- running = False
- elif event.type == pygame.KEYDOWN:
- if event.key in (pygame.K_q, pygame.K_ESCAPE):
- running = False
- elif event.key == pygame.K_r:
- # Reset
- obs, state, info = backend.reset(seed=42)
- step_count = 0
- render_frame()
- print("\n--- Episode Reset ---")
- print(f"Starting at {state.agent_position}")
- elif event.key in key_to_action:
- action = key_to_action[event.key]
- obs, reward, terminated, truncated, state, info = backend.step(action)
- step_count += 1
- render_frame()
- print_status()
-
- if terminated:
- print("\n*** GOAL REACHED! ***")
- print(f"Completed in {step_count} steps")
- print("Press R to reset or Q to quit")
- elif truncated:
- print("\n*** TIME LIMIT REACHED ***")
- print("Press R to reset or Q to quit")
-
- clock.tick(30)
-
- pygame.quit()
- backend.close()
- print("\nβ Interactive session ended")
-
-
-def save_image(obs: np.ndarray, path: str):
- """Save observation as PNG image."""
- try:
- from PIL import Image
- img = Image.fromarray(obs)
- img.save(path)
- print(f" Saved: {path}")
- except ImportError:
- print(" PIL not available, skipping image save")
-
-
-def demo_backend_basics(save_images: bool = False):
- """Demonstrate basic backend usage."""
- print("\n" + "=" * 60)
- print("Demo 1: Backend Basics")
- print("=" * 60)
-
- # Load a task
- task_path = Path(__file__).parent / "tasks" / "tier1" / "maze_simple_001.json"
- spec = TaskSpecification.from_json(str(task_path))
-
- print(f"\nTask: {spec.task_id}")
- print(f"Description: {spec.description}")
- print(f"Grid size: {spec.maze.dimensions}")
- print(f"Start: {spec.maze.start.to_tuple()}")
- print(f"Goal: {spec.maze.goal.to_tuple()}")
-
- # Create backend
- backend = get_backend("minigrid", render_mode="rgb_array")
- backend.configure(spec)
-
- # Reset environment
- obs, state, info = backend.reset(seed=42)
-
- print(f"\nInitial state:")
- print(f" Agent position: {state.agent_position}")
- print(f" Agent direction: {state.agent_direction}")
- print(f" Observation shape: {obs.shape}")
- print(f" Mission: {backend.get_mission_text()}")
-
- # Take a few steps
- actions = [
- MiniGridActions.TURN_RIGHT,
- MiniGridActions.MOVE_FORWARD,
- MiniGridActions.MOVE_FORWARD,
- ]
-
- print("\nExecuting actions:")
- for action in actions:
- obs, reward, terminated, truncated, state, info = backend.step(action)
- print(f" {ACTION_NAMES[action]}: pos={state.agent_position}, reward={reward:.2f}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- save_image(obs, str(output_dir / "demo1_minigrid_basic.png"))
-
- backend.close()
- print("\nβ Backend basics demo complete")
-
-
-def demo_key_door_puzzle(save_images: bool = False):
- """Demonstrate a key-door puzzle (Tier 2)."""
- print("\n" + "=" * 60)
- print("Demo 2: Key-Door Puzzle (Tier 2)")
- print("=" * 60)
-
- task_path = Path(__file__).parent / "tasks" / "tier2" / "single_key_001.json"
- spec = TaskSpecification.from_json(str(task_path))
-
- print(f"\nTask: {spec.task_id}")
- print(f"Description: {spec.description}")
- print(f"Keys: {[(k.id, k.color) for k in spec.mechanisms.keys]}")
- print(f"Doors: {[(d.id, d.requires_key) for d in spec.mechanisms.doors]}")
-
- backend = get_backend("minigrid", render_mode="rgb_array")
- backend.configure(spec)
- obs, state, info = backend.reset(seed=42)
-
- print(f"\nInitial: Agent at {state.agent_position}, carrying: {state.agent_carrying}")
-
- # Expert solution for this puzzle
- solution = [
- MiniGridActions.TURN_RIGHT, # Face down
- MiniGridActions.MOVE_FORWARD, # Move down
- MiniGridActions.MOVE_FORWARD, # Move down to key row
- MiniGridActions.TURN_LEFT, # Face right
- MiniGridActions.MOVE_FORWARD, # Move to key
- MiniGridActions.PICKUP, # Get key
- MiniGridActions.MOVE_FORWARD, # Move right
- MiniGridActions.MOVE_FORWARD, # Move right
- MiniGridActions.TOGGLE, # Unlock door
- MiniGridActions.MOVE_FORWARD, # Through door
- MiniGridActions.MOVE_FORWARD, # Continue
- MiniGridActions.TURN_RIGHT, # Face down
- MiniGridActions.MOVE_FORWARD, # Move to goal
- MiniGridActions.MOVE_FORWARD,
- MiniGridActions.MOVE_FORWARD,
- ]
-
- print("\nExecuting expert solution:")
- for i, action in enumerate(solution):
- obs, reward, terminated, truncated, state, info = backend.step(action)
- status = ""
- if state.agent_carrying:
- status = f", carrying={state.agent_carrying}"
- if terminated:
- status += " [GOAL REACHED]"
- print(f" {i+1}. {ACTION_NAMES[action]}: pos={state.agent_position}{status}")
-
- if terminated:
- break
-
- print(f"\nResult: {'SUCCESS' if terminated else 'IN PROGRESS'}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- save_image(obs, str(output_dir / "demo2_key_door.png"))
-
- backend.close()
- print("\nβ Key-door puzzle demo complete")
-
-
-def demo_runner_evaluation(save_images: bool = False):
- """Demonstrate using GridRunner for evaluation."""
- print("\n" + "=" * 60)
- print("Demo 3: GridRunner Evaluation")
- print("=" * 60)
-
- # Load multiple tasks
- task_dir = Path(__file__).parent / "tasks"
- tasks = []
- for tier in range(1, 4): # Tiers 1-3
- tier_dir = task_dir / f"tier{tier}"
- if tier_dir.exists():
- for json_file in sorted(tier_dir.glob("*.json"))[:1]: # First task per tier
- tasks.append(TaskSpecification.from_json(str(json_file)))
-
- print(f"\nLoaded {len(tasks)} tasks:")
- for t in tasks:
- print(f" - {t.task_id} (Tier {t.difficulty_tier})")
-
- # Create runner with random policy
- runner = GridRunner(render_mode="rgb_array")
-
- def random_policy(obs, state, mission):
- """Simple random policy with bias toward forward movement."""
- import random
- weights = [0.1, 0.1, 0.5, 0.1, 0.05, 0.1, 0.05] # Heavy forward bias
- return random.choices(range(7), weights=weights)[0]
-
- print("\nRunning episodes with random policy:")
- results = []
- for spec in tasks:
- result = runner.run_episode(spec, policy_fn=random_policy, seed=42)
- results.append(result)
- status = "SUCCESS" if result.success else "FAILED"
- print(f" {spec.task_id}: {status} in {result.steps_taken} steps")
-
- # Summary
- success_rate = sum(r.success for r in results) / len(results) * 100
- avg_steps = sum(r.steps_taken for r in results) / len(results)
-
- print(f"\nSummary:")
- print(f" Success rate: {success_rate:.1f}%")
- print(f" Average steps: {avg_steps:.1f}")
-
- if save_images and results:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- # Save final observation from first result
- if results[0].trajectory:
- final_obs = results[0].trajectory[-1].observation
- save_image(final_obs, str(output_dir / "demo3_evaluation.png"))
-
- runner.close()
- print("\nβ Runner evaluation demo complete")
-
-
-def demo_all_tiers():
- """Show all available task tiers."""
- print("\n" + "=" * 60)
- print("Demo 4: Available Tasks by Tier")
- print("=" * 60)
-
- available = list_available_envs()
-
- total = 0
- for tier_name, task_ids in sorted(available.items()):
- print(f"\n{tier_name.upper()}:")
- for task_id in task_ids:
- print(f" - {task_id}")
- total += len(task_ids)
-
- print(f"\nTotal: {total} tasks available")
- print("\nβ Task listing complete")
-
-
-def demo_observation_shapes(save_images: bool = False):
- """Show observation and render shapes."""
- print("\n" + "=" * 60)
- print("Demo 5: Observation & Render Shapes")
- print("=" * 60)
-
- task_path = Path(__file__).parent / "tasks" / "tier1" / "maze_simple_001.json"
- spec = TaskSpecification.from_json(str(task_path))
-
- backend = MiniGridBackend(render_mode="rgb_array")
- backend.configure(spec)
- obs, state, info = backend.reset(seed=42)
-
- print(f"\nObservation from reset():")
- print(f" Shape: {obs.shape}")
- print(f" Dtype: {obs.dtype}")
- print(f" Range: [{obs.min()}, {obs.max()}]")
-
- render = backend.render()
- print(f"\nRender output:")
- print(f" Shape: {render.shape}")
- print(f" Dtype: {render.dtype}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- save_image(obs, str(output_dir / "demo5_observation.png"))
- save_image(render, str(output_dir / "demo5_render.png"))
-
- backend.close()
- print("\nβ Observation shapes demo complete")
-
-
-def demo_deterministic_replay():
- """Demonstrate deterministic behavior with same seed."""
- print("\n" + "=" * 60)
- print("Demo 6: Deterministic Replay")
- print("=" * 60)
-
- task_path = Path(__file__).parent / "tasks" / "tier1" / "maze_simple_001.json"
- spec = TaskSpecification.from_json(str(task_path))
-
- actions = [
- MiniGridActions.TURN_RIGHT,
- MiniGridActions.MOVE_FORWARD,
- MiniGridActions.MOVE_FORWARD,
- MiniGridActions.TURN_LEFT,
- MiniGridActions.MOVE_FORWARD,
- ]
-
- def run_with_seed(seed):
- backend = get_backend("minigrid", render_mode="rgb_array")
- backend.configure(spec)
- obs, state, _ = backend.reset(seed=seed)
- positions = [state.agent_position]
-
- for action in actions:
- obs, _, _, _, state, _ = backend.step(action)
- positions.append(state.agent_position)
-
- backend.close()
- return positions
-
- # Run twice with same seed
- positions1 = run_with_seed(42)
- positions2 = run_with_seed(42)
- positions3 = run_with_seed(99) # Different seed
-
- print(f"\nSeed 42 (run 1): {positions1}")
- print(f"Seed 42 (run 2): {positions2}")
- print(f"Seed 99: {positions3}")
-
- print(f"\nRun 1 == Run 2: {positions1 == positions2}")
- print(f"Run 1 == Run 3: {positions1 == positions3}")
-
- print("\nβ Deterministic replay demo complete")
-
-
-def main():
- parser = argparse.ArgumentParser(description="MiniGrid Backend Demo")
- parser.add_argument("--visual", action="store_true", help="Save PNG images")
- parser.add_argument("--demo", type=int, help="Run specific demo (1-6)")
- parser.add_argument("--play", action="store_true", help="Interactive play mode")
- parser.add_argument("--task", type=str, help="Task to play (e.g., tier2/single_key_001)")
- args = parser.parse_args()
-
- # Interactive play mode
- if args.play:
- interactive_play(args.task)
- return
-
- print("=" * 60)
- print("MiniGrid Backend Demo")
- print("=" * 60)
- print("\nThis demo uses the MiniGridBackend (gymnasium minigrid package)")
- print("for standard square grid tasks.")
-
- demos = [
- demo_backend_basics,
- demo_key_door_puzzle,
- demo_runner_evaluation,
- demo_all_tiers,
- demo_observation_shapes,
- demo_deterministic_replay,
- ]
-
- if args.demo:
- if 1 <= args.demo <= len(demos):
- demos[args.demo - 1](save_images=args.visual)
- else:
- print(f"Invalid demo number. Choose 1-{len(demos)}")
- else:
- for demo_fn in demos:
- if demo_fn == demo_all_tiers:
- demo_fn() # No save_images param
- elif demo_fn == demo_deterministic_replay:
- demo_fn() # No save_images param
- else:
- demo_fn(save_images=args.visual)
-
- print("\n" + "=" * 60)
- print("MiniGrid Demo Complete!")
- print("=" * 60)
-
- if args.visual:
- output_dir = Path(__file__).parent / "demo_output"
- print(f"\nImages saved to: {output_dir}")
-
-
-if __name__ == "__main__":
- main()
diff --git a/gridworld/envs/__init__.py b/gridworld/envs/__init__.py
deleted file mode 100644
index 1aa43d7..0000000
--- a/gridworld/envs/__init__.py
+++ /dev/null
@@ -1,27 +0,0 @@
-"""
-Pre-configured MiniGrid Environments by Tier
-
-Provides convenient access to environments organized by difficulty tier.
-"""
-
-from .tier_envs import (
- get_tier1_envs,
- get_tier2_envs,
- get_tier3_envs,
- get_tier4_envs,
- get_tier5_envs,
- get_all_envs,
- get_env_by_id,
- list_available_envs,
-)
-
-__all__ = [
- "get_tier1_envs",
- "get_tier2_envs",
- "get_tier3_envs",
- "get_tier4_envs",
- "get_tier5_envs",
- "get_all_envs",
- "get_env_by_id",
- "list_available_envs",
-]
diff --git a/gridworld/envs/tier_envs.py b/gridworld/envs/tier_envs.py
deleted file mode 100644
index f707fcd..0000000
--- a/gridworld/envs/tier_envs.py
+++ /dev/null
@@ -1,262 +0,0 @@
-"""
-Pre-configured Environments by Difficulty Tier
-
-Provides factory functions to create environments for each tier.
-Also supports loading standard MiniGrid environments as fallback.
-"""
-
-from pathlib import Path
-from typing import Optional, List, Dict
-import json
-import glob
-
-from ..task_spec import TaskSpecification
-from ..task_parser import TaskParser, load_task_from_file
-from ..backends.minigrid_backend import MiniGridBackend
-
-
-# Base path for task files
-TASKS_DIR = Path(__file__).parent.parent / "tasks"
-
-
-def _load_tasks_from_dir(tier_dir: Path) -> List[TaskSpecification]:
- """Load all task specifications from a tier directory."""
- tasks = []
- if tier_dir.exists():
- for json_file in sorted(tier_dir.glob("*.json")):
- try:
- spec = TaskSpecification.from_json(str(json_file))
- tasks.append(spec)
- except Exception as e:
- print(f"Warning: Failed to load {json_file}: {e}")
- return tasks
-
-
-def get_tier1_envs(render_mode: str = "rgb_array") -> List[tuple]:
- """
- Get Tier 1 (Navigation) environments.
-
- Returns:
- List of (task_spec, env) tuples
- """
- tier_dir = TASKS_DIR / "tier1"
- tasks = _load_tasks_from_dir(tier_dir)
-
- parser = TaskParser(render_mode=render_mode)
- envs = []
- for task in tasks:
- try:
- env = parser.parse(task)
- envs.append((task, env))
- except Exception as e:
- print(f"Warning: Failed to create env for {task.task_id}: {e}")
-
- return envs
-
-
-def get_tier2_envs(render_mode: str = "rgb_array") -> List[tuple]:
- """
- Get Tier 2 (Linear Dependencies - Keys/Doors) environments.
-
- Returns:
- List of (task_spec, env) tuples
- """
- tier_dir = TASKS_DIR / "tier2"
- tasks = _load_tasks_from_dir(tier_dir)
-
- parser = TaskParser(render_mode=render_mode)
- envs = []
- for task in tasks:
- try:
- env = parser.parse(task)
- envs.append((task, env))
- except Exception as e:
- print(f"Warning: Failed to create env for {task.task_id}: {e}")
-
- return envs
-
-
-def get_tier3_envs(render_mode: str = "rgb_array") -> List[tuple]:
- """
- Get Tier 3 (Multi-Mechanism - Keys/Doors/Switches/Gates) environments.
-
- Returns:
- List of (task_spec, env) tuples
- """
- tier_dir = TASKS_DIR / "tier3"
- tasks = _load_tasks_from_dir(tier_dir)
-
- parser = TaskParser(render_mode=render_mode)
- envs = []
- for task in tasks:
- try:
- env = parser.parse(task)
- envs.append((task, env))
- except Exception as e:
- print(f"Warning: Failed to create env for {task.task_id}: {e}")
-
- return envs
-
-
-def get_tier4_envs(render_mode: str = "rgb_array") -> List[tuple]:
- """
- Get Tier 4 (Irreversibility - Pushable blocks) environments.
-
- Returns:
- List of (task_spec, env) tuples
- """
- tier_dir = TASKS_DIR / "tier4"
- tasks = _load_tasks_from_dir(tier_dir)
-
- parser = TaskParser(render_mode=render_mode)
- envs = []
- for task in tasks:
- try:
- env = parser.parse(task)
- envs.append((task, env))
- except Exception as e:
- print(f"Warning: Failed to create env for {task.task_id}: {e}")
-
- return envs
-
-
-def get_tier5_envs(render_mode: str = "rgb_array") -> List[tuple]:
- """
- Get Tier 5 (Hidden Information) environments.
-
- Returns:
- List of (task_spec, env) tuples
- """
- tier_dir = TASKS_DIR / "tier5"
- tasks = _load_tasks_from_dir(tier_dir)
-
- parser = TaskParser(render_mode=render_mode)
- envs = []
- for task in tasks:
- try:
- env = parser.parse(task)
- envs.append((task, env))
- except Exception as e:
- print(f"Warning: Failed to create env for {task.task_id}: {e}")
-
- return envs
-
-
-def get_all_envs(render_mode: str = "rgb_array") -> Dict[str, List[tuple]]:
- """
- Get all environments organized by tier.
-
- Returns:
- Dictionary mapping tier names to lists of (task_spec, env) tuples
- """
- return {
- "tier1": get_tier1_envs(render_mode),
- "tier2": get_tier2_envs(render_mode),
- "tier3": get_tier3_envs(render_mode),
- "tier4": get_tier4_envs(render_mode),
- "tier5": get_tier5_envs(render_mode),
- }
-
-
-def get_env_by_id(
- task_id: str,
- render_mode: str = "rgb_array"
-) -> Optional[tuple]:
- """
- Get a specific environment by task ID.
-
- Args:
- task_id: The task ID to find
- render_mode: Rendering mode for the environment
-
- Returns:
- (task_spec, env) tuple or None if not found
- """
- # Search all tier directories
- for tier_num in range(1, 6):
- tier_dir = TASKS_DIR / f"tier{tier_num}"
- if tier_dir.exists():
- for json_file in tier_dir.glob("*.json"):
- try:
- spec = TaskSpecification.from_json(str(json_file))
- if spec.task_id == task_id:
- parser = TaskParser(render_mode=render_mode)
- env = parser.parse(spec)
- return (spec, env)
- except Exception:
- continue
-
- return None
-
-
-def list_available_envs() -> Dict[str, List[str]]:
- """
- List all available task IDs organized by tier.
-
- Returns:
- Dictionary mapping tier names to lists of task IDs
- """
- result = {}
- for tier_num in range(1, 6):
- tier_name = f"tier{tier_num}"
- tier_dir = TASKS_DIR / tier_name
- task_ids = []
-
- if tier_dir.exists():
- for json_file in sorted(tier_dir.glob("*.json")):
- try:
- spec = TaskSpecification.from_json(str(json_file))
- task_ids.append(spec.task_id)
- except Exception:
- task_ids.append(json_file.stem)
-
- result[tier_name] = task_ids
-
- return result
-
-
-def get_standard_minigrid_env(env_name: str, render_mode: str = "rgb_array"):
- """
- Get a standard MiniGrid environment by name.
-
- This provides access to built-in MiniGrid environments as fallback.
-
- Args:
- env_name: Standard MiniGrid environment name (e.g., "MiniGrid-Empty-8x8-v0")
- render_mode: Rendering mode
-
- Returns:
- Gymnasium environment
- """
- import gymnasium as gym
- return gym.make(env_name, render_mode=render_mode)
-
-
-# Mapping of tiers to standard MiniGrid environments (as fallback)
-STANDARD_MINIGRID_ENVS = {
- "tier1": [
- "MiniGrid-Empty-5x5-v0",
- "MiniGrid-Empty-8x8-v0",
- "MiniGrid-Empty-16x16-v0",
- "MiniGrid-FourRooms-v0",
- ],
- "tier2": [
- "MiniGrid-DoorKey-5x5-v0",
- "MiniGrid-DoorKey-8x8-v0",
- "MiniGrid-DoorKey-16x16-v0",
- ],
- "tier3": [
- "MiniGrid-LockedRoom-v0",
- "MiniGrid-KeyCorridorS3R1-v0",
- "MiniGrid-KeyCorridorS3R2-v0",
- "MiniGrid-KeyCorridorS3R3-v0",
- ],
- "tier4": [
- "MiniGrid-BlockedUnlockPickup-v0",
- ],
- "tier5": [
- "MiniGrid-MemoryS7-v0",
- "MiniGrid-MemoryS9-v0",
- "MiniGrid-RedBlueDoors-8x8-v0",
- ],
-}
diff --git a/gridworld/fixtures/manifest.conditional_eval.json b/gridworld/fixtures/manifest.conditional_eval.json
index 2345094..0c8a605 100644
--- a/gridworld/fixtures/manifest.conditional_eval.json
+++ b/gridworld/fixtures/manifest.conditional_eval.json
@@ -1,5 +1,5 @@
{
- "description": "Conditional-evaluation manifest (15 mazes) = the 10 validation_10 mazes + 5 held-out S/M/B/D/D mazes (one S, one M, one blind B probe, two D), all held out from manifest.ogbench_50_smbd.json so verification experiments cannot affect the 50-maze run. The B row is the blind probe (mazes/conditional/blind_probe_B_holdout.json). See docs/conditional_experiments_launch_checklist.md.",
+ "description": "Conditional-evaluation manifest (15 mazes) = the 10 validation_10 mazes + 5 held-out S/M/B/D/D mazes (one S, one M, one blind B probe, two D), all held out from manifest.ogbench_50_smbd.json so verification experiments cannot affect the 50-maze run. The B row is the blind probe (mazes/conditional/blind_probe_B_holdout.json).",
"selection": {
"counts": {
"validation_10": 10,
diff --git a/gridworld/fixtures/manifest.ctx_current_kimi_missing.json b/gridworld/fixtures/manifest.ctx_current_kimi_missing.json
deleted file mode 100644
index 4ea2c5f..0000000
--- a/gridworld/fixtures/manifest.ctx_current_kimi_missing.json
+++ /dev/null
@@ -1,62 +0,0 @@
-{
- "description": "KIMI missing-maze subset for ctxfix_ctx_current (4 mazes)",
- "selection": {
- "counts": {
- "validation_10": 10,
- "S": 1,
- "M": 1,
- "B": 1,
- "D": 2
- },
- "policy": "validation_10 + 1 S + 1 M + 1 blind B (held-out) + 2 D, all disjoint from the 50-maze run."
- },
- "tasks": [
- {
- "task_id": "conditional_m_m1_10x10_corridor_kr_0",
- "experiment": "conditional",
- "condition": "M",
- "variant": "10x10_corridor_kr",
- "source": "ogbench/ogbench/procgen/maze_jsons/M1/10x10_corridor_kr_0.json",
- "expected_mechanisms": [
- "kr"
- ],
- "maze_family": "M",
- "notes": "Held-out single key-door maze (not in the 50-run)."
- },
- {
- "task_id": "conditional_b_blind_probe_holdout",
- "experiment": "conditional",
- "condition": "B",
- "variant": "blind_probe_holdout",
- "source": "mazes/conditional/blind_probe_B_holdout.json",
- "expected_mechanisms": [
- "kr",
- "s1"
- ],
- "maze_family": "B",
- "notes": "Held-out blind probe (11th B): all keys/doors grey, switches white; decoy key k2 + decoy switch s2. See tests/test_blind_probe_maze.py."
- },
- {
- "task_id": "conditional_d_d1_10x10_corridor_wrong_ky_kr_0",
- "experiment": "conditional",
- "condition": "D",
- "variant": "10x10_corridor_wrong_ky_kr",
- "source": "ogbench/ogbench/procgen/maze_jsons/D1/10x10_corridor_wrong_ky_kr_0.json",
- "expected_mechanisms": [
- "kr"
- ],
- "maze_family": "D",
- "notes": "Held-out distractor maze (wrong-key decoy; not in the 50-run)."
- },
- {
- "task_id": "conditional_d_d3_10x10_dense_deadend_ky_dy_1",
- "experiment": "conditional",
- "condition": "D",
- "variant": "10x10_dense_deadend_ky_dy",
- "source": "ogbench/ogbench/procgen/maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json",
- "expected_mechanisms": [],
- "maze_family": "D",
- "notes": "Held-out distractor maze (dead-end decoy; not in the 50-run)."
- }
- ]
-}
\ No newline at end of file
diff --git a/gridworld/fixtures/manifest.json b/gridworld/fixtures/manifest.json
index 9fe022d..ac47e1b 100644
--- a/gridworld/fixtures/manifest.json
+++ b/gridworld/fixtures/manifest.json
@@ -366,7 +366,7 @@
"experiment": "r1",
"condition": "D",
"variant": "10x10_dense_wrong_ky_kr_sg_kb_0",
- "source": "mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D1",
@@ -377,7 +377,7 @@
"experiment": "r1",
"condition": "D",
"variant": "10x10_dense_wrong_ky_kr_sg_kb_1",
- "source": "mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D1",
@@ -388,7 +388,7 @@
"experiment": "r1",
"condition": "D",
"variant": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "source": "mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -399,7 +399,7 @@
"experiment": "r1",
"condition": "D",
"variant": "10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0",
- "source": "mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -410,7 +410,7 @@
"experiment": "r1",
"condition": "D",
"variant": "14x14_dense_wrong_ky_inactive_sb_sg_kr_1",
- "source": "mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -421,7 +421,7 @@
"experiment": "r1",
"condition": "D",
"variant": "14x14_dense_wrong_ky_kr_inactive_sb_sg_1",
- "source": "mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -432,7 +432,7 @@
"experiment": "r1",
"condition": "D",
"variant": "14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0",
- "source": "mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -443,7 +443,7 @@
"experiment": "r1",
"condition": "D",
"variant": "14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1",
- "source": "mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -454,7 +454,7 @@
"experiment": "r1",
"condition": "D",
"variant": "8x8_corridor_wrong_ky_inactive_sb_sg_kr_1",
- "source": "mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D2",
@@ -465,7 +465,7 @@
"experiment": "r1",
"condition": "D",
"variant": "10x10_dense_deadend_ky_dy_1",
- "source": "mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json",
"expected_mechanisms": [],
"maze_family": "D",
"maze_category": "D3",
@@ -476,7 +476,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_corridor_kr_1",
- "source": "mazes/exp_maze_jsons/M1/10x10_corridor_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/10x10_corridor_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -487,7 +487,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_kr_0",
- "source": "mazes/exp_maze_jsons/M1/10x10_dense_kr_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/10x10_dense_kr_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -498,7 +498,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_corridor_kr_0",
- "source": "mazes/exp_maze_jsons/M1/14x14_corridor_kr_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/14x14_corridor_kr_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -509,7 +509,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_corridor_kr_1",
- "source": "mazes/exp_maze_jsons/M1/14x14_corridor_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/14x14_corridor_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -520,7 +520,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_kr_0",
- "source": "mazes/exp_maze_jsons/M1/14x14_dense_kr_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/14x14_dense_kr_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -531,7 +531,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_kr_1",
- "source": "mazes/exp_maze_jsons/M1/14x14_dense_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/14x14_dense_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -542,7 +542,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_kr_0",
- "source": "mazes/exp_maze_jsons/M1/8x8_corridor_kr_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/8x8_corridor_kr_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -553,7 +553,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_kr_1",
- "source": "mazes/exp_maze_jsons/M1/8x8_corridor_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M1/8x8_corridor_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M1",
@@ -564,7 +564,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_corridor_sg_1",
- "source": "mazes/exp_maze_jsons/M2/10x10_corridor_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/10x10_corridor_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -575,7 +575,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_sg_0",
- "source": "mazes/exp_maze_jsons/M2/10x10_dense_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/10x10_dense_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -586,7 +586,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_corridor_sg_0",
- "source": "mazes/exp_maze_jsons/M2/14x14_corridor_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/14x14_corridor_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -597,7 +597,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_corridor_sg_1",
- "source": "mazes/exp_maze_jsons/M2/14x14_corridor_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/14x14_corridor_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -608,7 +608,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_sg_0",
- "source": "mazes/exp_maze_jsons/M2/14x14_dense_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/14x14_dense_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -619,7 +619,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_sg_1",
- "source": "mazes/exp_maze_jsons/M2/14x14_dense_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/14x14_dense_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -630,7 +630,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_sg_0",
- "source": "mazes/exp_maze_jsons/M2/8x8_corridor_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/8x8_corridor_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -641,7 +641,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_sg_1",
- "source": "mazes/exp_maze_jsons/M2/8x8_corridor_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M2/8x8_corridor_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M2",
@@ -652,7 +652,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_kr_sg_0",
- "source": "mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M3/10x10_dense_kr_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M3",
@@ -663,7 +663,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_kr_sg_1",
- "source": "mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M3/10x10_dense_kr_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M3",
@@ -674,7 +674,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_kr_sg_0",
- "source": "mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M3/14x14_dense_kr_sg_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M3",
@@ -685,7 +685,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_kr_sg_1",
- "source": "mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M3/8x8_corridor_kr_sg_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M3",
@@ -696,7 +696,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_sg_kr_0",
- "source": "mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M4/10x10_dense_sg_kr_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M4",
@@ -707,7 +707,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_sg_kr_1",
- "source": "mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M4/10x10_dense_sg_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M4",
@@ -718,7 +718,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_sg_kr_1",
- "source": "mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M4/8x8_corridor_sg_kr_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M4",
@@ -729,7 +729,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_kr_kb_0",
- "source": "mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M5/10x10_dense_kr_kb_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M5",
@@ -740,7 +740,7 @@
"experiment": "r1",
"condition": "M",
"variant": "10x10_dense_kr_kb_1",
- "source": "mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M5/10x10_dense_kr_kb_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M5",
@@ -751,7 +751,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_kr_kb_1",
- "source": "mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M5/8x8_corridor_kr_kb_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M5",
@@ -762,7 +762,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_kr_sg_kb_0",
- "source": "mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M6/14x14_dense_kr_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M6",
@@ -773,7 +773,7 @@
"experiment": "r1",
"condition": "M",
"variant": "14x14_dense_kr_sg_kb_1",
- "source": "mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M6/14x14_dense_kr_sg_kb_1.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M6",
@@ -784,7 +784,7 @@
"experiment": "r1",
"condition": "M",
"variant": "8x8_corridor_kr_sg_kb_0",
- "source": "mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/M6/8x8_corridor_kr_sg_kb_0.json",
"expected_mechanisms": [],
"maze_family": "M",
"maze_category": "M6",
@@ -795,7 +795,7 @@
"experiment": "r1",
"condition": "S",
"variant": "10x10_dense_1",
- "source": "mazes/exp_maze_jsons/S4/10x10_dense_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/S4/10x10_dense_1.json",
"expected_mechanisms": [],
"maze_family": "S",
"maze_category": "S4",
@@ -806,7 +806,7 @@
"experiment": "r1",
"condition": "S",
"variant": "14x14_corridor_0",
- "source": "mazes/exp_maze_jsons/S5/14x14_corridor_0.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/S5/14x14_corridor_0.json",
"expected_mechanisms": [],
"maze_family": "S",
"maze_category": "S5",
@@ -817,7 +817,7 @@
"experiment": "r1",
"condition": "S",
"variant": "14x14_corridor_1",
- "source": "mazes/exp_maze_jsons/S5/14x14_corridor_1.json",
+ "source": "ogbench/ogbench/procgen/maze_jsons/S5/14x14_corridor_1.json",
"expected_mechanisms": [],
"maze_family": "S",
"maze_category": "S5",
diff --git a/gridworld/fixtures/manifest.r1_balanced_03.json b/gridworld/fixtures/manifest.r1_balanced_03.json
index 33822f6..00fe65b 100644
--- a/gridworld/fixtures/manifest.r1_balanced_03.json
+++ b/gridworld/fixtures/manifest.r1_balanced_03.json
@@ -1,7 +1,7 @@
{
"description": "R1 balanced: general-purpose 50-maze panel.",
"selection": {
- "source_set": "analysis/candidate_mazes/sets/balanced_03",
+ "source_set": "balanced_03",
"candidate": "balanced_03",
"maze_count": 50,
"order": "ascending BFS optimal_steps (rank)",
diff --git a/gridworld/fixtures/manifest.r1_frontier_probe_01.json b/gridworld/fixtures/manifest.r1_frontier_probe_01.json
deleted file mode 100644
index 864b946..0000000
--- a/gridworld/fixtures/manifest.r1_frontier_probe_01.json
+++ /dev/null
@@ -1,201 +0,0 @@
-{
- "description": "Frontier probe subset (9 of 50 R1 balanced_03 mazes) for post-R1 frontier models (Fable, GPT-5.6-sol, optionally kimi-k3 / qwen3.7-pro). Spans the difficulty ladder: 2 solved-band anchors, the max-discrimination maze, the near-miss maze, switch-cliff + mixed-mechanism + distractor probes, and 2 deep-band mazes (long nav + full chain). Selection rationale: analysis/r1-20260717/frontier_probe.md",
- "selection": {
- "derived_from": "gridworld/fixtures/manifest.r1_balanced_03.json",
- "method": "hand-picked ladder from r1-20260717 outcomes",
- "maze_count": 9
- },
- "tasks": [
- {
- "task_id": "r1_S4_10x10_dense_1",
- "experiment": "r1",
- "condition": "S",
- "variant": "10x10_dense_1",
- "source": "ogbench/ogbench/procgen/maze_jsons/S4/10x10_dense_1.json",
- "expected_mechanisms": [],
- "maze_family": "S",
- "maze_category": "S4",
- "rank": 2,
- "optimal_steps": 23,
- "path_signature": "none",
- "path_depth": 0,
- "distractor_count": 0,
- "five_option": false,
- "topology": "dense",
- "grid": "10x10",
- "comparison_cell": "10x10:dense:1"
- },
- {
- "task_id": "r1_B1_8x8_corridor_swg_0",
- "experiment": "r1",
- "condition": "B",
- "variant": "8x8_corridor_swg_0",
- "source": "ogbench/ogbench/procgen/maze_jsons/B1/8x8_corridor_swg_0.json",
- "expected_mechanisms": [
- "g1"
- ],
- "maze_family": "B",
- "maze_category": "B1",
- "rank": 3,
- "optimal_steps": 26,
- "path_signature": "S",
- "path_depth": 1,
- "distractor_count": 0,
- "five_option": false,
- "topology": "corridor",
- "grid": "8x8",
- "comparison_cell": "8x8:corridor:0"
- },
- {
- "task_id": "r1_M1_8x8_corridor_kr_0",
- "experiment": "r1",
- "condition": "M",
- "variant": "8x8_corridor_kr_0",
- "source": "ogbench/ogbench/procgen/maze_jsons/M1/8x8_corridor_kr_0.json",
- "expected_mechanisms": [
- "DR"
- ],
- "maze_family": "M",
- "maze_category": "M1",
- "rank": 6,
- "optimal_steps": 27,
- "path_signature": "K",
- "path_depth": 1,
- "distractor_count": 0,
- "five_option": false,
- "topology": "corridor",
- "grid": "8x8",
- "comparison_cell": "8x8:corridor:0"
- },
- {
- "task_id": "r1_M3_8x8_corridor_kr_sg_1",
- "experiment": "r1",
- "condition": "M",
- "variant": "8x8_corridor_kr_sg_1",
- "source": "ogbench/ogbench/procgen/maze_jsons/M3/8x8_corridor_kr_sg_1.json",
- "expected_mechanisms": [
- "DR",
- "g1"
- ],
- "maze_family": "M",
- "maze_category": "M3",
- "rank": 10,
- "optimal_steps": 29,
- "path_signature": "K->S",
- "path_depth": 2,
- "distractor_count": 0,
- "five_option": false,
- "topology": "corridor",
- "grid": "8x8",
- "comparison_cell": "8x8:corridor:1"
- },
- {
- "task_id": "r1_M5_10x10_dense_kr_kb_1",
- "experiment": "r1",
- "condition": "M",
- "variant": "10x10_dense_kr_kb_1",
- "source": "ogbench/ogbench/procgen/maze_jsons/M5/10x10_dense_kr_kb_1.json",
- "expected_mechanisms": [
- "DR",
- "DB"
- ],
- "maze_family": "M",
- "maze_category": "M5",
- "rank": 19,
- "optimal_steps": 43,
- "path_signature": "K->K",
- "path_depth": 2,
- "distractor_count": 0,
- "five_option": false,
- "topology": "dense",
- "grid": "10x10",
- "comparison_cell": "10x10:dense:1"
- },
- {
- "task_id": "r1_M1_10x10_corridor_kr_1",
- "experiment": "r1",
- "condition": "M",
- "variant": "10x10_corridor_kr_1",
- "source": "ogbench/ogbench/procgen/maze_jsons/M1/10x10_corridor_kr_1.json",
- "expected_mechanisms": [
- "DR"
- ],
- "maze_family": "M",
- "maze_category": "M1",
- "rank": 23,
- "optimal_steps": 45,
- "path_signature": "K",
- "path_depth": 1,
- "distractor_count": 0,
- "five_option": false,
- "topology": "corridor",
- "grid": "10x10",
- "comparison_cell": "10x10:corridor:1"
- },
- {
- "task_id": "r1_D2_10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "experiment": "r1",
- "condition": "D",
- "variant": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "source": "ogbench/ogbench/procgen/maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json",
- "expected_mechanisms": [
- "DR",
- "g1",
- "DB"
- ],
- "maze_family": "D",
- "maze_category": "D2",
- "rank": 24,
- "optimal_steps": 47,
- "path_signature": "K->S->K",
- "path_depth": 3,
- "distractor_count": 2,
- "five_option": true,
- "topology": "corridor",
- "grid": "10x10",
- "comparison_cell": "10x10:corridor:0"
- },
- {
- "task_id": "r1_S5_14x14_corridor_0",
- "experiment": "r1",
- "condition": "S",
- "variant": "14x14_corridor_0",
- "source": "ogbench/ogbench/procgen/maze_jsons/S5/14x14_corridor_0.json",
- "expected_mechanisms": [],
- "maze_family": "S",
- "maze_category": "S5",
- "rank": 34,
- "optimal_steps": 77,
- "path_signature": "none",
- "path_depth": 0,
- "distractor_count": 0,
- "five_option": false,
- "topology": "corridor",
- "grid": "14x14",
- "comparison_cell": "14x14:corridor:0"
- },
- {
- "task_id": "r1_M6_14x14_dense_kr_sg_kb_0",
- "experiment": "r1",
- "condition": "M",
- "variant": "14x14_dense_kr_sg_kb_0",
- "source": "ogbench/ogbench/procgen/maze_jsons/M6/14x14_dense_kr_sg_kb_0.json",
- "expected_mechanisms": [
- "DR",
- "g1",
- "DB"
- ],
- "maze_family": "M",
- "maze_category": "M6",
- "rank": 46,
- "optimal_steps": 95,
- "path_signature": "K->S->K",
- "path_depth": 3,
- "distractor_count": 0,
- "five_option": false,
- "topology": "dense",
- "grid": "14x14",
- "comparison_cell": "14x14:dense:0"
- }
- ]
-}
\ No newline at end of file
diff --git a/gridworld/fixtures/manifest.r1_kimi_rerun.json b/gridworld/fixtures/manifest.r1_kimi_rerun.json
index d21f1a4..d3fef44 100644
--- a/gridworld/fixtures/manifest.r1_kimi_rerun.json
+++ b/gridworld/fixtures/manifest.r1_kimi_rerun.json
@@ -3,7 +3,7 @@
"selection": {
"source_set": "gridworld/fixtures/manifest.r1_balanced_03.json",
"criteria": "end_reason=parse_failed(infra) OR doomed=True in R1_FINAL_episode_runs (Kimi leg)",
- "evidence": "Multinet-v2-results/r1-20260717/analysis/metrics/long_table.csv (doomed, doomed_at_env_step)",
+ "evidence": "doomed / doomed_at_env_step columns of the R1 per-episode metrics table (Kimi leg)",
"maze_count": 2
},
"tasks": [
diff --git a/gridworld/fixtures/manifest.r1_long_tail_02.json b/gridworld/fixtures/manifest.r1_long_tail_02.json
index 55ec3c1..95d7209 100644
--- a/gridworld/fixtures/manifest.r1_long_tail_02.json
+++ b/gridworld/fixtures/manifest.r1_long_tail_02.json
@@ -1,7 +1,7 @@
{
"description": "R1 long-tail: 80+-action-heavy 50-maze panel.",
"selection": {
- "source_set": "analysis/candidate_mazes/sets/long_tail_02",
+ "source_set": "long_tail_02",
"candidate": "long_tail_02",
"maze_count": 50,
"order": "ascending BFS optimal_steps (rank)",
diff --git a/gridworld/fixtures/manifest.r1_mechanism_rich_01.json b/gridworld/fixtures/manifest.r1_mechanism_rich_01.json
index f4e5ef6..9630270 100644
--- a/gridworld/fixtures/manifest.r1_mechanism_rich_01.json
+++ b/gridworld/fixtures/manifest.r1_mechanism_rich_01.json
@@ -1,7 +1,7 @@
{
"description": "R1 mechanism-rich: distractor/depth-stress 50-maze panel.",
"selection": {
- "source_set": "analysis/candidate_mazes/sets/mechanism_rich_01",
+ "source_set": "mechanism_rich_01",
"candidate": "mechanism_rich_01",
"maze_count": 50,
"order": "ascending BFS optimal_steps (rank)",
diff --git a/gridworld/fixtures/manifest.r1_pairwise_01.json b/gridworld/fixtures/manifest.r1_pairwise_01.json
index 9261aef..a4a1263 100644
--- a/gridworld/fixtures/manifest.r1_pairwise_01.json
+++ b/gridworld/fixtures/manifest.r1_pairwise_01.json
@@ -1,7 +1,7 @@
{
"description": "R1 pairwise: controlled M1/M2 + M3/M4/M5 comparison panel.",
"selection": {
- "source_set": "analysis/candidate_mazes/sets/pairwise_01",
+ "source_set": "pairwise_01",
"candidate": "pairwise_01",
"maze_count": 50,
"order": "ascending BFS optimal_steps (rank)",
diff --git a/gridworld/fixtures/manifest.r1_smoke_batch.json b/gridworld/fixtures/manifest.r1_smoke_batch.json
index e48aa31..f5c0662 100644
--- a/gridworld/fixtures/manifest.r1_smoke_batch.json
+++ b/gridworld/fixtures/manifest.r1_smoke_batch.json
@@ -1,7 +1,7 @@
{
"description": "R1 batch-API validation smoke: 5 mazes spanning the ~30-80 optimal-step band (navigation, K->S, K->K, K->S->K, K) for the Claude/Kimi Batch API lockstep validation. Not a scored panel; drives scripts/run_batch_smoke.py.",
"selection": {
- "source_set": "analysis/candidate_mazes/all_maze_features.csv",
+ "source_set": "maze feature table",
"candidate": "r1_smoke_batch",
"maze_count": 5,
"order": "ascending BFS optimal_steps (rank)",
diff --git a/gridworld/fixtures/manifest.smoke_eval.json b/gridworld/fixtures/manifest.smoke_eval.json
index d8da6f6..589831c 100644
--- a/gridworld/fixtures/manifest.smoke_eval.json
+++ b/gridworld/fixtures/manifest.smoke_eval.json
@@ -1,5 +1,5 @@
{
- "description": "Smoke-eval manifest (3 mazes) for distributed-orchestration validation only: 2 Qwen runners + 1 Kimi runner with coordinator work-stealing. Not for measurement. See docs/conditional_experiments_launch_checklist.md Β§6.",
+ "description": "Smoke-eval manifest (3 mazes) for distributed-orchestration validation only: 2 Qwen runners + 1 Kimi runner with coordinator work-stealing. Not for measurement.",
"selection": {
"policy": "Three small validation_10 mazes spanning navigation, key-door, and switch-gate so the smoke exercises the scorer path without a heavy solver/runtime cost.",
"counts": {"navigation": 1, "key_door": 1, "switch_gate": 1}
diff --git a/gridworld/fixtures/manifest.text_summary_kimi_missing.json b/gridworld/fixtures/manifest.text_summary_kimi_missing.json
deleted file mode 100644
index 37729e2..0000000
--- a/gridworld/fixtures/manifest.text_summary_kimi_missing.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "description": "KIMI missing-maze subset for ctxfix_ctx_text_summary (5 mazes)",
- "selection": {
- "counts": {
- "validation_10": 10,
- "S": 1,
- "M": 1,
- "B": 1,
- "D": 2
- },
- "policy": "validation_10 + 1 S + 1 M + 1 blind B (held-out) + 2 D, all disjoint from the 50-maze run."
- },
- "tasks": [
- {
- "task_id": "conditional_s_s5_14x14_corridor_1",
- "experiment": "conditional",
- "condition": "S",
- "variant": "14x14_corridor",
- "source": "ogbench/ogbench/procgen/maze_jsons/S5/14x14_corridor_1.json",
- "expected_mechanisms": [],
- "maze_family": "S",
- "notes": "Held-out simple navigation maze (not in the 50-run)."
- },
- {
- "task_id": "conditional_m_m1_10x10_corridor_kr_0",
- "experiment": "conditional",
- "condition": "M",
- "variant": "10x10_corridor_kr",
- "source": "ogbench/ogbench/procgen/maze_jsons/M1/10x10_corridor_kr_0.json",
- "expected_mechanisms": [
- "kr"
- ],
- "maze_family": "M",
- "notes": "Held-out single key-door maze (not in the 50-run)."
- },
- {
- "task_id": "conditional_b_blind_probe_holdout",
- "experiment": "conditional",
- "condition": "B",
- "variant": "blind_probe_holdout",
- "source": "mazes/conditional/blind_probe_B_holdout.json",
- "expected_mechanisms": [
- "kr",
- "s1"
- ],
- "maze_family": "B",
- "notes": "Held-out blind probe (11th B): all keys/doors grey, switches white; decoy key k2 + decoy switch s2. See tests/test_blind_probe_maze.py."
- },
- {
- "task_id": "conditional_d_d1_10x10_corridor_wrong_ky_kr_0",
- "experiment": "conditional",
- "condition": "D",
- "variant": "10x10_corridor_wrong_ky_kr",
- "source": "ogbench/ogbench/procgen/maze_jsons/D1/10x10_corridor_wrong_ky_kr_0.json",
- "expected_mechanisms": [
- "kr"
- ],
- "maze_family": "D",
- "notes": "Held-out distractor maze (wrong-key decoy; not in the 50-run)."
- },
- {
- "task_id": "conditional_d_d3_10x10_dense_deadend_ky_dy_1",
- "experiment": "conditional",
- "condition": "D",
- "variant": "10x10_dense_deadend_ky_dy",
- "source": "ogbench/ogbench/procgen/maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json",
- "expected_mechanisms": [],
- "maze_family": "D",
- "notes": "Held-out distractor maze (dead-end decoy; not in the 50-run)."
- }
- ]
-}
\ No newline at end of file
diff --git a/gridworld/fixtures/run_config.conditional_context_window_claude_only.json b/gridworld/fixtures/run_config.conditional_context_window_claude_only.json
deleted file mode 100644
index e4fab8e..0000000
--- a/gridworld/fixtures/run_config.conditional_context_window_claude_only.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
- "description": "Conditional-eval run config for --conditions \"Context window\" across local Qwen, Kimi, and Claude over the 15-maze conditional set. [API-only: Kimi + Claude, no Qwen.] [CLAUDE-ONLY re-run w/ coord fix]",
- "manifest": "gridworld/fixtures/manifest.conditional_eval.json",
- "conditions": "Context window",
- "models": {
- "claude_opus": {
- "provider": "claude",
- "model": "claude-opus-4-8",
- "max_tokens": 4096,
- "timeout": 180,
- "group": "claude-api",
- "max_in_flight": 1,
- "tasks": [
- "all"
- ],
- "enable_thinking": true,
- "effort": "low"
- }
- }
-}
\ No newline at end of file
diff --git a/gridworld/fixtures/run_config.conditional_context_window_kimi_only.json b/gridworld/fixtures/run_config.conditional_context_window_kimi_only.json
deleted file mode 100644
index ead42b7..0000000
--- a/gridworld/fixtures/run_config.conditional_context_window_kimi_only.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
- "description": "Conditional-eval run config for --conditions \"Context window\" across local Qwen, Kimi, and Claude over the 15-maze conditional set. [API-only: Kimi + Claude, no Qwen.] [KIMI-ONLY missing-maze fill]",
- "conditions": "Context window",
- "models": {
- "kimi_k26": {
- "provider": "kimi",
- "model": "kimi-k2.6",
- "temperature": 0.6,
- "max_tokens": 4096,
- "timeout": 180,
- "group": "kimi-api",
- "worker_count": 1,
- "max_in_flight": 1,
- "tasks": [
- "all"
- ],
- "enable_thinking": false
- }
- }
-}
\ No newline at end of file
diff --git a/gridworld/fixtures/run_config.ogbench_50_claude_kimi_qwen.json b/gridworld/fixtures/run_config.ogbench_50_claude_kimi_qwen.json
deleted file mode 100644
index 92a27d7..0000000
--- a/gridworld/fixtures/run_config.ogbench_50_claude_kimi_qwen.json
+++ /dev/null
@@ -1,51 +0,0 @@
-{
- "description": "Run the ogbench 50-maze S/M/B/D selection across Claude, Kimi, and local Qwen. Use with --manifest gridworld/fixtures/manifest.ogbench_50_smbd.json.",
- "manifest": "gridworld/fixtures/manifest.ogbench_50_smbd.json",
- "conditions": null,
- "models": {
- "claude_sonnet": {
- "provider": "claude",
- "model": "claude-sonnet-4-6",
- "temperature": 0.0,
- "max_tokens": 4096,
- "timeout": 180,
- "group": "claude-api",
- "max_in_flight": 1,
- "tasks": [
- "all"
- ]
- },
- "kimi_k26": {
- "provider": "kimi",
- "model": "kimi-k2.6",
- "temperature": 0.0,
- "max_tokens": 4096,
- "timeout": 180,
- "group": "kimi-api",
- "max_in_flight": 1,
- "tasks": [
- "all"
- ]
- },
- "qwen35_27b_hf": {
- "provider": "qwen",
- "model": "Qwen/Qwen3.5-27B",
- "temperature": 0.0,
- "max_tokens": 8192,
- "enable_thinking": true,
- "device_map": {
- "": 0
- },
- "local_files_only": true,
- "torch_dtype": "auto",
- "load_in_4bit": true,
- "group": "qwen35-27b",
- "hardware_profile": "local-gpu",
- "worker_count": 1,
- "max_in_flight": 1,
- "tasks": [
- "all"
- ]
- }
- }
-}
diff --git a/gridworld/fixtures/run_config.qwen35_27b_hf_smoke.json b/gridworld/fixtures/run_config.qwen35_27b_hf_smoke.json
deleted file mode 100644
index 833065c..0000000
--- a/gridworld/fixtures/run_config.qwen35_27b_hf_smoke.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "description": "Single-task Qwen/Qwen3.5-27B HF smoke run for parser/output-contract validation.",
- "manifest": "gridworld/fixtures/manifest.json",
- "models": {
- "qwen35_27b_hf": {
- "provider": "qwen",
- "model": "Qwen/Qwen3.5-27B",
- "temperature": 0.0,
- "max_tokens": 512,
- "enable_thinking": false,
- "device_map": {
- "": 0
- },
- "local_files_only": true,
- "torch_dtype": "auto",
- "load_in_4bit": true,
- "tasks": [
- "validation_10_v01_empty_room"
- ]
- }
- }
-}
diff --git a/gridworld/fixtures/run_config.qwen35_27b_hf_validation10.json b/gridworld/fixtures/run_config.qwen35_27b_hf_validation10.json
deleted file mode 100644
index 82935d6..0000000
--- a/gridworld/fixtures/run_config.qwen35_27b_hf_validation10.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "description": "Local HF Transformers run for Qwen/Qwen3.5-27B over tests 1-3 and validation_10 manifest rows.",
- "manifest": "gridworld/fixtures/manifest.json",
- "models": {
- "qwen35_27b_hf": {
- "provider": "qwen",
- "model": "Qwen/Qwen3.5-27B",
- "temperature": 0.0,
- "max_tokens": 4096,
- "enable_thinking": false,
- "device_map": {
- "": 0
- },
- "local_files_only": true,
- "torch_dtype": "auto",
- "load_in_4bit": true,
- "tasks": [
- "all"
- ]
- }
- }
-}
diff --git a/gridworld/fixtures/run_config.r1.json b/gridworld/fixtures/run_config.r1.json
index 21d0cbb..f04bca4 100644
--- a/gridworld/fixtures/run_config.r1.json
+++ b/gridworld/fixtures/run_config.r1.json
@@ -1,5 +1,5 @@
{
- "description": "R1 phase-1 fixed-cell run on balanced_03 (50 mazes): minimal prompt, image_only, egocentric, zero_shot, text_summary_and_last3 (chat_history=stateless), progress_stall_k=30. Thinking ON all 3 models, Claude xhigh. Single condition (no sweep). TWO-TIER QWEN: this is phase 1 (qwen cap 8000, cap-hitters truncate server-side and are re-run wide in phase 2 via run_config.r1.qwen_phase2.json + scripts/scan_truncations.py). Claude/Kimi run the full 64k cap from the start (allow_unequal_max_tokens). See docs/qwen-two-tier-rerun-design.md and docs/qwen-two-tier-rerun.md.",
+ "description": "R1 phase-1 fixed-cell run on balanced_03 (50 mazes): minimal prompt, image_only, egocentric, zero_shot, text_summary_and_last3 (chat_history=stateless), progress_stall_k=30. Thinking ON all 3 models, Claude xhigh. Single condition (no sweep). TWO-TIER QWEN: this is phase 1 (qwen cap 8000, cap-hitters truncate server-side and are re-run wide in phase 2 via run_config.r1.qwen_phase2.json + scripts/scan_truncations.py). Claude/Kimi run the full 64k cap from the start (allow_unequal_max_tokens). See docs/qwen-two-tier-rerun-design.md.",
"phase": {"pass": 1, "label": "phase1"},
"allow_unequal_max_tokens": true,
"_note_unequal_caps": "deliberate two-tier exception: qwen phase-1 8k vs Claude/Kimi 64k; see docs/qwen-two-tier-rerun-design.md",
@@ -11,7 +11,7 @@
"gridworld/fixtures/manifest.r1_pairwise_01.json"
],
"_note_no_conditions": "No conditions key => single (default) cell built from experiment_config overlay. Do NOT add conditions (that would re-enable the sweep).",
- "_note_model_params": "Thinking ON for all 3. Claude/Kimi max_tokens=64000 (Anthropic ~64k xhigh/max starting budget for Opus 4.8); Claude effort=xhigh + adaptive thinking; Kimi temp=1.0 (Moonshot mode-forces when thinking on). Qwen temp=0.6 (greedy degenerates in thinking). TWO-TIER QWEN CAP: phase-1 qwen max_tokens=8000 so cap-hitters truncate server-side and return (a cap-hitting 8k decode at concurrency ~13-16 is ~1140s; timeout=1800 lets it return rather than client-timeout+retry); flagged mazes re-run at 64k in phase 2. Claude/Kimi max_in_flight=64 (>= MAX_BATCHES=50, required by the lockstep batch-API worker; see docs/batch-api-lockstep-runner-design.md). Qwen serve args (max_model_len, max_num_seqs) come from QWEN_MAX_MODEL_LEN/QWEN_MAX_NUM_SEQS env at launch, NOT this config. See docs/qwen-two-tier-rerun-design.md and docs/qwen-two-tier-rerun.md.",
+ "_note_model_params": "Thinking ON for all 3. Claude/Kimi max_tokens=64000 (Anthropic ~64k xhigh/max starting budget for Opus 4.8); Claude effort=xhigh + adaptive thinking; Kimi temp=1.0 (Moonshot mode-forces when thinking on). Qwen temp=0.6 (greedy degenerates in thinking). TWO-TIER QWEN CAP: phase-1 qwen max_tokens=8000 so cap-hitters truncate server-side and return (a cap-hitting 8k decode at concurrency ~13-16 is ~1140s; timeout=1800 lets it return rather than client-timeout+retry); flagged mazes re-run at 64k in phase 2. Claude/Kimi max_in_flight=64 (>= MAX_BATCHES=50, required by the lockstep batch-API worker; see docs/batch-api-lockstep-runner-design.md). Qwen serve args (max_model_len, max_num_seqs) come from QWEN_MAX_MODEL_LEN/QWEN_MAX_NUM_SEQS env at launch, NOT this config. See docs/qwen-two-tier-rerun-design.md.",
"experiment_config": {
"prompting": "minimal",
"observation": "image_only",
diff --git a/gridworld/fixtures/run_config.r1.kimi_rerun.json b/gridworld/fixtures/run_config.r1.kimi_rerun.json
index 064cd4e..586c2e7 100644
--- a/gridworld/fixtures/run_config.r1.kimi_rerun.json
+++ b/gridworld/fixtures/run_config.r1.kimi_rerun.json
@@ -1,5 +1,5 @@
{
- "description": "R1 Kimi make-up rerun: same fixed cell as run_config.r1.json (minimal/image_only/egocentric/zero_shot/text_summary_and_last3 stateless, K=30, thinking ON, 64k), Kimi ONLY, on manifest.r1_kimi_rerun.json (2 mazes). Runs on the DROP-enabled harness \u2014 action vocabulary includes DROP, so episodes are DROP-aware and not prompt-identical to the R1 corpus (deliberate; see docs/r1-kimi-rerun-package.md).",
+ "description": "R1 Kimi make-up rerun: same fixed cell as run_config.r1.json (minimal/image_only/egocentric/zero_shot/text_summary_and_last3 stateless, K=30, thinking ON, 64k), Kimi ONLY, on manifest.r1_kimi_rerun.json (2 mazes). Runs on the DROP-enabled harness \u2014 action vocabulary includes DROP, so episodes are DROP-aware and not prompt-identical to the R1 corpus (deliberate).",
"manifest": "gridworld/fixtures/manifest.r1_kimi_rerun.json",
"_note_no_conditions": "No conditions key => single (default) cell built from experiment_config overlay. Do NOT add conditions (that would re-enable the sweep).",
"experiment_config": {
diff --git a/gridworld/fixtures/run_config.r1.kimi_rerun_d2.json b/gridworld/fixtures/run_config.r1.kimi_rerun_d2.json
index 0cbabf2..d29dbbb 100644
--- a/gridworld/fixtures/run_config.r1.kimi_rerun_d2.json
+++ b/gridworld/fixtures/run_config.r1.kimi_rerun_d2.json
@@ -1,5 +1,5 @@
{
- "description": "arm 3 of the 3-arm rerun: the wrong-key decoy maze (the actual DROP test). Single-task split of run_config.r1.kimi_rerun.json so the two fresh arms run as isolated parallel processes (the local pipeline is sequential and has no per-episode exception isolation: one arm crashing must not strand the other). Identical fixed cell to run_config.r1.json; runs on the DROP-enabled harness \u2014 see docs/r1-kimi-rerun-package.md. Retry hardening after arm 3 died on 5 consecutive 2400s timeouts (2026-07-31, ~54 queries lost): timeout=900 (legitimate replies land in ~5min; a 40min wait is a hung reply worth re-sending) and max_attempts=20, so ~5h of consecutive hangs is survivable instead of 3.3h being fatal. Client-side patience only \u2014 not sampling parameters, no effect on comparability.",
+ "description": "arm 3 of the 3-arm rerun: the wrong-key decoy maze (the actual DROP test). Single-task split of run_config.r1.kimi_rerun.json so the two fresh arms run as isolated parallel processes (the local pipeline is sequential and has no per-episode exception isolation: one arm crashing must not strand the other). Identical fixed cell to run_config.r1.json; runs on the DROP-enabled harness. Retry hardening after arm 3 died on 5 consecutive 2400s timeouts (2026-07-31, ~54 queries lost): timeout=900 (legitimate replies land in ~5min; a 40min wait is a hung reply worth re-sending) and max_attempts=20, so ~5h of consecutive hangs is survivable instead of 3.3h being fatal. Client-side patience only \u2014 not sampling parameters, no effect on comparability.",
"manifest": "gridworld/fixtures/manifest.r1_kimi_rerun.json",
"_note_no_conditions": "No conditions key => single (default) cell built from experiment_config overlay. Do NOT add conditions (that would re-enable the sweep).",
"experiment_config": {
diff --git a/gridworld/fixtures/run_config.r1.kimi_rerun_m6.json b/gridworld/fixtures/run_config.r1.kimi_rerun_m6.json
index 8a1ed20..638f3f5 100644
--- a/gridworld/fixtures/run_config.r1.kimi_rerun_m6.json
+++ b/gridworld/fixtures/run_config.r1.kimi_rerun_m6.json
@@ -1,5 +1,5 @@
{
- "description": "arm 2 of the 3-arm rerun: fresh M6 from step 1 (no decoy keys; DROP should never rationally fire). Single-task split of run_config.r1.kimi_rerun.json so the two fresh arms run as isolated parallel processes (the local pipeline is sequential and has no per-episode exception isolation: one arm crashing must not strand the other). Identical fixed cell to run_config.r1.json; runs on the DROP-enabled harness \u2014 see docs/r1-kimi-rerun-package.md. Retry hardening after arm 3 died on 5 consecutive 2400s timeouts (2026-07-31, ~54 queries lost): timeout=900 (legitimate replies land in ~5min; a 40min wait is a hung reply worth re-sending) and max_attempts=20, so ~5h of consecutive hangs is survivable instead of 3.3h being fatal. Client-side patience only \u2014 not sampling parameters, no effect on comparability.",
+ "description": "arm 2 of the 3-arm rerun: fresh M6 from step 1 (no decoy keys; DROP should never rationally fire). Single-task split of run_config.r1.kimi_rerun.json so the two fresh arms run as isolated parallel processes (the local pipeline is sequential and has no per-episode exception isolation: one arm crashing must not strand the other). Identical fixed cell to run_config.r1.json; runs on the DROP-enabled harness. Retry hardening after arm 3 died on 5 consecutive 2400s timeouts (2026-07-31, ~54 queries lost): timeout=900 (legitimate replies land in ~5min; a 40min wait is a hung reply worth re-sending) and max_attempts=20, so ~5h of consecutive hangs is survivable instead of 3.3h being fatal. Client-side patience only \u2014 not sampling parameters, no effect on comparability.",
"manifest": "gridworld/fixtures/manifest.r1_kimi_rerun.json",
"_note_no_conditions": "No conditions key => single (default) cell built from experiment_config overlay. Do NOT add conditions (that would re-enable the sweep).",
"experiment_config": {
diff --git a/gridworld/fixtures/run_config.r1.qwen_phase2.json b/gridworld/fixtures/run_config.r1.qwen_phase2.json
index 7fca2a6..848014c 100644
--- a/gridworld/fixtures/run_config.r1.qwen_phase2.json
+++ b/gridworld/fixtures/run_config.r1.qwen_phase2.json
@@ -1,5 +1,5 @@
{
- "description": "R1 phase-2 QWEN-ONLY rerun: re-runs ONLY the phase-1 mazes flagged as token-cap truncated (output_tokens>=8000 or finish_reason==length), now at the full 64k cap. The manifest is a subset of manifest.r1_balanced_03.json GENERATED by scripts/scan_truncations.py --out gridworld/fixtures/manifest.r1_qwen_phase2.json (it does not exist until phase 1 has run + been scanned). REQUIRED SERVE ENV at launch: QWEN_MAX_MODEL_LEN=96000 QWEN_MAX_NUM_SEQS=3 (fits 64k gen + prompt at reduced concurrency; ~14-min served reload from phase-1 args). Single-model, so the equal-token-caps guard auto-passes. Phase-2 episodes overwrite phase-1 for flagged task_ids at aggregation (later-pass-wins). See docs/qwen-two-tier-rerun-design.md and docs/qwen-two-tier-rerun.md.",
+ "description": "R1 phase-2 QWEN-ONLY rerun: re-runs ONLY the phase-1 mazes flagged as token-cap truncated (output_tokens>=8000 or finish_reason==length), now at the full 64k cap. The manifest is a subset of manifest.r1_balanced_03.json GENERATED by scripts/scan_truncations.py --out gridworld/fixtures/manifest.r1_qwen_phase2.json (it does not exist until phase 1 has run + been scanned). REQUIRED SERVE ENV at launch: QWEN_MAX_MODEL_LEN=96000 QWEN_MAX_NUM_SEQS=3 (fits 64k gen + prompt at reduced concurrency; ~14-min served reload from phase-1 args). Single-model, so the equal-token-caps guard auto-passes. Phase-2 episodes overwrite phase-1 for flagged task_ids at aggregation (later-pass-wins). See docs/qwen-two-tier-rerun-design.md.",
"phase": {"pass": 2, "label": "qwen_phase2"},
"manifest": "gridworld/fixtures/manifest.r1_qwen_phase2.json",
"_note_no_conditions": "No conditions key => single (default) cell built from experiment_config overlay. Must match phase-1's cell exactly so reruns are comparable.",
diff --git a/gridworld/fixtures/run_config.r1_frontier_probe.DRAFT.json b/gridworld/fixtures/run_config.r1_frontier_probe.DRAFT.json
deleted file mode 100644
index a378a0b..0000000
--- a/gridworld/fixtures/run_config.r1_frontier_probe.DRAFT.json
+++ /dev/null
@@ -1,55 +0,0 @@
-{
- "_DRAFT": "NOT RUNNABLE AS-IS \u2014 frontier probe draft; resolve _todo fields per analysis/r1-20260717/frontier_probe.md before any paid run.",
- "description": "R1 frontier probe: 9-maze subset (manifest.r1_frontier_probe_01.json) x post-R1 frontier models. Identical experiment cell to R1; single 64k tier for ALL models (two-tier dropped per teardown \u00a76); equal caps.",
- "manifest": "gridworld/fixtures/manifest.r1_frontier_probe_01.json",
- "experiment_config": {
- "prompting": "minimal",
- "observation": "image_only",
- "context_window": "text_summary_and_last3",
- "chat_history": "stateless",
- "in_context_learning": "zero_shot",
- "action_space": "egocentric",
- "querying": "step_by_step",
- "progress_stall_k": 30
- },
- "models": [
- {
- "model": "claude-fable-5",
- "provider": "claude",
- "enable_thinking": true,
- "effort": "xhigh",
- "max_tokens": 64000,
- "group": "claude-api",
- "tasks": [
- "all"
- ],
- "_todo": "confirm model id + effort semantics + no-sampling-params rule for Fable"
- },
- {
- "model": "gpt-5.6-sol",
- "provider": "openai",
- "enable_thinking": true,
- "max_tokens": 64000,
- "group": "openai-api",
- "tasks": [
- "all"
- ],
- "_todo": "NO AGENT EXISTS \u2014 implement interface/agents/openai agent + parse tests first"
- },
- {
- "model": "kimi-k3",
- "provider": "kimi",
- "enable_thinking": true,
- "temperature": 1,
- "timeout": 2400,
- "max_tokens": 64000,
- "group": "kimi-api",
- "tasks": [
- "all"
- ],
- "_todo": "OPTIONAL leg; confirm k3 keeps k2.6 mode-forced temperature + deep-thinking timeout"
- }
- ],
- "_note_qwen37": "qwen3.7-pro leg deferred until serving decision (API vs fresh A100 vLLM).",
- "_note_smoke": "run 1-maze smoke per model from unit model_config (not stripped plan[models]) before the 9-maze batch (R1 smoke bug)."
-}
\ No newline at end of file
diff --git a/interactive_demo.py b/interactive_demo.py
deleted file mode 100644
index f08dc37..0000000
--- a/interactive_demo.py
+++ /dev/null
@@ -1,430 +0,0 @@
-#!/usr/bin/env python3
-"""
-Interactive pygame demo for MultiGrid.
-
-Controls:
-- Arrow Keys / WASD: Move agent (FORWARD in facing direction)
-- Q/E: Turn left/right
-- SPACE: Pick up / Drop object
-- P: Push object
-- R: Reset environment
-- 1/2/3: Switch between Square/Hex/Triangle grids
-- ESC: Quit
-"""
-
-import sys
-import os
-import pygame
-import math
-import numpy as np
-
-# Add parent directory to path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-from multigrid.env import MultiGridEnv
-from multigrid.agent import Action
-
-
-# Colors
-WHITE = (255, 255, 255)
-BLACK = (0, 0, 0)
-GRAY = (200, 200, 200)
-LIGHT_GRAY = (240, 240, 240)
-DARK_GRAY = (100, 100, 100)
-BLUE = (50, 100, 255)
-RED = (255, 50, 50)
-GREEN = (50, 255, 50)
-YELLOW = (255, 255, 50)
-PURPLE = (200, 50, 200)
-ORANGE = (255, 165, 0)
-
-
-def draw_hex(surface, center, size, color, filled=True):
- """Draw a hexagon."""
- vertices = []
- for i in range(6):
- angle = math.pi / 2 - i * math.pi / 3
- x = center[0] + size * math.cos(angle)
- y = center[1] - size * math.sin(angle)
- vertices.append((x, y))
-
- if filled:
- pygame.draw.polygon(surface, color, vertices)
- pygame.draw.polygon(surface, BLACK, vertices, 2)
-
-
-def draw_triangle(surface, center, size, color, pointing_up, filled=True):
- """
- Draw an equilateral triangle.
-
- Args:
- center: (x, y) position of triangle centroid
- size: height of the triangle
- pointing_up: True for upward pointing, False for downward
- """
- # For equilateral triangle with height h:
- # - Side length s = 2h / sqrt(3)
- # - Half of base = s / 2 = h / sqrt(3)
- # - Centroid is h/3 from base, 2h/3 from apex
-
- half_base = size / math.sqrt(3)
-
- if pointing_up:
- # Apex is 2/3 of height above centroid
- # Base is 1/3 of height below centroid
- vertices = [
- (center[0], center[1] - 2 * size / 3), # Top apex
- (center[0] - half_base, center[1] + size / 3), # Bottom left
- (center[0] + half_base, center[1] + size / 3) # Bottom right
- ]
- else:
- # Apex is 2/3 of height below centroid
- # Base is 1/3 of height above centroid
- vertices = [
- (center[0], center[1] + 2 * size / 3), # Bottom apex
- (center[0] - half_base, center[1] - size / 3), # Top left
- (center[0] + half_base, center[1] - size / 3) # Top right
- ]
-
- if filled:
- pygame.draw.polygon(surface, color, vertices)
- pygame.draw.polygon(surface, BLACK, vertices, 2)
-
-
-def draw_square(surface, center, size, color, filled=True):
- """Draw a square."""
- rect = pygame.Rect(center[0] - size / 2, center[1] - size / 2, size, size)
- if filled:
- pygame.draw.rect(surface, color, rect)
- pygame.draw.rect(surface, BLACK, rect, 2)
-
-
-def draw_agent(surface, center, size, facing_angle):
- """Draw the agent as a triangle pointing in facing direction."""
- # Draw body (circle)
- pygame.draw.circle(surface, BLUE, (int(center[0]), int(center[1])), int(size * 0.6))
-
- # Draw facing indicator (triangle)
- indicator_size = size * 0.8
- angle = facing_angle
- vertices = [
- (center[0] + indicator_size * math.cos(angle),
- center[1] - indicator_size * math.sin(angle)),
- (center[0] + indicator_size * 0.3 * math.cos(angle + 2.5),
- center[1] - indicator_size * 0.3 * math.sin(angle + 2.5)),
- (center[0] + indicator_size * 0.3 * math.cos(angle - 2.5),
- center[1] - indicator_size * 0.3 * math.sin(angle - 2.5))
- ]
- pygame.draw.polygon(surface, WHITE, vertices)
- pygame.draw.polygon(surface, BLACK, vertices, 1)
-
-
-def draw_object(surface, center, size, color):
- """Draw an object (cube)."""
- pygame.draw.circle(surface, color, (int(center[0]), int(center[1])), int(size * 0.5))
- pygame.draw.circle(surface, BLACK, (int(center[0]), int(center[1])), int(size * 0.5), 2)
-
-
-class InteractiveDemo:
- def __init__(self, width=800, height=800):
- pygame.init()
- self.width = width
- self.height = height
- self.screen = pygame.display.set_mode((width, height + 100)) # Extra space for info
- pygame.display.set_caption("MultiGrid Interactive Demo")
- self.clock = pygame.time.Clock()
- self.font = pygame.font.Font(None, 24)
- self.big_font = pygame.font.Font(None, 36)
-
- self.tiling_type = "square"
- self.grid_size = 10
-
- self.env = None
- self.reset_env()
-
- def reset_env(self):
- """Create/reset the environment."""
- task_spec = {
- "task_id": "interactive_demo",
- "seed": 42,
- "scene": {
- "bounds": {"width": 1.0, "height": 1.0},
- "objects": [
- {
- "id": "cube_red",
- "type": "movable",
- "color": "red",
- "position": {"x": 0.7, "y": 0.3},
- "size": 0.1
- },
- {
- "id": "cube_green",
- "type": "movable",
- "color": "green",
- "position": {"x": 0.3, "y": 0.7},
- "size": 0.1
- }
- ],
- "agent": {
- "position": {"x": 0.2, "y": 0.2},
- "facing": 1 # Facing east
- }
- },
- "goal": {},
- "limits": {"max_steps": 1000},
- "tiling": {"type": self.tiling_type, "grid_size": {"width": self.grid_size, "height": self.grid_size}}
- }
-
- self.env = MultiGridEnv(task_spec, tiling=self.tiling_type)
- self.env.reset()
-
- def handle_input(self):
- """Handle keyboard input."""
- for event in pygame.event.get():
- if event.type == pygame.QUIT:
- return False
- elif event.type == pygame.KEYDOWN:
- if event.key == pygame.K_ESCAPE:
- return False
- elif event.key == pygame.K_r:
- self.reset_env()
- elif event.key == pygame.K_1:
- self.tiling_type = "square"
- self.reset_env()
- elif event.key == pygame.K_2:
- self.tiling_type = "hex"
- self.reset_env()
- elif event.key == pygame.K_3:
- self.tiling_type = "triangle"
- self.reset_env()
- elif event.key in [pygame.K_UP, pygame.K_w]:
- self.env.step(Action.FORWARD)
- elif event.key in [pygame.K_DOWN, pygame.K_s]:
- self.env.step(Action.BACKWARD)
- elif event.key in [pygame.K_LEFT, pygame.K_a, pygame.K_q]:
- self.env.step(Action.TURN_LEFT)
- elif event.key in [pygame.K_RIGHT, pygame.K_d, pygame.K_e]:
- self.env.step(Action.TURN_RIGHT)
- elif event.key == pygame.K_SPACE:
- if self.env.state.agent.holding:
- self.env.step(Action.DROP)
- else:
- self.env.step(Action.PICKUP)
- elif event.key == pygame.K_p:
- self.env.step(Action.PUSH)
-
- return True
-
- def draw_grid(self):
- """Draw the grid."""
- self.screen.fill(WHITE)
-
- tiling = self.env.tiling
-
- # Calculate proper cell sizes for each tiling type
- margin = 50
- usable_width = self.width - 2 * margin
- usable_height = self.height - 2 * margin
-
- # Draw grid cells
- for cell_id, cell in tiling.cells.items():
- x_norm, y_norm = cell.position_hint
- x = x_norm * usable_width + margin
- y = y_norm * usable_height + margin
-
- if self.tiling_type == "square":
- cell_size = usable_width / self.grid_size
- draw_square(self.screen, (x, y), cell_size, LIGHT_GRAY, filled=True)
- elif self.tiling_type == "hex":
- # Calculate hex size matching HexTiling coordinate system
- width_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- height_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- size_from_width = 0.95 / ((self.grid_size + 0.5) * math.sqrt(3)) if self.grid_size > 0 else 0.1
- size_from_height = 0.95 / (height_spacing * 1.5) if height_spacing > 0 else 0.1
- size = min(size_from_width, size_from_height)
- # Convert to screen space
- hex_size = size * usable_width
- draw_hex(self.screen, (x, y), hex_size, LIGHT_GRAY, filled=True)
- elif self.tiling_type == "triangle":
- # Triangles are subdivisions of hexagons
- # Parse triangle ID: tri_hexcol_hexrow_triidx
- parts = cell_id.split("_")
- if len(parts) == 4:
- from multigrid.tilings.hex import OffsetCoord, offset_to_axial
- _, hex_col_str, hex_row_str, tri_idx_str = parts
- tri_idx = int(tri_idx_str)
- hex_col = int(hex_col_str)
- hex_row = int(hex_row_str)
-
- # Calculate hex size (same as HexTiling)
- width_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- height_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- size_from_width = 0.95 / ((self.grid_size + 0.5) * math.sqrt(3)) if self.grid_size > 0 else 0.1
- size_from_height = 0.95 / (height_spacing * 1.5) if height_spacing > 0 else 0.1
- hex_size = min(size_from_width, size_from_height)
-
- # Calculate hex center in normalized coordinates
- col_pos = hex_col * math.sqrt(3) * hex_size
- row_pos = hex_row * 1.5 * hex_size
- if hex_row % 2 == 1:
- col_pos += math.sqrt(3) / 2 * hex_size
-
- grid_width = (self.grid_size + 0.5) * math.sqrt(3) * hex_size
- grid_height = (self.grid_size - 0.5) * 1.5 * hex_size
- x_offset = (1.0 - grid_width) / 2
- y_offset = (1.0 - grid_height) / 2
-
- hex_center_x_norm = col_pos + x_offset
- hex_center_y_norm = row_pos + y_offset
-
- # Convert to screen coordinates
- hex_center_x = hex_center_x_norm * usable_width + margin
- hex_center_y = hex_center_y_norm * usable_height + margin
- hex_size_screen = hex_size * usable_width
-
- # Calculate the 3 vertices of this triangle
- angle_apex = math.pi / 2 - tri_idx * math.pi / 3
- angle_base1 = math.pi / 2 - ((tri_idx - 1) % 6) * math.pi / 3
- angle_base2 = math.pi / 2 - ((tri_idx + 1) % 6) * math.pi / 3
-
- # Apex vertex
- apex_x = hex_center_x + hex_size_screen * math.cos(angle_apex)
- apex_y = hex_center_y - hex_size_screen * math.sin(angle_apex)
-
- # Base vertices (adjacent hex vertices)
- base1_x = hex_center_x + hex_size_screen * math.cos(angle_base1)
- base1_y = hex_center_y - hex_size_screen * math.sin(angle_base1)
-
- base2_x = hex_center_x + hex_size_screen * math.cos(angle_base2)
- base2_y = hex_center_y - hex_size_screen * math.sin(angle_base2)
-
- vertices = [
- (apex_x, apex_y),
- (base1_x, base1_y),
- (base2_x, base2_y)
- ]
-
- pygame.draw.polygon(self.screen, LIGHT_GRAY, vertices)
- pygame.draw.polygon(self.screen, BLACK, vertices, 2)
-
- # Calculate cell size for objects/agent
- if self.tiling_type == "square":
- cell_size = usable_width / self.grid_size
- elif self.tiling_type == "hex":
- # Use same calculation as hex rendering
- width_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- height_spacing = (self.grid_size - 1) if self.grid_size > 1 else 1
- size_from_width = 0.95 / ((self.grid_size + 0.5) * math.sqrt(3)) if self.grid_size > 0 else 0.1
- size_from_height = 0.95 / (height_spacing * 1.5) if height_spacing > 0 else 0.1
- size = min(size_from_width, size_from_height)
- cell_size = size * usable_width
- else: # triangle
- # Use triangle side length
- side_length = 0.95 * 2 / (self.grid_size + 0.5)
- cell_size = side_length * usable_width
-
- # Draw objects
- for obj in self.env.state.objects.values():
- if obj.cell_id:
- x_norm, y_norm = tiling.cell_to_canonical(obj.cell_id)
- x = x_norm * usable_width + margin
- y = y_norm * usable_height + margin
-
- color_map = {'red': RED, 'green': GREEN, 'blue': BLUE, 'yellow': YELLOW}
- draw_object(self.screen, (x, y), cell_size, color_map.get(obj.color, GRAY))
-
- # Draw agent
- agent_x_norm, agent_y_norm = tiling.cell_to_canonical(self.env.state.agent.cell_id)
- agent_x = agent_x_norm * usable_width + margin
- agent_y = agent_y_norm * usable_height + margin
-
- # Calculate facing angle - match direction vectors
- facing_dir = self.env.state.agent.get_facing_direction(tiling)
- angle_map_square = {
- "north": math.pi / 2, # Up
- "east": 0, # Right
- "south": -math.pi / 2, # Down
- "west": math.pi # Left
- }
- angle_map_hex = {
- "north": math.pi / 2, # Up (0, -1)
- "northeast": math.pi / 6, # Up-right (1, -1)
- "southeast": -math.pi / 6, # Down-right (1, 0)
- "south": -math.pi / 2, # Down (0, 1)
- "southwest": -5 * math.pi / 6, # Down-left (-1, 1)
- "northwest": 5 * math.pi / 6 # Up-left (-1, 0)
- }
- angle_map_triangle = {
- "edge0": math.pi, # Left
- "edge1": 0, # Right
- "edge2": -math.pi / 2 # Down or Up depending on orientation
- }
-
- if self.tiling_type == "square":
- facing_angle = angle_map_square.get(facing_dir, 0)
- elif self.tiling_type == "hex":
- facing_angle = angle_map_hex.get(facing_dir, 0)
- else:
- facing_angle = angle_map_triangle.get(facing_dir, 0)
-
- draw_agent(self.screen, (agent_x, agent_y), cell_size, facing_angle)
-
- # Draw held object indicator above agent (adjusts with facing)
- if self.env.state.agent.holding:
- held_obj = self.env.state.agent.holding
- color_map = {'red': RED, 'green': GREEN, 'blue': BLUE, 'yellow': YELLOW}
- color = color_map.get(held_obj.color, GRAY)
- # Position held object in direction agent is facing
- held_x = agent_x + cell_size * 0.6 * math.cos(facing_angle)
- held_y = agent_y - cell_size * 0.6 * math.sin(facing_angle)
- pygame.draw.circle(self.screen, color, (int(held_x), int(held_y)), int(cell_size * 0.3))
- pygame.draw.circle(self.screen, BLACK, (int(held_x), int(held_y)), int(cell_size * 0.3), 2)
-
- def draw_info(self):
- """Draw information panel."""
- info_y = self.height + 10
-
- state = self.env.get_state_dict()
-
- # Title
- title = self.big_font.render(f"{self.tiling_type.upper()} GRID", True, BLACK)
- self.screen.blit(title, (10, info_y))
-
- # Info text
- info_texts = [
- f"Position: {state['agent']['cell_id']}",
- f"Facing: {state['agent']['facing_direction']}",
- f"Holding: {state['agent']['holding'] or 'Nothing'}",
- f"Steps: {self.env.steps}"
- ]
-
- for i, text in enumerate(info_texts):
- surface = self.font.render(text, True, BLACK)
- self.screen.blit(surface, (10, info_y + 40 + i * 25))
-
- # Controls
- controls = [
- "Arrow/WASD: Move | Q/E: Turn | SPACE: Pickup/Drop | P: Push",
- "1: Square | 2: Hex | 3: Triangle | R: Reset | ESC: Quit"
- ]
-
- for i, text in enumerate(controls):
- surface = self.font.render(text, True, DARK_GRAY)
- self.screen.blit(surface, (self.width // 2 + 10, info_y + 40 + i * 25))
-
- def run(self):
- """Main game loop."""
- running = True
- while running:
- running = self.handle_input()
- self.draw_grid()
- self.draw_info()
- pygame.display.flip()
- self.clock.tick(60)
-
- pygame.quit()
-
-
-if __name__ == "__main__":
- demo = InteractiveDemo(width=800, height=800)
- demo.run()
diff --git a/launch_distributed.sh b/launch_distributed.sh
index bc68a28..2ec8ed5 100755
--- a/launch_distributed.sh
+++ b/launch_distributed.sh
@@ -4,8 +4,7 @@ set -euo pipefail
# Generic run_config-driven distributed provisioner. Derives VM topology from a
# run_config, finds A100 capacity across zones, verifies on-VM code matches the
# local committed sha, applies the cost-safety net, starts the fleet, and writes
-# .runs//manifest.json. See
-# docs/superpowers/specs/2026-06-30-distributed-provisioner-design.md
+# .runs//manifest.json.
#
# Required: RUN_CONFIG, MANIFEST, MAX_RUN_DURATION.
# Subcommands (no creds / no MAX_RUN_DURATION): stop | delete (operate on the manifest).
diff --git a/launch_smoke_4vm.sh b/launch_smoke_4vm.sh
index c12543b..a78fcab 100755
--- a/launch_smoke_4vm.sh
+++ b/launch_smoke_4vm.sh
@@ -24,7 +24,7 @@ source "$(dirname "${BASH_SOURCE[0]}")/lib/cost_safety.sh"
# ./launch_smoke_4vm.sh stop # spin all 4 VMs down, KEEP disks + run data
# ./launch_smoke_4vm.sh delete # delete all 4 VMs incl. disks (post-export only)
#
-# Cost safety net (see docs/superpowers/specs/2026-06-29-distributed-run-cost-safety-net-design.md):
+# Cost safety net (three defense-in-depth layers):
# Layer 0 GCP-native: every created VM gets --max-run-duration=$MAX_RUN_DURATION
# --instance-termination-action=STOP (server-side stop, data preserved).
# Layer 1 On-VM watchdog: each VM schedules `sudo shutdown -h` at the floor + 1h.
diff --git a/lib/distributed_start.sh b/lib/distributed_start.sh
index 56b8330..cced7b6 100644
--- a/lib/distributed_start.sh
+++ b/lib/distributed_start.sh
@@ -3,7 +3,6 @@
# Provides start_coordinator + start_worker, generalized from launch_qwen_smoke.sh
# (coordinator prepare/serve; GPU worker) and launch_smoke_4vm.sh (API worker + key
# delivery). Consumed by launch_distributed.sh (replaces its stub start hooks).
-# See docs/superpowers/specs/2026-07-01-distributed-start-hooks-design.md
worker_field() { # $1 vm-name $2 field -> value from TOPO_JSON on stdout
printf '%s' "$TOPO_JSON" | python3 -c '
@@ -200,7 +199,7 @@ REMOTE
# or "lockstep-worker" (batch-API lockstep runner; R1 uses this). For lockstep,
# API_WORKER_CONCURRENCY is MAX_BATCHES (working-set size; R1: 50) and the
# coordinator must be serving with --stale-after-seconds >= worst-case batch
- # round (see docs/batch-api-lockstep-runner-design.md, docs/r1-run-preparation.md).
+ # round (see docs/batch-api-lockstep-runner-design.md).
# Exactly ONE lockstep worker per API model group β a second one double-pays.
local api_role="${API_WORKER_ROLE:-worker}"
case "$api_role" in
diff --git a/lib/vllm_serve_args.sh b/lib/vllm_serve_args.sh
index 7a858c4..2f73132 100644
--- a/lib/vllm_serve_args.sh
+++ b/lib/vllm_serve_args.sh
@@ -13,7 +13,7 @@
# UNSET env reproduces today's exact phase-1 hard-coded string. The phase-2
# reload (lib/distributed_start.sh::reload_gpu_worker) exports the phase-2 knobs
# before relaunching the worker; served serve-args cannot change at runtime, so
-# switching phases is a real ~14-min server reload (docs/qwen-served-vllm-concurrency.md).
+# switching phases is a real ~14-min server reload.
#
# The served model name is site-specific (--served-model-name "$MODEL") and stays
# at each call site; --port/--dtype/--trust-remote-code are NOT phase-dependent
diff --git a/mazes/exp_maze_images/README.md b/mazes/exp_maze_images/README.md
deleted file mode 100644
index a3ad0c0..0000000
--- a/mazes/exp_maze_images/README.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Experimental Maze Images
-
-This directory contains example visualizations of the experimental maze sets. Each folder represents a different configuration or scenario type.
-
-## Folder Overview
-
-### M1 - Multi-Agent/Mechanism Maze (Key Required)
-- **Example**: `10x10_corridor_kr_0.png`
-- **Characteristics**: Contains key-required mechanics (kr variant)
-- **Sizes**: 8Γ8, 10Γ10, 14Γ14
-- **Layouts**: Corridor-like and dense arrangements
-- **Purpose**: Tests agent navigation with interactive mechanisms (keys, doors, switches, etc.)
-
-### S1 - Empty Room Scenario
-- **Example**: `8x8_empty_room_0.png`
-- **Characteristics**: No walls, simple open space
-- **Purpose**: Baseline test for agent movement in unrestricted environment
-
-### S2 - Simple Corridor (8Γ8)
-- **Example**: `8x8_corridor_0.png`
-- **Characteristics**: Straight corridors with walls
-- **Size**: 8Γ8
-- **Purpose**: Tests navigation in simple linear layouts
-
-### S3 - Medium Corridor (10Γ10)
-- **Example**: `10x10_corridor_0.png`
-- **Characteristics**: More complex corridor layout with more variation
-- **Size**: 10Γ10
-- **Purpose**: Tests navigation in moderately complex layouts
-
-### S4 - Dense Medium Maze (10Γ10)
-- **Example**: `10x10_dense_0.png`
-- **Characteristics**: High wall density, many branching paths
-- **Size**: 10Γ10
-- **Purpose**: Tests pathfinding and decision-making in complex space
-
-### S5 - Large Corridor (14Γ14)
-- **Example**: `14x14_corridor_0.png`
-- **Characteristics**: Corridor-style layout at larger scale
-- **Size**: 14Γ14
-- **Purpose**: Tests navigation in larger but structured environments
-
-### S6 - Dense Large Maze (14Γ14)
-- **Example**: `14x14_dense_0.png`
-- **Characteristics**: High wall density in large space, most complex
-- **Size**: 14Γ14
-- **Purpose**: Tests pathfinding under maximum complexity
-
-## Key Differences
-
-| Category | M1 | S1-S6 |
-|----------|----|----|
-| **Mechanics** | Contains keys, doors, switches, gates | Simple movement + goal |
-| **Interaction** | Requires mechanism solving | Direct pathfinding |
-| **Complexity** | Variable (kr variants) | Structured progression |
-| **Sizes** | Multi-scale (8-14Γ14) | Per-scenario (S1: 8Γ8, S2-S3: sizes vary, S4-S6: increase) |
-
-## Usage
-
-These example images correspond to JSON specifications in `../exp_maze_jsons/`. Each PNG is a rendered visualization of the corresponding maze layout.
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_0.json
deleted file mode 100644
index f77d3cc..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_0.json
+++ /dev/null
@@ -1,61 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_1.json
deleted file mode 100644
index 3f9160e..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_1.json
+++ /dev/null
@@ -1,65 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, a distractor yellow key, and a red key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_0.json
deleted file mode 100644
index 5270c41..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_0.json
+++ /dev/null
@@ -1,73 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_1.json
deleted file mode 100644
index 293cc1a..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_kb_1.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_kr_kb_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [3, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 4],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_0.json
deleted file mode 100644
index b18d558..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_0.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_1.json
deleted file mode 100644
index 37a47e0..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_0.json
deleted file mode 100644
index 76befb4..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_0.json
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [8, 6],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_1.json
deleted file mode 100644
index c77d6b4..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_kr_sg_kb_1.json
+++ /dev/null
@@ -1,93 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [7, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 3],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_0.json
deleted file mode 100644
index fb887aa..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_0.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_1.json
deleted file mode 100644
index ad7494c..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_1.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key and switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_0.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_0.json
deleted file mode 100644
index ef2892f..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_0.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_1.json b/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_1.json
deleted file mode 100644
index 2060b69..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_corridor_wrong_ky_sg_kr_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 4],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_0.json
deleted file mode 100644
index 0125106..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_0.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_1.json
deleted file mode 100644
index 4b21f7e..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_1.json
+++ /dev/null
@@ -1,65 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, a distractor yellow key, and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_0.json
deleted file mode 100644
index 9700c3b..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_0.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_1.json
deleted file mode 100644
index eb1089a..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_kb_1.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10_dense_wrong_ky_kr_kb_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_0.json
deleted file mode 100644
index c90ede5..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_0.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_1.json
deleted file mode 100644
index 1ce2e93..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10_dense_wrong_ky_kr_sg_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json
deleted file mode 100644
index c3a6139..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_0.json
+++ /dev/null
@@ -1,92 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_1.json
deleted file mode 100644
index e90ac06..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_kr_sg_kb_1.json
+++ /dev/null
@@ -1,93 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_0.json
deleted file mode 100644
index d5a0a04..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_0.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_1.json
deleted file mode 100644
index c9547ac..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_1.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key and switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_0.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_0.json
deleted file mode 100644
index 1f543e2..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_0.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [8, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_1.json b/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_1.json
deleted file mode 100644
index 830245a..0000000
--- a/mazes/exp_maze_jsons/D1/10x10_dense_wrong_ky_sg_kr_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10_dense_wrong_ky_sg_kr_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_0.json
deleted file mode 100644
index a655718..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_0.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_1.json
deleted file mode 100644
index 3a92360..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_1.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, a distractor yellow key, and a red key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_0.json
deleted file mode 100644
index fc88ae6..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_0.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [10, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_1.json
deleted file mode 100644
index dbad07c..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_kb_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14_corridor_wrong_ky_kr_kb_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [6, 1],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [8, 12],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_0.json
deleted file mode 100644
index b934118..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_0.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_1.json
deleted file mode 100644
index b6b5587..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_1.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_0.json
deleted file mode 100644
index 133864d..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_0.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [10, 11],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_1.json
deleted file mode 100644
index 272a506..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_kr_sg_kb_1.json
+++ /dev/null
@@ -1,97 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [9, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_0.json
deleted file mode 100644
index 0d74b03..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_0.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_1.json
deleted file mode 100644
index 9a5d564..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_1.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key and switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_0.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_0.json
deleted file mode 100644
index a8ec69b..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_0.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [10, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_1.json b/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_1.json
deleted file mode 100644
index a5815ed..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_corridor_wrong_ky_sg_kr_1.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [6, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [8, 12],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_0.json
deleted file mode 100644
index 883e74d..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_0.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_1.json
deleted file mode 100644
index 04876af..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_1.json
+++ /dev/null
@@ -1,69 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, a distractor yellow key, and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_0.json
deleted file mode 100644
index f31269a..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_0.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 11],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 10],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_1.json
deleted file mode 100644
index 042c21e..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_kb_1.json
+++ /dev/null
@@ -1,81 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14_dense_wrong_ky_kr_kb_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_0.json
deleted file mode 100644
index 8c34ce0..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_0.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_1.json
deleted file mode 100644
index 41693ce..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_1.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14_dense_wrong_ky_kr_sg_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_0.json
deleted file mode 100644
index 997b1c0..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_0.json
+++ /dev/null
@@ -1,97 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 8],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_1.json
deleted file mode 100644
index 4565772..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_kr_sg_kb_1.json
+++ /dev/null
@@ -1,97 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [12, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_0.json
deleted file mode 100644
index 670a346..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_0.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_1.json
deleted file mode 100644
index ec19f52..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_1.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key and switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_0.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_0.json
deleted file mode 100644
index 0aefc4f..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_0.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 11],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 10],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_1.json b/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_1.json
deleted file mode 100644
index 6d0cffb..0000000
--- a/mazes/exp_maze_jsons/D1/14x14_dense_wrong_ky_sg_kr_1.json
+++ /dev/null
@@ -1,85 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14_dense_wrong_ky_sg_kr_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [10, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_0.json
deleted file mode 100644
index 2a262f5..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_0.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with a distractor yellow key, turns and a key-door mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_1.json
deleted file mode 100644
index d343909..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_1.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with turns, a distractor yellow key, and a red key-door mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_0.json
deleted file mode 100644
index e26da64..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_0.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [3, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_1.json
deleted file mode 100644
index be2a47e..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_kb_1.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8_corridor_wrong_ky_kr_kb_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [3, 4],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [4, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_0.json
deleted file mode 100644
index 35d7ea1..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_0.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_1.json
deleted file mode 100644
index 30c1fa2..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_1.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_0.json
deleted file mode 100644
index 7ec0426..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_0.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [4, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_1.json
deleted file mode 100644
index ee64c57..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_kr_sg_kb_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 2],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_0.json
deleted file mode 100644
index 488b804..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_0.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with a distractor yellow key, turns and a switch-gate mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_1.json
deleted file mode 100644
index a8a756b..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_1.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with a distractor yellow key and switch-gate mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_0.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_0.json
deleted file mode 100644
index 3ca1288..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_0.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_1.json b/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_1.json
deleted file mode 100644
index 43dc969..0000000
--- a/mazes/exp_maze_jsons/D1/8x8_corridor_wrong_ky_sg_kr_1.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 4],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 1],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_0.json
deleted file mode 100644
index 227ea10..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_1.json
deleted file mode 100644
index 8bd9ef6..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_0.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_0.json
deleted file mode 100644
index 6883126..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_0.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_inactive_sb_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_1.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_1.json
deleted file mode 100644
index 8b178d8..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_inactive_sb_sg_kr_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 4],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_0.json
deleted file mode 100644
index ce53caa..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_1.json
deleted file mode 100644
index 063ac25..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 6],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
deleted file mode 100644
index 4674e57..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
+++ /dev/null
@@ -1,99 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [8, 6],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json b/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
deleted file mode 100644
index 6e256a2..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
+++ /dev/null
@@ -1,103 +0,0 @@
-{
- "task_id": "10x10_corridor_wrong_ky_kr_inactive_sb_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [7, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 3],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 6],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_0.json
deleted file mode 100644
index 7131cc3..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,77 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 7],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 6],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_1.json
deleted file mode 100644
index 4fafdb9..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_0.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_0.json
deleted file mode 100644
index bee95b9..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_0.json
+++ /dev/null
@@ -1,90 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_inactive_sb_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends, switch-gate, and key-door mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 7],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [8, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 6],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_1.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_1.json
deleted file mode 100644
index 8fc71b4..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_inactive_sb_sg_kr_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10_dense_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_0.json
deleted file mode 100644
index bae89d2..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,90 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends, key-door, and switch-gate mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [7, 7],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_1.json
deleted file mode 100644
index d63a7d2..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10_dense_wrong_ky_kr_sg_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 7],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json
deleted file mode 100644
index 822a173..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json
+++ /dev/null
@@ -1,102 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with a distractor yellow key, dead ends and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [8, 7],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [7, 7],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json b/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json
deleted file mode 100644
index 02a9b78..0000000
--- a/mazes/exp_maze_jsons/D2/10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json
+++ /dev/null
@@ -1,103 +0,0 @@
-{
- "task_id": "10x10_dense_wrong_ky_kr_inactive_sb_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 5],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 7],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_0.json
deleted file mode 100644
index 7ec035c..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_1.json
deleted file mode 100644
index 6aac155..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,82 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor maze with a distractor yellow key and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 3],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_0.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_0.json
deleted file mode 100644
index d168162..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_0.json
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_inactive_sb_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [10, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_1.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_1.json
deleted file mode 100644
index 9be29d8..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_inactive_sb_sg_kr_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [6, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [8, 12],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 3],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_0.json
deleted file mode 100644
index 2f5d6cb..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [8, 9],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_1.json
deleted file mode 100644
index be52155..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
deleted file mode 100644
index 373f1d0..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
+++ /dev/null
@@ -1,101 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [10, 11],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [8, 9],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json b/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
deleted file mode 100644
index a6a21cf..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "task_id": "14x14_corridor_wrong_ky_kr_inactive_sb_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [9, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [5, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_0.json
deleted file mode 100644
index dda65a3..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,82 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 4],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_1.json
deleted file mode 100644
index 7f89ebe..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,82 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a single switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 6],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_single_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_0.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_0.json
deleted file mode 100644
index 06b319c..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_0.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_inactive_sb_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends, switch-gate, and key-door mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 11],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 10],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 4],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_1.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_1.json
deleted file mode 100644
index 65b3fb7..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_inactive_sb_sg_kr_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14_dense_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [10, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_0.json
deleted file mode 100644
index cb64858..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends, key-door, and switch-gate mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 11],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_1.json
deleted file mode 100644
index 20dad35..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14_dense_wrong_ky_kr_sg_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 9],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json
deleted file mode 100644
index e0036a4..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with a distractor yellow key, dead ends and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 8],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 11],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json b/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json
deleted file mode 100644
index 86ea70b..0000000
--- a/mazes/exp_maze_jsons/D2/14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "task_id": "14x14_dense_wrong_ky_kr_inactive_sb_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [2, 6],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [12, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 9],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_0.json
deleted file mode 100644
index 128cf6f..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,73 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with a distractor yellow key, turns and a switch-gate mechanism. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [4, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_1.json
deleted file mode 100644
index 98be598..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 1,
- "difficulty_tier": 3,
- "description": "8x8 corridor with a distractor yellow key and an inactive blue switch on the path to the switch gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- }
- ],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 2],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_0.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_0.json
deleted file mode 100644
index 324141d..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_0.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_inactive_sb_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns, switch-gate, and key-door mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [4, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json
deleted file mode 100644
index 5feff3b..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_inactive_sb_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8_corridor_wrong_ky_sg_kr_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 3],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 4],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 1],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 2],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [1, 1],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_switch_gate_then_key_door_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_0.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_0.json
deleted file mode 100644
index 8341456..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_0.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_inactive_sb_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns, key-door, and switch-gate mechanism chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_1.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_1.json
deleted file mode 100644
index e7adad2..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_1.json
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_inactive_sb_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8_corridor_wrong_ky_kr_sg_1 with a distractor yellow key before the red key. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_key_door_then_switch_gate_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
deleted file mode 100644
index 135af16..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_0.json
+++ /dev/null
@@ -1,98 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with a distractor yellow key, turns and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [4, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [2, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "after_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json b/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
deleted file mode 100644
index 5510c92..0000000
--- a/mazes/exp_maze_jsons/D2/8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_1.json
+++ /dev/null
@@ -1,101 +0,0 @@
-{
- "task_id": "8x8_corridor_wrong_ky_kr_inactive_sb_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, a distractor yellow key, and a red key-door, switch-gate, then blue key-door chain. Includes an inactive blue switch distractor that does not control any gate.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [1, 2],
- "color": "yellow"
- },
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 2],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- },
- {
- "id": "inactive_sb",
- "position": [3, 5],
- "controls": [],
- "color": "blue",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "wrong_key_then_kr_sg_kb_inactive_blue_switch",
- "tiling": "square",
- "wall_topology": "winding",
- "distractor_type": "inactive_blue_switch",
- "inactive_switch_position_rule": "before_real_switch"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_0.json
deleted file mode 100644
index d748b3c..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,62 +0,0 @@
-{
- "task_id": "10x10_dense_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "S4",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json
deleted file mode 100644
index 7caf9ab..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
- "task_id": "10x10_dense_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze variant with dead ends. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "S4",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_0.json
deleted file mode 100644
index 91ded29..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "10x10_dense_kr_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single key-door mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M1",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_1.json
deleted file mode 100644
index 3fc8c68..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
- "task_id": "10x10_dense_kr_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single key-door mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M1",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_0.json
deleted file mode 100644
index beab167..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "task_id": "10x10_dense_kr_kb_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and two key-door pairs in sequence: red then blue. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 8],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M5",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_1.json
deleted file mode 100644
index 25b5d1e..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_kb_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
- "task_id": "10x10_dense_kr_kb_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and two key-door pairs in sequence: red then blue. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 8],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M5",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_0.json
deleted file mode 100644
index 692e307..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,90 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, key-door, and switch-gate mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M3",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_1.json
deleted file mode 100644
index 2edab3c..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, key-door, and switch-gate mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M3",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_0.json
deleted file mode 100644
index 8d0bb99..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,102 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_kb_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 5],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M6",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_1.json
deleted file mode 100644
index 80e819c..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_kr_sg_kb_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,103 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_kb_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M6",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_0.json
deleted file mode 100644
index fdc82c9..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
- "task_id": "10x10_dense_sg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M2",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_1.json
deleted file mode 100644
index 1d794d6..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_sg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "10x10_dense_sg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M2",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_0.json
deleted file mode 100644
index e38282a..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,90 +0,0 @@
-{
- "task_id": "10x10_dense_sg_kr_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, switch-gate, and key-door mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [8, 8],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M4",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_1.json
deleted file mode 100644
index f16f4af..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_sg_kr_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "10x10_dense_sg_kr_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, switch-gate, and key-door mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 8],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M4",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_0.json
deleted file mode 100644
index 3e4e0b8..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,78 +0,0 @@
-{
- "task_id": "10x10_dense_swg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single white switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [4, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [3, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "white",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_white_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "B1",
- "deadend_branch_leaf": [3, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_1.json
deleted file mode 100644
index 8904b53..0000000
--- a/mazes/exp_maze_jsons/D3/10x10_dense_swg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "10x10_dense_swg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single white switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "white",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_white_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "B1",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_0.json
deleted file mode 100644
index 6c88bbb..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
- "task_id": "14x14_dense_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with many walls and dead ends. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "S6",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_1.json
deleted file mode 100644
index 6ff4404..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
- "task_id": "14x14_dense_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze variant with many walls and dead ends. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "S6",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_0.json
deleted file mode 100644
index f11c44a..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "14x14_dense_kr_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single key-door mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M1",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_1.json
deleted file mode 100644
index 3f25f81..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
- "task_id": "14x14_dense_kr_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single key-door mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M1",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_0.json
deleted file mode 100644
index 38ffd04..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "14x14_dense_kr_kb_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and two key-door pairs in sequence: red then blue. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 11],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 10],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M5",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_1.json
deleted file mode 100644
index 3ffd93a..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_kb_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "task_id": "14x14_dense_kr_kb_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and two key-door pairs in sequence: red then blue. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 9],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M5",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_0.json
deleted file mode 100644
index 8d2f129..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, key-door, and switch-gate mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M3",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_1.json
deleted file mode 100644
index 2ce3775..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, key-door, and switch-gate mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M3",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_0.json
deleted file mode 100644
index 7b0ec72..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_kb_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 9],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 8],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M6",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_1.json
deleted file mode 100644
index cfe04e9..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_kr_sg_kb_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_kb_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [12, 12],
- "color": "blue"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M6",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_0.json
deleted file mode 100644
index 9f4ff40..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
- "task_id": "14x14_dense_sg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M2",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_1.json
deleted file mode 100644
index 4eda883..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_sg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
- "task_id": "14x14_dense_sg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M2",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_0.json
deleted file mode 100644
index f21d88b..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_sg_kr_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, switch-gate, and key-door mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 11],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 10],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M4",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_1.json
deleted file mode 100644
index 66869e5..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_sg_kr_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
- "task_id": "14x14_dense_sg_kr_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, switch-gate, and key-door mechanism chain. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 9],
- "color": "red"
- },
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [10, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "M4",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_0.json b/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_0.json
deleted file mode 100644
index 1911a26..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_0.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
- "task_id": "14x14_dense_swg_deadend_ky_dy_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single white switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [10, 7],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [9, 7],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "white",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_white_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "B1",
- "deadend_branch_leaf": [9, 7]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_1.json b/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_1.json
deleted file mode 100644
index 9faeadd..0000000
--- a/mazes/exp_maze_jsons/D3/14x14_dense_swg_deadend_ky_dy_1.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
- "task_id": "14x14_dense_swg_deadend_ky_dy_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single white switch-gate mechanism. Includes a yellow key-door distractor leading into a dead-end branch.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kY",
- "position": [5, 1],
- "color": "yellow"
- }
- ],
- "doors": [
- {
- "id": "DY",
- "position": [4, 1],
- "color": "yellow",
- "requires_key": "yellow",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "white",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_white_switch_gate_deadend_yellow_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends",
- "distractor_type": "deadend_yellow_key_door",
- "source_category": "B1",
- "deadend_branch_leaf": [4, 1]
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/10x10_corridor_kr_0.json b/mazes/exp_maze_jsons/M1/10x10_corridor_kr_0.json
deleted file mode 100644
index 251c26a..0000000
--- a/mazes/exp_maze_jsons/M1/10x10_corridor_kr_0.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/10x10_corridor_kr_1.json b/mazes/exp_maze_jsons/M1/10x10_corridor_kr_1.json
deleted file mode 100644
index c2201ec..0000000
--- a/mazes/exp_maze_jsons/M1/10x10_corridor_kr_1.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, a vertical layout, and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/10x10_dense_kr_0.json b/mazes/exp_maze_jsons/M1/10x10_dense_kr_0.json
deleted file mode 100644
index 956d2d7..0000000
--- a/mazes/exp_maze_jsons/M1/10x10_dense_kr_0.json
+++ /dev/null
@@ -1,59 +0,0 @@
-{
- "task_id": "10x10_dense_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/10x10_dense_kr_1.json b/mazes/exp_maze_jsons/M1/10x10_dense_kr_1.json
deleted file mode 100644
index 1006779..0000000
--- a/mazes/exp_maze_jsons/M1/10x10_dense_kr_1.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
- "task_id": "10x10_dense_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/14x14_corridor_kr_0.json b/mazes/exp_maze_jsons/M1/14x14_corridor_kr_0.json
deleted file mode 100644
index 6ee5754..0000000
--- a/mazes/exp_maze_jsons/M1/14x14_corridor_kr_0.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/14x14_corridor_kr_1.json b/mazes/exp_maze_jsons/M1/14x14_corridor_kr_1.json
deleted file mode 100644
index d7fae66..0000000
--- a/mazes/exp_maze_jsons/M1/14x14_corridor_kr_1.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, a vertical layout, and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/14x14_dense_kr_0.json b/mazes/exp_maze_jsons/M1/14x14_dense_kr_0.json
deleted file mode 100644
index 173aa69..0000000
--- a/mazes/exp_maze_jsons/M1/14x14_dense_kr_0.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "task_id": "14x14_dense_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/14x14_dense_kr_1.json b/mazes/exp_maze_jsons/M1/14x14_dense_kr_1.json
deleted file mode 100644
index 17093aa..0000000
--- a/mazes/exp_maze_jsons/M1/14x14_dense_kr_1.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "task_id": "14x14_dense_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single key-door mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/8x8_corridor_kr_0.json b/mazes/exp_maze_jsons/M1/8x8_corridor_kr_0.json
deleted file mode 100644
index cbe7ce3..0000000
--- a/mazes/exp_maze_jsons/M1/8x8_corridor_kr_0.json
+++ /dev/null
@@ -1,55 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with turns and a key-door mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M1/8x8_corridor_kr_1.json b/mazes/exp_maze_jsons/M1/8x8_corridor_kr_1.json
deleted file mode 100644
index c06bb7a..0000000
--- a/mazes/exp_maze_jsons/M1/8x8_corridor_kr_1.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with turns and a key-door mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/10x10_corridor_sg_0.json b/mazes/exp_maze_jsons/M2/10x10_corridor_sg_0.json
deleted file mode 100644
index 3bce02a..0000000
--- a/mazes/exp_maze_jsons/M2/10x10_corridor_sg_0.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
- "task_id": "10x10_corridor_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/10x10_corridor_sg_1.json b/mazes/exp_maze_jsons/M2/10x10_corridor_sg_1.json
deleted file mode 100644
index 43e08e8..0000000
--- a/mazes/exp_maze_jsons/M2/10x10_corridor_sg_1.json
+++ /dev/null
@@ -1,62 +0,0 @@
-{
- "task_id": "10x10_corridor_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, a vertical layout, and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/10x10_dense_sg_0.json b/mazes/exp_maze_jsons/M2/10x10_dense_sg_0.json
deleted file mode 100644
index e14f33a..0000000
--- a/mazes/exp_maze_jsons/M2/10x10_dense_sg_0.json
+++ /dev/null
@@ -1,61 +0,0 @@
-{
- "task_id": "10x10_dense_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/10x10_dense_sg_1.json b/mazes/exp_maze_jsons/M2/10x10_dense_sg_1.json
deleted file mode 100644
index c313233..0000000
--- a/mazes/exp_maze_jsons/M2/10x10_dense_sg_1.json
+++ /dev/null
@@ -1,62 +0,0 @@
-{
- "task_id": "10x10_dense_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/14x14_corridor_sg_0.json b/mazes/exp_maze_jsons/M2/14x14_corridor_sg_0.json
deleted file mode 100644
index c4fd7f9..0000000
--- a/mazes/exp_maze_jsons/M2/14x14_corridor_sg_0.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
- "task_id": "14x14_corridor_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/14x14_corridor_sg_1.json b/mazes/exp_maze_jsons/M2/14x14_corridor_sg_1.json
deleted file mode 100644
index ce9d5ff..0000000
--- a/mazes/exp_maze_jsons/M2/14x14_corridor_sg_1.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
- "task_id": "14x14_corridor_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, a vertical layout, and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/14x14_dense_sg_0.json b/mazes/exp_maze_jsons/M2/14x14_dense_sg_0.json
deleted file mode 100644
index 338065d..0000000
--- a/mazes/exp_maze_jsons/M2/14x14_dense_sg_0.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
- "task_id": "14x14_dense_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/14x14_dense_sg_1.json b/mazes/exp_maze_jsons/M2/14x14_dense_sg_1.json
deleted file mode 100644
index aad967b..0000000
--- a/mazes/exp_maze_jsons/M2/14x14_dense_sg_1.json
+++ /dev/null
@@ -1,66 +0,0 @@
-{
- "task_id": "14x14_dense_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a single switch-gate mechanism.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/8x8_corridor_sg_0.json b/mazes/exp_maze_jsons/M2/8x8_corridor_sg_0.json
deleted file mode 100644
index a39bf8d..0000000
--- a/mazes/exp_maze_jsons/M2/8x8_corridor_sg_0.json
+++ /dev/null
@@ -1,57 +0,0 @@
-{
- "task_id": "8x8_corridor_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with turns and a switch-gate mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M2/8x8_corridor_sg_1.json b/mazes/exp_maze_jsons/M2/8x8_corridor_sg_1.json
deleted file mode 100644
index 2b65b73..0000000
--- a/mazes/exp_maze_jsons/M2/8x8_corridor_sg_1.json
+++ /dev/null
@@ -1,60 +0,0 @@
-{
- "task_id": "8x8_corridor_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "8x8 corridor with turns and a switch-gate mechanism.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "single_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_0.json b/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_0.json
deleted file mode 100644
index 4ab99fa..0000000
--- a/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_0.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_1.json b/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_1.json
deleted file mode 100644
index 8b8d1a9..0000000
--- a/mazes/exp_maze_jsons/M3/10x10_corridor_kr_sg_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_0.json b/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_0.json
deleted file mode 100644
index b78e504..0000000
--- a/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_0.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_1.json b/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_1.json
deleted file mode 100644
index 57c7dad..0000000
--- a/mazes/exp_maze_jsons/M3/10x10_dense_kr_sg_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_0.json b/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_0.json
deleted file mode 100644
index 18170ad..0000000
--- a/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_0.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_1.json b/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_1.json
deleted file mode 100644
index 4b409f2..0000000
--- a/mazes/exp_maze_jsons/M3/14x14_corridor_kr_sg_1.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_0.json b/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_0.json
deleted file mode 100644
index bfd2361..0000000
--- a/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_0.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_1.json b/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_1.json
deleted file mode 100644
index b037086..0000000
--- a/mazes/exp_maze_jsons/M3/14x14_dense_kr_sg_1.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_0.json b/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_0.json
deleted file mode 100644
index 7e7ae21..0000000
--- a/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_0.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_sg_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_1.json b/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_1.json
deleted file mode 100644
index 5ab06bf..0000000
--- a/mazes/exp_maze_jsons/M3/8x8_corridor_kr_sg_1.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_sg_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, key-door, and switch-gate mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "key_door_then_switch_gate",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_0.json b/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_0.json
deleted file mode 100644
index f10496e..0000000
--- a/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_0.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "10x10_corridor_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_1.json b/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_1.json
deleted file mode 100644
index 1603174..0000000
--- a/mazes/exp_maze_jsons/M4/10x10_corridor_sg_kr_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "10x10_corridor_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 5],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 4],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_0.json b/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_0.json
deleted file mode 100644
index 7d0bbe5..0000000
--- a/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_0.json
+++ /dev/null
@@ -1,75 +0,0 @@
-{
- "task_id": "10x10_dense_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [8, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_1.json b/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_1.json
deleted file mode 100644
index 1d5a048..0000000
--- a/mazes/exp_maze_jsons/M4/10x10_dense_sg_kr_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "10x10_dense_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 8],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [5, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_0.json b/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_0.json
deleted file mode 100644
index 724ce1d..0000000
--- a/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_0.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "14x14_corridor_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [10, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_1.json b/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_1.json
deleted file mode 100644
index ffaeca7..0000000
--- a/mazes/exp_maze_jsons/M4/14x14_corridor_sg_kr_1.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_corridor_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [6, 1],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [8, 12],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_0.json b/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_0.json
deleted file mode 100644
index 9073c1d..0000000
--- a/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_0.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_dense_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 11],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 10],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [1, 7],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_1.json b/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_1.json
deleted file mode 100644
index 28125a3..0000000
--- a/mazes/exp_maze_jsons/M4/14x14_dense_sg_kr_1.json
+++ /dev/null
@@ -1,80 +0,0 @@
-{
- "task_id": "14x14_dense_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 9],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [10, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 8],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_0.json b/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_0.json
deleted file mode 100644
index 2a08d3e..0000000
--- a/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_0.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
- "task_id": "8x8_corridor_sg_kr_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 5],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 3],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_1.json b/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_1.json
deleted file mode 100644
index cc73ad1..0000000
--- a/mazes/exp_maze_jsons/M4/8x8_corridor_sg_kr_1.json
+++ /dev/null
@@ -1,74 +0,0 @@
-{
- "task_id": "8x8_corridor_sg_kr_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns, switch-gate, and key-door mechanism chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 4],
- "color": "red"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 1],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 3],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [2, 6],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "switch_gate_then_key_door",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_0.json b/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_0.json
deleted file mode 100644
index 54ff132..0000000
--- a/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_0.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_1.json b/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_1.json
deleted file mode 100644
index 071a566..0000000
--- a/mazes/exp_maze_jsons/M5/10x10_corridor_kr_kb_1.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [3, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 4],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_0.json b/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_0.json
deleted file mode 100644
index 90150a7..0000000
--- a/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_0.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
- "task_id": "10x10_dense_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_1.json b/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_1.json
deleted file mode 100644
index dc4a06f..0000000
--- a/mazes/exp_maze_jsons/M5/10x10_dense_kr_kb_1.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
- "task_id": "10x10_dense_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_0.json b/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_0.json
deleted file mode 100644
index f694dfb..0000000
--- a/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_0.json
+++ /dev/null
@@ -1,70 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [10, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_1.json b/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_1.json
deleted file mode 100644
index 0d31cb6..0000000
--- a/mazes/exp_maze_jsons/M5/14x14_corridor_kr_kb_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [6, 1],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [8, 12],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_0.json b/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_0.json
deleted file mode 100644
index 9be4c40..0000000
--- a/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_0.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "14x14_dense_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 11],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 10],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_1.json b/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_1.json
deleted file mode 100644
index bd7fe08..0000000
--- a/mazes/exp_maze_jsons/M5/14x14_dense_kr_kb_1.json
+++ /dev/null
@@ -1,76 +0,0 @@
-{
- "task_id": "14x14_dense_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_0.json b/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_0.json
deleted file mode 100644
index 1fe2150..0000000
--- a/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_0.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [1, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [3, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_1.json b/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_1.json
deleted file mode 100644
index 0711f91..0000000
--- a/mazes/exp_maze_jsons/M5/8x8_corridor_kr_kb_1.json
+++ /dev/null
@@ -1,70 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns and two key-door pairs in sequence: red then blue.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [3, 4],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [4, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kk",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_0.json b/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_0.json
deleted file mode 100644
index c954007..0000000
--- a/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_0.json
+++ /dev/null
@@ -1,84 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [8, 6],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [6, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_1.json b/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_1.json
deleted file mode 100644
index 9ed0312..0000000
--- a/mazes/exp_maze_jsons/M6/10x10_corridor_kr_sg_kb_1.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "task_id": "10x10_corridor_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [7, 8],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [7, 3],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 4],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_0.json b/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_0.json
deleted file mode 100644
index 64e564e..0000000
--- a/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_0.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [4, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [8, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_1.json b/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_1.json
deleted file mode 100644
index ada85f0..0000000
--- a/mazes/exp_maze_jsons/M6/10x10_dense_kr_sg_kb_1.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "task_id": "10x10_dense_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [8, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [6, 2],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [5, 8],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [5, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_0.json b/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_0.json
deleted file mode 100644
index 04b7fc9..0000000
--- a/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_0.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [10, 11],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [7, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 11],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [10, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_1.json b/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_1.json
deleted file mode 100644
index 7df2dd3..0000000
--- a/mazes/exp_maze_jsons/M6/14x14_corridor_kr_sg_kb_1.json
+++ /dev/null
@@ -1,92 +0,0 @@
-{
- "task_id": "14x14_corridor_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [9, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 11],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [10, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [6, 1],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [8, 12],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_0.json b/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_0.json
deleted file mode 100644
index 12ff5f4..0000000
--- a/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_0.json
+++ /dev/null
@@ -1,92 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [5, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 9],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [1, 7],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 8],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 11],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [7, 10],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_1.json b/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_1.json
deleted file mode 100644
index 6896584..0000000
--- a/mazes/exp_maze_jsons/M6/14x14_dense_kr_sg_kb_1.json
+++ /dev/null
@@ -1,92 +0,0 @@
-{
- "task_id": "14x14_dense_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with dead ends and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 5],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [12, 12],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [6, 8],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [11, 1],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 9],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [10, 11],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_0.json b/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_0.json
deleted file mode 100644
index c2d5ab1..0000000
--- a/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_0.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_sg_kb_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [3, 1],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [4, 5],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [3, 3],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [1, 5],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [3, 5],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_1.json b/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_1.json
deleted file mode 100644
index 20873a3..0000000
--- a/mazes/exp_maze_jsons/M6/8x8_corridor_kr_sg_kb_1.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
- "task_id": "8x8_corridor_kr_sg_kb_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "8x8 corridor with turns and a red key-door, switch-gate, then blue key-door chain.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [
- {
- "id": "kR",
- "position": [1, 3],
- "color": "red"
- },
- {
- "id": "kB",
- "position": [5, 2],
- "color": "blue"
- }
- ],
- "doors": [
- {
- "id": "DR",
- "position": [2, 6],
- "color": "red",
- "requires_key": "red",
- "initial_state": "locked"
- },
- {
- "id": "DB",
- "position": [5, 5],
- "color": "blue",
- "requires_key": "blue",
- "initial_state": "locked"
- }
- ],
- "switches": [
- {
- "id": "s1",
- "position": [3, 4],
- "controls": ["g1"],
- "color": "yellow",
- "switch_type": "toggle",
- "initial_state": "off"
- }
- ],
- "gates": [
- {
- "id": "g1",
- "position": [4, 1],
- "color": "black",
- "initial_state": "closed"
- }
- ]
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "kr_sg_kb",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S1/8x8_empty_room_0.json b/mazes/exp_maze_jsons/S1/8x8_empty_room_0.json
deleted file mode 100644
index 19ecce3..0000000
--- a/mazes/exp_maze_jsons/S1/8x8_empty_room_0.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
- "task_id": "8x8_empty_room_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 1,
- "description": "8x8 empty room with implicit perimeter walls.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "open"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S1/8x8_empty_room_1.json b/mazes/exp_maze_jsons/S1/8x8_empty_room_1.json
deleted file mode 100644
index 39d2548..0000000
--- a/mazes/exp_maze_jsons/S1/8x8_empty_room_1.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
- "task_id": "8x8_empty_room_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 1,
- "description": "8x8 empty room with implicit perimeter walls.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [],
- "start": [1, 1],
- "goal": [4, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [4, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "open"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S2/8x8_corridor_0.json b/mazes/exp_maze_jsons/S2/8x8_corridor_0.json
deleted file mode 100644
index 49109d9..0000000
--- a/mazes/exp_maze_jsons/S2/8x8_corridor_0.json
+++ /dev/null
@@ -1,41 +0,0 @@
-{
- "task_id": "8x8_corridor_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 2,
- "description": "8x8 corridor with turns.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S2/8x8_corridor_1.json b/mazes/exp_maze_jsons/S2/8x8_corridor_1.json
deleted file mode 100644
index bcfe417..0000000
--- a/mazes/exp_maze_jsons/S2/8x8_corridor_1.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
- "task_id": "8x8_corridor_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 2,
- "description": "8x8 corridor with turns and a vertical layout.",
- "maze": {
- "dimensions": [8, 8],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2],
- [2, 3], [4, 3], [6, 3],
- [2, 4], [4, 4], [6, 4],
- [2, 5], [4, 5], [6, 5],
- [4, 6]
- ],
- "start": [1, 1],
- "goal": [6, 6]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [6, 6],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S3/10x10_corridor_0.json b/mazes/exp_maze_jsons/S3/10x10_corridor_0.json
deleted file mode 100644
index d151ee4..0000000
--- a/mazes/exp_maze_jsons/S3/10x10_corridor_0.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
- "task_id": "10x10_corridor_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [1, 2], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4],
- [1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [1, 8]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [1, 8],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S3/10x10_corridor_1.json b/mazes/exp_maze_jsons/S3/10x10_corridor_1.json
deleted file mode 100644
index fe30f0f..0000000
--- a/mazes/exp_maze_jsons/S3/10x10_corridor_1.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
- "task_id": "10x10_corridor_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 3,
- "description": "10x10 corridor with turns and a vertical layout.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [6, 1],
- [2, 2], [4, 2], [6, 2], [8, 2],
- [2, 3], [4, 3], [6, 3], [8, 3],
- [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [6, 6], [8, 6],
- [2, 7], [4, 7], [6, 7], [8, 7],
- [4, 8], [8, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S4/10x10_dense_0.json b/mazes/exp_maze_jsons/S4/10x10_dense_0.json
deleted file mode 100644
index a172f7c..0000000
--- a/mazes/exp_maze_jsons/S4/10x10_dense_0.json
+++ /dev/null
@@ -1,45 +0,0 @@
-{
- "task_id": "10x10_dense_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze with dead ends.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [2, 1], [8, 1],
- [2, 2], [3, 2], [4, 2], [6, 2], [7, 2], [8, 2],
- [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [2, 5], [4, 5], [6, 5], [8, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [7, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [7, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S4/10x10_dense_1.json b/mazes/exp_maze_jsons/S4/10x10_dense_1.json
deleted file mode 100644
index 4c6be73..0000000
--- a/mazes/exp_maze_jsons/S4/10x10_dense_1.json
+++ /dev/null
@@ -1,46 +0,0 @@
-{
- "task_id": "10x10_dense_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 4,
- "description": "10x10 dense maze variant with dead ends.",
- "maze": {
- "dimensions": [10, 10],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2],
- [1, 3], [4, 3], [8, 3],
- [1, 4], [2, 4], [4, 4], [6, 4], [8, 4],
- [4, 5], [6, 5],
- [1, 6], [3, 6], [4, 6], [6, 6], [7, 6], [8, 6],
- [1, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [6, 8], [7, 8]
- ],
- "start": [1, 1],
- "goal": [8, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [8, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S5/14x14_corridor_0.json b/mazes/exp_maze_jsons/S5/14x14_corridor_0.json
deleted file mode 100644
index ed05176..0000000
--- a/mazes/exp_maze_jsons/S5/14x14_corridor_0.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
- "task_id": "14x14_corridor_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 corridor with turns.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [11, 2], [12, 2],
- [1, 4], [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [9, 4], [10, 4], [11, 4],
- [2, 6], [3, 6], [4, 6], [5, 6], [6, 6], [7, 6], [8, 6], [9, 6], [10, 6], [11, 6], [12, 6],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8],
- [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10], [10, 10], [11, 10], [12, 10],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S5/14x14_corridor_1.json b/mazes/exp_maze_jsons/S5/14x14_corridor_1.json
deleted file mode 100644
index 0e221f5..0000000
--- a/mazes/exp_maze_jsons/S5/14x14_corridor_1.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
- "task_id": "14x14_corridor_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 5,
- "description": "14x14 vertical corridor with turns.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [8, 1], [12, 1],
- [2, 2], [4, 2], [6, 2], [8, 2], [10, 2], [12, 2],
- [2, 3], [4, 3], [6, 3], [8, 3], [10, 3], [12, 3],
- [2, 4], [4, 4], [6, 4], [8, 4], [10, 4], [12, 4],
- [2, 5], [4, 5], [6, 5], [8, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [6, 6], [8, 6], [10, 6], [12, 6],
- [2, 7], [4, 7], [6, 7], [8, 7], [10, 7], [12, 7],
- [2, 8], [4, 8], [6, 8], [8, 8], [10, 8], [12, 8],
- [2, 9], [4, 9], [6, 9], [8, 9], [10, 9], [12, 9],
- [2, 10], [4, 10], [6, 10], [8, 10], [10, 10], [12, 10],
- [2, 11], [4, 11], [6, 11], [8, 11], [10, 11], [12, 11],
- [2, 12], [6, 12], [10, 12]
- ],
- "start": [1, 12],
- "goal": [12, 12]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 12],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "winding"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S6/14x14_dense_0.json b/mazes/exp_maze_jsons/S6/14x14_dense_0.json
deleted file mode 100644
index 9421c2c..0000000
--- a/mazes/exp_maze_jsons/S6/14x14_dense_0.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
- "task_id": "14x14_dense_0",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze with many walls and dead ends.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [4, 1], [12, 1],
- [1, 2], [2, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [9, 2], [10, 2], [12, 2],
- [2, 3], [10, 3], [12, 3],
- [2, 4], [3, 4], [4, 4], [5, 4], [6, 4], [7, 4], [8, 4], [10, 4], [12, 4],
- [6, 5], [10, 5], [12, 5],
- [2, 6], [4, 6], [5, 6], [6, 6], [8, 6], [9, 6], [10, 6], [12, 6],
- [2, 7], [8, 7], [12, 7],
- [2, 8], [3, 8], [4, 8], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [4, 9], [12, 9],
- [1, 10], [2, 10], [4, 10], [5, 10], [6, 10], [8, 10], [12, 10],
- [8, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [5, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [5, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/mazes/exp_maze_jsons/S6/14x14_dense_1.json b/mazes/exp_maze_jsons/S6/14x14_dense_1.json
deleted file mode 100644
index f218b56..0000000
--- a/mazes/exp_maze_jsons/S6/14x14_dense_1.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
- "task_id": "14x14_dense_1",
- "version": "1.0",
- "seed": 0,
- "difficulty_tier": 6,
- "description": "14x14 dense maze variant with many walls and dead ends.",
- "maze": {
- "dimensions": [14, 14],
- "walls": [
- [3, 1],
- [1, 2], [3, 2], [4, 2], [5, 2], [7, 2], [8, 2], [9, 2], [11, 2], [12, 2],
- [1, 3], [5, 3], [9, 3], [12, 3],
- [1, 4], [2, 4], [3, 4], [5, 4], [6, 4], [7, 4], [9, 4], [10, 4], [12, 4],
- [3, 5], [7, 5], [10, 5], [12, 5],
- [1, 6], [3, 6], [4, 6], [5, 6], [7, 6], [8, 6], [10, 6], [12, 6],
- [1, 7], [8, 7], [12, 7],
- [1, 8], [2, 8], [3, 8], [4, 8], [5, 8], [7, 8], [8, 8], [9, 8], [10, 8], [12, 8],
- [3, 9], [10, 9], [12, 9],
- [1, 10], [3, 10], [4, 10], [5, 10], [7, 10], [8, 10], [10, 10], [12, 10],
- [1, 11], [7, 11],
- [1, 12], [2, 12], [3, 12], [4, 12], [5, 12], [6, 12], [7, 12], [8, 12], [9, 12], [10, 12], [11, 12]
- ],
- "start": [1, 1],
- "goal": [12, 1]
- },
- "mechanisms": {
- "keys": [],
- "doors": [],
- "switches": [],
- "gates": []
- },
- "rules": {
- "key_consumption": true,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7
- },
- "goal": {
- "type": "reach_position",
- "target": [12, 1],
- "auxiliary_conditions": []
- },
- "metadata": {
- "chain_pattern": "none",
- "tiling": "square",
- "wall_topology": "dense_dead_ends"
- },
- "max_steps": 1000
-}
diff --git a/monitor_run.sh b/monitor_run.sh
index 8379b79..0415241 100755
--- a/monitor_run.sh
+++ b/monitor_run.sh
@@ -13,8 +13,6 @@ set -euo pipefail
#
# All automatic actions preserve data: finalize -> egress (scp) -> STOP.
# Egress MUST succeed before any spin-down; nothing here ever deletes.
-#
-# See docs/superpowers/specs/2026-06-29-distributed-run-cost-safety-net-design.md
ZONE=""
COORD=""
diff --git a/multigrid/demo.py b/multigrid/demo.py
deleted file mode 100644
index e17a798..0000000
--- a/multigrid/demo.py
+++ /dev/null
@@ -1,726 +0,0 @@
-#!/usr/bin/env python3
-"""
-MultiGrid Backend Demo
-
-Demonstrates the custom MultiGrid implementation with:
-- Multiple tiling types (square, hex, triangle)
-- All object types (keys, doors, switches, gates, hazards, teleporters, zones)
-- Mechanism interactions
-
-Usage:
- python demo.py # Run all demos
- python demo.py --visual # Save PNG images of each demo
- python demo.py --demo 3 # Run specific demo
- python demo.py --play # Interactive play mode
- python demo.py --play --tiling hex # Play with hex grid
-"""
-
-import sys
-import argparse
-from pathlib import Path
-import numpy as np
-
-# Ensure imports work
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from multigrid.env import MultiGridEnv, TilingRegistry
-from multigrid.agent import Action
-from multigrid.rendering import render_multigrid
-
-
-def save_image(frame: np.ndarray, path: str):
- """Save frame as PNG image."""
- try:
- from PIL import Image
- img = Image.fromarray(frame)
- img.save(path)
- print(f" Saved: {path}")
- except ImportError:
- print(" PIL not available, skipping image save")
-
-
-def interactive_play(tiling: str = "square"):
- """
- Interactive play mode - control the agent with keyboard.
-
- Controls:
- Arrow Keys: Move/Turn
- Up: Move forward
- Down: Move backward
- Left: Turn left
- Right: Turn right
- Space: Pickup
- D: Drop
- T or Enter: Toggle (open door, activate switch)
- P: Push
- R: Reset episode
- Q or Escape: Quit
- """
- import pygame
-
- print("\n" + "=" * 60)
- print("Interactive Play Mode")
- print("=" * 60)
- print(f"\nTiling: {tiling}")
- print(f"\nControls:")
- print(" Arrow Up : Move forward")
- print(" Arrow Down : Move backward")
- print(" Arrow Left : Turn left")
- print(" Arrow Right : Turn right")
- print(" Space : Pickup")
- print(" D : Drop")
- print(" T / Enter : Toggle (doors, switches)")
- print(" P : Push")
- print(" R : Reset")
- print(" Q / Escape : Quit")
- print("\n" + "-" * 60)
-
- # Create a playground task with various objects
- task_spec = {
- "task_id": "interactive_play",
- "seed": 42,
- "tiling": {"type": tiling, "grid_size": {"width": 8, "height": 8}},
- "rules": {"key_consumption": True},
- "scene": {
- "agent": {"position": {"x": 0.15, "y": 0.15}, "facing": 1},
- "objects": [
- # Key and door
- {"id": "key_blue", "type": "key", "color": "blue",
- "position": {"x": 0.35, "y": 0.15}},
- {"id": "door_blue", "type": "door", "color": "blue",
- "position": {"x": 0.55, "y": 0.15}, "is_locked": True},
-
- # Switch and gate
- {"id": "switch_1", "type": "switch", "color": "yellow",
- "position": {"x": 0.15, "y": 0.45}, "switch_type": "toggle",
- "controls": ["gate_1"], "initial_state": False},
- {"id": "gate_1", "type": "gate", "color": "yellow",
- "position": {"x": 0.55, "y": 0.45}, "is_open": False,
- "controlled_by": ["switch_1"]},
-
- # Pushable box
- {"id": "box_1", "type": "movable", "color": "green",
- "position": {"x": 0.35, "y": 0.65}},
-
- # Hazard
- {"id": "lava_1", "type": "hazard", "color": "red",
- "position": {"x": 0.75, "y": 0.75}, "hazard_type": "lava"},
-
- # Goal zone
- {"id": "goal_zone", "type": "zone", "color": "cyan",
- "position": {"x": 0.85, "y": 0.15}},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.85, "y": 0.15}},
- "limits": {"max_steps": 200}
- }
-
- env = MultiGridEnv(task_spec, tiling=tiling, render_mode="rgb_array")
- obs, info = env.reset()
-
- # Initialize pygame
- pygame.init()
-
- # Scale up for visibility
- scale = 2
- display_size = (obs.shape[1] * scale, obs.shape[0] * scale)
- screen = pygame.display.set_mode(display_size)
- pygame.display.set_caption(f"MultiGrid ({tiling}): Interactive Play")
-
- # Key mapping
- key_to_action = {
- pygame.K_UP: Action.FORWARD,
- pygame.K_DOWN: Action.BACKWARD,
- pygame.K_LEFT: Action.TURN_LEFT,
- pygame.K_RIGHT: Action.TURN_RIGHT,
- pygame.K_SPACE: Action.PICKUP,
- pygame.K_d: Action.DROP,
- pygame.K_t: Action.TOGGLE,
- pygame.K_RETURN: Action.TOGGLE,
- pygame.K_p: Action.PUSH,
- }
-
- clock = pygame.time.Clock()
- running = True
- step_count = 0
-
- def render_frame():
- frame = env.render()
- surf = pygame.surfarray.make_surface(frame.swapaxes(0, 1))
- surf = pygame.transform.scale(surf, display_size)
- screen.blit(surf, (0, 0))
- pygame.display.flip()
-
- def print_status():
- agent = env.state.agent
- holding = agent.holding.id if agent.holding else "nothing"
- facing = agent.get_facing_direction(env.tiling)
- print(f" Step {step_count}: cell={agent.cell_id}, facing={facing}, holding={holding}")
-
- render_frame()
- print(f"\nStarting at {env.state.agent.cell_id}")
- print(f"Goal: reach the cyan zone at top-right")
-
- while running:
- for event in pygame.event.get():
- if event.type == pygame.QUIT:
- running = False
- elif event.type == pygame.KEYDOWN:
- if event.key in (pygame.K_q, pygame.K_ESCAPE):
- running = False
- elif event.key == pygame.K_r:
- # Reset
- obs, info = env.reset()
- step_count = 0
- render_frame()
- print("\n--- Episode Reset ---")
- print(f"Starting at {env.state.agent.cell_id}")
- elif event.key in key_to_action:
- action = key_to_action[event.key]
- obs, reward, terminated, truncated, info = env.step(action.value)
- step_count += 1
- render_frame()
- print_status()
-
- # Show action effects
- if info.get("action_effect"):
- print(f" -> {info['action_effect']}")
- if info.get("invalid_action"):
- print(f" -> blocked")
-
- if info.get("hazard_hit"):
- print("\n*** STEPPED IN LAVA! ***")
- print("Press R to reset or Q to quit")
- elif terminated:
- print("\n*** GOAL REACHED! ***")
- print(f"Completed in {step_count} steps")
- print("Press R to reset or Q to quit")
- elif truncated:
- print("\n*** TIME LIMIT REACHED ***")
- print("Press R to reset or Q to quit")
-
- clock.tick(30)
-
- pygame.quit()
- print("\nβ Interactive session ended")
-
-
-def demo_tiling_types(save_images: bool = False):
- """Demonstrate all three tiling types."""
- print("\n" + "=" * 60)
- print("Demo 1: Tiling Types (Square, Hex, Triangle)")
- print("=" * 60)
-
- output_dir = Path(__file__).parent / "demo_output"
- if save_images:
- output_dir.mkdir(exist_ok=True)
-
- for tiling_name in ["square", "hex", "triangle"]:
- print(f"\n--- {tiling_name.upper()} Tiling ---")
-
- task_spec = {
- "task_id": f"demo_{tiling_name}",
- "seed": 42,
- "tiling": {
- "type": tiling_name,
- "grid_size": {"width": 5, "height": 5}
- },
- "scene": {
- "agent": {"position": {"x": 0.3, "y": 0.3}, "facing": 0},
- "objects": [
- {"id": "box_1", "type": "movable", "color": "blue",
- "position": {"x": 0.5, "y": 0.5}},
- {"id": "box_2", "type": "movable", "color": "red",
- "position": {"x": 0.7, "y": 0.3}},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.8, "y": 0.8}},
- "limits": {"max_steps": 50}
- }
-
- env = MultiGridEnv(task_spec, tiling=tiling_name, render_mode="rgb_array")
- obs, info = env.reset()
-
- tiling = env.tiling
- print(f" Cells: {len(tiling.cells)}")
- print(f" Directions: {len(tiling.directions)} ({', '.join(tiling.directions)})")
- print(f" Agent at: {env.state.agent.cell_id}")
- print(f" Observation shape: {obs.shape}")
-
- if save_images:
- frame = env.render()
- save_image(frame, str(output_dir / f"demo1_{tiling_name}.png"))
-
- print("\nβ Tiling types demo complete")
-
-
-def demo_all_objects(save_images: bool = False):
- """Demonstrate all object types."""
- print("\n" + "=" * 60)
- print("Demo 2: All Object Types")
- print("=" * 60)
-
- task_spec = {
- "task_id": "demo_objects",
- "seed": 42,
- "tiling": {"type": "square", "grid_size": {"width": 8, "height": 8}},
- "rules": {"key_consumption": True},
- "scene": {
- "agent": {"position": {"x": 0.1, "y": 0.1}, "facing": 1},
- "objects": [
- # Row 1: Key and Door
- {"id": "key_blue", "type": "key", "color": "blue",
- "position": {"x": 0.25, "y": 0.15}},
- {"id": "door_blue", "type": "door", "color": "blue",
- "position": {"x": 0.4, "y": 0.15}, "is_locked": True},
-
- # Row 2: Switch and Gate
- {"id": "switch_1", "type": "switch", "color": "yellow",
- "position": {"x": 0.25, "y": 0.35}, "switch_type": "toggle",
- "controls": ["gate_1"], "initial_state": False},
- {"id": "gate_1", "type": "gate", "color": "yellow",
- "position": {"x": 0.5, "y": 0.35}, "is_open": False},
-
- # Row 3: Movable and Wall
- {"id": "box_1", "type": "movable", "color": "green",
- "position": {"x": 0.25, "y": 0.55}},
- {"id": "wall_1", "type": "wall", "color": "grey",
- "position": {"x": 0.5, "y": 0.55}},
-
- # Row 4: Hazard and Zone
- {"id": "lava_1", "type": "hazard", "color": "red",
- "position": {"x": 0.25, "y": 0.75}, "hazard_type": "lava"},
- {"id": "zone_1", "type": "zone", "color": "cyan",
- "position": {"x": 0.5, "y": 0.75}},
-
- # Teleporter pair
- {"id": "tele_1", "type": "teleporter", "color": "purple",
- "position": {"x": 0.75, "y": 0.25}, "linked_to": "tele_2"},
- {"id": "tele_2", "type": "teleporter", "color": "purple",
- "position": {"x": 0.75, "y": 0.75}, "linked_to": "tele_1"},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.9, "y": 0.9}},
- "limits": {"max_steps": 100}
- }
-
- env = MultiGridEnv(task_spec, tiling="square", render_mode="rgb_array")
- env.reset()
-
- print("\nObjects in scene:")
- for obj_id, obj in env.state.objects.items():
- details = f"at {obj.cell_id}"
- if hasattr(obj, "is_locked"):
- details += f", locked={obj.is_locked}"
- if hasattr(obj, "is_open"):
- details += f", open={obj.is_open}"
- if hasattr(obj, "is_active"):
- details += f", active={obj.is_active}"
- if hasattr(obj, "linked_to"):
- details += f", linked_to={obj.linked_to}"
- print(f" {obj_id} ({obj.obj_type}, {obj.color}): {details}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo2_all_objects.png"))
-
- print("\nβ All objects demo complete")
-
-
-def demo_key_door_mechanism(save_images: bool = False):
- """Demonstrate key + door interaction."""
- print("\n" + "=" * 60)
- print("Demo 3: Key + Door Mechanism")
- print("=" * 60)
-
- # Grid layout (6 wide):
- # sq_1_0 (agent) -> sq_1_1 (key) -> sq_1_2 -> sq_1_3 (door) -> sq_1_4 -> sq_1_5 (goal)
- task_spec = {
- "task_id": "demo_key_door",
- "seed": 42,
- "tiling": {"type": "square", "grid_size": {"width": 6, "height": 3}},
- "rules": {"key_consumption": True},
- "scene": {
- "agent": {"position": {"x": 0.08, "y": 0.5}, "facing": 1}, # sq_1_0, face east
- "objects": [
- {"id": "key_blue", "type": "key", "color": "blue",
- "position": {"x": 0.25, "y": 0.5}}, # sq_1_1
- {"id": "door_blue", "type": "door", "color": "blue",
- "position": {"x": 0.58, "y": 0.5}, "is_locked": True}, # sq_1_3
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.92, "y": 0.5}}, # sq_1_5
- "limits": {"max_steps": 20}
- }
-
- env = MultiGridEnv(task_spec, tiling="square", render_mode="rgb_array")
- env.reset()
-
- door = env.state.objects["door_blue"]
-
- print(f"\nInitial state:")
- print(f" Agent: {env.state.agent.cell_id}, facing: {env.state.agent.get_facing_direction(env.tiling)}")
- print(f" Key: {env.state.objects['key_blue'].cell_id}")
- print(f" Door: {door.cell_id}, locked={door.is_locked}, open={door.is_open}")
-
- # Execute solution: agent at sq_1_0, key at sq_1_1, door at sq_1_3
- actions = [
- (Action.FORWARD, "Move to key (sq_1_1)"),
- (Action.PICKUP, "Pick up key"),
- (Action.FORWARD, "Move to sq_1_2"),
- (Action.FORWARD, "Move to door (sq_1_3) - blocked"),
- (Action.TOGGLE, "Unlock door with key"),
- (Action.FORWARD, "Move through door (sq_1_3)"),
- (Action.FORWARD, "Move to sq_1_4"),
- (Action.FORWARD, "Move to goal (sq_1_5)"),
- ]
-
- print("\nExecuting actions:")
- for action, desc in actions:
- obs, reward, terminated, truncated, info = env.step(action.value)
- holding = env.state.agent.holding.id if env.state.agent.holding else None
- status = f"pos={env.state.agent.cell_id}, holding={holding}"
- if info.get("action_effect"):
- status += f", effect={info['action_effect']}"
- if info.get("invalid_action"):
- status += " [BLOCKED]"
- print(f" {desc}: {status}")
-
- if terminated:
- print(" >>> GOAL REACHED!")
- break
-
- print(f"\nFinal state:")
- print(f" Door: locked={door.is_locked}, open={door.is_open}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo3_key_door.png"))
-
- print("\nβ Key + door demo complete")
-
-
-def demo_switch_gate_mechanism(save_images: bool = False):
- """Demonstrate switch + gate interaction."""
- print("\n" + "=" * 60)
- print("Demo 4: Switch + Gate Mechanism")
- print("=" * 60)
-
- # Grid layout (6 wide):
- # sq_1_0 (agent) -> sq_1_1 (switch) -> sq_1_2 -> sq_1_3 (gate) -> sq_1_4 -> sq_1_5 (goal)
- task_spec = {
- "task_id": "demo_switch_gate",
- "seed": 42,
- "tiling": {"type": "square", "grid_size": {"width": 6, "height": 3}},
- "scene": {
- "agent": {"position": {"x": 0.08, "y": 0.5}, "facing": 1}, # sq_1_0
- "objects": [
- {"id": "switch_1", "type": "switch", "color": "yellow",
- "position": {"x": 0.25, "y": 0.5}, "switch_type": "toggle", # sq_1_1
- "controls": ["gate_1"], "initial_state": False},
- {"id": "gate_1", "type": "gate", "color": "yellow",
- "position": {"x": 0.58, "y": 0.5}, "is_open": False, # sq_1_3
- "controlled_by": ["switch_1"]},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.92, "y": 0.5}}, # sq_1_5
- "limits": {"max_steps": 20}
- }
-
- env = MultiGridEnv(task_spec, tiling="square", render_mode="rgb_array")
- env.reset()
-
- switch = env.state.objects["switch_1"]
- gate = env.state.objects["gate_1"]
-
- print(f"\nInitial state:")
- print(f" Agent: {env.state.agent.cell_id}")
- print(f" Switch: {switch.cell_id}, active={switch.is_active}")
- print(f" Gate: {gate.cell_id}, open={gate.is_open}")
-
- actions = [
- (Action.FORWARD, "Move to switch (sq_1_1)"),
- (Action.TOGGLE, "Activate switch"),
- (Action.FORWARD, "Move to sq_1_2"),
- (Action.FORWARD, "Move through gate (sq_1_3)"),
- (Action.FORWARD, "Move to sq_1_4"),
- (Action.FORWARD, "Move to goal (sq_1_5)"),
- ]
-
- print("\nExecuting actions:")
- for action, desc in actions:
- obs, reward, terminated, truncated, info = env.step(action.value)
- status = f"pos={env.state.agent.cell_id}, switch={switch.is_active}, gate={gate.is_open}"
- if info.get("action_effect"):
- status += f", effect={info['action_effect']}"
- print(f" {desc}: {status}")
-
- if terminated:
- print(" >>> GOAL REACHED!")
- break
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo4_switch_gate.png"))
-
- print("\nβ Switch + gate demo complete")
-
-
-def demo_hazard(save_images: bool = False):
- """Demonstrate hazard termination."""
- print("\n" + "=" * 60)
- print("Demo 5: Hazard (Lava)")
- print("=" * 60)
-
- task_spec = {
- "task_id": "demo_hazard",
- "seed": 42,
- "tiling": {"type": "square", "grid_size": {"width": 4, "height": 3}},
- "scene": {
- "agent": {"position": {"x": 0.15, "y": 0.5}, "facing": 1},
- "objects": [
- {"id": "lava_1", "type": "hazard", "color": "red",
- "position": {"x": 0.5, "y": 0.5}, "hazard_type": "lava"},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.85, "y": 0.5}},
- "limits": {"max_steps": 10}
- }
-
- env = MultiGridEnv(task_spec, tiling="square", render_mode="rgb_array")
- env.reset()
-
- print(f"\nAgent starting at {env.state.agent.cell_id}")
- print(f"Lava at {env.state.objects['lava_1'].cell_id}")
-
- print("\nMoving toward lava...")
- obs, reward, terminated, truncated, info = env.step(Action.FORWARD.value)
- print(f" Step 1: pos={env.state.agent.cell_id}")
-
- obs, reward, terminated, truncated, info = env.step(Action.FORWARD.value)
- print(f" Step 2: pos={env.state.agent.cell_id}")
- print(f" Hazard hit: {info.get('hazard_hit', False)}")
- print(f" Terminated: {terminated}")
-
- if terminated:
- print("\n >>> AGENT DIED IN LAVA!")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo5_hazard.png"))
-
- print("\nβ Hazard demo complete")
-
-
-def demo_push_action(save_images: bool = False):
- """Demonstrate push action."""
- print("\n" + "=" * 60)
- print("Demo 6: Push Action")
- print("=" * 60)
-
- task_spec = {
- "task_id": "demo_push",
- "seed": 42,
- "tiling": {"type": "square", "grid_size": {"width": 5, "height": 3}},
- "scene": {
- "agent": {"position": {"x": 0.1, "y": 0.5}, "facing": 1},
- "objects": [
- {"id": "box_1", "type": "movable", "color": "green",
- "position": {"x": 0.3, "y": 0.5}},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.9, "y": 0.5}},
- "limits": {"max_steps": 20}
- }
-
- env = MultiGridEnv(task_spec, tiling="square", render_mode="rgb_array")
- env.reset()
-
- box = env.state.objects["box_1"]
-
- print(f"\nInitial: Agent at {env.state.agent.cell_id}, Box at {box.cell_id}")
-
- # Push the box
- obs, reward, terminated, truncated, info = env.step(Action.PUSH.value)
- print(f"\nAfter PUSH:")
- print(f" Agent at {env.state.agent.cell_id}")
- print(f" Box at {box.cell_id}")
- print(f" Effect: {info.get('action_effect')}")
-
- # Push again
- obs, reward, terminated, truncated, info = env.step(Action.FORWARD.value)
- obs, reward, terminated, truncated, info = env.step(Action.PUSH.value)
- print(f"\nAfter move + PUSH:")
- print(f" Agent at {env.state.agent.cell_id}")
- print(f" Box at {box.cell_id}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo6_push.png"))
-
- print("\nβ Push demo complete")
-
-
-def demo_triangle_navigation(save_images: bool = False):
- """Demonstrate navigation in triangle tiling."""
- print("\n" + "=" * 60)
- print("Demo 7: Triangle Tiling Navigation")
- print("=" * 60)
-
- task_spec = {
- "task_id": "demo_triangle_nav",
- "seed": 42,
- "tiling": {"type": "triangle", "grid_size": {"width": 4, "height": 4}},
- "scene": {
- "agent": {"position": {"x": 0.3, "y": 0.3}, "facing": 0},
- "objects": [
- {"id": "goal_marker", "type": "zone", "color": "green",
- "position": {"x": 0.7, "y": 0.7}},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.7, "y": 0.7}},
- "limits": {"max_steps": 30}
- }
-
- env = MultiGridEnv(task_spec, tiling="triangle", render_mode="rgb_array")
- env.reset()
-
- print(f"\nTriangle tiling:")
- print(f" Total cells: {len(env.tiling.cells)}")
- print(f" Directions: {env.tiling.directions}")
- print(f" Agent at: {env.state.agent.cell_id}")
- print(f" Agent facing: {env.state.agent.get_facing_direction(env.tiling)}")
-
- print("\nNavigating (10 random moves):")
- import random
- for i in range(10):
- action = random.choice([Action.FORWARD, Action.TURN_LEFT, Action.TURN_RIGHT])
- obs, reward, terminated, truncated, info = env.step(action.value)
- facing = env.state.agent.get_facing_direction(env.tiling)
- print(f" {i+1}. {action.name}: cell={env.state.agent.cell_id}, facing={facing}")
-
- if terminated:
- print(" >>> GOAL REACHED!")
- break
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo7_triangle.png"))
-
- print("\nβ Triangle navigation demo complete")
-
-
-def demo_hex_with_mechanisms(save_images: bool = False):
- """Demonstrate hex tiling with mechanisms."""
- print("\n" + "=" * 60)
- print("Demo 8: Hex Tiling with Mechanisms")
- print("=" * 60)
-
- task_spec = {
- "task_id": "demo_hex_mechanisms",
- "seed": 42,
- "tiling": {"type": "hex", "grid_size": {"width": 4, "height": 4}},
- "rules": {"key_consumption": True},
- "scene": {
- "agent": {"position": {"x": 0.2, "y": 0.2}, "facing": 1},
- "objects": [
- {"id": "key_red", "type": "key", "color": "red",
- "position": {"x": 0.4, "y": 0.3}},
- {"id": "door_red", "type": "door", "color": "red",
- "position": {"x": 0.6, "y": 0.5}, "is_locked": True},
- {"id": "box_1", "type": "movable", "color": "blue",
- "position": {"x": 0.3, "y": 0.6}},
- ]
- },
- "goal": {"type": "reach_position", "target": {"x": 0.8, "y": 0.8}},
- "limits": {"max_steps": 50}
- }
-
- env = MultiGridEnv(task_spec, tiling="hex", render_mode="rgb_array")
- env.reset()
-
- print(f"\nHex tiling:")
- print(f" Total cells: {len(env.tiling.cells)}")
- print(f" Directions: {env.tiling.directions}")
-
- print("\nObjects:")
- for obj_id, obj in env.state.objects.items():
- print(f" {obj_id} ({obj.obj_type}): {obj.cell_id}")
-
- if save_images:
- output_dir = Path(__file__).parent / "demo_output"
- output_dir.mkdir(exist_ok=True)
- frame = env.render()
- save_image(frame, str(output_dir / "demo8_hex_mechanisms.png"))
-
- print("\nβ Hex mechanisms demo complete")
-
-
-def main():
- parser = argparse.ArgumentParser(description="MultiGrid Backend Demo")
- parser.add_argument("--visual", action="store_true", help="Save PNG images")
- parser.add_argument("--demo", type=int, help="Run specific demo (1-8)")
- parser.add_argument("--play", action="store_true", help="Interactive play mode")
- parser.add_argument("--tiling", type=str, default="square",
- choices=["square", "hex", "triangle"],
- help="Tiling type for play mode (default: square)")
- args = parser.parse_args()
-
- # Interactive play mode
- if args.play:
- interactive_play(args.tiling)
- return
-
- print("=" * 60)
- print("MultiGrid Backend Demo")
- print("=" * 60)
- print("\nThis demo uses the custom MultiGrid implementation with")
- print("support for square, hex, and triangle tilings.")
-
- demos = [
- ("Tiling Types", demo_tiling_types),
- ("All Objects", demo_all_objects),
- ("Key + Door", demo_key_door_mechanism),
- ("Switch + Gate", demo_switch_gate_mechanism),
- ("Hazard", demo_hazard),
- ("Push Action", demo_push_action),
- ("Triangle Navigation", demo_triangle_navigation),
- ("Hex with Mechanisms", demo_hex_with_mechanisms),
- ]
-
- if args.demo:
- if 1 <= args.demo <= len(demos):
- name, fn = demos[args.demo - 1]
- fn(save_images=args.visual)
- else:
- print(f"Invalid demo number. Choose 1-{len(demos)}")
- print("\nAvailable demos:")
- for i, (name, _) in enumerate(demos, 1):
- print(f" {i}. {name}")
- else:
- for name, fn in demos:
- fn(save_images=args.visual)
-
- print("\n" + "=" * 60)
- print("MultiGrid Demo Complete!")
- print("=" * 60)
-
- if args.visual:
- output_dir = Path(__file__).parent / "demo_output"
- print(f"\nImages saved to: {output_dir}")
-
-
-if __name__ == "__main__":
- main()
diff --git a/ogbench b/ogbench
index 31a0549..8d8cecd 160000
--- a/ogbench
+++ b/ogbench
@@ -1 +1 @@
-Subproject commit 31a0549e0cbe76bd94348e12fb955ccc891a6317
+Subproject commit 8d8cecd0925d2191450332888f6ebb7f46b105ee
diff --git a/prompting_experiments/prompts.txt b/prompting_experiments/prompts.txt
deleted file mode 100644
index dc2f3d3..0000000
--- a/prompting_experiments/prompts.txt
+++ /dev/null
@@ -1,1280 +0,0 @@
-Prompt Experiment Preview
-Maze: /home/sean/AI_training/Manifold/MultiNet-v2.0/mazes/validation_10/V01_empty_room.json
-Max steps: 5
-Preview prompt state: after 3 random steps (seed: 0)
-
-========================================================================================
-condition set 1: Prompt
-========================================================================================
-variant name: standard
-description: Standard task prompt with mechanism descriptions.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: minimal
-description: Minimal prompt with action list only.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: Solve the maze by reaching the goal.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: verbose
-description: Standard prompt plus explicit domain rules.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-RULES (domain logic):
- - PICKUP: pick up a key while standing in the same cell.
- - Doors: face a locked door with the matching key in inventory and TOGGLE to open it, then
- MOVE_FORWARD through the open door. MOVE_FORWARD alone does not open a locked door.
- - Switches: TOGGLE while standing on them. Linked gates are open if its linked switch is on, and closed if it is off.
- - Gates: CLOSED gates block movement; OPEN gates do not. TOGGLE linked switches to control them.
- - Closed doors you lack a key for block movement like walls until resolved.
- - Use DONE only when you are standing on the goal cell.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 2: Observation format
-========================================================================================
-variant name: standard
-description: Image block only, no natural-language observation (ablates the text half of the image+text default).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-[image block 5]
-Your inventory: empty.
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-----------------------------------------------------------------------------------------
-variant name: text_only
-description: Natural-language current observation, no image blocks.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-The world is a 14 by 14 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (1, 12).
-The following cells are walls: (1,3), (2,1), (2,3), (2,4), (2,6), (2,8), (2,10), (2,11), (2,12), (3,1), (3,4), (3,6), (3,8), (3,12), (4,1), (4,2), (4,4), (4,6), (4,8), (4,9), (4,10), (4,12), (5,2), (5,4), (5,6), (5,9), (5,12), (6,1), (6,2), (6,4), (6,5), (6,6), (6,7), (6,8), (6,9), (6,11), (6,12), (7,1), (7,4), (7,11), (7,12), (8,1), (8,2), (8,4), (8,6), (8,7), (8,9), (8,10), (8,12), (9,2), (9,6), (9,10), (9,12), (10,1), (10,2), (10,3), (10,5), (10,6), (10,8), (10,10), (10,12), (11,1), (11,5), (11,8), (12,1), (12,2), (12,3), (12,4), (12,5), (12,6), (12,7), (12,8), (12,9), (12,10), (12,11).
-There is a red key at (8,5).
-There is a blue key at (1,8).
-There is a locked red door at (7,6). It requires the red key to open.
-There is a locked blue door at (1,11). It requires the blue key to open.
-There is a toggle switch at (5,10) (currently off). It controls: g1.
-There is a gate (g1) at (4,11). It is currently closed (initially closed).
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-----------------------------------------------------------------------------------------
-variant name: image_text
-description: Image block plus natural-language observation.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 3: Context window
-========================================================================================
-variant name: standard
-description: Current observation only, no history (the 0-history ablation of the last3 default).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-[image block 2]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: last3
-description: Last three executed steps rendered in one stateless message - same as the fair default.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: text_summary
-description: One-sentence summary of all prior mechanism events/path waypoints, in one stateless message.
-prompts:
-preview steps: 10 rollout seed: 5
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Activity summary:
-first you navigated to (1, 2), then you navigated to (2, 2), finally you passed (2, 1)
-
-
-[image block 2]
-You are at (2, 1) facing WEST.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-additional text_summary example: one_shot_example maze after one_shot_example_solution
-maze: /home/sean/AI_training/Manifold/MultiNet-v2.0/mazes/one_shot_example/one_shot_example_14x14_dense_kr_sg_kb_2.json
-solution steps replayed: 51
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 14 by 14 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (1, 12).
-The following cells are walls: (1,3), (2,1), (2,3), (2,4), (2,6), (2,8), (2,10), (2,11), (2,12), (3,1), (3,4), (3,6), (3,8), (3,12), (4,1), (4,2), (4,4), (4,6), (4,8), (4,9), (4,10), (4,12), (5,2), (5,4), (5,6), (5,9), (5,12), (6,1), (6,2), (6,4), (6,5), (6,6), (6,7), (6,8), (6,9), (6,11), (6,12), (7,1), (7,4), (7,11), (7,12), (8,1), (8,2), (8,4), (8,6), (8,7), (8,9), (8,10), (8,12), (9,2), (9,6), (9,10), (9,12), (10,1), (10,2), (10,3), (10,5), (10,6), (10,8), (10,10), (10,12), (11,1), (11,5), (11,8), (12,1), (12,2), (12,3), (12,4), (12,5), (12,6), (12,7), (12,8), (12,9), (12,10), (12,11).
-There is a red key at (8,5).
-There is a blue key at (1,8).
-There is a locked red door at (7,6). It requires the red key to open.
-There is a locked blue door at (1,11). It requires the blue key to open.
-There is a toggle switch at (5,10) (currently off). It controls: g1.
-There is a gate (g1) at (4,11). It is currently closed (initially closed).
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Activity summary:
-first you picked up the red key, then you opened the red door, then you opened the black gate, then you picked up the blue key, then you opened the blue door, finally you passed (1, 11)
-
-
-[image block 2]
-You are at (1, 12) facing SOUTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-There is a open red door at (7,6). It requires the red key to open.
-There is a open blue door at (1,11). It requires the blue key to open.
-There is a toggle switch at (5,10) (currently on). It controls: g1.
-There is a gate (g1) at (4,11). It is currently open (initially closed).
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: text_summary_and_last3
-description: One-sentence summary of all prior mechanism events/path waypoints, in one stateless message, and last three executed steps rendered as 3 images-each with the action taken in that step.
-prompts:
-preview steps: 10 rollout seed: 5
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Activity summary:
-first you navigated to (1, 2), then you navigated to (2, 2), finally you passed (2, 1)
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: MOVE_FORWARD
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_RIGHT
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: MOVE_FORWARD
-
-Recent history (last 3 steps, oldest first):
-Position after: (2, 2), facing SOUTH
-FINAL_OUTPUT: MOVE_FORWARD
-Feedback: MOVED β MOVE_FORWARD: Moved to (2, 2).
-Position after: (2, 2), facing WEST
-FINAL_OUTPUT: TURN_RIGHT
-Feedback: TURNED β TURN_RIGHT: Now facing WEST.
-Position after: (2, 1), facing WEST
-FINAL_OUTPUT: MOVE_FORWARD
-Feedback: MOVED β MOVE_FORWARD: Moved to (2, 1).
-
-
-[image block 5]
-You are at (2, 1) facing WEST.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-additional text_summary_and_last3 example: one_shot_example maze after one_shot_example_solution
-maze: /home/sean/AI_training/Manifold/MultiNet-v2.0/mazes/one_shot_example/one_shot_example_14x14_dense_kr_sg_kb_2.json
-solution steps replayed: 51
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 14 by 14 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (1, 12).
-The following cells are walls: (1,3), (2,1), (2,3), (2,4), (2,6), (2,8), (2,10), (2,11), (2,12), (3,1), (3,4), (3,6), (3,8), (3,12), (4,1), (4,2), (4,4), (4,6), (4,8), (4,9), (4,10), (4,12), (5,2), (5,4), (5,6), (5,9), (5,12), (6,1), (6,2), (6,4), (6,5), (6,6), (6,7), (6,8), (6,9), (6,11), (6,12), (7,1), (7,4), (7,11), (7,12), (8,1), (8,2), (8,4), (8,6), (8,7), (8,9), (8,10), (8,12), (9,2), (9,6), (9,10), (9,12), (10,1), (10,2), (10,3), (10,5), (10,6), (10,8), (10,10), (10,12), (11,1), (11,5), (11,8), (12,1), (12,2), (12,3), (12,4), (12,5), (12,6), (12,7), (12,8), (12,9), (12,10), (12,11).
-There is a red key at (8,5).
-There is a blue key at (1,8).
-There is a locked red door at (7,6). It requires the red key to open.
-There is a locked blue door at (1,11). It requires the blue key to open.
-There is a toggle switch at (5,10) (currently off). It controls: g1.
-There is a gate (g1) at (4,11). It is currently closed (initially closed).
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Activity summary:
-first you picked up the red key, then you opened the red door, then you opened the black gate, then you picked up the blue key, then you opened the blue door, finally you passed (1, 11)
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: kB.
-FINAL_OUTPUT: TOGGLE
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: MOVE_FORWARD
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: MOVE_FORWARD
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 10), facing SOUTH
-FINAL_OUTPUT: TOGGLE
-Feedback: OPENED β TOGGLE: Opened blue door DB.
-Position after: (1, 11), facing SOUTH
-FINAL_OUTPUT: MOVE_FORWARD
-Feedback: MOVED β MOVE_FORWARD: Moved to (1, 11).
-Position after: (1, 12), facing SOUTH
-FINAL_OUTPUT: MOVE_FORWARD
-Feedback: SUCCESS β MOVE_FORWARD: Reached goal at (1, 12).
-
-
-[image block 5]
-You are at (1, 12) facing SOUTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-There is a open red door at (7,6). It requires the red key to open.
-There is a open blue door at (1,11). It requires the blue key to open.
-There is a toggle switch at (5,10) (currently on). It controls: g1.
-There is a gate (g1) at (4,11). It is currently open (initially closed).
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 4: Action space
-========================================================================================
-variant name: egocentric
-description: Turn-and-move interface - same as the standard prompt (the default).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: cardinal
-description: Absolute moves (MOVE_NORTH/SOUTH/EAST/WEST) plus PICKUP, INTERACT, DONE; each move is expanded into egocentric primitives at runtime.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: MOVE_NORTH, MOVE_SOUTH, MOVE_EAST, MOVE_WEST, PICKUP, INTERACT, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 5: Querying strategy
-========================================================================================
-variant name: standard
-description: Ask for one action each query-same as the standard prompt.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: subgoal
-description: Ask for a short subgoal and action chunk.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-SUB_GOAL:
-FINAL_OUTPUT: , , ... (comma-separated; one or more valid actions to reach it)
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: full_trajectory
-description: Ask once for a complete action trajectory.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is the full sequence of actions you will take to complete the task?
-
-Output exactly:
-FINAL_OUTPUT: , , ... (comma-separated; one or more valid actions)
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 6: In-context learning
-========================================================================================
-variant name: standard
-description: No examples (the ablation of the one_shot default).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Recent steps (oldest first):
-
-[image block 1]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 4]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: one_shot
-description: One example trajectory prepended to each user message (14x14 dense kr_sg_kb maze, separate from evaluation mazes).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-========================================================================================
-condition set 7: History mechanism
-========================================================================================
-variant name: single_message
-description: History in one stateless message (last3) - same as the fair default.
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-Recent steps (oldest first):
-
-[image block 2]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 3]
-Your inventory: empty.
-FINAL_OUTPUT: PICKUP
-
-[image block 4]
-Your inventory: empty.
-FINAL_OUTPUT: TURN_LEFT
-
-Recent history (last 3 steps, oldest first):
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing EAST
-FINAL_OUTPUT: PICKUP
-Feedback: NOTHING β PICKUP: Nothing to pick up here. You remain at (1, 1).
-Position after: (1, 1), facing NORTH
-FINAL_OUTPUT: TURN_LEFT
-Feedback: TURNED β TURN_LEFT: Now facing NORTH.
-
-
-[image block 5]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
-variant name: multiturn
-description: Rolling 3-turn chat; each prior turn carries its own observation image (context_window=current so history comes from turns, not in-prompt, avoiding duplication).
-prompts:
-preview steps: 3 rollout seed: 0
-[system prompt]
-Task: You are the triangular agent trying to navigate this maze. You are facing the pointy end. Move to the green goal cell in the grid.
-The environment may contain:
-Keys, doors, switches, and gates.
-Valid actions: TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, PICKUP, TOGGLE, DONE.
-
-Initial maze (fixed for this episode):
-The world is a 8 by 8 grid.
-Coordinates are ``(row, column)`` from the **top-left** corner ``(1, 1)``: the row number increases going **south** (down); the column number increases going **east** (right). To reach a cell with a larger row number, go south; with a larger column number, go east.
-The start is at (1, 1).
-The goal is at (6, 6).
-The following cells are walls: none.
-
-[user prompt]
-Example maze and solution (14x14 maze with a red key-door, switch-gate, and blue key-door chain):
-
-[image block 1]
-
-Actions to solve: TURN_RIGHT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, TOGGLE, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT, MOVE_FORWARD, MOVE_FORWARD, TURN_LEFT, PICKUP, TURN_LEFT, TURN_LEFT, MOVE_FORWARD, TOGGLE, MOVE_FORWARD, MOVE_FORWARD, DONE
-
-
-[image block 2]
-You are at (1, 1) facing NORTH.
-Your inventory: empty.
-
-Map contents as of this step (keys on the ground, doors, switches, gates):
-(No keys on the ground, doors, switches, or gates in the current state description.)
-
-What is your next action?
-
-Output exactly:
-FINAL_OUTPUT:
-
-Reminder: decide your single next action without narrating your reasoning. Your response must end with the line `FINAL_OUTPUT: ` and nothing after it.
-----------------------------------------------------------------------------------------
diff --git a/pyproject.toml b/pyproject.toml
index 2e3ac32..ce8583b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,10 +4,12 @@ build-backend = "setuptools.build_meta"
[project]
name = "multinet-v2-0"
-version = "0.1.0"
+version = "2.0.0"
description = "Gridworld and multigrid evaluation harness for multimodal model benchmarking."
readme = "README.md"
requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "Manifold Research Group"}]
dependencies = [
"gymnasium",
"minigrid",
@@ -39,6 +41,10 @@ vllm = [
"vllm==0.19.0",
]
+[project.urls]
+Homepage = "https://multinet.ai"
+Repository = "https://github.com/ManifoldRG/MultiNet-v2.0"
+
[project.scripts]
multinet-run-eval = "run_eval:main"
multinet-play-task = "play_task:main"
@@ -60,20 +66,19 @@ multinet-run-pipeline = "scripts.run_pipeline:main"
# Multinet-v2-results is the sibling data repo (often checked out nested here);
# it now hosts the moved analysis package + its tests, which import `analysis.*`
# and must not be collected from this repo.
-addopts = "--ignore=ogbench --ignore=Multinet-v2-results"
+addopts = "--ignore=ogbench --ignore=Multinet-v2-results -m 'not slow'"
+markers = [
+ "slow: load-sensitive performance/scalability benchmarks; excluded by default, run with -m slow",
+]
[tool.setuptools]
include-package-data = true
py-modules = [
"evaluation_harness",
- "example_usage",
- "interactive_demo",
"model_interface",
"play_task",
"run_eval",
"visualize_all_tilings",
- "visualize_grid",
- "visualize_grids_proper",
]
[tool.setuptools.packages.find]
@@ -82,10 +87,8 @@ include = [
"adapters*",
"cross_domain*",
"demo*",
- "deploy*",
"gridworld*",
"interface*",
- "mazes*",
"multigrid*",
"pipeline*",
"prompting_experiments*",
@@ -95,5 +98,4 @@ include = [
[tool.setuptools.package-data]
gridworld = ["tasks/**/*.json", "tasks/*.json", "fixtures/**/*.json", "fixtures/*.json"]
-mazes = ["validation_10/**/*.json", "validation_10/*.json"]
scorer = ["scorer_config.json"]
diff --git a/run_qwen_backfill.sh b/run_qwen_backfill.sh
deleted file mode 100755
index f08d9e0..0000000
--- a/run_qwen_backfill.sh
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env bash
-# run_qwen_backfill.sh β finish the Qwen run locally: the 3 units the cloud fleet missed.
-#
-# baseline_thinking (thinking ON) : validation_10_v02_winding_corridor [standard]
-# cond_prompt (thinking OFF): conditional_s_s5_14x14_corridor_1 [standard] + [minimal]
-#
-# It auto-generates minimal 2-maze subset manifests + Qwen-only run-configs so ONLY those
-# 3 units run (no re-doing the other mazes or the API models). Outputs land as
-# episode_runs.jsonl under artifacts/qwen_backfill//.
-#
-# Prereqs: a free GPU (~40 GB) with Qwen/Qwen3.6-27B cached; the vLLM venv.
-# Usage: bash run_qwen_backfill.sh # from the repo root
-# QWEN_VENV=/path/to/venv bash run_qwen_backfill.sh # override the venv
-set -euo pipefail
-cd "$(dirname "$0")" # repo root
-source "${QWEN_VENV:-.venv-qwen-vllm}/bin/activate"
-source lib/vllm_serve_args.sh # vllm_serve_args(): two-tier serve args
-
-OUT=artifacts/qwen_backfill; GEN="$OUT/_gen"; mkdir -p "$GEN"
-BASE_RC=gridworld/fixtures/run_config.conditional_baseline_thinking_claude_kimi_qwen.json
-PROMPT_RC=gridworld/fixtures/run_config.conditional_prompt_claude_kimi_qwen.json
-MANIFEST=gridworld/fixtures/manifest.conditional_eval.json
-
-echo "[1/3] generating minimal 2-maze subsets + Qwen-only run-configs -> $GEN"
-python3 - "$MANIFEST" "$BASE_RC" "$PROMPT_RC" "$GEN" <<'PY'
-import json, sys, pathlib
-manifest, base_rc, prompt_rc, gen = sys.argv[1:5]; gen = pathlib.Path(gen)
-man = json.load(open(manifest))
-def subset(tids, name):
- m = dict(man); m["tasks"] = [t for t in man["tasks"] if t["task_id"] in tids]
- assert len(m["tasks"]) == len(tids), f"{name}: wanted {tids}, got {[t['task_id'] for t in m['tasks']]}"
- json.dump(m, open(gen/f"manifest.{name}.json", "w"), indent=1)
-def qwen_only(src, sub_manifest, name):
- rc = json.load(open(src))
- rc["models"] = {k: v for k, v in rc["models"].items() if v.get("provider") == "qwen_vllm_api"}
- assert rc["models"], f"no qwen model in {src}"
- rc["manifest"] = str(gen/f"manifest.{sub_manifest}.json")
- for v in rc["models"].values(): v["tasks"] = ["all"]
- json.dump(rc, open(gen/f"run_config.{name}.json", "w"), indent=1)
-subset({"validation_10_v02_winding_corridor"}, "winding")
-subset({"conditional_s_s5_14x14_corridor_1"}, "s5")
-qwen_only(base_rc, "winding", "baseline_qwen")
-qwen_only(prompt_rc, "s5", "prompt_qwen")
-print(" ok")
-PY
-
-echo "[2/3] ensuring vLLM (Qwen/Qwen3.6-27B) is serving on :8000"
-if ! curl -fsS http://127.0.0.1:8000/v1/models >/dev/null 2>&1; then
- echo " launching vLLM (~14 min to load; log: $OUT/vllm.log)"
- # TWO-TIER PHASE-TRANSITION POINT: serve args from vllm_serve_args() (phase-1
- # defaults reproduce today's line; QWEN_MAX_MODEL_LEN=96000 etc. -> phase 2).
- nohup env HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 \
- vllm serve Qwen/Qwen3.6-27B --served-model-name Qwen/Qwen3.6-27B $(vllm_serve_args) \
- > "$OUT/vllm.log" 2>&1 &
- for _ in $(seq 1 180); do curl -fsS http://127.0.0.1:8000/v1/models >/dev/null 2>&1 && break; sleep 10; done
-fi
-curl -fsS http://127.0.0.1:8000/v1/models >/dev/null 2>&1 || { echo "vLLM never became ready β see $OUT/vllm.log"; exit 1; }
-echo " vLLM ready."
-
-echo "[3/3] running the 3 missing units"
-run() { #
- echo " --> $4"
- python -m scripts.run_pipeline --run-config "$1" --manifest "$2" \
- --conditions Prompt --prompt-variant "$3" --seeds 0 --force \
- --artifacts-root "$OUT/$4" --run-set-id "$4"
-}
-run "$GEN/run_config.baseline_qwen.json" "$GEN/manifest.winding.json" standard baseline_thinking_winding
-run "$GEN/run_config.prompt_qwen.json" "$GEN/manifest.s5.json" standard cond_prompt_s5_standard
-run "$GEN/run_config.prompt_qwen.json" "$GEN/manifest.s5.json" minimal cond_prompt_s5_minimal
-
-echo
-echo "DONE. Results:"
-for d in baseline_thinking_winding cond_prompt_s5_standard cond_prompt_s5_minimal; do
- j="$OUT/$d/episode_runs.jsonl"
- [ -f "$j" ] && echo " $d: $(wc -l < "$j") episode(s) -> $j" || echo " $d: NO OUTPUT (check logs)"
-done
-echo "These backfill winding_corridor (baseline_thinking) + s5 (cond_prompt std+min) to 135/135 + 45/45."
diff --git a/scripts/demo_baselines.py b/scripts/demo_baselines.py
deleted file mode 100644
index 205bd46..0000000
--- a/scripts/demo_baselines.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""Run the built-in gridworld baselines on a small mechanism task.
-
-The default task includes a key, a locked door, a switch, and a gate. A
-different task JSON can be supplied with ``--task`` when benchmark files are
-available in the checkout.
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-if str(ROOT) not in sys.path:
- sys.path.insert(0, str(ROOT))
-
-from evaluation_harness import EvaluationHarness
-from gridworld.actions import ACTION_NAMES
-from gridworld.baselines import BFSModelInterface, GreedyModelInterface
-from gridworld.task_spec import TaskSpecification
-from gridworld.task_validator import compute_difficulty
-from model_interface import RandomModelInterface
-
-
-def built_in_demo_task() -> TaskSpecification:
- """Return a compact task with the same dependency objects used in demos."""
- return TaskSpecification.from_dict({
- "task_id": "demo_key_door_switch_gate",
- "seed": 7,
- "difficulty_tier": 3,
- "description": "Pick up a key, open a door, toggle a switch, then cross a gate.",
- "maze": {
- "dimensions": [8, 5],
- "walls": [[1, 2], [2, 2], [3, 2], [5, 2], [6, 2]],
- "start": [1, 1],
- "goal": [6, 1],
- },
- "mechanisms": {
- "keys": [{"id": "red_key", "position": [2, 1], "color": "red"}],
- "doors": [{"id": "red_door", "position": [3, 1], "requires_key": "red"}],
- "switches": [
- {
- "id": "gate_switch",
- "position": [4, 2],
- "controls": ["exit_gate"],
- "switch_type": "toggle",
- "initial_state": "off",
- }
- ],
- "gates": [{"id": "exit_gate", "position": [5, 1], "initial_state": "closed"}],
- "blocks": [],
- "teleporters": [],
- "hazards": [],
- },
- "rules": {
- "key_consumption": True,
- "switch_type": "toggle",
- "hidden_mechanisms": [],
- "observability": "full",
- "view_size": 7,
- },
- "goal": {"type": "reach_position", "target": [6, 1], "auxiliary_conditions": []},
- "max_steps": 30,
- })
-
-
-def load_task(path: str | None) -> TaskSpecification:
- """Load a task JSON, or fall back to the built-in mechanism task."""
- if path is None:
- return built_in_demo_task()
- return TaskSpecification.from_json(path)
-
-
-def make_agent(name: str):
- """Construct one baseline agent by CLI name."""
- if name == "bfs":
- return BFSModelInterface()
- if name == "greedy":
- return GreedyModelInterface()
- if name == "random":
- return RandomModelInterface(seed=42)
- raise ValueError(f"Unknown agent: {name}")
-
-
-def run_agent(agent_name: str, spec: TaskSpecification, verbose: bool) -> None:
- """Run one baseline and print a compact result summary."""
- model = make_agent(agent_name)
- harness = EvaluationHarness(model, history_images=0, history_text=False)
- try:
- result = harness.evaluate_task(spec, seed=spec.seed, verbose=verbose)
- finally:
- harness.close()
-
- difficulty = compute_difficulty(spec)
- action_names = [ACTION_NAMES.get(step.action, str(step.action)) for step in result.trajectory]
- preview = ", ".join(action_names[:12])
- if len(action_names) > 12:
- preview += ", ..."
-
- print(f"\nAgent: {agent_name}")
- print(f"Task: {spec.task_id}")
- print(f"Success: {result.success}")
- print(f"Steps: {result.steps_taken}/{spec.max_steps}")
- print(f"Validator optimal steps: {difficulty.optimal_steps}")
- print(f"Actions: {preview or 'none'}")
-
-
-def main() -> None:
- parser = argparse.ArgumentParser(description="Run BFS, greedy, and random baselines on a demo task.")
- parser.add_argument("--agent", choices=["all", "bfs", "greedy", "random"], default="all")
- parser.add_argument("--task", default=None, help="Optional task JSON path. Defaults to built-in demo task.")
- parser.add_argument("--verbose", action="store_true", help="Print each environment step.")
- args = parser.parse_args()
-
- spec = load_task(args.task)
- agents = ["bfs", "greedy", "random"] if args.agent == "all" else [args.agent]
- for agent_name in agents:
- run_agent(agent_name, spec, args.verbose)
-
-
-if __name__ == "__main__":
- main()
diff --git a/scripts/launch_kimi_rerun.sh b/scripts/launch_kimi_rerun.sh
deleted file mode 100755
index 49763a5..0000000
--- a/scripts/launch_kimi_rerun.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env bash
-# R1 Kimi make-up rerun β three parallel arms. See docs/r1-kimi-rerun-package.md.
-#
-# Arm 1 resume M6 from step 143 under the AS-RUN harness (no DROP),
-# via the e0542b5 worktree + scripts/resume_from_archive.py
-# Arm 2 M6 fresh from step 1 under the DROP-enabled branch
-# Arm 3 D2 (wrong-key decoy) fresh under the DROP-enabled branch
-#
-# All three run as independent processes with independent artifact roots, so a
-# crash in one never strands the others.
-#
-# PAID RUN. Gates, in order: Moonshot balance precheck (manual), committed
-# clean tree on fix/drop-key-bookkeeping, free replay-verify pass.
-#
-# Usage: MOONSHOT_API_KEY=... scripts/launch_kimi_rerun.sh
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-
-OUT="${1:?usage: launch_kimi_rerun.sh }"
-ASRUN_SHA=e0542b5
-ASRUN_TREE=/tmp/multinet-r1-asrun
-# The suite maximum R1 was launched with (RUN_NOTES_incidents_and_findings.md:
-# "launched with DIFFICULTY_MAX=3000"). It normalizes difficulty_weight, which
-# feeds the composite, so it MUST match R1 or the rerun rows are not comparable.
-# Cross-checked against the archive: M6 1120.367/0.373456 = 3000.0 exactly, and
-# D2 631.234/0.210411 = 3000.0. The shipped scorer config leaves it unset (and
-# the sweep default of 1000 is below M6's static score, so it would hard-fail).
-DIFFICULTY_MAX=3000
-ARCHIVE="$ROOT/Multinet-v2-results/r1-20260717/runs/r1_M6_14x14_dense_kr_sg_kb_1/minigrid/kimi-k2.6/seed_0/default"
-
-# ---------------------------------------------------------------- gates
-: "${MOONSHOT_API_KEY:?MOONSHOT_API_KEY is required (and check the Moonshot
-console balance FIRST β the batch precheck once killed a leg at \$0 spent)}"
-
-branch="$(git branch --show-current)"
-[ "$branch" = "fix/drop-key-bookkeeping" ] || {
- echo "FATAL: on branch '$branch', expected fix/drop-key-bookkeeping" >&2; exit 1; }
-git diff --quiet && git diff --cached --quiet || {
- echo "FATAL: working tree not clean (code-sync invariant)" >&2; exit 1; }
-
-[ -d "$ASRUN_TREE" ] || git worktree add "$ASRUN_TREE" "$ASRUN_SHA"
-
-echo "== free gate: deterministic replay of the archived episode =="
-python scripts/resume_from_archive.py \
- --archive-dir "$ARCHIVE" --repo-root "$ASRUN_TREE" \
- --out-dir "$OUT/arm1_resume_m6_verify" --mode replay-verify
-
-mkdir -p "$OUT"/{arm1_resume_m6,fresh_m6,fresh_d2,logs}
-
-# ---------------------------------------------------------------- arms
-echo "== launching arm 1 (resume M6, as-run harness, no DROP) =="
-nohup python scripts/resume_from_archive.py \
- --archive-dir "$ARCHIVE" --repo-root "$ASRUN_TREE" \
- --out-dir "$OUT/arm1_resume_m6" --mode continue --max-new-queries 200 \
- --timeout 2400 \
- > "$OUT/logs/arm1_resume.log" 2>&1 &
-ARM1=$!
-
-# Arms 2 and 3 run as SEPARATE processes with separate artifact roots: the
-# local pipeline is sequential (max_in_flight is a distributed-only knob) and
-# has no per-episode exception isolation, so one process per maze both halves
-# wall clock and stops a crash in one arm from stranding the other.
-echo "== launching arm 2 (fresh M6, DROP-enabled harness) =="
-nohup python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.r1.kimi_rerun_m6.json \
- --manifest gridworld/fixtures/manifest.r1_kimi_rerun.json \
- --seeds 0 --artifacts-root "$OUT/fresh_m6" \
- --difficulty-max-static-score "$DIFFICULTY_MAX" \
- > "$OUT/logs/arm2_fresh_m6.log" 2>&1 &
-ARM2=$!
-
-echo "== launching arm 3 (fresh D2 wrong-key, DROP-enabled harness) =="
-nohup python -m scripts.run_pipeline \
- --run-config gridworld/fixtures/run_config.r1.kimi_rerun_d2.json \
- --manifest gridworld/fixtures/manifest.r1_kimi_rerun.json \
- --seeds 0 --artifacts-root "$OUT/fresh_d2" \
- --difficulty-max-static-score "$DIFFICULTY_MAX" \
- > "$OUT/logs/arm3_fresh_d2.log" 2>&1 &
-ARM3=$!
-
-echo "arm1 pid=$ARM1 arm2 pid=$ARM2 arm3 pid=$ARM3 β waiting..."
-FAIL=0
-wait "$ARM1" || { echo "ARM 1 EXITED NONZERO β see logs/arm1_resume.log"; FAIL=1; }
-wait "$ARM2" || { echo "ARM 2 EXITED NONZERO β see logs/arm2_fresh_m6.log"; FAIL=1; }
-wait "$ARM3" || { echo "ARM 3 EXITED NONZERO β see logs/arm3_fresh_d2.log"; FAIL=1; }
-
-# ---------------------------------------------------------------- summary
-echo "== outcomes =="
-python3 - "$OUT" <<'EOF'
-import json, sys
-from pathlib import Path
-out = Path(sys.argv[1])
-for label, p in [
- ("arm1 resume M6 (no DROP)", out / "arm1_resume_m6" / "episode.json"),
- ("arm2 fresh M6 (DROP)", next(iter((out / "fresh_m6").glob(
- "runs/r1_M6*/minigrid/kimi-k2.6/seed_0/*/episode.json")), None)),
- ("arm3 fresh D2 (DROP)", next(iter((out / "fresh_d2").glob(
- "runs/r1_D2*/minigrid/kimi-k2.6/seed_0/*/episode.json")), None)),
-]:
- if p and Path(p).is_file():
- ep = json.load(open(p))
- steps = [t for t in ep["transcript"] if t["kind"] == "step"]
- drops = sum(1 for s in steps if s.get("action") == "DROP")
- print(f"{label}: end={ep.get('end_reason')} success={ep.get('success')} "
- f"steps={ep.get('steps_used')} DROP-actions={drops}")
- else:
- print(f"{label}: NO EPISODE ARTIFACT")
-EOF
-exit "$FAIL"
diff --git a/scripts/ollama_maze_shape_check.py b/scripts/ollama_maze_shape_check.py
index 16ae3d0..6496f30 100644
--- a/scripts/ollama_maze_shape_check.py
+++ b/scripts/ollama_maze_shape_check.py
@@ -80,7 +80,7 @@ def build_prompt() -> str:
def main() -> None:
parser = argparse.ArgumentParser(description="Probe an Ollama vision model for maze-shape perception.")
- root = Path(__file__).resolve().parent
+ root = Path(__file__).resolve().parents[1]
parser.add_argument("--model", required=True, help="Ollama model name")
parser.add_argument("--base-url", default="http://localhost:11434", help="Ollama base URL")
parser.add_argument(
diff --git a/scripts/ollama_vision_check.py b/scripts/ollama_vision_check.py
index c266aca..be30bcf 100644
--- a/scripts/ollama_vision_check.py
+++ b/scripts/ollama_vision_check.py
@@ -63,7 +63,7 @@ def ask_ollama(*, model: str, base_url: str, prompt: str, image) -> str:
def main() -> None:
parser = argparse.ArgumentParser(description="Quick Ollama vision check on a rendered task image.")
- root = Path(__file__).resolve().parent
+ root = Path(__file__).resolve().parents[1]
parser.add_argument("--model", required=True, help="Ollama model name")
parser.add_argument("--base-url", default="http://localhost:11434", help="Ollama base URL")
parser.add_argument(
diff --git a/scripts/probe_vlm.py b/scripts/probe_vlm.py
index 288b541..88bf73a 100644
--- a/scripts/probe_vlm.py
+++ b/scripts/probe_vlm.py
@@ -336,7 +336,7 @@ def parse_args() -> argparse.Namespace:
def main() -> None:
args = parse_args()
- root = Path(__file__).resolve().parent
+ root = Path(__file__).resolve().parents[1]
task_path = args.task or str(root / "mazes" / "validation_10" / "V01_empty_room.json")
actions = parse_action_sequence(args.actions)
context = collect_probe_context(
diff --git a/scripts/render_maze_jsons.py b/scripts/render_maze_jsons.py
deleted file mode 100644
index aa5b913..0000000
--- a/scripts/render_maze_jsons.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""Render maze JSON files through the local MiniGrid backend."""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from PIL import Image
-
-from gridworld.backends.minigrid_backend import MiniGridBackend
-from gridworld.task_spec import TaskSpecification
-
-
-def find_maze_files(input_dir: Path) -> list[Path]:
- return sorted(path for path in input_dir.rglob("*.json") if path.is_file())
-
-
-def output_path_for(input_dir: Path, output_dir: Path, json_path: Path) -> Path:
- return output_dir / json_path.relative_to(input_dir).with_suffix(".png")
-
-
-def render_maze(json_path: Path, output_path: Path) -> None:
- spec = TaskSpecification.from_json(str(json_path))
- backend = MiniGridBackend(render_mode="rgb_array")
- backend.configure(spec)
- image, _, _ = backend.reset(seed=spec.seed)
-
- if backend.env is not None and backend.env.highlight:
- raise RuntimeError(f"MiniGrid highlight overlay is enabled for {json_path}")
-
- output_path.parent.mkdir(parents=True, exist_ok=True)
- Image.fromarray(image).save(output_path)
-
-
-def main() -> int:
- parser = argparse.ArgumentParser(
- description="Render all maze JSON files with gridworld.backends.MiniGridBackend."
- )
- parser.add_argument(
- "--input-dir",
- type=Path,
- default=Path("mazes/ogbench"),
- help="Directory containing maze JSON files.",
- )
- parser.add_argument(
- "--output-dir",
- type=Path,
- default=Path("mazes/maze_image"),
- help="Directory where PNG images will be written.",
- )
- args = parser.parse_args()
-
- maze_files = find_maze_files(args.input_dir)
- if not maze_files:
- print(f"No JSON files found in: {args.input_dir}")
- return 1
-
- failures: list[tuple[Path, str]] = []
- for json_path in maze_files:
- output_path = output_path_for(args.input_dir, args.output_dir, json_path)
- try:
- render_maze(json_path, output_path)
- except Exception as exc: # noqa: BLE001
- failures.append((json_path, str(exc)))
- print(f"FAIL: {json_path.relative_to(args.input_dir)} ({exc})")
- continue
- print(f"OK: {json_path.relative_to(args.input_dir)} -> {output_path}")
-
- rendered = len(maze_files) - len(failures)
- print(f"Rendered {rendered}/{len(maze_files)} mazes to {args.output_dir}")
- if failures:
- print("Failed files:")
- for path, error in failures:
- print(f" - {path.name}: {error}")
- return 1
- return 0
-
-
-if __name__ == "__main__":
- raise SystemExit(main())
diff --git a/scripts/render_multigrid_maze_jsons.py b/scripts/render_multigrid_maze_jsons.py
deleted file mode 100644
index 13a28fb..0000000
--- a/scripts/render_multigrid_maze_jsons.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""Render maze JSON files through the local MultiGrid backend."""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from PIL import Image
-
-from gridworld.backends.multigrid_backend import MultiGridBackend
-from gridworld.task_spec import TaskSpecification
-
-
-def find_maze_files(input_dir: Path) -> list[Path]:
- return sorted(path for path in input_dir.rglob("*.json") if path.is_file())
-
-
-def output_path_for(input_dir: Path, output_dir: Path, tiling: str, json_path: Path) -> Path:
- return output_dir / tiling / json_path.relative_to(input_dir).with_suffix(".png")
-
-
-def render_maze(json_path: Path, output_path: Path, tiling: str) -> None:
- spec = TaskSpecification.from_json(str(json_path))
- backend = MultiGridBackend(tiling=tiling, render_mode="rgb_array")
- backend.configure(spec)
- backend.reset(seed=spec.seed)
- image = backend.render()
-
- output_path.parent.mkdir(parents=True, exist_ok=True)
- Image.fromarray(image).save(output_path)
-
-
-def main() -> int:
- parser = argparse.ArgumentParser(
- description="Render all maze JSON files with gridworld.backends.MultiGridBackend."
- )
- parser.add_argument(
- "--input-dir",
- type=Path,
- default=Path("mazes/ogbench"),
- help="Directory containing maze JSON files.",
- )
- parser.add_argument(
- "--output-dir",
- type=Path,
- default=Path("mazes/multigrid_image"),
- help="Directory where tiling-specific PNG folders will be written.",
- )
- parser.add_argument(
- "--tilings",
- nargs="+",
- default=["square", "hex"],
- help="MultiGrid tilings to render.",
- )
- args = parser.parse_args()
-
- maze_files = find_maze_files(args.input_dir)
- if not maze_files:
- print(f"No JSON files found in: {args.input_dir}")
- return 1
-
- failures: list[tuple[str, Path, str]] = []
- for tiling in args.tilings:
- for json_path in maze_files:
- output_path = output_path_for(args.input_dir, args.output_dir, tiling, json_path)
- try:
- render_maze(json_path, output_path, tiling)
- except Exception as exc: # noqa: BLE001
- failures.append((tiling, json_path, str(exc)))
- print(f"FAIL: {tiling}: {json_path.relative_to(args.input_dir)} ({exc})")
- continue
- print(f"OK: {tiling}: {json_path.relative_to(args.input_dir)} -> {output_path}")
-
- total = len(maze_files) * len(args.tilings)
- rendered = total - len(failures)
- print(f"Rendered {rendered}/{total} MultiGrid mazes to {args.output_dir}")
- if failures:
- print("Failed files:")
- for tiling, path, error in failures:
- print(f" - {tiling}/{path.name}: {error}")
- return 1
- return 0
-
-
-if __name__ == "__main__":
- raise SystemExit(main())
diff --git a/scripts/render_ogbench_mazes.py b/scripts/render_ogbench_mazes.py
deleted file mode 100644
index 0e4d3a4..0000000
--- a/scripts/render_ogbench_mazes.py
+++ /dev/null
@@ -1,139 +0,0 @@
-"""Render OGBench maze JSONs through all local grid backends."""
-
-from __future__ import annotations
-
-import argparse
-import shutil
-from pathlib import Path
-
-from scripts.render_maze_jsons import (
- find_maze_files,
- output_path_for as minigrid_output_path_for,
- render_maze as render_minigrid_maze,
-)
-from scripts.render_multigrid_maze_jsons import (
- output_path_for as multigrid_output_path_for,
- render_maze as render_multigrid_maze,
-)
-
-
-def _clean_path(path: Path) -> None:
- if path.exists():
- shutil.rmtree(path)
- path.mkdir(parents=True, exist_ok=True)
-
-
-def main() -> int:
- parser = argparse.ArgumentParser(
- description=(
- "Render OGBench maze JSONs recursively through MiniGrid and "
- "MultiGrid, preserving input subdirectories."
- )
- )
- parser.add_argument(
- "--input-dir",
- type=Path,
- default=Path("mazes/ogbench"),
- help="Directory containing maze JSON files, possibly nested.",
- )
- parser.add_argument(
- "--minigrid-output-dir",
- type=Path,
- default=Path("mazes/maze_image"),
- help="Directory for MiniGrid PNGs.",
- )
- parser.add_argument(
- "--multigrid-output-dir",
- type=Path,
- default=Path("mazes/multigrid_image"),
- help="Directory for MultiGrid tiling-specific PNG folders.",
- )
- parser.add_argument(
- "--tilings",
- nargs="+",
- default=["square", "hex"],
- help="MultiGrid tilings to render.",
- )
- parser.add_argument(
- "--skip-minigrid",
- action="store_true",
- help="Do not render MiniGrid images.",
- )
- parser.add_argument(
- "--skip-multigrid",
- action="store_true",
- help="Do not render MultiGrid images.",
- )
- parser.add_argument(
- "--clean",
- action="store_true",
- help="Remove output directories before rendering.",
- )
- args = parser.parse_args()
-
- maze_files = find_maze_files(args.input_dir)
- if not maze_files:
- print(f"No JSON files found in: {args.input_dir}")
- return 1
-
- if args.clean:
- if not args.skip_minigrid:
- _clean_path(args.minigrid_output_dir)
- if not args.skip_multigrid:
- for tiling in args.tilings:
- _clean_path(args.multigrid_output_dir / tiling)
-
- failures: list[tuple[str, Path, str]] = []
-
- if not args.skip_minigrid:
- for json_path in maze_files:
- output_path = minigrid_output_path_for(
- args.input_dir, args.minigrid_output_dir, json_path
- )
- try:
- render_minigrid_maze(json_path, output_path)
- except Exception as exc: # noqa: BLE001
- failures.append(("minigrid", json_path, str(exc)))
- print(f"FAIL: minigrid: {json_path.relative_to(args.input_dir)} ({exc})")
- continue
- print(f"OK: minigrid: {json_path.relative_to(args.input_dir)} -> {output_path}")
-
- if not args.skip_multigrid:
- for tiling in args.tilings:
- for json_path in maze_files:
- output_path = multigrid_output_path_for(
- args.input_dir, args.multigrid_output_dir, tiling, json_path
- )
- try:
- render_multigrid_maze(json_path, output_path, tiling)
- except Exception as exc: # noqa: BLE001
- failures.append((f"multigrid/{tiling}", json_path, str(exc)))
- print(
- f"FAIL: multigrid/{tiling}: "
- f"{json_path.relative_to(args.input_dir)} ({exc})"
- )
- continue
- print(
- f"OK: multigrid/{tiling}: "
- f"{json_path.relative_to(args.input_dir)} -> {output_path}"
- )
-
- backends = 0
- if not args.skip_minigrid:
- backends += 1
- if not args.skip_multigrid:
- backends += len(args.tilings)
- total = len(maze_files) * backends
- rendered = total - len(failures)
- print(f"Rendered {rendered}/{total} images from {len(maze_files)} maze JSON files")
-
- if failures:
- print("Failed files:")
- for backend, path, error in failures:
- print(f" - {backend}/{path.relative_to(args.input_dir)}: {error}")
- return 1
- return 0
-
-
-if __name__ == "__main__":
- raise SystemExit(main())
diff --git a/scripts/run_pipeline.py b/scripts/run_pipeline.py
index 2859e11..aee39b4 100644
--- a/scripts/run_pipeline.py
+++ b/scripts/run_pipeline.py
@@ -1,4 +1,4 @@
-"""Bare-bones run-pipeline orchestrator for MultiNet v2.0 (tests 1-3).
+"""Run-pipeline orchestrator for MultiNet v2.0: manifest + run-config driven evaluation runs.
Sequential, inspectable Stage 1->5 driver. No DAG runner. Writes the
``artifacts/`` tree:
@@ -319,7 +319,7 @@ def _expected_run_hash(
"""Hash the inputs that determine a Stage-3 episode.
Excludes scorer config: that invalidates run_score, not the model call.
- TODO(release): fold in backend_version + adapter/model code version so code
+ TODO(post-release): fold in backend_version + adapter/model code version so code
changes invalidate cached episodes at v1.
"""
return stable_hash(
@@ -1110,7 +1110,7 @@ def _build_agent_from_spec(name: str, model_cfg: dict[str, Any]) -> tuple[Agent,
def main(argv: Optional[list[str]] = None) -> None:
- parser = argparse.ArgumentParser(description="MultiNet v2.0 bare-bones run pipeline (tests 1-3).")
+ parser = argparse.ArgumentParser(description="MultiNet v2.0 run pipeline: manifest + run-config driven evaluation runs.")
parser.add_argument("--run-config", help="JSON run-config mapping models to task files (preferred).")
parser.add_argument("--manifest", default=str(_DEFAULT_MANIFEST), help="Task catalog (metadata).")
parser.add_argument("--seeds", type=int, nargs="+", default=[0])
diff --git a/scripts/vlm_sanity_check.py b/scripts/vlm_sanity_check.py
index 01567f9..ecaacbe 100644
--- a/scripts/vlm_sanity_check.py
+++ b/scripts/vlm_sanity_check.py
@@ -508,7 +508,7 @@ def run_sanity_check_all_tiers(
return reports
-if __name__ == "__main__":
+def main() -> None:
import argparse
parser = argparse.ArgumentParser(description="VLM Vision Sanity Check")
@@ -558,3 +558,7 @@ def ask_fn(image, question):
with open(args.output, "w") as f:
json.dump(report.to_dict(), f, indent=2)
print(f"\nResults saved to {args.output}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/supervise_run.sh b/supervise_run.sh
index 1992ce4..d31243d 100755
--- a/supervise_run.sh
+++ b/supervise_run.sh
@@ -2,7 +2,7 @@
# supervise_run.sh β self-contained distributed-run supervisor.
# Consumes .runs//manifest.json, drives a live run to a terminal state,
# owns the guaranteed STOP on every terminal path, NEVER deletes. Does not use or
-# modify monitor_run.sh. See docs/superpowers/specs/2026-07-01-distributed-supervisor-design.md
+# modify monitor_run.sh.
set -uo pipefail
source "$(dirname "${BASH_SOURCE[0]}")/lib/cost_safety.sh"
diff --git a/sweep_run.sh b/sweep_run.sh
index 5f9f908..92a0a50 100755
--- a/sweep_run.sh
+++ b/sweep_run.sh
@@ -3,7 +3,7 @@
# SINGLE reused fleet (3 Qwen + 1 Kimi + 1 Claude + coordinator). It composes the
# already-tested primitives (launch_distributed.sh + lib/cost_safety.sh +
# lib/distributed_start.sh) and holds NO cost-safety logic of its own. It STOPs,
-# never deletes. See docs/superpowers/specs/2026-07-03-sequential-supervised-sweep-design.md
+# never deletes.
#
# NOTE: -e is intentionally OFF β a tick must survive a nonzero sub-step so the
# fail-closed egress guard can run and the fleet is never left in a half-known state.
diff --git a/tests/maze_test_utils.py b/tests/maze_test_utils.py
index 1a0a15a..c199305 100644
--- a/tests/maze_test_utils.py
+++ b/tests/maze_test_utils.py
@@ -4,7 +4,18 @@
from BFS_solver import solve
-MAZE_JSON_DIR = Path(__file__).resolve().parent.parent / 'mazes' / 'exp_maze_jsons'
+# The experiment corpus lives in the ogbench submodule β the same files every
+# R1 manifest resolves. (mazes/exp_maze_jsons/ was a stale duplicate, removed
+# 2026-08: it had drifted on 9 files and carried a goal-invariant violation.)
+MAZE_JSON_DIR = (
+ Path(__file__).resolve().parent.parent
+ / 'ogbench' / 'ogbench' / 'procgen' / 'maze_jsons'
+)
+if not MAZE_JSON_DIR.exists():
+ raise RuntimeError(
+ f'Maze corpus missing at {MAZE_JSON_DIR} β the ogbench submodule is '
+ 'not initialized. Run: git submodule update --init'
+ )
MECHANISM_KEYS = ('keys', 'doors', 'switches', 'gates')
diff --git a/tests/test_baselines_drop_edge.py b/tests/test_baselines_drop_edge.py
new file mode 100644
index 0000000..2d0c23a
--- /dev/null
+++ b/tests/test_baselines_drop_edge.py
@@ -0,0 +1,73 @@
+"""The planner's DROP edge exists only when the harness exposed DROP.
+
+R1 ran without DROP in the model-facing vocabulary, so a decoy-key pickup was
+mechanically unrecoverable ("doomed"). The 2026-07-30 rerun exposed DROP, so the
+same state is recoverable and must not be scored as doomed.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from gridworld.baselines import TaskPlanningContext, _successors
+from gridworld.task_spec import TaskSpecification
+
+D2 = Path("ogbench/ogbench/procgen/maze_jsons/D2/8x8_corridor_wrong_ky_inactive_sb_sg_kr_1.json")
+
+
+def _spec():
+ return TaskSpecification.from_dict(json.loads(D2.read_text()))
+
+
+def _carrying_decoy(ctx):
+ """A planner state holding the yellow decoy key."""
+ decoy = next(k for k, v in ctx.keys_by_id.items() if v["color"] == "yellow")
+ base = ctx.initial_state()
+ return base.__class__(
+ agent_pos=ctx.keys_by_id[decoy]["position"],
+ agent_dir=base.agent_dir,
+ carrying_key=decoy,
+ collected_keys=frozenset({decoy}),
+ active_switches=base.active_switches,
+ used_switches=base.used_switches,
+ open_gates=base.open_gates,
+ open_doors=base.open_doors,
+ )
+
+
+def test_no_drop_edge_by_default():
+ ctx = TaskPlanningContext(_spec())
+ labels = [t.label for t in _successors(ctx, _carrying_decoy(ctx))]
+ assert not any(l.startswith("drop:") for l in labels)
+
+
+def test_drop_edge_when_enabled():
+ ctx = TaskPlanningContext(_spec(), drop_available=True)
+ state = _carrying_decoy(ctx)
+ drops = [t for t in _successors(ctx, state) if t.label.startswith("drop:")]
+ assert len(drops) == 1
+ after = drops[0].next_state
+ assert after.carrying_key is None
+ # The key stays "collected" β it is gone from the world, not re-acquirable.
+ assert after.collected_keys == state.collected_keys
+ assert after.agent_pos == state.agent_pos
+
+
+def test_no_drop_edge_with_empty_hands():
+ ctx = TaskPlanningContext(_spec(), drop_available=True)
+ labels = [t.label for t in _successors(ctx, ctx.initial_state())]
+ assert not any(l.startswith("drop:") for l in labels)
+
+
+def test_optimal_cost_is_unchanged_by_the_drop_edge():
+ """The regression gate: DROP must never shorten the optimal solution, or
+ every difficulty number in the corpus shifts."""
+ from gridworld.baselines import plan_bfs_path
+
+ spec = _spec()
+ without = plan_bfs_path(spec)
+ with_drop = plan_bfs_path(spec, drop_available=True)
+ # The brief's test compares path length via len(); PlannedPath is a plain
+ # dataclass with no __len__, so we compare the actual action-count field
+ # it's meant to express (see task-1-report.md for why).
+ assert len(without.actions) == len(with_drop.actions)
diff --git a/tests/test_console_entry_points.py b/tests/test_console_entry_points.py
new file mode 100644
index 0000000..b2972d4
--- /dev/null
+++ b/tests/test_console_entry_points.py
@@ -0,0 +1,29 @@
+"""Every declared multinet-* console script must resolve to a callable.
+
+Guards the packaging surface: a [project.scripts] target pointing at a
+missing function ships an installed command that crashes on first run.
+"""
+from importlib.metadata import entry_points
+
+import pytest
+
+_EPS = sorted(
+ (ep for ep in entry_points(group="console_scripts") if ep.name.startswith("multinet-")),
+ key=lambda ep: ep.name,
+)
+
+
+def test_all_declared_entry_points_found():
+ assert len(_EPS) >= 10, (
+ "expected the 10 multinet-* console scripts from pyproject; "
+ "is the package installed (pip install -e .)?"
+ )
+
+
+@pytest.mark.parametrize("ep", _EPS, ids=lambda ep: ep.name)
+def test_console_script_target_resolves(ep):
+ try:
+ target = ep.load()
+ except ModuleNotFoundError as exc:
+ pytest.skip(f"optional third-party dependency not installed: {exc.name}")
+ assert callable(target), f"{ep.name} -> {ep.value} is not callable"
diff --git a/tests/test_deploy_package.py b/tests/test_deploy_package.py
index 4442843..cfad788 100644
--- a/tests/test_deploy_package.py
+++ b/tests/test_deploy_package.py
@@ -7,11 +7,3 @@
def test_deploy_exposes_repo_root():
assert (deploy.REPO_ROOT / "pyproject.toml").is_file()
-
-
-def test_future_directions_doc_flags_vllm():
- doc = deploy.REPO_ROOT / "docs" / "future_directions.md"
- assert doc.is_file()
- text = doc.read_text(encoding="utf-8").lower()
- assert "vllm" in text
- assert "sglang" in text
diff --git a/tests/test_drop_action.py b/tests/test_drop_action.py
index 5e123cf..eac1231 100644
--- a/tests/test_drop_action.py
+++ b/tests/test_drop_action.py
@@ -448,8 +448,15 @@ def test_no_fixture_maze_needs_a_drop_to_solve(self):
from gridworld.baselines import plan_bfs_path
mazes_root = Path(__file__).resolve().parent.parent / "mazes"
+ ogbench_root = (
+ Path(__file__).resolve().parent.parent
+ / "ogbench" / "ogbench" / "procgen" / "maze_jsons"
+ )
+ maze_paths = list(mazes_root.rglob("*.json"))
+ if ogbench_root.exists():
+ maze_paths.extend(ogbench_root.rglob("*.json"))
checked = 0
- for path in sorted(mazes_root.rglob("*.json")):
+ for path in sorted(maze_paths):
with open(path) as fh:
try:
raw = json.load(fh)
diff --git a/tests/test_maze_goal_invariant.py b/tests/test_maze_goal_invariant.py
new file mode 100644
index 0000000..31271e0
--- /dev/null
+++ b/tests/test_maze_goal_invariant.py
@@ -0,0 +1,30 @@
+import json
+import sys
+import unittest
+from pathlib import Path
+
+_REPO_ROOT = str(Path(__file__).resolve().parent.parent)
+if _REPO_ROOT not in sys.path:
+ sys.path.insert(0, _REPO_ROOT)
+
+from maze_test_utils import MAZE_JSON_DIR
+
+
+class TestGoalInvariantAllFamilies(unittest.TestCase):
+ """CLAUDE.md 'one goal source': goal.target must equal maze.goal for every
+ maze in the experiment corpus. The per-family suites assert this only for
+ D1 and M mazes, which let a defective D3 spec ship undetected."""
+
+ def test_goal_target_matches_maze_goal_everywhere(self):
+ maze_files = sorted(MAZE_JSON_DIR.rglob('*.json'))
+ self.assertTrue(maze_files, f'no maze JSONs under {MAZE_JSON_DIR}')
+ violations = []
+ for path in maze_files:
+ spec = json.loads(path.read_text(encoding='utf-8'))
+ target = spec.get('goal', {}).get('target')
+ if target is not None and target != spec['maze']['goal']:
+ violations.append(
+ f'{path.relative_to(MAZE_JSON_DIR)}: '
+ f'goal.target={target} != maze.goal={spec["maze"]["goal"]}'
+ )
+ self.assertEqual(violations, [])
diff --git a/tests/test_one_shot_solution.py b/tests/test_one_shot_solution.py
index b4d34c7..b3f9db1 100644
--- a/tests/test_one_shot_solution.py
+++ b/tests/test_one_shot_solution.py
@@ -7,6 +7,17 @@
_REPO = Path(__file__).resolve().parents[1]
_ONE_SHOT_DIR = _REPO / "mazes" / "one_shot_example"
+_OGBENCH_MAZE_DIR = _REPO / "ogbench" / "ogbench" / "procgen" / "maze_jsons"
+
+
+def _eval_maze_paths():
+ paths = [
+ p for p in (_REPO / "mazes").rglob("*.json")
+ if _ONE_SHOT_DIR not in p.parents
+ ]
+ if _OGBENCH_MAZE_DIR.exists():
+ paths.extend(_OGBENCH_MAZE_DIR.rglob("*.json"))
+ return paths
def _action_to_enum(a: str) -> Action:
@@ -55,8 +66,8 @@ def test_one_shot_example_is_disjoint_from_evaluation_mazes():
"""The ICL one-shot example must never double as an evaluation maze: it must
not share a task_id or maze content with any eval maze, and no manifest may
reference it. Evaluation mazes are every maze under mazes/ outside the
- dedicated one_shot_example/ directory (covers validation_10 today and the
- conditional S/M/B/D mazes once they land)."""
+ dedicated one_shot_example/ directory, plus the ogbench procgen corpus
+ that the R1 manifests resolve."""
one_shot_mazes = {
path: payload
for path in sorted(_ONE_SHOT_DIR.glob("*.json"))
@@ -66,9 +77,8 @@ def test_one_shot_example_is_disjoint_from_evaluation_mazes():
eval_payloads = [
payload
- for path in (_REPO / "mazes").rglob("*.json")
- if _ONE_SHOT_DIR not in path.parents
- and "maze" in (payload := json.loads(path.read_text()))
+ for path in _eval_maze_paths()
+ if "maze" in (payload := json.loads(path.read_text()))
]
assert eval_payloads, "expected to find evaluation mazes under mazes/"
diff --git a/tests/test_performance.py b/tests/test_performance.py
index f9186e1..107bd2b 100644
--- a/tests/test_performance.py
+++ b/tests/test_performance.py
@@ -10,6 +10,8 @@
from multigrid.env import MultiGridEnv, Action
+pytestmark = pytest.mark.slow
+
def create_task(grid_size=10, max_steps=100):
"""Helper to create a task spec for performance testing."""
diff --git a/tests/test_run_pipeline.py b/tests/test_run_pipeline.py
index 32820c4..d2fea43 100644
--- a/tests/test_run_pipeline.py
+++ b/tests/test_run_pipeline.py
@@ -1232,8 +1232,7 @@ def test_run_hash_canonicalizes_numeric_spelling():
# The six condition sets launched over the conditional eval, and the
-# deduplicated rollout that runs the shared baseline exactly once. See
-# docs/validation10_condition_sweep_rollout.md.
+# deduplicated rollout that runs the shared baseline exactly once.
_LAUNCH_CONDITION_SETS = [
"Prompt",
"Observation format",
diff --git a/tests/test_serve_arg_rendering.py b/tests/test_serve_arg_rendering.py
index fbb71dd..a764768 100644
--- a/tests/test_serve_arg_rendering.py
+++ b/tests/test_serve_arg_rendering.py
@@ -13,8 +13,8 @@
REPO = Path(__file__).resolve().parent.parent
-# Today's hard-coded phase-1 arg string (lib/distributed_start.sh gpu branch +
-# run_qwen_backfill.sh, verbatim, modulo ordering which is irrelevant to vllm).
+# Today's hard-coded phase-1 arg string (lib/distributed_start.sh gpu branch,
+# verbatim, modulo ordering which is irrelevant to vllm).
PHASE1 = ("--port 8000 --gpu-memory-utilization 0.9 --max-model-len 16384 "
"--max-num-seqs 64 --dtype bfloat16 --trust-remote-code")
@@ -22,7 +22,6 @@
TOUCHED = [
"lib/vllm_serve_args.sh",
"lib/distributed_start.sh",
- "run_qwen_backfill.sh",
"launch_qwen_smoke.sh",
"sweep_run.sh",
]
diff --git a/tests/test_smoke_qwen.py b/tests/test_smoke_qwen.py
index 7de0512..27f09f3 100644
--- a/tests/test_smoke_qwen.py
+++ b/tests/test_smoke_qwen.py
@@ -7,7 +7,7 @@ def test_format_verdict_below_target():
msg = format_verdict(42.0)
assert "BELOW" in msg
assert "42.0" in msg
- assert "future_directions" in msg
+ assert "single-stream HF generate" in msg
def test_format_verdict_meets_target():
diff --git a/tests/test_sweep_run.py b/tests/test_sweep_run.py
index 0e9910f..292f490 100644
--- a/tests/test_sweep_run.py
+++ b/tests/test_sweep_run.py
@@ -239,7 +239,7 @@ def test_publish_excludes_png_and_runs_git_only_in_results_repo(tmp_path):
def test_results_repo_is_gitignored():
# The results repo is a SEPARATE git repo; the code repo must never track it.
- assert bash("git check-ignore Multinet-v2-results").returncode == 0
+ assert bash("git check-ignore Multinet-v2-results/").returncode == 0
def test_status_renders_table(tmp_path):
diff --git a/visualize_grid.py b/visualize_grid.py
deleted file mode 100644
index e2b742b..0000000
--- a/visualize_grid.py
+++ /dev/null
@@ -1,368 +0,0 @@
-#!/usr/bin/env python3
-"""
-Visualization script for MultiGrid environments.
-
-This script creates a simple grid environment and visualizes it using matplotlib.
-"""
-
-import sys
-import os
-import math
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.patches import Polygon, Circle, Rectangle
-import matplotlib.patches as mpatches
-
-# Add parent directory to path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-from multigrid.env import MultiGridEnv, TilingRegistry
-from multigrid.tilings import SquareTiling, HexTiling, TriangleTiling
-from multigrid.agent import Action
-
-
-def visualize_grid(tiling_name="square", width=10, height=10):
- """
- Visualize a grid with the specified tiling.
-
- Args:
- tiling_name: Type of tiling ("square", "hex", or "triangle")
- width: Grid width in cells
- height: Grid height in cells
- """
- # Create tiling
- tiling = TilingRegistry.get(tiling_name)
- cells = tiling.generate_graph(width, height, seed=0)
-
- # Create figure
- fig, ax = plt.subplots(1, 1, figsize=(12, 12))
- ax.set_aspect('equal')
- ax.set_xlim(-0.1, 1.1)
- ax.set_ylim(-0.1, 1.1)
- ax.set_title(f"{tiling_name.capitalize()} Grid ({width}x{height})")
-
- # Draw cells
- for cell_id, cell in cells.items():
- x, y = cell.position_hint
-
- # Draw cell based on tiling type
- if tiling_name == "square":
- # Draw square cell
- cell_size = 1.0 / width
- rect = Rectangle(
- (x - cell_size/2, y - cell_size/2),
- cell_size, cell_size,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(rect)
-
- elif tiling_name == "hex":
- # Draw hexagon cell with proper sizing to match HexTiling coordinate system
- from matplotlib.patches import RegularPolygon
-
- # Calculate hex size matching HexTiling._axial_to_normalized()
- width_spacing = (width - 1) if width > 1 else 1
- height_spacing = (height - 1) if height > 1 else 1
- size_from_width = 0.95 / ((width + 0.5) * math.sqrt(3)) if width > 0 else 0.1
- size_from_height = 0.95 / (height_spacing * 1.5) if height_spacing > 0 else 0.1
- size = min(size_from_width, size_from_height)
-
- hexagon = RegularPolygon(
- (x, y),
- numVertices=6,
- radius=size, # Full size for edge-to-edge tiling
- orientation=math.pi / 2, # Point top
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(hexagon)
-
- elif tiling_name == "triangle":
- # Triangles are subdivisions of hexagons
- # Parse triangle ID: tri_hexcol_hexrow_triidx
- parts = cell_id.split("_")
- if len(parts) == 4:
- from multigrid.tilings.hex import OffsetCoord, offset_to_axial
- _, hex_col, hex_row, tri_idx = parts
- tri_idx = int(tri_idx)
- hex_col = int(hex_col)
- hex_row = int(hex_row)
-
- # Get hex center position
- offset = OffsetCoord(hex_col, hex_row)
- axial = offset_to_axial(offset)
-
- # Calculate hex size (same as HexTiling)
- width_spacing = (width - 1) if width > 1 else 1
- height_spacing = (height - 1) if height > 1 else 1
- size_from_width = 0.95 / ((width + 0.5) * math.sqrt(3))
- size_from_height = 0.95 / (height_spacing * 1.5)
- hex_size = min(size_from_width, size_from_height)
-
- # Calculate hex center in normalized coordinates
- col_pos = hex_col * math.sqrt(3) * hex_size
- row_pos = hex_row * 1.5 * hex_size
- if hex_row % 2 == 1:
- col_pos += math.sqrt(3) / 2 * hex_size
-
- grid_width = (width + 0.5) * math.sqrt(3) * hex_size
- grid_height = (height - 0.5) * 1.5 * hex_size
- x_offset = (1.0 - grid_width) / 2
- y_offset = (1.0 - grid_height) / 2
-
- hex_center_x = col_pos + x_offset
- hex_center_y = row_pos + y_offset
-
- # Calculate the 3 vertices of this triangle
- # Each triangle has apex at a hex vertex and base edges to adjacent vertices
- angle_apex = math.pi / 2 - tri_idx * math.pi / 3
- angle_base1 = math.pi / 2 - ((tri_idx - 1) % 6) * math.pi / 3
- angle_base2 = math.pi / 2 - ((tri_idx + 1) % 6) * math.pi / 3
-
- # Apex vertex
- apex_x = hex_center_x + hex_size * math.cos(angle_apex)
- apex_y = hex_center_y - hex_size * math.sin(angle_apex)
-
- # Base vertices (adjacent hex vertices)
- base1_x = hex_center_x + hex_size * math.cos(angle_base1)
- base1_y = hex_center_y - hex_size * math.sin(angle_base1)
-
- base2_x = hex_center_x + hex_size * math.cos(angle_base2)
- base2_y = hex_center_y - hex_size * math.sin(angle_base2)
-
- vertices = [
- (apex_x, apex_y),
- (base1_x, base1_y),
- (base2_x, base2_y)
- ]
-
- triangle = Polygon(
- vertices,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(triangle)
-
- # Draw cell center point
- ax.plot(x, y, 'k.', markersize=1)
-
- # Add legend
- legend_elements = [
- mpatches.Patch(facecolor='none', edgecolor='gray', label=f'{len(cells)} cells'),
- mpatches.Patch(facecolor='none', edgecolor='blue', label=f'{len(tiling.directions)} directions per cell')
- ]
- ax.legend(handles=legend_elements, loc='upper right')
-
- plt.tight_layout()
- plt.savefig(f'grid_visualization_{tiling_name}.png', dpi=150, bbox_inches='tight')
- print(f"Saved visualization to grid_visualization_{tiling_name}.png")
- plt.close()
-
-
-def visualize_environment():
- """
- Visualize a complete environment with agent and objects.
- """
- # Create a simple task spec
- task_spec = {
- "task_id": "demo_001",
- "seed": 42,
- "scene": {
- "bounds": {"width": 1.0, "height": 1.0},
- "objects": [
- {
- "id": "cube_red",
- "type": "movable",
- "color": "red",
- "position": {"x": 0.7, "y": 0.7},
- "size": 0.1
- },
- {
- "id": "cube_green",
- "type": "movable",
- "color": "green",
- "position": {"x": 0.3, "y": 0.7},
- "size": 0.1
- }
- ],
- "agent": {
- "position": {"x": 0.2, "y": 0.2},
- "facing": 0
- }
- },
- "goal": {
- "predicate": "object_in_zone",
- "object_id": "cube_red",
- "zone_id": "zone_blue"
- },
- "limits": {"max_steps": 100},
- "tiling": {"type": "square", "grid_size": {"width": 10, "height": 10}}
- }
-
- # Create environment
- env = MultiGridEnv(task_spec, tiling="square")
- obs, info = env.reset(seed=42)
-
- # Create figure
- fig, axes = plt.subplots(1, 3, figsize=(18, 6))
-
- tiling_types = ["square", "hex", "triangle"]
-
- for idx, tiling_name in enumerate(tiling_types):
- ax = axes[idx]
- ax.set_aspect('equal')
- ax.set_xlim(-0.1, 1.1)
- ax.set_ylim(-0.1, 1.1)
- ax.set_title(f"{tiling_name.capitalize()} Tiling (10x10)")
-
- # Create environment with this tiling
- task_spec["tiling"]["type"] = tiling_name
- env = MultiGridEnv(task_spec, tiling=tiling_name)
- obs, info = env.reset(seed=42)
-
- # Draw grid
- import math
- from matplotlib.patches import RegularPolygon
- tiling = env.tiling
- cell_size = 1.0 / 10
-
- # Draw all cells
- for cell_id, cell in tiling.cells.items():
- x, y = cell.position_hint
-
- if tiling_name == "square":
- rect = Rectangle(
- (x - cell_size/2, y - cell_size/2),
- cell_size, cell_size,
- facecolor='lightgray',
- edgecolor='gray',
- linewidth=0.3
- )
- ax.add_patch(rect)
- elif tiling_name == "hex":
- # Calculate proper hex size matching HexTiling coordinate system
- width_spacing = 9 # 10 - 1
- height_spacing = 9 # 10 - 1
- size_from_width = 0.95 / ((10 + 0.5) * math.sqrt(3))
- size_from_height = 0.95 / (height_spacing * 1.5)
- size = min(size_from_width, size_from_height)
- hexagon = RegularPolygon(
- (x, y),
- numVertices=6,
- radius=size, # Full size for edge-to-edge
- orientation=math.pi / 2,
- facecolor='lightgray',
- edgecolor='gray',
- linewidth=0.3
- )
- ax.add_patch(hexagon)
- elif tiling_name == "triangle":
- # Triangles are subdivisions of hexagons
- # Parse triangle ID: tri_hexcol_hexrow_triidx
- parts = cell_id.split("_")
- if len(parts) == 4:
- from multigrid.tilings.hex import OffsetCoord, offset_to_axial
- _, hex_col, hex_row, tri_idx = parts
- tri_idx = int(tri_idx)
- hex_col = int(hex_col)
- hex_row = int(hex_row)
-
- # Get hex center position
- offset = OffsetCoord(hex_col, hex_row)
- axial = offset_to_axial(offset)
-
- # Calculate hex size (same as HexTiling)
- width_spacing = 9 # 10 - 1
- height_spacing = 9 # 10 - 1
- size_from_width = 0.95 / ((10 + 0.5) * math.sqrt(3))
- size_from_height = 0.95 / (height_spacing * 1.5)
- hex_size = min(size_from_width, size_from_height)
-
- # Calculate hex center in normalized coordinates
- col_pos = hex_col * math.sqrt(3) * hex_size
- row_pos = hex_row * 1.5 * hex_size
- if hex_row % 2 == 1:
- col_pos += math.sqrt(3) / 2 * hex_size
-
- grid_width = (10 + 0.5) * math.sqrt(3) * hex_size
- grid_height = (10 - 0.5) * 1.5 * hex_size
- x_offset = (1.0 - grid_width) / 2
- y_offset = (1.0 - grid_height) / 2
-
- hex_center_x = col_pos + x_offset
- hex_center_y = row_pos + y_offset
-
- # Calculate the 3 vertices of this triangle
- angle_apex = math.pi / 2 - tri_idx * math.pi / 3
- angle_base1 = math.pi / 2 - ((tri_idx - 1) % 6) * math.pi / 3
- angle_base2 = math.pi / 2 - ((tri_idx + 1) % 6) * math.pi / 3
-
- # Apex vertex
- apex_x = hex_center_x + hex_size * math.cos(angle_apex)
- apex_y = hex_center_y - hex_size * math.sin(angle_apex)
-
- # Base vertices (adjacent hex vertices)
- base1_x = hex_center_x + hex_size * math.cos(angle_base1)
- base1_y = hex_center_y - hex_size * math.sin(angle_base1)
-
- base2_x = hex_center_x + hex_size * math.cos(angle_base2)
- base2_y = hex_center_y - hex_size * math.sin(angle_base2)
-
- vertices = [
- (apex_x, apex_y),
- (base1_x, base1_y),
- (base2_x, base2_y)
- ]
-
- triangle = Polygon(
- vertices,
- facecolor='lightgray',
- edgecolor='gray',
- linewidth=0.3
- )
- ax.add_patch(triangle)
-
- # Draw agent
- agent_x, agent_y = tiling.cell_to_canonical(env.state.agent.cell_id)
- ax.plot(agent_x, agent_y, 'bo', markersize=15, label='Agent')
-
- # Draw objects
- for obj in env.state.objects.values():
- if obj.cell_id:
- obj_x, obj_y = tiling.cell_to_canonical(obj.cell_id)
- color_map = {'red': 'r', 'green': 'g', 'blue': 'b'}
- ax.plot(obj_x, obj_y, f'{color_map.get(obj.color, "k")}s', markersize=10, label=f'{obj.color} cube')
-
- ax.legend(loc='upper right', fontsize=8)
- ax.grid(True, alpha=0.2)
-
- plt.tight_layout()
- plt.savefig('environment_comparison.png', dpi=150, bbox_inches='tight')
- print("Saved environment comparison to environment_comparison.png")
- plt.close()
-
-
-if __name__ == "__main__":
- print("MultiGrid Visualization Script")
- print("=" * 50)
-
- # Visualize different grid types
- for tiling_name in ["square", "hex", "triangle"]:
- print(f"\nGenerating {tiling_name} grid visualization...")
- visualize_grid(tiling_name, width=10, height=10)
-
- # Visualize complete environments
- print("\nGenerating environment comparison...")
- visualize_environment()
-
- print("\n" + "=" * 50)
- print("All visualizations generated successfully!")
- print("\nGenerated files:")
- print(" - grid_visualization_square.png")
- print(" - grid_visualization_hex.png")
- print(" - grid_visualization_triangle.png")
- print(" - environment_comparison.png")
diff --git a/visualize_grids_proper.py b/visualize_grids_proper.py
deleted file mode 100644
index faa93d2..0000000
--- a/visualize_grids_proper.py
+++ /dev/null
@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-"""
-Proper grid visualization showing actual tiled patterns.
-"""
-
-import sys
-import os
-import math
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-from matplotlib.patches import Polygon, Circle, RegularPolygon
-import numpy as np
-
-# Add parent directory to path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-from multigrid.tilings import SquareTiling, HexTiling, TriangleTiling
-
-
-def visualize_square_grid(width=10, height=10):
- """Visualize square grid with proper tiling."""
- tiling = SquareTiling()
- tiling.generate_graph(width, height, seed=0)
-
- fig, ax = plt.subplots(1, 1, figsize=(10, 10))
- ax.set_aspect('equal')
- ax.set_xlim(-0.05, 1.05)
- ax.set_ylim(-0.05, 1.05)
- ax.set_title(f"Square Tiling ({width}Γ{height} cells, 4 directions per cell)", fontsize=14)
-
- cell_size = 1.0 / width
-
- # Draw all cells
- for cell_id, cell in tiling.cells.items():
- x_norm, y_norm = cell.position_hint
-
- # Draw square
- square = mpatches.Rectangle(
- (x_norm - cell_size/2, y_norm - cell_size/2),
- cell_size, cell_size,
- fill=True,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(square)
-
- # Draw cell center
- ax.plot(x_norm, y_norm, 'k.', markersize=1)
-
- # Highlight a sample cell and its neighbors
- sample_cell_id = f"sq_5_5"
- if sample_cell_id in tiling.cells:
- cell = tiling.cells[sample_cell_id]
- x, y = cell.position_hint
-
- # Highlight center cell
- square = mpatches.Rectangle(
- (x - cell_size/2, y - cell_size/2),
- cell_size, cell_size,
- fill=True,
- facecolor='yellow',
- edgecolor='red',
- linewidth=2
- )
- ax.add_patch(square)
-
- # Highlight neighbors
- for direction, neighbor_id in cell.neighbors.items():
- neighbor = tiling.cells[neighbor_id]
- nx, ny = neighbor.position_hint
- square = mpatches.Rectangle(
- (nx - cell_size/2, ny - cell_size/2),
- cell_size, cell_size,
- fill=True,
- facecolor='lightgreen',
- edgecolor='green',
- linewidth=1.5
- )
- ax.add_patch(square)
-
- plt.savefig('square_grid_proper.png', dpi=150, bbox_inches='tight')
- print("Saved square_grid_proper.png")
- plt.close()
-
-
-def visualize_hex_grid(width=10, height=10):
- """Visualize hexagonal grid with proper tiling."""
- tiling = HexTiling()
- tiling.generate_graph(width, height, seed=0)
-
- fig, ax = plt.subplots(1, 1, figsize=(12, 10))
- ax.set_aspect('equal')
- ax.set_xlim(-0.05, 1.05)
- ax.set_ylim(-0.05, 1.05)
- ax.set_title(f"Hexagonal Tiling ({width}Γ{height} cells, 6 directions per cell)", fontsize=14)
-
- # Calculate hex size based on grid dimensions
- hex_width_units = width * math.sqrt(3)
- hex_height_units = height * 1.5 + 0.5
- size = min(1.0 / hex_width_units, 1.0 / hex_height_units)
-
- # Draw all hexagons
- for cell_id, cell in tiling.cells.items():
- x_norm, y_norm = cell.position_hint
-
- # Create hexagon vertices
- hexagon = RegularPolygon(
- (x_norm, y_norm),
- numVertices=6,
- radius=size * 0.98, # Slightly smaller to see edges
- orientation=math.pi / 2, # Point top
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(hexagon)
-
- # Draw cell center
- ax.plot(x_norm, y_norm, 'k.', markersize=1)
-
- # Highlight a sample cell in the middle and its neighbors
- mid_cells = [c for c in tiling.cells.values() if 0.4 < c.position_hint[0] < 0.6 and 0.4 < c.position_hint[1] < 0.6]
- if mid_cells:
- cell = mid_cells[0]
- x, y = cell.position_hint
-
- # Highlight center cell
- hexagon = RegularPolygon(
- (x, y),
- numVertices=6,
- radius=size * 0.98,
- orientation=math.pi / 2,
- facecolor='yellow',
- edgecolor='red',
- linewidth=2
- )
- ax.add_patch(hexagon)
-
- # Highlight neighbors
- for direction, neighbor_id in cell.neighbors.items():
- neighbor = tiling.cells[neighbor_id]
- nx, ny = neighbor.position_hint
- hexagon = RegularPolygon(
- (nx, ny),
- numVertices=6,
- radius=size * 0.98,
- orientation=math.pi / 2,
- facecolor='lightgreen',
- edgecolor='green',
- linewidth=1.5
- )
- ax.add_patch(hexagon)
-
- plt.savefig('hex_grid_proper.png', dpi=150, bbox_inches='tight')
- print("Saved hex_grid_proper.png")
- plt.close()
-
-
-def visualize_triangle_grid(width=10, height=10):
- """Visualize triangular grid with proper tiling."""
- tiling = TriangleTiling()
- tiling.generate_graph(width, height, seed=0)
-
- fig, ax = plt.subplots(1, 1, figsize=(10, 10))
- ax.set_aspect('equal')
- ax.set_xlim(-0.05, 1.05)
- ax.set_ylim(-0.05, 1.05)
- ax.set_title(f"Triangular Tiling ({width}Γ{height} cells, 3 edges per cell)", fontsize=14)
-
- cell_size = 1.0 / width
-
- # Draw all triangles
- for cell_id, cell in tiling.cells.items():
- x_norm, y_norm = cell.position_hint
-
- # Determine if triangle points up or down
- pointing_up = (cell.row + cell.col) % 2 == 0
-
- if pointing_up:
- # Upward pointing triangle
- vertices = [
- (x_norm, y_norm - cell_size * 0.4),
- (x_norm - cell_size * 0.4, y_norm + cell_size * 0.2),
- (x_norm + cell_size * 0.4, y_norm + cell_size * 0.2)
- ]
- else:
- # Downward pointing triangle
- vertices = [
- (x_norm, y_norm + cell_size * 0.4),
- (x_norm - cell_size * 0.4, y_norm - cell_size * 0.2),
- (x_norm + cell_size * 0.4, y_norm - cell_size * 0.2)
- ]
-
- triangle = Polygon(
- vertices,
- fill=True,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.5
- )
- ax.add_patch(triangle)
-
- # Draw cell center
- ax.plot(x_norm, y_norm, 'k.', markersize=1)
-
- plt.savefig('triangle_grid_proper.png', dpi=150, bbox_inches='tight')
- print("Saved triangle_grid_proper.png")
- plt.close()
-
-
-def create_comparison():
- """Create side-by-side comparison of all three tilings."""
- fig, axes = plt.subplots(1, 3, figsize=(18, 6))
-
- tilings = [
- (SquareTiling(), "Square (4-connected)", 'square_cell'),
- (HexTiling(), "Hexagonal (6-connected)", 'hex_cell'),
- (TriangleTiling(), "Triangular (3-connected)", 'tri_cell')
- ]
-
- width, height = 8, 8
-
- for ax, (tiling_obj, title, prefix) in zip(axes, tilings):
- tiling_obj.generate_graph(width, height, seed=0)
-
- ax.set_aspect('equal')
- ax.set_xlim(-0.05, 1.05)
- ax.set_ylim(-0.05, 1.05)
- ax.set_title(title, fontsize=12)
- ax.set_xticks([])
- ax.set_yticks([])
-
- if isinstance(tiling_obj, SquareTiling):
- cell_size = 1.0 / width
- for cell in list(tiling_obj.cells.values())[:64]:
- x, y = cell.position_hint
- square = mpatches.Rectangle(
- (x - cell_size/2, y - cell_size/2),
- cell_size, cell_size,
- fill=True,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.8
- )
- ax.add_patch(square)
-
- elif isinstance(tiling_obj, HexTiling):
- hex_width_units = width * math.sqrt(3)
- hex_height_units = height * 1.5 + 0.5
- size = min(1.0 / hex_width_units, 1.0 / hex_height_units)
-
- for cell in list(tiling_obj.cells.values())[:64]:
- x, y = cell.position_hint
- hexagon = RegularPolygon(
- (x, y),
- numVertices=6,
- radius=size * 0.98,
- orientation=math.pi / 2,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.8
- )
- ax.add_patch(hexagon)
-
- elif isinstance(tiling_obj, TriangleTiling):
- cell_size = 1.0 / width
- for cell in list(tiling_obj.cells.values())[:64]:
- x, y = cell.position_hint
- pointing_up = (cell.row + cell.col) % 2 == 0
-
- if pointing_up:
- vertices = [
- (x, y - cell_size * 0.4),
- (x - cell_size * 0.4, y + cell_size * 0.2),
- (x + cell_size * 0.4, y + cell_size * 0.2)
- ]
- else:
- vertices = [
- (x, y + cell_size * 0.4),
- (x - cell_size * 0.4, y - cell_size * 0.2),
- (x + cell_size * 0.4, y - cell_size * 0.2)
- ]
-
- triangle = Polygon(
- vertices,
- fill=True,
- facecolor='lightblue',
- edgecolor='darkblue',
- linewidth=0.8
- )
- ax.add_patch(triangle)
-
- plt.tight_layout()
- plt.savefig('tiling_comparison.png', dpi=150, bbox_inches='tight')
- print("Saved tiling_comparison.png")
- plt.close()
-
-
-if __name__ == "__main__":
- print("Generating proper grid visualizations...")
- print("=" * 50)
-
- visualize_square_grid(10, 10)
- visualize_hex_grid(10, 10)
- visualize_triangle_grid(10, 10)
- create_comparison()
-
- print("=" * 50)
- print("All visualizations created!")
- print("\nGenerated files:")
- print(" - square_grid_proper.png")
- print(" - hex_grid_proper.png")
- print(" - triangle_grid_proper.png")
- print(" - tiling_comparison.png")