Spaces:

openenv-community
/

optigami

Running

App Files Files Community

new-environment

by ianalin123 - opened 3 days ago

base: refs/heads/main

←

from: refs/pr/5

Discussion Files changed

+24718

-222

This view is limited to 50 files because it contains too many changes. See the raw diff here.

Files changed (50) hide show

.dockerignore +18 -0
.gitignore +2 -3
Dockerfile +27 -0
README.md +21 -67
build/asset-manifest.json +13 -0
build/favicon.ico +0 -0
build/index.html +1 -0
build/logo192.png +0 -0
build/logo512.png +0 -0
build/manifest.json +25 -0
build/robots.txt +3 -0
build/static/css/main.edb517bf.css +2 -0
build/static/css/main.edb517bf.css.map +1 -0
build/static/js/main.7e6cf91b.js +0 -0
build/static/js/main.7e6cf91b.js.LICENSE.txt +49 -0
build/static/js/main.7e6cf91b.js.map +0 -0
docs/optigami_handoff.md +767 -0
engine/fold_engine.py +42 -0
engine/metrics.py +127 -0
engine/paper.py +38 -1
engine/physics.py +260 -0
engine/validation.py +22 -0
env/__init__.py +0 -0
env/environment.py +243 -0
env/graph.py +117 -0
env/paper_state.py +150 -0
env/prompts.py +235 -0
env/rewards.py +93 -0
env/targets/__init__.py +0 -0
env/targets/accordion_3h.fold +67 -0
env/targets/accordion_4h.fold +79 -0
env/targets/diagonal_anti.fold +35 -0
env/targets/diagonal_main.fold +35 -0
env/targets/half_horizontal.fold +43 -0
env/targets/half_vertical.fold +43 -0
env/targets/thirds_h.fold +55 -0
env/targets/thirds_v.fold +55 -0
env/targets/validator.py +119 -0
env/targets/validator_check.py +19 -0
env/verifier.py +221 -0
openenv.yaml +6 -0
openenv_runtime/__init__.py +11 -0
openenv_runtime/environment.py +183 -0
openenv_runtime/models.py +63 -0
openenv_server/__init__.py +1 -0
openenv_server/app.py +150 -0
package-lock.json +0 -0
plans/implementation_plan.md +485 -0
pyproject.toml +20 -0
requirements.txt +5 -0

.dockerignore ADDED Viewed

	@@ -0,0 +1,18 @@

+.git
+.DS_Store
+__pycache__
+*.pyc
+*.pyo
+.pytest_cache
+.claude
+node_modules
+build
+research
+docs
+plans
+RESEARCH_NOTES.md
+trainer
+train.py
+sim
+viz
+planner

.gitignore CHANGED Viewed

@@ -8,9 +8,6 @@
 # testing
 /coverage
-# production
-/build
 # misc
 .DS_Store
 .env.local
@@ -28,3 +25,5 @@ __pycache__/
 # Reference repos (not pushed to HF)
 .reference/

 # testing
 /coverage
 # misc
 .DS_Store
 .env.local
 # Reference repos (not pushed to HF)
 .reference/
+*.pyc
+__pycache__/

Dockerfile ADDED Viewed

	@@ -0,0 +1,27 @@

+FROM node:20-alpine AS web-builder
+WORKDIR /web
+COPY package*.json ./
+RUN npm ci --no-audit --no-fund
+COPY public ./public
+COPY src ./src
+RUN npm run build
+FROM ghcr.io/meta-pytorch/openenv-base:latest
+WORKDIR /app
+# Install Python deps first for better layer caching
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt \
+    && pip install --no-cache-dir "openenv-core[core]>=0.2.1"
+# Copy application source
+COPY . /app
+# Overlay the compiled React frontend
+COPY --from=web-builder /web/build /app/build
+EXPOSE 8000
+CMD ["uvicorn", "openenv_server.app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md CHANGED Viewed

@@ -3,81 +3,35 @@ title: Optigami
 emoji: 🐠
 colorFrom: indigo
 colorTo: red
-sdk: static
 pinned: false
-app_build_command: npm run build
-app_file: build/index.html
 license: mit
-short_description: ':)'
 ---
-# Getting Started with Create React App
-This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
-## Available Scripts
-In the project directory, you can run:
-### `npm start`
-Runs the app in the development mode.\
-Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
-The page will reload when you make changes.\
-You may also see any lint errors in the console.
-### `npm test`
-Launches the test runner in the interactive watch mode.\
-See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
-### `npm run build`
-Builds the app for production to the `build` folder.\
-It correctly bundles React in production mode and optimizes the build for the best performance.
-The build is minified and the filenames include the hashes.\
-Your app is ready to be deployed!
-See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
-### `npm run eject`
-**Note: this is a one-way operation. Once you `eject`, you can't go back!**
-If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
-Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
-You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
-## Learn More
-You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
-To learn React, check out the [React documentation](https://reactjs.org/).
-### Code Splitting
-This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
-### Analyzing the Bundle Size
-This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
-### Making a Progressive Web App
-This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
-### Advanced Configuration
-This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
-### Deployment
-This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
-### `npm run build` fails to minify
-This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)

 emoji: 🐠
 colorFrom: indigo
 colorTo: red
+sdk: docker
 pinned: false
+app_port: 8000
 license: mit
+short_description: OpenEnv origami environment and demo
 ---
+# Optigami
+OpenEnv-compatible origami RL environment with:
+- environment + reward checks in `env/`
+- OpenEnv server adapter in `openenv_runtime/` and `openenv_server/`
+- Dockerized deployment for Hugging Face Spaces
+Entry point: `openenv_server.app:app`
+Manifest: `openenv.yaml`
+Container: `Dockerfile`
+## Local Run
+```bash
+uvicorn openenv_server.app:app --host 0.0.0.0 --port 8000
+```
+## Frontend (optional local React demo)
+```bash
+npm install
+npm start
+```
+This serves the dashboard against the FastAPI API.

build/asset-manifest.json ADDED Viewed

	@@ -0,0 +1,13 @@

+{
+  "files": {
+    "main.css": "/static/css/main.edb517bf.css",
+    "main.js": "/static/js/main.7e6cf91b.js",
+    "index.html": "/index.html",
+    "main.edb517bf.css.map": "/static/css/main.edb517bf.css.map",
+    "main.7e6cf91b.js.map": "/static/js/main.7e6cf91b.js.map"
+  },
+  "entrypoints": [
+    "static/css/main.edb517bf.css",
+    "static/js/main.7e6cf91b.js"
+  ]
+}

build/favicon.ico ADDED Viewed

build/index.html ADDED Viewed

	@@ -0,0 +1 @@

+ <!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>React App</title><script defer="defer" src="/static/js/main.7e6cf91b.js"></script><link href="/static/css/main.edb517bf.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

build/logo192.png ADDED Viewed

build/logo512.png ADDED Viewed

build/manifest.json ADDED Viewed

	@@ -0,0 +1,25 @@

+{
+  "short_name": "React App",
+  "name": "Create React App Sample",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
+      "type": "image/png",
+      "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+}

build/robots.txt ADDED Viewed

	@@ -0,0 +1,3 @@

+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Disallow:

build/static/css/main.edb517bf.css ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ @import url(https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&family=IBM+Plex+Mono:wght@300;400;500&display=swap);*,:after,:before{box-sizing:border-box;margin:0;padding:0}body{-webkit-font-smoothing:antialiased;background:#0d0d14;color:#f8fafc;font-family:IBM Plex Mono,monospace;font-size:13px;line-height:1.5;overflow-x:hidden}::-webkit-scrollbar{height:4px;width:4px}::-webkit-scrollbar-track{background:#0d0d14}::-webkit-scrollbar-thumb{background:#2a2a3a}::-webkit-scrollbar-thumb:hover{background:#3a3a5a}:root{--bg:#0d0d14;--surface:#13131d;--surface-2:#1a1a2e;--paper-white:#fafaf5;--paper-edge:#2a2a3a;--mountain:#f59e0b;--valley:#38bdf8;--target-ghost:#7c3aed33;--target-ghost-stroke:#7c3aed73;--validity:#22d3ee;--progress:#22c55e;--economy:#a78bfa;--text-primary:#f8fafc;--text-dim:#64748b;--border:#2a2a3a;--border-bright:#3a3a5a;--font-display:"JetBrains Mono",monospace;--font-mono:"IBM Plex Mono",monospace}.app{background:#0d0d14;background:var(--bg);display:flex;flex-direction:column;height:100vh;overflow:hidden}.app-header{align-items:center;background:#13131d;background:var(--surface);border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);display:flex;flex-shrink:0;gap:24px;height:48px;padding:0 20px;z-index:10}.app-title{color:#f8fafc;color:var(--text-primary);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:14px;font-weight:700;letter-spacing:.12em;white-space:nowrap}.app-title .title-accent{color:#f59e0b;color:var(--mountain)}.header-sep{background:#2a2a3a;background:var(--border);flex-shrink:0;height:24px;width:1px}.header-right{gap:16px;margin-left:auto}.api-status,.header-right{align-items:center;display:flex}.api-status{font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;gap:6px;letter-spacing:.08em}.api-status-dot{background:#64748b;background:var(--text-dim);border-radius:50%;height:6px;width:6px}.api-status-dot.ok{background:#22c55e;background:var(--progress);box-shadow:0 0 6px #22c55e;box-shadow:0 0 6px var(--progress)}.api-status-dot.err{background:#ef4444;box-shadow:0 0 6px #ef4444}.app-body{display:grid;flex:1 1;grid-template-columns:1fr 280px;overflow:hidden}.app-left{border-right:1px solid #2a2a3a;border-right:1px solid var(--border)}.app-left,.app-right{display:flex;flex-direction:column;overflow:hidden}.app-right{background:#13131d;background:var(--surface)}.canvas-row{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);display:flex;flex-shrink:0;gap:0;overflow-x:auto;padding:16px}.canvas-wrap{display:flex;flex:1 1;flex-direction:column;gap:8px;min-width:280px}.canvas-wrap+.canvas-wrap{margin-left:16px}.canvas-label{color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.14em;text-transform:uppercase}.canvas-svg{background:#fafaf5;background:var(--paper-white);display:block}.canvas-3d{background:linear-gradient(180deg,#1a1a2e,#0f101a);border:1px solid #2a2a3a;border:1px solid var(--border);display:block}.canvas-label-row{align-items:center;display:flex;gap:10px;justify-content:space-between}.fold-mode-toggle{background:#13131d;background:var(--surface);border:1px solid #2a2a3a;border:1px solid var(--border);display:inline-flex}.fold-mode-btn{background:#0000;border:none;color:#64748b;color:var(--text-dim);cursor:pointer;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:9px;letter-spacing:.08em;padding:3px 7px}.fold-mode-btn+.fold-mode-btn{border-left:1px solid #2a2a3a;border-left:1px solid var(--border)}.fold-mode-btn.active{background:#1f2538;color:#f8fafc;color:var(--text-primary)}.step-feed-section{display:flex;flex:1 1;flex-direction:column;overflow:hidden}.section-header{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.14em;padding:8px 16px;text-transform:uppercase}.step-feed{flex:1 1;overflow-y:auto;padding:4px 0}.step-entry{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);cursor:default;display:flex;flex-direction:column;gap:2px;padding:8px 16px;transition:background .1s}.step-entry:hover{background:#13131d;background:var(--surface)}.step-entry.active{background:#1a1a2e;background:var(--surface-2);border-left:2px solid #38bdf8;border-left:2px solid var(--valley);padding-left:14px}.step-entry-top{align-items:center;display:flex;gap:8px}.step-num{color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:700;width:24px}.step-instruction{color:#f8fafc;color:var(--text-primary);flex:1 1;font-size:12px}.assign-badge{flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:700;line-height:1.4;padding:1px 5px}.assign-badge.M{background:#f59e0b;background:var(--mountain);color:#0d0d14}.assign-badge.V{background:#38bdf8;background:var(--valley);color:#0d0d14}.assign-badge.B{background:#3a3a5a;background:var(--border-bright)}.assign-badge.B,.step-reward-delta{color:#64748b;color:var(--text-dim)}.step-reward-delta{font-size:11px;padding-left:32px}.step-reward-delta .delta-positive{color:#22c55e;color:var(--progress)}.step-reward-delta .delta-negative{color:#ef4444}.reward-panel{border-bottom:1px solid #2a2a3a;border-bottom:1px solid var(--border);flex-shrink:0;padding:12px 16px}.reward-row{align-items:center;display:flex;gap:8px;margin-bottom:6px}.reward-row:last-child{margin-bottom:0}.reward-label{color:#64748b;color:var(--text-dim);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:10px;font-weight:500;letter-spacing:.06em;text-transform:uppercase;width:72px}.reward-track{background:#0d0d14;background:var(--bg);border:1px solid #2a2a3a;border:1px solid var(--border);flex:1 1;height:8px;overflow:hidden}.reward-bar{height:100%;transition:width .4s ease}.reward-value{color:#f8fafc;color:var(--text-primary);flex-shrink:0;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;font-weight:500;text-align:right;width:36px}.reward-value.dim{color:#64748b;color:var(--text-dim)}.reward-divider{background:#2a2a3a;background:var(--border);height:1px;margin:6px 0}.info-badges{display:flex;flex-direction:column;gap:8px;padding:12px 16px}.info-row{align-items:center;display:flex;gap:8px;justify-content:space-between}.info-key{color:#64748b;color:var(--text-dim);font-size:10px;font-weight:500;letter-spacing:.06em;text-transform:uppercase}.info-key,.info-val{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}.info-val{color:#f8fafc;color:var(--text-primary);font-size:11px;font-weight:700}.info-val.bool-true{color:#22c55e;color:var(--progress)}.info-val.bool-false{color:#ef4444}.info-val.dim{color:#64748b;color:var(--text-dim)}.target-selector{align-items:center;display:flex;gap:8px}.target-selector-label{color:#64748b;color:var(--text-dim);font-size:10px;font-weight:500;letter-spacing:.1em;text-transform:uppercase;white-space:nowrap}.target-select,.target-selector-label{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}.target-select{background:#1a1a2e;background:var(--surface-2);border:1px solid #3a3a5a;border:1px solid var(--border-bright);color:#f8fafc;color:var(--text-primary);cursor:pointer;font-size:11px;min-width:180px;outline:none;padding:4px 8px}.target-select:focus{border-color:#38bdf8;border-color:var(--valley)}optgroup{background:#13131d;background:var(--surface);color:#64748b;color:var(--text-dim);font-size:10px}optgroup,option{font-family:JetBrains Mono,monospace;font-family:var(--font-display)}option{background:#1a1a2e;background:var(--surface-2);color:#f8fafc;color:var(--text-primary)}.player-controls{align-items:center;display:flex;flex-shrink:0;gap:6px}.ctrl-btn{background:#1a1a2e;background:var(--surface-2);border:1px solid #3a3a5a;border:1px solid var(--border-bright);color:#f8fafc;color:var(--text-primary);cursor:pointer;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;font-weight:500;letter-spacing:.04em;line-height:1.4;padding:4px 10px;transition:background .1s,border-color .1s;white-space:nowrap}.ctrl-btn:hover:not(:disabled){background:#13131d;background:var(--surface);border-color:#64748b;border-color:var(--text-dim)}.ctrl-btn:disabled{cursor:not-allowed;opacity:.35}.ctrl-btn.play{border-color:#38bdf8;border-color:var(--valley);color:#38bdf8;color:var(--valley)}.ctrl-btn.play:hover:not(:disabled){background:#38bdf81a}.ctrl-step-display{border:1px solid #2a2a3a;border:1px solid var(--border);color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;min-width:72px;padding:4px 8px;text-align:center;white-space:nowrap}.app-overlay,.ctrl-step-display{background:#0d0d14;background:var(--bg)}.app-overlay{inset:0;justify-content:center;position:fixed;z-index:100}.app-overlay,.overlay-message{align-items:center;display:flex}.overlay-message{color:#64748b;color:var(--text-dim);font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:13px;gap:12px;letter-spacing:.1em}.pulse-dot{animation:pulse 1.2s ease-in-out infinite;background:#38bdf8;background:var(--valley);border-radius:50%;height:8px;width:8px}@keyframes pulse{0%,to{opacity:.2;transform:scale(.8)}50%{opacity:1;transform:scale(1)}}.episode-loading{align-items:center;color:#64748b;color:var(--text-dim);display:flex;font-family:JetBrains Mono,monospace;font-family:var(--font-display);font-size:11px;gap:8px;justify-content:center;letter-spacing:.08em;padding:12px 16px}
2	+ /# sourceMappingURL=main.edb517bf.css.map/

build/static/css/main.edb517bf.css.map ADDED Viewed

	@@ -0,0 +1 @@

+ {"version":3,"file":"static/css/main.edb517bf.css","mappings":"6IAEA,iBACE,qBAAsB,CACtB,QAAS,CACT,SACF,CAEA,KAME,kCAAmC,CALnC,kBAAmB,CACnB,aAAc,CACd,mCAAuC,CACvC,cAAe,CACf,eAAgB,CAEhB,iBACF,CAEA,oBAEE,UAAW,CADX,SAEF,CAEA,0BACE,kBACF,CAEA,0BACE,kBACF,CAEA,gCACE,kBACF,CCjCA,MACE,YAAa,CACb,iBAAkB,CAClB,mBAAoB,CACpB,qBAAsB,CACtB,oBAAqB,CACrB,kBAAmB,CACnB,gBAAiB,CACjB,wBAAwC,CACxC,+BAA+C,CAC/C,kBAAmB,CACnB,kBAAmB,CACnB,iBAAkB,CAClB,sBAAuB,CACvB,kBAAmB,CACnB,gBAAiB,CACjB,uBAAwB,CACxB,yCAA2C,CAC3C,qCACF,CAEA,KAIE,kBAAqB,CAArB,oBAAqB,CAHrB,YAAa,CACb,qBAAsB,CACtB,YAAa,CAEb,eACF,CAGA,YAEE,kBAAmB,CAKnB,kBAA0B,CAA1B,yBAA0B,CAD1B,+BAAsC,CAAtC,qCAAsC,CALtC,YAAa,CAOb,aAAc,CALd,QAAS,CAET,WAAY,CADZ,cAAe,CAKf,UACF,CAEA,WAKE,aAA0B,CAA1B,yBAA0B,CAJ1B,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,kBACF,CAEA,yBACE,aAAsB,CAAtB,qBACF,CAEA,YAGE,kBAAyB,CAAzB,wBAAyB,CACzB,aAAc,CAFd,WAAY,CADZ,SAIF,CAEA,cAGE,QAAS,CACT,gBACF,CAEA,0BALE,kBAAmB,CADnB,YAaF,CAPA,YAEE,oCAAgC,CAAhC,+BAAgC,CADhC,cAAe,CAKf,OAAQ,CAHR,oBAIF,CAEA,gBAIE,kBAA2B,CAA3B,0BAA2B,CAD3B,iBAAkB,CADlB,UAAW,CADX,SAIF,CAEA,mBACE,kBAA2B,CAA3B,0BAA2B,CAC3B,0BAAmC,CAAnC,kCACF,CAEA,oBACE,kBAAmB,CACnB,0BACF,CAGA,UACE,YAAa,CAEb,QAAO,CADP,+BAAgC,CAEhC,eACF,CAEA,UAIE,8BAAqC,CAArC,oCACF,CAEA,qBANE,YAAa,CACb,qBAAsB,CACtB,eASF,CALA,WAIE,kBAA0B,CAA1B,yBACF,CAGA,YAKE,+BAAsC,CAAtC,qCAAsC,CAJtC,YAAa,CAGb,aAAc,CAFd,KAAM,CAIN,eAAgB,CAHhB,YAIF,CAEA,aACE,YAAa,CAGb,QAAO,CAFP,qBAAsB,CACtB,OAAQ,CAER,eACF,CAEA,0BACE,gBACF,CAEA,cAKE,aAAsB,CAAtB,qBAAsB,CAJtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,wBACF,CAEA,YAEE,kBAA8B,CAA9B,6BAA8B,CAD9B,aAEF,CAEA,WAEE,kDAA6D,CAC7D,wBAA+B,CAA/B,8BAA+B,CAF/B,aAGF,CAEA,kBAEE,kBAAmB,CADnB,YAAa,CAGb,QAAS,CADT,6BAEF,CAEA,kBAGE,kBAA0B,CAA1B,yBAA0B,CAD1B,wBAA+B,CAA/B,8BAA+B,CAD/B,mBAGF,CAEA,eAEE,gBAAuB,CADvB,WAAY,CAEZ,aAAsB,CAAtB,qBAAsB,CAKtB,cAAe,CAJf,oCAAgC,CAAhC,+BAAgC,CAChC,aAAc,CACd,oBAAsB,CACtB,eAEF,CAEA,8BACE,6BAAoC,CAApC,mCACF,CAEA,sBAEE,kBAAmB,CADnB,aAA0B,CAA1B,yBAEF,CAGA,mBAEE,YAAa,CADb,QAAO,CAEP,qBAAsB,CACtB,eACF,CAEA,gBAQE,+BAAsC,CAAtC,qCAAsC,CAHtC,aAAsB,CAAtB,qBAAsB,CAItB,aAAc,CARd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAGtB,gBAAiB,CADjB,wBAIF,CAEA,WAEE,QAAO,CADP,eAAgB,CAEhB,aACF,CAEA,YAKE,+BAAsC,CAAtC,qCAAsC,CACtC,cAAe,CALf,YAAa,CACb,qBAAsB,CACtB,OAAQ,CACR,gBAAiB,CAGjB,yBACF,CAEA,kBACE,kBAA0B,CAA1B,yBACF,CAEA,mBACE,kBAA4B,CAA5B,2BAA4B,CAC5B,6BAAoC,CAApC,mCAAoC,CACpC,iBACF,CAEA,gBAEE,kBAAmB,CADnB,YAAa,CAEb,OACF,CAEA,UAIE,aAAsB,CAAtB,qBAAsB,CAEtB,aAAc,CALd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAEhB,UAEF,CAEA,kBAEE,aAA0B,CAA1B,yBAA0B,CAC1B,QAAO,CAFP,cAGF,CAEA,cAME,aAAc,CALd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAEhB,eAAgB,CADhB,eAGF,CAEA,gBACE,kBAA2B,CAA3B,0BAA2B,CAC3B,aACF,CAEA,gBACE,kBAAyB,CAAzB,wBAAyB,CACzB,aACF,CAEA,gBACE,kBAAgC,CAAhC,+BAEF,CAEA,mCAHE,aAAsB,CAAtB,qBAOF,CAJA,mBACE,cAAe,CAEf,iBACF,CAEA,mCACE,aAAsB,CAAtB,qBACF,CAEA,mCACE,aACF,CAGA,cAEE,+BAAsC,CAAtC,qCAAsC,CACtC,aAAc,CAFd,iBAGF,CAEA,YAEE,kBAAmB,CADnB,YAAa,CAEb,OAAQ,CACR,iBACF,CAEA,uBACE,eACF,CAEA,cAKE,aAAsB,CAAtB,qBAAsB,CAEtB,aAAc,CANd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAItB,wBAAyB,CAFzB,UAGF,CAEA,cAGE,kBAAqB,CAArB,oBAAqB,CACrB,wBAA+B,CAA/B,8BAA+B,CAH/B,QAAO,CACP,UAAW,CAGX,eACF,CAEA,YACE,WAAY,CACZ,yBACF,CAEA,cAIE,aAA0B,CAA1B,yBAA0B,CAG1B,aAAc,CANd,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAGhB,gBAAiB,CADjB,UAGF,CAEA,kBACE,aAAsB,CAAtB,qBACF,CAEA,gBAEE,kBAAyB,CAAzB,wBAAyB,CADzB,UAAW,CAEX,YACF,CAGA,aAEE,YAAa,CACb,qBAAsB,CACtB,OAAQ,CAHR,iBAIF,CAEA,UAEE,kBAAmB,CADnB,YAAa,CAGb,OAAQ,CADR,6BAEF,CAEA,UAKE,aAAsB,CAAtB,qBAAsB,CAHtB,cAAe,CACf,eAAgB,CAChB,oBAAsB,CAEtB,wBACF,CAEA,oBARE,oCAAgC,CAAhC,+BAaF,CALA,UAIE,aAA0B,CAA1B,yBAA0B,CAF1B,cAAe,CACf,eAEF,CAEA,oBACE,aAAsB,CAAtB,qBACF,CAEA,qBACE,aACF,CAEA,cACE,aAAsB,CAAtB,qBACF,CAGA,iBAEE,kBAAmB,CADnB,YAAa,CAEb,OACF,CAEA,uBAKE,aAAsB,CAAtB,qBAAsB,CAHtB,cAAe,CACf,eAAgB,CAChB,mBAAsB,CAEtB,wBAAyB,CACzB,kBACF,CAEA,sCATE,oCAAgC,CAAhC,+BAmBF,CAVA,eACE,kBAA4B,CAA5B,2BAA4B,CAC5B,wBAAsC,CAAtC,qCAAsC,CACtC,aAA0B,CAA1B,yBAA0B,CAK1B,cAAe,CAHf,cAAe,CAIf,eAAgB,CAFhB,YAAa,CADb,eAIF,CAEA,qBACE,oBAA2B,CAA3B,0BACF,CAEA,SACE,kBAA0B,CAA1B,yBAA0B,CAC1B,aAAsB,CAAtB,qBAAsB,CAEtB,cACF,CAEA,gBAJE,oCAAgC,CAAhC,+BAQF,CAJA,OACE,kBAA4B,CAA5B,2BAA4B,CAC5B,aAA0B,CAA1B,yBAEF,CAGA,iBAEE,kBAAmB,CADnB,YAAa,CAGb,aAAc,CADd,OAEF,CAEA,UACE,kBAA4B,CAA5B,2BAA4B,CAC5B,wBAAsC,CAAtC,qCAAsC,CACtC,aAA0B,CAA1B,yBAA0B,CAK1B,cAAe,CAJf,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CACf,eAAgB,CAKhB,oBAAsB,CADtB,eAAgB,CAHhB,gBAAiB,CAKjB,0CAA8C,CAH9C,kBAIF,CAEA,+BACE,kBAA0B,CAA1B,yBAA0B,CAC1B,oBAA6B,CAA7B,4BACF,CAEA,mBAEE,kBAAmB,CADnB,WAEF,CAEA,eACE,oBAA2B,CAA3B,0BAA2B,CAC3B,aAAoB,CAApB,mBACF,CAEA,oCACE,oBACF,CAEA,mBAKE,wBAA+B,CAA/B,8BAA+B,CAF/B,aAAsB,CAAtB,qBAAsB,CAFtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAMf,cAAe,CAJf,eAAgB,CAKhB,iBAAkB,CAFlB,kBAGF,CAGA,gCAPE,kBAAqB,CAArB,oBAeF,CARA,aAEE,OAAQ,CAGR,sBAAuB,CAJvB,cAAe,CAMf,WACF,CAEA,8BANE,kBAAmB,CADnB,YAeF,CARA,iBAIE,aAAsB,CAAtB,qBAAsB,CAHtB,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAKf,QAAS,CAJT,mBAKF,CAEA,WAKE,yCAA0C,CAD1C,kBAAyB,CAAzB,wBAAyB,CADzB,iBAAkB,CADlB,UAAW,CADX,SAKF,CAEA,iBACE,MAAW,UAAY,CAAE,mBAAuB,CAChD,IAAM,SAAU,CAAE,kBAAqB,CACzC,CAGA,iBAEE,kBAAmB,CAMnB,aAAsB,CAAtB,qBAAsB,CAPtB,YAAa,CAKb,oCAAgC,CAAhC,+BAAgC,CAChC,cAAe,CAHf,OAAQ,CADR,sBAAuB,CAMvB,oBAAsB,CAJtB,iBAKF","sources":["index.css","App.css"],"sourcesContent":["@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;700&family=IBM+Plex+Mono:wght@300;400;500&display=swap');\n\n*, *::before, *::after {\n box-sizing: border-box;\n margin: 0;\n padding: 0;\n}\n\nbody {\n background: #0d0d14;\n color: #f8fafc;\n font-family: 'IBM Plex Mono', monospace;\n font-size: 13px;\n line-height: 1.5;\n -webkit-font-smoothing: antialiased;\n overflow-x: hidden;\n}\n\n::-webkit-scrollbar {\n width: 4px;\n height: 4px;\n}\n\n::-webkit-scrollbar-track {\n background: #0d0d14;\n}\n\n::-webkit-scrollbar-thumb {\n background: #2a2a3a;\n}\n\n::-webkit-scrollbar-thumb:hover {\n background: #3a3a5a;\n}\n",":root {\n --bg: #0d0d14;\n --surface: #13131d;\n --surface-2: #1a1a2e;\n --paper-white: #fafaf5;\n --paper-edge: #2a2a3a;\n --mountain: #f59e0b;\n --valley: #38bdf8;\n --target-ghost: rgba(124, 58, 237, 0.20);\n --target-ghost-stroke: rgba(124, 58, 237, 0.45);\n --validity: #22d3ee;\n --progress: #22c55e;\n --economy: #a78bfa;\n --text-primary: #f8fafc;\n --text-dim: #64748b;\n --border: #2a2a3a;\n --border-bright: #3a3a5a;\n --font-display: 'JetBrains Mono', monospace;\n --font-mono: 'IBM Plex Mono', monospace;\n}\n\n.app {\n display: flex;\n flex-direction: column;\n height: 100vh;\n background: var(--bg);\n overflow: hidden;\n}\n\n/* ─── HEADER ─── */\n.app-header {\n display: flex;\n align-items: center;\n gap: 24px;\n padding: 0 20px;\n height: 48px;\n border-bottom: 1px solid var(--border);\n background: var(--surface);\n flex-shrink: 0;\n z-index: 10;\n}\n\n.app-title {\n font-family: var(--font-display);\n font-size: 14px;\n font-weight: 700;\n letter-spacing: 0.12em;\n color: var(--text-primary);\n white-space: nowrap;\n}\n\n.app-title .title-accent {\n color: var(--mountain);\n}\n\n.header-sep {\n width: 1px;\n height: 24px;\n background: var(--border);\n flex-shrink: 0;\n}\n\n.header-right {\n display: flex;\n align-items: center;\n gap: 16px;\n margin-left: auto;\n}\n\n.api-status {\n font-size: 11px;\n font-family: var(--font-display);\n letter-spacing: 0.08em;\n display: flex;\n align-items: center;\n gap: 6px;\n}\n\n.api-status-dot {\n width: 6px;\n height: 6px;\n border-radius: 50%;\n background: var(--text-dim);\n}\n\n.api-status-dot.ok {\n background: var(--progress);\n box-shadow: 0 0 6px var(--progress);\n}\n\n.api-status-dot.err {\n background: #ef4444;\n box-shadow: 0 0 6px #ef4444;\n}\n\n/* ─── MAIN LAYOUT ─── */\n.app-body {\n display: grid;\n grid-template-columns: 1fr 280px;\n flex: 1;\n overflow: hidden;\n}\n\n.app-left {\n display: flex;\n flex-direction: column;\n overflow: hidden;\n border-right: 1px solid var(--border);\n}\n\n.app-right {\n display: flex;\n flex-direction: column;\n overflow: hidden;\n background: var(--surface);\n}\n\n/* ─── CANVAS ROW ─── */\n.canvas-row {\n display: flex;\n gap: 0;\n padding: 16px;\n flex-shrink: 0;\n border-bottom: 1px solid var(--border);\n overflow-x: auto;\n}\n\n.canvas-wrap {\n display: flex;\n flex-direction: column;\n gap: 8px;\n flex: 1;\n min-width: 280px;\n}\n\n.canvas-wrap + .canvas-wrap {\n margin-left: 16px;\n}\n\n.canvas-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.14em;\n color: var(--text-dim);\n text-transform: uppercase;\n}\n\n.canvas-svg {\n display: block;\n background: var(--paper-white);\n}\n\n.canvas-3d {\n display: block;\n background: linear-gradient(180deg, #1a1a2e 0%, #0f101a 100%);\n border: 1px solid var(--border);\n}\n\n.canvas-label-row {\n display: flex;\n align-items: center;\n justify-content: space-between;\n gap: 10px;\n}\n\n.fold-mode-toggle {\n display: inline-flex;\n border: 1px solid var(--border);\n background: var(--surface);\n}\n\n.fold-mode-btn {\n border: none;\n background: transparent;\n color: var(--text-dim);\n font-family: var(--font-display);\n font-size: 9px;\n letter-spacing: 0.08em;\n padding: 3px 7px;\n cursor: pointer;\n}\n\n.fold-mode-btn + .fold-mode-btn {\n border-left: 1px solid var(--border);\n}\n\n.fold-mode-btn.active {\n color: var(--text-primary);\n background: #1f2538;\n}\n\n/* ─── STEP FEED ─── */\n.step-feed-section {\n flex: 1;\n display: flex;\n flex-direction: column;\n overflow: hidden;\n}\n\n.section-header {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.14em;\n color: var(--text-dim);\n text-transform: uppercase;\n padding: 8px 16px;\n border-bottom: 1px solid var(--border);\n flex-shrink: 0;\n}\n\n.step-feed {\n overflow-y: auto;\n flex: 1;\n padding: 4px 0;\n}\n\n.step-entry {\n display: flex;\n flex-direction: column;\n gap: 2px;\n padding: 8px 16px;\n border-bottom: 1px solid var(--border);\n cursor: default;\n transition: background 0.1s;\n}\n\n.step-entry:hover {\n background: var(--surface);\n}\n\n.step-entry.active {\n background: var(--surface-2);\n border-left: 2px solid var(--valley);\n padding-left: 14px;\n}\n\n.step-entry-top {\n display: flex;\n align-items: center;\n gap: 8px;\n}\n\n.step-num {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 700;\n color: var(--text-dim);\n width: 24px;\n flex-shrink: 0;\n}\n\n.step-instruction {\n font-size: 12px;\n color: var(--text-primary);\n flex: 1;\n}\n\n.assign-badge {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 700;\n padding: 1px 5px;\n line-height: 1.4;\n flex-shrink: 0;\n}\n\n.assign-badge.M {\n background: var(--mountain);\n color: #0d0d14;\n}\n\n.assign-badge.V {\n background: var(--valley);\n color: #0d0d14;\n}\n\n.assign-badge.B {\n background: var(--border-bright);\n color: var(--text-dim);\n}\n\n.step-reward-delta {\n font-size: 11px;\n color: var(--text-dim);\n padding-left: 32px;\n}\n\n.step-reward-delta .delta-positive {\n color: var(--progress);\n}\n\n.step-reward-delta .delta-negative {\n color: #ef4444;\n}\n\n/* ─── REWARD PANEL ─── */\n.reward-panel {\n padding: 12px 16px;\n border-bottom: 1px solid var(--border);\n flex-shrink: 0;\n}\n\n.reward-row {\n display: flex;\n align-items: center;\n gap: 8px;\n margin-bottom: 6px;\n}\n\n.reward-row:last-child {\n margin-bottom: 0;\n}\n\n.reward-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.06em;\n color: var(--text-dim);\n width: 72px;\n flex-shrink: 0;\n text-transform: uppercase;\n}\n\n.reward-track {\n flex: 1;\n height: 8px;\n background: var(--bg);\n border: 1px solid var(--border);\n overflow: hidden;\n}\n\n.reward-bar {\n height: 100%;\n transition: width 0.4s ease;\n}\n\n.reward-value {\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 500;\n color: var(--text-primary);\n width: 36px;\n text-align: right;\n flex-shrink: 0;\n}\n\n.reward-value.dim {\n color: var(--text-dim);\n}\n\n.reward-divider {\n height: 1px;\n background: var(--border);\n margin: 6px 0;\n}\n\n/* ─── INFO BADGES ─── */\n.info-badges {\n padding: 12px 16px;\n display: flex;\n flex-direction: column;\n gap: 8px;\n}\n\n.info-row {\n display: flex;\n align-items: center;\n justify-content: space-between;\n gap: 8px;\n}\n\n.info-key {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.06em;\n color: var(--text-dim);\n text-transform: uppercase;\n}\n\n.info-val {\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 700;\n color: var(--text-primary);\n}\n\n.info-val.bool-true {\n color: var(--progress);\n}\n\n.info-val.bool-false {\n color: #ef4444;\n}\n\n.info-val.dim {\n color: var(--text-dim);\n}\n\n/* ─── TARGET SELECTOR ─── */\n.target-selector {\n display: flex;\n align-items: center;\n gap: 8px;\n}\n\n.target-selector-label {\n font-family: var(--font-display);\n font-size: 10px;\n font-weight: 500;\n letter-spacing: 0.10em;\n color: var(--text-dim);\n text-transform: uppercase;\n white-space: nowrap;\n}\n\n.target-select {\n background: var(--surface-2);\n border: 1px solid var(--border-bright);\n color: var(--text-primary);\n font-family: var(--font-display);\n font-size: 11px;\n padding: 4px 8px;\n outline: none;\n cursor: pointer;\n min-width: 180px;\n}\n\n.target-select:focus {\n border-color: var(--valley);\n}\n\noptgroup {\n background: var(--surface);\n color: var(--text-dim);\n font-family: var(--font-display);\n font-size: 10px;\n}\n\noption {\n background: var(--surface-2);\n color: var(--text-primary);\n font-family: var(--font-display);\n}\n\n/* ─── PLAYER CONTROLS ─── */\n.player-controls {\n display: flex;\n align-items: center;\n gap: 6px;\n flex-shrink: 0;\n}\n\n.ctrl-btn {\n background: var(--surface-2);\n border: 1px solid var(--border-bright);\n color: var(--text-primary);\n font-family: var(--font-display);\n font-size: 11px;\n font-weight: 500;\n padding: 4px 10px;\n cursor: pointer;\n white-space: nowrap;\n line-height: 1.4;\n letter-spacing: 0.04em;\n transition: background 0.1s, border-color 0.1s;\n}\n\n.ctrl-btn:hover:not(:disabled) {\n background: var(--surface);\n border-color: var(--text-dim);\n}\n\n.ctrl-btn:disabled {\n opacity: 0.35;\n cursor: not-allowed;\n}\n\n.ctrl-btn.play {\n border-color: var(--valley);\n color: var(--valley);\n}\n\n.ctrl-btn.play:hover:not(:disabled) {\n background: rgba(56, 189, 248, 0.1);\n}\n\n.ctrl-step-display {\n font-family: var(--font-display);\n font-size: 11px;\n color: var(--text-dim);\n padding: 4px 8px;\n border: 1px solid var(--border);\n background: var(--bg);\n white-space: nowrap;\n min-width: 72px;\n text-align: center;\n}\n\n/* ─── LOADING / ERROR ─── */\n.app-overlay {\n position: fixed;\n inset: 0;\n display: flex;\n align-items: center;\n justify-content: center;\n background: var(--bg);\n z-index: 100;\n}\n\n.overlay-message {\n font-family: var(--font-display);\n font-size: 13px;\n letter-spacing: 0.1em;\n color: var(--text-dim);\n display: flex;\n align-items: center;\n gap: 12px;\n}\n\n.pulse-dot {\n width: 8px;\n height: 8px;\n border-radius: 50%;\n background: var(--valley);\n animation: pulse 1.2s ease-in-out infinite;\n}\n\n@keyframes pulse {\n 0%, 100% { opacity: 0.2; transform: scale(0.8); }\n 50% { opacity: 1; transform: scale(1); }\n}\n\n/* ─── MISC ─── */\n.episode-loading {\n display: flex;\n align-items: center;\n justify-content: center;\n gap: 8px;\n padding: 12px 16px;\n font-family: var(--font-display);\n font-size: 11px;\n color: var(--text-dim);\n letter-spacing: 0.08em;\n}\n"],"names":[],"sourceRoot":""}

build/static/js/main.7e6cf91b.js ADDED Viewed

The diff for this file is too large to render. See raw diff

build/static/js/main.7e6cf91b.js.LICENSE.txt ADDED Viewed

	@@ -0,0 +1,49 @@

+/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

build/static/js/main.7e6cf91b.js.map ADDED Viewed

The diff for this file is too large to render. See raw diff

docs/optigami_handoff.md ADDED Viewed

	@@ -0,0 +1,767 @@

+# OrigamiRL — OpenEnv Hackathon Handoff Document
+## TL;DR
+Build the **first multi-turn RL environment where an LLM learns to generate origami folding instructions**, verified by a computational origami simulator. Target the OpenEnv Hackathon (March 7-8, 2026, SF — $100K+ in prizes). Use OpenEnv spec + Unsloth GRPO for training. Dense verifiable rewards from origami geometry theorems (Kawasaki, Maekawa). No learned reward model needed.
+---
+## Hackathon Context
+- **Event:** OpenEnv Hackathon SF, hosted by Cerebral Valley + Shack15 + Meta/PyTorch
+- **Date:** March 7-8, 2026 (happening NOW)
+- **Prize:** $100K+ cash
+- **Teams:** Up to 4 people
+- **Format:** Build RL environments, post-train a base model
+### Judging Criteria
+| Category | Weight | What Matters |
+|----------|--------|-------------|
+| Environment Innovation | 40% | Novel, creative, challenging. Does it meaningfully test agent behavior? |
+| Storytelling | 30% | Clear problem explanation, engaging demo, easy to follow |
+| Training Script Showing Improvement | 20% | Observable reward curves, before/after behavior |
+| Reward and Training Pipeline Setup | 10% | Coherent reward logic, meaningful improvement in inference |
+### Key Sponsors to Impress
+- **Meta/PyTorch** — OpenEnv creators, want environments using their spec
+- **Unsloth AI** — GRPO training infra, ART (Agent Reinforcement Trainer). USE THEIR TOOLS.
+- **OpenPipe** — ART trainer (frontend/backend split for GRPO). Also use.
+- **Patronus AI** — Building "generative simulators" (auto-scaling RL environments). They care about curriculum difficulty scaling and verifiable rewards.
+- **Snorkel AI** — "2026 is the year of environments." They care about data quality and environment diversity.
+- **Hugging Face** — OpenEnv Hub, want environments deployed there
+- **Scale AI / Mercor** — Agent evaluation, structured task environments
+---
+## The Pitch (for judges)
+> "Spatial reasoning is the next frontier for LLM training — NeurIPS 2025 papers like OrigamiSpace showed that even GPT-5 fails at multi-step origami reasoning. But those are benchmarks, not training environments. We built OrigamiRL: the first multi-turn RL environment where an LLM agent learns to fold paper by outputting instructions, receiving geometric feedback, and improving through GRPO. Our reward function is fully verifiable — fold validity is checked against computational origami axioms, not an LLM judge. We built it on OpenEnv + Unsloth with a natural curriculum from single folds to full cranes."
+---
+## Prior Work (What Exists, Where the Gaps Are)
+### 1. OrigamiSpace (NeurIPS 2025 Spotlight)
+- **Paper:** https://arxiv.org/abs/2511.18450
+- **What it is:** Benchmark with 350 origami data instances (CP diagrams, folding processes, folded shapes). 4 evaluation tasks: Pattern Prediction, Multi-step Spatial Reasoning, Spatial Relationship Prediction, End-to-End CP Code Generation.
+- **Their compiler:** Outputs detailed flattened diagrams with crease locations and stacking relationships, supports interactive simulation with MLLMs, provides comprehensive error feedback. Checks: syntax validity, geometric foldability, no self-intersections, Kawasaki's theorem, Maekawa's theorem.
+- **Their reward metrics for code gen:** Hausdorff distance (shape similarity), dihedral angle distribution, bounding box aspect ratios, constraint satisfaction.
+- **Difficulty levels:** Easy (3-9 steps), Medium (10-19 steps), Hard (20-30 steps)
+- **Gap:** Single-turn only (LLM generates complete CP code in one shot). They mention RL exploration but it's not the focus. No multi-turn sequential folding.
+### 2. GamiBench (Dec 2025)
+- **Paper:** https://arxiv.org/abs/2512.22207
+- **What it is:** 186 regular + 186 impossible 2D crease patterns with 3D folded shapes from 6 viewpoints. 3 VQA tasks.
+- **Gap:** Evaluation-only, no training. Tests single-step spatial understanding.
+### 3. SpatialThinker (NeurIPS 2025)
+- **Paper:** https://arxiv.org/abs/2511.07403
+- **What it is:** 3D-aware MLLM trained with RL using dense spatial rewards. Constructs scene graphs. Multi-objective reward with lexicographic gating.
+- **Key architecture to steal:** Dense reward design with lexicographic ordering — format → count → accuracy → spatial. Nearly doubled RL training gains vs sparse rewards. Only needed 7K training samples with GRPO.
+- **Gap:** Static scene understanding (objects on a table), not sequential physical transformations.
+### 4. rigid-origami Gym (IJCAI 2023)
+- **Repo:** https://github.com/belalugaX/rigid-origami
+- **Paper:** "Automating Rigid Origami Design" (https://arxiv.org/abs/2211.13219)
+- **What it is:** Gym environment where agent constructs crease pattern graphs on a board. Sparse rewards. Foldability validated by triangle intersection tests + kinematic rigidity model. Game terminates on non-foldable states.
+- **Gap:** Classical RL agents (discrete grid actions), NOT LLMs generating text. Rigid-origami tessellations only, not traditional origami. No natural language.
+### 5. The Unique Gap We Fill
+Nobody has built a model that reasons about **sequential 2D-to-3D geometric transformations with physical constraints** through **natural language instructions** in a **multi-turn RL training loop**. Origami is uniquely hard because it requires tracking how a flat sheet's topology changes through a sequence of folds — mental rotation, spatial visualization, and perspective-taking all at once.
+---
+## Environment Design
+### Architecture Overview
+```
++---------------------------------------------------+
+|                   OpenEnv Server                   |
+|  +-----------+  +----------+  +--------------+    |
+|  |   State   |  |  Action  |  |   Reward     |    |
+|  | (FOLD JSON|  | (LLM     |  | (Dense,      |    |
+|  |  + target)|  |  output) |  |  verifiable) |    |
+|  +-----------+  +----------+  +--------------+    |
+|         |              |              |            |
+|         v              v              v            |
+|  +-----------------------------------------------+|
+|  |         Paper Geometry Engine (Python)         ||
+|  |  - Polygon state (Shapely)                    ||
+|  |  - Fold operations (reflection across line)   ||
+|  |  - Kawasaki/Maekawa constraint checks         ||
+|  |  - Layer tracking                             ||
+|  |  - FOLD format import/export                  ||
+|  +-----------------------------------------------+|
+|         |                                          |
+|         v                                          |
+|  +-----------------------------------------------+|
+|  |         Three.js Visualizer (Demo only)        ||
+|  |  - 3D fold animation                          ||
+|  |  - Strain heatmap                             ||
+|  |  - Instruction stream                         ||
+|  +-----------------------------------------------+|
++---------------------------------------------------+
+         |                    ^
+         v                    |
++---------------------------------------------------+
+|              Unsloth ART / GRPO Trainer            |
+|  - Qwen2.5-VL-7B or Qwen3-4B base model          |
+|  - LoRA/QLoRA for efficient training              |
+|  - Multi-turn rollouts                            |
++---------------------------------------------------+
+```
+### OpenEnv Spec Compliance
+Must implement these APIs:
+```python
+class OrigamiEnv:
+    async def reset() -> Observation     # New episode: flat paper + target
+    async def step(action) -> (Observation, reward, done, info)
+    async def state() -> State           # Current paper geometry
+    async def close()                    # Cleanup
+```
+OpenEnv repo: https://github.com/meta-pytorch/OpenEnv
+Install: `pip install -e .` then `openenv init origami_env`
+### State Space
+```python
+@dataclass
+class OrigamiState:
+    # Current paper geometry
+    vertices: List[Tuple[float, float]]       # 2D vertex positions
+    edges: List[Tuple[int, int]]              # Edge connectivity
+    edges_assignment: List[str]               # 'M', 'V', 'B', 'F' (mountain/valley/boundary/flat)
+    edges_foldAngle: List[float]              # -180 to 180 degrees
+    faces: List[List[int]]                    # Face vertex indices
+    layer_order: List[List[int]]              # Face stacking order
+    # Episode context
+    target_crease_pattern: dict               # Target FOLD JSON
+    target_shape_image: Optional[np.ndarray]  # Target folded shape (for multimodal)
+    instruction_history: List[str]            # Previous instructions
+    step_count: int
+    max_steps: int
+```
+This maps directly to the **FOLD format** (JSON-based, used by all origami software):
+```json
+{
+  "vertices_coords": [[0,0], [1,0], [1,1], [0,1]],
+  "edges_vertices": [[0,1], [1,2], [2,3], [3,0]],
+  "edges_assignment": ["B", "B", "B", "B"],
+  "edges_foldAngle": [0, 0, 0, 0],
+  "faces_vertices": [[0, 1, 2, 3]]
+}
+```
+FOLD spec: https://github.com/edemaine/fold
+FOLD JS library: https://edemaine.github.io/fold/
+### Action Space
+The LLM outputs a JSON action:
+```json
+{
+  "instruction": "Fold the top edge down to meet the bottom edge",
+  "fold_line": [[0, 0.5], [1, 0.5]],
+  "fold_angle": -180,
+  "assignment": "V"
+}
+```
+The `instruction` field is natural language (what we're training the model to produce well). The geometric fields are the verifiable representation. During training, the model outputs both; for the final demo, the NL instruction is the star.
+Alternative simpler action (for early iterations):
+```json
+{
+  "instruction": "Valley fold along the horizontal center line",
+  "fold_type": "valley",
+  "fold_axis": "horizontal",
+  "fold_position": 0.5
+}
+```
+### Reward Function — Dense, Multi-Objective, Lexicographically Gated
+Inspired by SpatialThinker's design. Rewards are computed in order; later rewards only apply if earlier gates pass.
+```python
+def compute_reward(state, action, new_state, target) -> dict:
+    rewards = {}
+    # LEVEL 1: Format (gate for everything else)
+    # Does the output parse into a valid fold operation?
+    rewards['format'] = 1.0 if parseable(action) else 0.0
+    if rewards['format'] == 0:
+        return rewards  # Stop here
+    # LEVEL 2: Local Geometric Validity
+    # Kawasaki's theorem: sector angles at each interior vertex sum to 2pi
+    kawasaki_valid = check_kawasaki(new_state)
+    # Maekawa's theorem: |M - V| = 2 at each interior vertex
+    maekawa_valid = check_maekawa(new_state)
+    # No self-intersection
+    no_intersection = check_no_self_intersection(new_state)
+    rewards['validity'] = (kawasaki_valid + maekawa_valid + no_intersection) / 3.0
+    if rewards['validity'] < 0.5:
+        return rewards  # Stop here
+    # LEVEL 3: Physical Feasibility
+    # Can this fold actually be performed given layer stack?
+    layer_consistent = check_layer_ordering(new_state)
+    fold_achievable = check_fold_angle_feasible(new_state)
+    rewards['feasibility'] = (layer_consistent + fold_achievable) / 2.0
+    # LEVEL 4: Progress Toward Target (Dense)
+    # Crease pattern graph similarity
+    cp_similarity = crease_pattern_similarity(new_state, target)
+    # Fold angle distribution match
+    angle_similarity = fold_angle_distribution_match(new_state, target)
+    # Bounding box aspect ratio match
+    bbox_similarity = bounding_box_similarity(new_state, target)
+    rewards['progress'] = 0.4 * cp_similarity + 0.4 * angle_similarity + 0.2 * bbox_similarity
+    # LEVEL 5: Completion Bonus
+    if shape_matches_target(new_state, target, tolerance=0.05):
+        rewards['completion'] = 10.0
+    # LEVEL 6: Efficiency
+    rewards['efficiency'] = -0.01  # Small step penalty to encourage fewer folds
+    # Total
+    rewards['total'] = (
+        0.1 * rewards['format'] +
+        0.2 * rewards['validity'] +
+        0.1 * rewards['feasibility'] +
+        0.5 * rewards['progress'] +
+        rewards.get('completion', 0) +
+        rewards['efficiency']
+    )
+    return rewards
+```
+### Key Origami Theorems for Verification
+These are the verifiable constraints — the "unit tests" of origami:
+1. **Kawasaki's Theorem:** At any interior vertex of a flat-foldable crease pattern, the alternating sum of sector angles equals zero (equivalently, they sum to 2pi on each side). NECESSARY condition for flat-foldability.
+2. **Maekawa's Theorem:** At any interior vertex, the number of mountain folds minus valley folds equals +/-2. |M - V| = 2.
+3. **No self-intersection:** Faces cannot penetrate each other during folding.
+4. **Euler's formula for planar graphs:** V - E + F = 2 (sanity check on graph structure).
+5. **Huzita-Hatori axioms:** The 7 axioms defining all possible single-fold operations (point-to-point, point-to-line, line-to-line, etc.). These define the VALID action space.
+### Curriculum Design
+| Level | Folds | Examples | Complexity |
+|-------|-------|----------|-----------|
+| 1 | 1 | Valley fold in half, mountain fold corner | Single fold validity |
+| 2 | 2-3 | Paper airplane nose, triangle fold | Sequential dependency |
+| 3 | 4-6 | Simple boat, fortune teller | Multi-step with symmetry |
+| 4 | 7-12 | Paper airplane (full), jumping frog | Longer horizon planning |
+| 5 | 13-20 | Crane, lily | Complex spatial tracking |
+For the hackathon, focus on Levels 1-3. Even showing reward improvement on Level 1-2 is a strong result.
+---
+## Core Implementation: Python Geometry Engine
+This is the MOST IMPORTANT piece. Pure Python, no JS dependencies.
+```python
+import numpy as np
+from shapely.geometry import Polygon, LineString, MultiPolygon
+from shapely.ops import split
+from typing import List, Tuple, Dict
+import json
+class PaperState:
+    """Represents the current state of the origami paper."""
+    def __init__(self, size: float = 1.0):
+        # Start with a unit square
+        self.regions = [Polygon([(0,0), (size,0), (size,size), (0,size)])]
+        self.fold_history = []
+        self.crease_lines = []
+        self.crease_assignments = []  # 'M' or 'V'
+        self.crease_angles = []
+        self.layer_order = [0]  # Stack order of regions
+    def apply_fold(self, fold_line: LineString, angle: float, assignment: str) -> dict:
+        """
+        Apply a fold operation. Returns dict with validity info.
+        fold_line: Shapely LineString defining the fold axis
+        angle: fold angle in degrees (-180 to 180)
+        assignment: 'M' (mountain) or 'V' (valley)
+        """
+        result = {'valid': True, 'errors': []}
+        # 1. Split regions by fold line
+        new_regions = []
+        for region in self.regions:
+            if fold_line.intersects(region):
+                parts = split(region, fold_line)
+                new_regions.extend(parts.geoms)
+            else:
+                new_regions.append(region)
+        # 2. Determine which side folds (based on assignment)
+        folding_side = []
+        staying_side = []
+        for region in new_regions:
+            centroid = region.centroid
+            side = self._point_side(centroid, fold_line)
+            if side > 0:
+                folding_side.append(region)
+            else:
+                staying_side.append(region)
+        # 3. Reflect folding regions across fold line
+        reflected = [self._reflect_polygon(r, fold_line) for r in folding_side]
+        # 4. Update state
+        self.regions = staying_side + reflected
+        self.crease_lines.append(fold_line)
+        self.crease_assignments.append(assignment)
+        self.crease_angles.append(angle)
+        self.fold_history.append({
+            'line': list(fold_line.coords),
+            'angle': angle,
+            'assignment': assignment
+        })
+        # 5. Update layer order
+        self._update_layer_order(staying_side, reflected)
+        return result
+    def _reflect_polygon(self, poly: Polygon, line: LineString) -> Polygon:
+        """Reflect a polygon across a line."""
+        coords = list(poly.exterior.coords)
+        reflected_coords = [self._reflect_point(p, line) for p in coords]
+        return Polygon(reflected_coords)
+    def _reflect_point(self, point: tuple, line: LineString) -> tuple:
+        """Reflect a point across a line."""
+        p = np.array(point[:2])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        d = l2 - l1
+        d = d / np.linalg.norm(d)
+        # Reflection formula: p' = p - 2(p-l1).n * n where n is normal to line
+        n = np.array([-d[1], d[0]])
+        v = p - l1
+        return tuple(p - 2 * np.dot(v, n) * n)
+    def _point_side(self, point, line: LineString) -> float:
+        """Returns positive if point is on left side of line, negative if right."""
+        p = np.array([point.x, point.y])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        return float(np.cross(l2 - l1, p - l1))
+    def _update_layer_order(self, staying, reflected):
+        """Update the layer stacking order after a fold."""
+        self.layer_order = list(range(len(staying))) + \
+                          list(range(len(staying), len(staying) + len(reflected)))
+    def to_fold_json(self) -> dict:
+        """Export current state as FOLD format JSON."""
+        vertices = set()
+        for line in self.crease_lines:
+            for coord in line.coords:
+                vertices.add(tuple(round(c, 10) for c in coord))
+        # Add boundary vertices
+        for region in self.regions:
+            for coord in region.exterior.coords:
+                vertices.add(tuple(round(c, 10) for c in coord[:2]))
+        vertices = sorted(list(vertices))
+        vertex_map = {v: i for i, v in enumerate(vertices)}
+        edge_set = set()
+        edges_list = []
+        assignments_list = []
+        angles_list = []
+        # Add crease edges
+        for i, line in enumerate(self.crease_lines):
+            c = [tuple(round(x, 10) for x in coord) for coord in line.coords]
+            edge = tuple(sorted([vertex_map[c[0]], vertex_map[c[1]]]))
+            if edge not in edge_set:
+                edge_set.add(edge)
+                edges_list.append(list(edge))
+                assignments_list.append(self.crease_assignments[i])
+                angles_list.append(self.crease_angles[i])
+        return {
+            'vertices_coords': [list(v) for v in vertices],
+            'edges_vertices': edges_list,
+            'edges_assignment': assignments_list,
+            'edges_foldAngle': angles_list,
+        }
+class OrigamiVerifier:
+    """Verifiable reward functions based on origami theorems."""
+    @staticmethod
+    def check_kawasaki(state: PaperState) -> bool:
+        """Kawasaki's theorem: alternating sum of angles at each interior vertex = 0."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+        for v_idx in range(len(vertices)):
+            v = vertices[v_idx]
+            incident_edges = [e for e in edges if v_idx in e]
+            if len(incident_edges) < 4:
+                continue  # Need degree-4+ for Kawasaki
+            # Calculate sector angles
+            angles = []
+            for e in incident_edges:
+                other = e[1] if e[0] == v_idx else e[0]
+                other_v = vertices[other]
+                angle = np.arctan2(other_v[1] - v[1], other_v[0] - v[0])
+                angles.append(angle)
+            angles.sort()
+            sector_angles = []
+            for i in range(len(angles) - 1):
+                sector_angles.append(angles[i+1] - angles[i])
+            sector_angles.append(2*np.pi - (angles[-1] - angles[0]))
+            # Kawasaki: alternating sum should be ~0
+            if len(sector_angles) >= 4:
+                alt_sum = sum(sector_angles[::2]) - sum(sector_angles[1::2])
+                if abs(alt_sum) > 0.01:
+                    return False
+        return True
+    @staticmethod
+    def check_maekawa(state: PaperState) -> bool:
+        """Maekawa's theorem: |M - V| = 2 at each interior vertex."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+        assignments = fold_json['edges_assignment']
+        for v_idx in range(len(vertices)):
+            incident = [(i, e) for i, e in enumerate(edges) if v_idx in e]
+            m_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'M')
+            v_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'V')
+            if m_count + v_count >= 4:  # Interior vertex with folds
+                if abs(m_count - v_count) != 2:
+                    return False
+        return True
+    @staticmethod
+    def crease_pattern_similarity(state: PaperState, target_fold_json: dict) -> float:
+        """Compare current crease pattern to target. Returns 0-1 similarity."""
+        current = state.to_fold_json()
+        n_current = len(current.get('edges_vertices', []))
+        n_target = len(target_fold_json.get('edges_vertices', []))
+        if n_target == 0:
+            return 1.0 if n_current == 0 else 0.0
+        edge_count_sim = 1.0 - abs(n_current - n_target) / max(n_target, 1)
+        edge_count_sim = max(0, edge_count_sim)
+        current_assignments = current.get('edges_assignment', [])
+        target_assignments = target_fold_json.get('edges_assignment', [])
+        c_m = current_assignments.count('M')
+        c_v = current_assignments.count('V')
+        t_m = target_assignments.count('M')
+        t_v = target_assignments.count('V')
+        total = max(t_m + t_v, 1)
+        assign_sim = 1.0 - (abs(c_m - t_m) + abs(c_v - t_v)) / (2 * total)
+        assign_sim = max(0, assign_sim)
+        return 0.5 * edge_count_sim + 0.5 * assign_sim
+```
+---
+## OpenEnv Environment Wrapper
+```python
+# origami_env/server.py
+from openenv.core import Environment
+from paper_engine import PaperState, OrigamiVerifier
+from shapely.geometry import LineString
+import json
+class OrigamiEnvironment(Environment):
+    def __init__(self, targets_dir="targets/", max_steps=20):
+        self.targets_dir = targets_dir
+        self.max_steps = max_steps
+        self.paper = None
+        self.target = None
+        self.step_count = 0
+    async def reset(self, target_id=None):
+        self.paper = PaperState(size=1.0)
+        self.target = self._load_target(target_id)
+        self.step_count = 0
+        return self._get_observation()
+    async def step(self, action):
+        self.step_count += 1
+        # Parse action
+        try:
+            fold_line = LineString(action['fold_line'])
+            angle = action['fold_angle']
+            assignment = action['assignment']
+        except (KeyError, Exception):
+            reward = {'format': 0, 'total': -0.1}
+            return self._get_observation(), reward, False, {'error': 'parse_failed'}
+        # Apply fold
+        result = self.paper.apply_fold(fold_line, angle, assignment)
+        # Compute rewards
+        reward = self._compute_reward(result)
+        # Check termination
+        done = (
+            self.step_count >= self.max_steps or
+            reward.get('completion', 0) > 0
+        )
+        return self._get_observation(), reward, done, {}
+    async def state(self):
+        return {
+            'paper': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'fold_history': self.paper.fold_history
+        }
+    def _compute_reward(self, fold_result):
+        rewards = {}
+        rewards['format'] = 1.0
+        kawasaki = OrigamiVerifier.check_kawasaki(self.paper)
+        maekawa = OrigamiVerifier.check_maekawa(self.paper)
+        rewards['validity'] = (float(kawasaki) + float(maekawa)) / 2.0
+        rewards['progress'] = OrigamiVerifier.crease_pattern_similarity(
+            self.paper, self.target
+        )
+        if rewards['progress'] > 0.95:
+            rewards['completion'] = 10.0
+        rewards['efficiency'] = -0.01
+        rewards['total'] = (
+            0.1 * rewards['format'] +
+            0.2 * rewards['validity'] +
+            0.6 * rewards['progress'] +
+            rewards.get('completion', 0) +
+            rewards['efficiency']
+        )
+        return rewards
+    def _get_observation(self):
+        return {
+            'paper_state': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'instruction_history': [str(f['line']) for f in self.paper.fold_history]
+        }
+    def _load_target(self, target_id):
+        if target_id:
+            with open(f"{self.targets_dir}/{target_id}.fold") as f:
+                return json.load(f)
+        # Default: simple valley fold in half
+        return {
+            'vertices_coords': [[0,0], [1,0], [1,1], [0,1], [0,0.5], [1,0.5]],
+            'edges_vertices': [[0,1], [1,2], [2,3], [3,0], [4,5]],
+            'edges_assignment': ['B', 'B', 'B', 'B', 'V'],
+            'edges_foldAngle': [0, 0, 0, 0, -180],
+        }
+```
+---
+## Training Script (Unsloth GRPO)
+```python
+# train.py
+from unsloth import FastLanguageModel
+from trl import GRPOConfig, GRPOTrainer
+import torch
+# Load model
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/Qwen2.5-7B-Instruct",
+    max_seq_length=4096,
+    load_in_4bit=True,
+)
+# Add LoRA
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=32,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                     "gate_proj", "up_proj", "down_proj"],
+    lora_alpha=32,
+    lora_dropout=0,
+    use_gradient_checkpointing="unsloth",
+)
+# Reward function
+def origami_reward(completions, prompts):
+    """Compute rewards for a batch of completions."""
+    rewards = []
+    for completion in completions:
+        try:
+            action = parse_fold_action(completion)
+            paper = PaperState()
+            result = paper.apply_fold(action['fold_line'], action['angle'], action['assignment'])
+            r = compute_reward(paper, target)
+            rewards.append(r['total'])
+        except Exception:
+            rewards.append(-0.1)
+    return rewards
+# GRPO Config
+config = GRPOConfig(
+    output_dir="origami-grpo",
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=5e-6,
+    max_completion_length=512,
+    num_generations=8,
+    temperature=1.0,
+    logging_steps=1,
+)
+dataset = load_origami_prompts()
+trainer = GRPOTrainer(
+    model=model,
+    config=config,
+    train_dataset=dataset,
+    reward_funcs=[origami_reward],
+    tokenizer=tokenizer,
+)
+trainer.train()
+```
+---
+## Visualization (Demo Only — Not in Training Loop)
+### Options
+1. **Origami Simulator** — https://github.com/amandaghassaei/OrigamiSimulator — Three.js, accepts FOLD files, shows folding animation with strain visualization
+2. **PackCAD** — https://packcad.com/ — Web-based, SVG crease patterns, rigid folding simulation
+3. **Custom Three.js** — Simpler but more control
+### Demo UI Layout
+```
++----------------------+----------------------+
+|   Instruction Stream |   3D Fold Viewer     |
+|                      |                      |
+| Step 1: Valley fold  |   [Three.js canvas]  |
+| along center [OK]    |                      |
+|                      |   Paper animating    |
+| Step 2: Fold top     |   fold by fold       |
+| corners to center    |                      |
+|                      |                      |
++----------------------+----------------------+
+|   Reward Dashboard                          |
+|   Format:   ========== 1.0                  |
+|   Validity: ========.. 0.8                  |
+|   Progress: ======.... 0.6                  |
+|   Total:    =======... 0.72                 |
+|                                              |
+|   [Reward curve over training steps]         |
++----------------------------------------------+
+```
+---
+## Key Libraries and Resources
+| Tool | Purpose | Link |
+|------|---------|------|
+| OpenEnv | Environment framework | https://github.com/meta-pytorch/OpenEnv |
+| Unsloth | GRPO training | https://github.com/unslothai/unsloth |
+| OpenPipe ART | Multi-turn RL trainer | https://github.com/OpenPipe/ART |
+| FOLD format | Origami data structure | https://github.com/edemaine/fold |
+| Rabbit Ear | JS origami library | https://github.com/rabbit-ear/rabbit-ear |
+| Origami Simulator | 3D visualization | https://github.com/amandaghassaei/OrigamiSimulator |
+| PackCAD | Folding simulation | https://packcad.com/ |
+| Shapely | Python geometry | pip install shapely |
+| rigid-origami gym | Reference gym env | https://github.com/belalugaX/rigid-origami |
+### Papers to Cite
+- OrigamiSpace: https://arxiv.org/abs/2511.18450
+- GamiBench: https://arxiv.org/abs/2512.22207
+- SpatialThinker: https://arxiv.org/abs/2511.07403
+- Automating Rigid Origami Design: https://arxiv.org/abs/2211.13219
+- FOLD format spec: https://github.com/edemaine/fold/blob/main/doc/spec.md
+---
+## Priority Build Order
+1. **Python geometry engine** — PaperState class with fold operations and FOLD export
+2. **Verifier functions** — Kawasaki, Maekawa, similarity metrics
+3. **OpenEnv wrapper** — step/reset/state API
+4. **Simple targets** — Hand-create 5-10 Level 1-2 targets as .fold files
+5. **Training script** — Wire up Unsloth GRPO with reward function
+6. **Run training** — Even on small model, get reward curves
+7. **Three.js visualizer** — For demo only, not in training loop
+8. **Before/after demo** — Show base model vs trained model outputs
+9. **Polish presentation narrative**
+---
+## Narrative for Judges
+**The story arc:**
+1. "LLMs are great at text but terrible at spatial reasoning"
+2. "Origami is the perfect testbed — it's sequential, physical, and verifiable"
+3. "NeurIPS 2025 showed even GPT-5 fails at origami benchmarks, but nobody built a TRAINING environment"
+4. "We built OrigamiRL — the first multi-turn RL environment for origami instruction generation"
+5. "Our rewards come from math theorems, not vibes — Kawasaki's theorem is our unit test"
+6. "Watch the model go from generating paper-tearing nonsense to valid fold sequences"
+7. "This generalizes to any domain where LLMs need to output structured physical instructions"

engine/fold_engine.py CHANGED Viewed

@@ -151,6 +151,8 @@ def apply_fold(
             elif face_sides[i] == "fixed" and face_sides[j] == "rotated":
                 new_paper.face_orders.append((j, i, 1))
     return new_paper, None
@@ -205,3 +207,43 @@ def execute_fold_strategy(
         applied.append(fold)
     return current, applied, None

             elif face_sides[i] == "fixed" and face_sides[j] == "rotated":
                 new_paper.face_orders.append((j, i, 1))
+    new_paper.fold_count += 1
     return new_paper, None
         applied.append(fold)
     return current, applied, None
+def apply_pleat(
+    paper: Paper,
+    line1: dict,
+    line2: dict,
+    angle: float = 180.0,
+) -> tuple[Paper, str | None]:
+    """Pleat fold: valley at line1, mountain at line2 (two parallel folds).
+    Both line dicts have the form: {"start": [x, y], "end": [x, y]}
+    Returns (new_paper, error_or_None).
+    """
+    paper, err = apply_fold(paper, {"type": "valley", "line": line1, "angle": angle})
+    if err:
+        return paper, f"Pleat valley fold failed: {err}"
+    paper, err = apply_fold(paper, {"type": "mountain", "line": line2, "angle": angle})
+    if err:
+        return paper, f"Pleat mountain fold failed: {err}"
+    return paper, None
+def apply_crimp(
+    paper: Paper,
+    line1: dict,
+    line2: dict,
+    angle: float = 180.0,
+) -> tuple[Paper, str | None]:
+    """Crimp fold: mountain at line1, valley at line2 (reverse of pleat).
+    Both line dicts have the form: {"start": [x, y], "end": [x, y]}
+    Returns (new_paper, error_or_None).
+    """
+    paper, err = apply_fold(paper, {"type": "mountain", "line": line1, "angle": angle})
+    if err:
+        return paper, f"Crimp mountain fold failed: {err}"
+    paper, err = apply_fold(paper, {"type": "valley", "line": line2, "angle": angle})
+    if err:
+        return paper, f"Crimp valley fold failed: {err}"
+    return paper, None

engine/metrics.py CHANGED Viewed

@@ -102,3 +102,130 @@ def compute_metrics(paper: Paper, original_paper: Paper | None = None) -> dict:
         "num_faces": len(paper.faces),
         "num_layers": paper.num_layers,
     }

         "num_faces": len(paper.faces),
         "num_layers": paper.num_layers,
     }
+def compute_all_metrics(paper, task: dict, validation: dict) -> dict:
+    """Compute every metric and return a flat dict.
+    Called after physics + validation. Combines validity, compactness,
+    structural, efficiency, and deployability metrics.
+    Parameters
+    ----------
+    paper : Paper
+        Current paper state (after simulate()).
+    task : dict
+        Task definition with keys: width, height, target_ratio, target_box, must_deploy.
+    validation : dict
+        Output of validate_state(paper).
+    """
+    import numpy as np
+    bb = paper.bounding_box  # (3,) array
+    original_area = paper.original_area if paper.original_area > 0 else (paper.material.thickness_mm / 1000.0)
+    t = paper.material.thickness_mm / 1000.0
+    original_bbox_vol = original_area * t
+    folded_bbox_vol = float(bb[0] * bb[1] * bb[2]) if bb[2] > 0 else float(bb[0] * bb[1] * t)
+    # ── Folded area (XY footprint) ────────────────────────────────
+    if len(paper.vertices) >= 3:
+        try:
+            from scipy.spatial import ConvexHull
+            hull = ConvexHull(paper.vertices[:, :2])
+            folded_area = float(hull.volume)
+        except Exception:
+            ptp = np.ptp(paper.vertices[:, :2], axis=0)
+            folded_area = float(ptp[0] * ptp[1])
+    else:
+        folded_area = original_area
+    deployment_ratio = folded_area / original_area if original_area > 0 else 1.0
+    compactness = 1.0 - deployment_ratio
+    volume_compaction = folded_bbox_vol / original_bbox_vol if original_bbox_vol > 0 else 1.0
+    material_volume = original_area * t
+    packing_efficiency = material_volume / folded_bbox_vol if folded_bbox_vol > 0 else 0.0
+    # ── Target box check ─────────────────────────────────────────
+    target_box = task.get("target_box")
+    fits_target_box = False
+    if target_box and len(target_box) == 3:
+        fits_target_box = bool(
+            bb[0] <= target_box[0] + 1e-6 and
+            bb[1] <= target_box[1] + 1e-6 and
+            bb[2] <= target_box[2] + 1e-6
+        )
+    # ── Strain ───────────────────────────────────────────────────
+    strain = paper.strain_per_vertex
+    max_strain = float(np.max(strain)) if len(strain) > 0 else 0.0
+    mean_strain = float(np.mean(strain)) if len(strain) > 0 else 0.0
+    # ── Energy ───────────────────────────────────────────────────
+    energy = paper.energy
+    # ── Efficiency ───────────────────────────────────────────────
+    fold_count = paper.fold_count
+    # Crease complexity: entropy of M/V assignment distribution
+    mv_assignments = [a for a in paper.assignments if a in ("M", "V")]
+    if mv_assignments:
+        total = len(mv_assignments)
+        m_count = mv_assignments.count("M")
+        v_count = mv_assignments.count("V")
+        p_m = m_count / total if total > 0 else 0
+        p_v = v_count / total if total > 0 else 0
+        crease_complexity = 0.0
+        if p_m > 0:
+            crease_complexity -= p_m * np.log2(p_m)
+        if p_v > 0:
+            crease_complexity -= p_v * np.log2(p_v)
+    else:
+        crease_complexity = 0.0
+    folding_efficiency = compactness / max(fold_count, 1)
+    # ── Deployability ─────────────────────────────────────────────
+    must_deploy = task.get("must_deploy", False)
+    # Simple deployability heuristic: if valid and compactness > 0, assume deployable
+    is_deployable = bool(validation.get("is_valid", False) and compactness > 0.01) if must_deploy else None
+    # Deployment force estimate from total energy gradient (rough)
+    deployment_force_estimate = float(energy.get("fold", 0.0)) / max(paper.original_area, 1e-6)
+    return {
+        # Validity (from validation dict)
+        "is_valid": validation.get("is_valid", False),
+        "kawasaki_violations": validation.get("kawasaki_violations", 0),
+        "kawasaki_total_error": validation.get("kawasaki_total_error", 0.0),
+        "maekawa_violations": validation.get("maekawa_violations", 0),
+        "self_intersections": validation.get("self_intersections", 0),
+        "strain_exceeded": validation.get("strain_exceeded", False),
+        # Compactness
+        "deployment_ratio": float(deployment_ratio),
+        "compactness": float(compactness),
+        "volume_compaction": float(volume_compaction),
+        "packing_efficiency": float(packing_efficiency),
+        "fits_target_box": fits_target_box,
+        "bounding_box": bb.tolist(),
+        # Structural
+        "max_strain": max_strain,
+        "mean_strain": mean_strain,
+        "total_energy": float(energy.get("total", 0.0)),
+        "energy_bar": float(energy.get("bar", 0.0)),
+        "energy_facet": float(energy.get("facet", 0.0)),
+        "energy_fold": float(energy.get("fold", 0.0)),
+        # Efficiency
+        "fold_count": fold_count,
+        "folding_efficiency": float(folding_efficiency),
+        "crease_complexity": float(crease_complexity),
+        # Deployability
+        "is_deployable": is_deployable,
+        "deployment_force_estimate": float(deployment_force_estimate),
+        # Shape similarity placeholders
+        "chamfer_distance": None,
+        "hausdorff_distance": None,
+    }

engine/paper.py CHANGED Viewed

@@ -89,6 +89,10 @@ class Paper:
     material: Material = field(default_factory=lambda: get_material("paper"))
     rest_lengths: np.ndarray = field(default_factory=lambda: np.empty(0))
     original_area: float = 0.0
     # ── constructors ────────────────────────────────────────────────
@@ -125,7 +129,7 @@ class Paper:
             dtype=np.float64,
         )
-        return Paper(
             vertices=verts,
             edges=edges,
             faces=faces,
@@ -135,6 +139,8 @@ class Paper:
             rest_lengths=rest_lengths,
             original_area=width * height,
         )
     # ── dict / prompt serialization (matches mock_env.PaperState.to_dict) ──
@@ -165,6 +171,33 @@ class Paper:
             },
         }
     # ── FOLD format serialization ───────────────────────────────────
     def to_fold_json(self) -> str:
@@ -485,4 +518,8 @@ class Paper:
             ),
             rest_lengths=self.rest_lengths.copy(),
             original_area=self.original_area,
         )

     material: Material = field(default_factory=lambda: get_material("paper"))
     rest_lengths: np.ndarray = field(default_factory=lambda: np.empty(0))
     original_area: float = 0.0
+    rest_positions: np.ndarray = field(default_factory=lambda: np.empty((0, 3)))
+    strain_per_vertex: np.ndarray = field(default_factory=lambda: np.empty(0))
+    energy: dict = field(default_factory=lambda: {"total": 0.0, "bar": 0.0, "facet": 0.0, "fold": 0.0})
+    fold_count: int = 0
     # ── constructors ────────────────────────────────────────────────
             dtype=np.float64,
         )
+        paper = Paper(
             vertices=verts,
             edges=edges,
             faces=faces,
             rest_lengths=rest_lengths,
             original_area=width * height,
         )
+        paper.rest_positions = verts.copy()
+        return paper
     # ── dict / prompt serialization (matches mock_env.PaperState.to_dict) ──
             },
         }
+    def to_observation_dict(self) -> dict:
+        bb = self.bounding_box
+        return {
+            "vertices_coords": self.vertices.tolist(),
+            "edges_vertices": self.edges.tolist(),
+            "faces_vertices": self.faces,
+            "edges_assignment": list(self.assignments),
+            "edges_foldAngle": self.fold_angles.tolist(),
+            "num_vertices": len(self.vertices),
+            "num_edges": len(self.edges),
+            "num_faces": len(self.faces),
+            "bounding_box": bb.tolist(),
+            "num_layers": self.num_layers,
+            "material": {
+                "name": self.material.name,
+                "thickness_mm": self.material.thickness_mm,
+                "youngs_modulus_gpa": self.material.youngs_modulus_gpa,
+                "max_strain": self.material.max_strain,
+                "poisson_ratio": self.material.poissons_ratio,
+            },
+            "strain_per_vertex": self.strain_per_vertex.tolist(),
+            "energy": dict(self.energy),
+            "fold_count": self.fold_count,
+            "width": float(self.original_area ** 0.5) if self.original_area > 0 else 1.0,
+            "height": float(self.original_area ** 0.5) if self.original_area > 0 else 1.0,
+        }
     # ── FOLD format serialization ───────────────────────────────────
     def to_fold_json(self) -> str:
             ),
             rest_lengths=self.rest_lengths.copy(),
             original_area=self.original_area,
+            rest_positions=self.rest_positions.copy(),
+            strain_per_vertex=self.strain_per_vertex.copy(),
+            energy=dict(self.energy),
+            fold_count=self.fold_count,
         )

engine/physics.py CHANGED Viewed

@@ -255,3 +255,263 @@ def _face_normal(verts: np.ndarray, face: list[int]) -> np.ndarray | None:
     if norm < 1e-15:
         return None
     return normal / norm

     if norm < 1e-15:
         return None
     return normal / norm
+# ────────────────────────────────────────────────────────────────────
+# Topology precomputation
+# ────────────────────────────────────────────────────────────────────
+def build_beam_list(paper: Paper) -> list[tuple[int, int, float, float]]:
+    """Build list of (node_a, node_b, rest_len, k_axial) for every edge.
+    Uses normalized stiffness values (arch doc constants) scaled by material
+    Young's modulus ratio — keeps the Verlet integrator stable at unit scale.
+    """
+    # Normalized stiffness constants (arch doc values)
+    K_AXIAL_BASE = 70.0
+    # Scale by material: paper (3 GPa) = 1.0 baseline
+    mat = paper.material
+    E_ratio = mat.youngs_modulus_gpa / 3.0
+    k_axial = K_AXIAL_BASE * E_ratio
+    beams = []
+    for ei, (v1, v2) in enumerate(paper.edges):
+        L0 = paper.rest_lengths[ei]
+        beams.append((int(v1), int(v2), float(L0), float(k_axial)))
+    return beams
+def build_crease_list(paper: Paper) -> list[tuple[int, int, int, int, float, float, str]]:
+    """Build list of (n1, n2, n3, n4, target_angle_rad, k, type) for each crease hinge.
+    Each hinge is defined by 4 nodes: n1-n2 is the hinge edge, n3 and n4 are
+    the wing-tip nodes of the two adjacent faces.
+    type is 'fold' (M/V crease) or 'facet' (interior flat edge).
+    """
+    verts = paper.vertices
+    # Build edge → face adjacency
+    edge_faces: dict[int, list[int]] = {}
+    for fi, face in enumerate(paper.faces):
+        n = len(face)
+        for k in range(n):
+            va, vb = face[k], face[(k + 1) % n]
+            for ei, e in enumerate(paper.edges):
+                if (e[0] == va and e[1] == vb) or (e[0] == vb and e[1] == va):
+                    edge_faces.setdefault(ei, []).append(fi)
+                    break
+    creases = []
+    for ei, adj in edge_faces.items():
+        if len(adj) < 2:
+            continue
+        f1, f2 = adj[0], adj[1]
+        face1, face2 = paper.faces[f1], paper.faces[f2]
+        n1, n2 = int(paper.edges[ei][0]), int(paper.edges[ei][1])
+        # Find wing-tip nodes (in each face, the vertex NOT on the shared edge)
+        wing1 = [v for v in face1 if v != n1 and v != n2]
+        wing2 = [v for v in face2 if v != n1 and v != n2]
+        if not wing1 or not wing2:
+            continue
+        n3, n4 = int(wing1[0]), int(wing2[0])
+        # Normalized stiffness constants (arch doc values), scaled by material
+        E_ratio = paper.material.youngs_modulus_gpa / 3.0
+        K_FACET = 0.2 * E_ratio
+        K_FOLD = 0.7 * E_ratio
+        asgn = paper.assignments[ei]
+        if asgn in ("M", "V"):
+            target = float(np.radians(paper.fold_angles[ei]))
+            k = K_FOLD
+            ctype = "fold"
+        else:
+            target = float(np.pi)
+            k = K_FACET
+            ctype = "facet"
+        creases.append((n1, n2, n3, n4, target, k, ctype))
+    return creases
+def _torque_to_forces(
+    p1: np.ndarray, p2: np.ndarray,
+    p3: np.ndarray, p4: np.ndarray,
+    torque: float,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Convert a dihedral torque into forces on the 4 hinge nodes.
+    p1-p2 is the hinge edge. p3 and p4 are wing tips.
+    Returns (f1, f2, f3, f4) as (3,) arrays.
+    """
+    e = p2 - p1
+    e_len = np.linalg.norm(e)
+    if e_len < 1e-12:
+        zero = np.zeros(3)
+        return zero, zero, zero, zero
+    e_hat = e / e_len
+    # Perpendicular components of wing vectors relative to hinge
+    d3 = p3 - p1
+    d4 = p4 - p1
+    d3_perp = d3 - np.dot(d3, e_hat) * e_hat
+    d4_perp = d4 - np.dot(d4, e_hat) * e_hat
+    len3 = np.linalg.norm(d3_perp)
+    len4 = np.linalg.norm(d4_perp)
+    if len3 < 1e-12 or len4 < 1e-12:
+        zero = np.zeros(3)
+        return zero, zero, zero, zero
+    # Force on wing tips proportional to torque / lever arm
+    f3 = torque / (len3 * e_len) * np.cross(e_hat, d3_perp / len3)
+    f4 = -torque / (len4 * e_len) * np.cross(e_hat, d4_perp / len4)
+    # Reaction forces distributed to hinge nodes
+    f1 = -(f3 + f4) * 0.5
+    f2 = -(f3 + f4) * 0.5
+    return f1, f2, f3, f4
+# ────────────────────────────────────────────────────────────────────
+# Verlet solver
+# ────────────────────────────────────────────────────────────────────
+def simulate(
+    paper: Paper,
+    fold_percent: float = 1.0,
+    n_steps: int = 500,
+    dt: float = 0.005,
+    damping: float = 0.15,
+) -> Paper:
+    """Run bar-and-hinge Verlet integration to relax the mesh.
+    Updates paper.vertices, paper.strain_per_vertex, and paper.energy in-place.
+    Returns the mutated paper for chaining.
+    Parameters
+    ----------
+    paper : Paper
+        Paper state after a fold has been applied (vertices already rotated).
+    fold_percent : float
+        How far along the fold to drive (0=flat, 1=full target angle).
+    n_steps : int
+        Maximum integration steps.
+    dt : float
+        Time step. Keep small (0.005) for stability with stiff materials.
+    damping : float
+        Velocity damping coefficient (0=undamped, 1=fully damped).
+    """
+    if len(paper.vertices) == 0:
+        return paper
+    beams = build_beam_list(paper)
+    creases = build_crease_list(paper)
+    pos = paper.vertices.copy()        # (N, 3) current positions
+    last_pos = pos.copy()              # (N, 3) previous positions (Verlet)
+    max_force_cap = 1e6  # prevent runaway forces
+    for _ in range(n_steps):
+        forces = np.zeros_like(pos)
+        # ── Beam (axial spring) forces ───────────────────────────────
+        for (a, b, L0, k) in beams:
+            delta = pos[b] - pos[a]
+            L = np.linalg.norm(delta)
+            if L < 1e-12:
+                continue
+            strain = (L - L0) / L0
+            F_mag = k * strain
+            F_vec = F_mag * (delta / L)
+            # Clamp to prevent instability
+            F_vec = np.clip(F_vec, -max_force_cap, max_force_cap)
+            forces[a] += F_vec
+            forces[b] -= F_vec
+        # ── Crease (dihedral spring) forces ─────────────────────────
+        for (n1, n2, n3, n4, target, k, ctype) in creases:
+            actual_target = target * fold_percent if ctype == "fold" else target
+            try:
+                theta = _compute_dihedral_rad(pos[n1], pos[n2], pos[n3], pos[n4])
+            except Exception:
+                continue
+            delta_theta = theta - actual_target
+            edge_len = np.linalg.norm(pos[n2] - pos[n1])
+            torque = k * edge_len * delta_theta
+            torque = float(np.clip(torque, -max_force_cap, max_force_cap))
+            f1, f2, f3, f4 = _torque_to_forces(
+                pos[n1], pos[n2], pos[n3], pos[n4], torque
+            )
+            forces[n1] += np.clip(f1, -max_force_cap, max_force_cap)
+            forces[n2] += np.clip(f2, -max_force_cap, max_force_cap)
+            forces[n3] += np.clip(f3, -max_force_cap, max_force_cap)
+            forces[n4] += np.clip(f4, -max_force_cap, max_force_cap)
+        # ── Verlet integration ───────────────────────────────────────
+        new_pos = pos + (1.0 - damping) * (pos - last_pos) + forces * (dt * dt)
+        # NaN guard
+        if np.any(np.isnan(new_pos)):
+            break
+        last_pos = pos
+        pos = new_pos
+        # ── Convergence check ────────────────────────────────────────
+        kinetic = np.sum((pos - last_pos) ** 2)
+        if kinetic < 1e-12:
+            break
+    # ── Write results back to paper ──────────────────────────────────
+    paper.vertices = pos
+    paper.strain_per_vertex = compute_strain(paper)
+    paper.energy = {
+        "total": compute_total_energy(paper),
+        "bar": compute_bar_energy(paper),
+        "facet": compute_facet_energy(paper),
+        "fold": compute_fold_energy(paper),
+    }
+    return paper
+def _compute_dihedral_rad(
+    p1: np.ndarray, p2: np.ndarray,
+    p3: np.ndarray, p4: np.ndarray,
+) -> float:
+    """Dihedral angle in radians between planes (p1,p2,p3) and (p1,p2,p4).
+    p1-p2 is the hinge edge. p3 and p4 are the wing tips.
+    Returns angle in [0, 2*pi).
+    """
+    e = p2 - p1
+    e_norm = np.linalg.norm(e)
+    if e_norm < 1e-12:
+        return float(np.pi)
+    e_hat = e / e_norm
+    n1 = np.cross(p3 - p1, e)
+    n2 = np.cross(e, p4 - p1)
+    len1 = np.linalg.norm(n1)
+    len2 = np.linalg.norm(n2)
+    if len1 < 1e-12 or len2 < 1e-12:
+        return float(np.pi)
+    n1 = n1 / len1
+    n2 = n2 / len2
+    cos_a = float(np.clip(np.dot(n1, n2), -1.0, 1.0))
+    angle = np.arccos(cos_a)
+    cross = np.cross(n1, n2)
+    if np.dot(cross, e_hat) < 0:
+        angle = 2.0 * np.pi - angle
+    return float(angle)

engine/validation.py CHANGED Viewed

@@ -254,3 +254,25 @@ def validate_paper(paper: Paper) -> ValidationResult:
         self_intersection_count=si_count,
         is_valid=k_valid and m_valid and si_valid,
     )

         self_intersection_count=si_count,
         is_valid=k_valid and m_valid and si_valid,
     )
+def validate_state(paper: Paper) -> dict:
+    """Run all validation checks and return a flat dict.
+    This is the interface used by OrigamiEnvironment. It calls the
+    existing validation functions and returns a dict with all fields
+    the environment and metrics system need.
+    """
+    result = validate_paper(paper)
+    strain_exceeded = bool(
+        len(paper.strain_per_vertex) > 0
+        and float(paper.strain_per_vertex.max()) > paper.material.max_strain
+    )
+    return {
+        "is_valid": result.is_valid and not strain_exceeded,
+        "kawasaki_violations": int(not result.kawasaki_valid),
+        "kawasaki_total_error": float(result.kawasaki_violation),
+        "maekawa_violations": int(not result.maekawa_valid),
+        "self_intersections": result.self_intersection_count,
+        "strain_exceeded": strain_exceeded,
+    }

env/__init__.py ADDED Viewed

File without changes

env/environment.py ADDED Viewed

	@@ -0,0 +1,243 @@

+import json
+import os
+import copy
+from pathlib import Path
+from typing import Optional
+from .paper_state import PaperState
+from .rewards import compute_reward, compute_terminal_reward, load_target, target_crease_edges
+from .prompts import (
+    code_as_policy_prompt,
+    step_level_prompt,
+    parse_fold_list,
+    parse_single_fold,
+)
+from .verifier import check_all_vertices
+TARGETS_DIR = Path(__file__).parent / 'targets'
+class OrigamiEnvironment:
+    """
+    OpenEnv-compatible origami crease pattern environment.
+    Supports two modes:
+    - code_as_policy: model outputs complete fold sequence, gets terminal reward
+    - step: model outputs one fold at a time, gets per-step reward
+    """
+    def __init__(
+        self,
+        mode: str = 'code_as_policy',  # 'code_as_policy' or 'step'
+        max_steps: int = 8,
+        targets_dir: Optional[str] = None,
+    ):
+        assert mode in ('code_as_policy', 'step'), f"Unknown mode: {mode}"
+        self.mode = mode
+        self.max_steps = max_steps
+        self.targets_dir = Path(targets_dir) if targets_dir else TARGETS_DIR
+        self.paper: Optional[PaperState] = None
+        self.target: Optional[dict] = None
+        self.target_name: Optional[str] = None
+        self.step_count: int = 0
+        self.last_reward: Optional[dict] = None
+        # Cache all available targets
+        self._targets = self._load_all_targets()
+    def _load_all_targets(self) -> dict[str, dict]:
+        targets = {}
+        for fold_file in self.targets_dir.glob('*.fold'):
+            with open(fold_file) as f:
+                targets[fold_file.stem] = json.load(f)
+        return targets
+    def available_targets(self) -> list[str]:
+        return sorted(self._targets.keys())
+    def reset(self, target_name: Optional[str] = None) -> dict:
+        """
+        Reset environment to start of a new episode.
+        Args:
+            target_name: name of target (stem of .fold file). If None, picks level-1 randomly.
+        Returns:
+            observation dict with 'prompt' key containing the LLM prompt string.
+        """
+        import random
+        if target_name:
+            assert target_name in self._targets, f"Unknown target: {target_name}"
+            self.target_name = target_name
+        else:
+            # Default to level-1 targets
+            level1 = [k for k, v in self._targets.items() if v.get('level', 1) == 1]
+            self.target_name = random.choice(level1 if level1 else list(self._targets.keys()))
+        self.target = self._targets[self.target_name]
+        self.paper = PaperState()
+        self.step_count = 0
+        self.last_reward = None
+        return self._get_observation()
+    def step(self, action) -> tuple[dict, dict, bool, dict]:
+        """
+        Execute an action.
+        In code_as_policy mode: action is a string (model completion with <folds> tags)
+            OR a list of fold dicts already parsed.
+        In step mode: action is a string (single fold JSON) or dict.
+        Returns:
+            (observation, reward, done, info)
+        """
+        if self.mode == 'code_as_policy':
+            return self._step_sequence(action)
+        else:
+            return self._step_single(action)
+    def _step_sequence(self, action) -> tuple[dict, dict, bool, dict]:
+        """Execute a complete fold sequence (code-as-policy mode)."""
+        # Parse action if it's a string
+        if isinstance(action, str):
+            try:
+                folds = parse_fold_list(action)
+            except ValueError as e:
+                bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+                return self._get_observation(), bad_reward, True, self._info()
+        else:
+            folds = action  # already a list of dicts
+        # Execute each fold sequentially
+        last_result = {'valid': True, 'anchored': True, 'new_vertices': [], 'errors': []}
+        for fold in folds:
+            try:
+                p1 = fold['from']
+                p2 = fold['to']
+                assignment = fold['assignment']
+            except (KeyError, TypeError) as e:
+                last_result = {'valid': False, 'anchored': False, 'new_vertices': [], 'errors': [str(e)]}
+                break
+            last_result = self.paper.add_crease(p1, p2, assignment)
+            self.step_count += 1
+            if not last_result['valid']:
+                break  # stop at first invalid fold, partial credit
+        reward = compute_terminal_reward(self.paper, self.target)
+        self.last_reward = reward
+        return self._get_observation(), reward, True, self._info()
+    def _step_single(self, action) -> tuple[dict, dict, bool, dict]:
+        """Execute a single fold (step mode)."""
+        if isinstance(action, str):
+            try:
+                fold = parse_single_fold(action)
+            except ValueError as e:
+                bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+                self.last_reward = bad_reward
+                done = self.step_count >= self.max_steps
+                return self._get_observation(), bad_reward, done, self._info()
+        else:
+            fold = action
+        try:
+            p1 = fold['from']
+            p2 = fold['to']
+            assignment = fold['assignment']
+        except (KeyError, TypeError) as e:
+            bad_reward = {'format': 0.0, 'total': -0.1, 'error': str(e)}
+            self.last_reward = bad_reward
+            done = self.step_count >= self.max_steps
+            return self._get_observation(), bad_reward, done, self._info()
+        result = self.paper.add_crease(p1, p2, assignment)
+        self.step_count += 1
+        reward = compute_reward(self.paper, result, self.target)
+        self.last_reward = reward
+        done = (
+            self.step_count >= self.max_steps or
+            reward.get('completion', 0) > 0
+        )
+        return self._get_observation(), reward, done, self._info()
+    def _get_observation(self) -> dict:
+        """Returns observation dict with the LLM prompt and raw state."""
+        if self.mode == 'code_as_policy':
+            prompt = code_as_policy_prompt(self.target, max_folds=self.max_steps)
+        else:
+            prompt = step_level_prompt(
+                target=self.target,
+                paper_state=self.paper,
+                step=self.step_count,
+                max_steps=self.max_steps,
+                last_reward=self.last_reward,
+            )
+        return {
+            'prompt': prompt,
+            'target_name': self.target_name,
+            'step': self.step_count,
+            'paper_fold_json': self.paper.graph.edges if self.paper else {},
+        }
+    def _info(self) -> dict:
+        """Returns diagnostic info dict for logging."""
+        if self.paper is None:
+            return {}
+        interior = self.paper.graph.interior_vertices()
+        vertex_scores = check_all_vertices(self.paper.graph)
+        return {
+            'local_foldability': (
+                vertex_scores['kawasaki'] == 1.0 and
+                vertex_scores['maekawa'] == 1.0
+            ),
+            'blb_satisfied': vertex_scores['blb'] == 1.0,
+            'global_foldability': 'not_checked',  # NP-complete (Bern-Hayes 1996)
+            'n_interior_vertices': len(interior),
+            'n_creases': len(self.paper.graph.crease_edges()),
+            'target_name': self.target_name,
+        }
+    def state(self) -> dict:
+        """Returns current environment state for logging/inspection."""
+        return {
+            'paper': {
+                'vertices': dict(self.paper.graph.vertices),
+                'edges': {
+                    k: v for k, v in self.paper.graph.edges.items()
+                    if v[2] in ('M', 'V')
+                },
+                'fold_history': self.paper.fold_history,
+            },
+            'target': self.target_name,
+            'step': self.step_count,
+            'mode': self.mode,
+        }
+    def close(self):
+        """Cleanup."""
+        pass
+    def clone(self) -> 'OrigamiEnvironment':
+        """Return a deep copy for parallel evaluation (used in GRPO)."""
+        new_env = OrigamiEnvironment(
+            mode=self.mode,
+            max_steps=self.max_steps,
+            targets_dir=str(self.targets_dir),
+        )
+        if self.paper is not None:
+            new_env.paper = copy.deepcopy(self.paper)
+        new_env.target = self.target
+        new_env.target_name = self.target_name
+        new_env.step_count = self.step_count
+        new_env.last_reward = self.last_reward
+        return new_env

env/graph.py ADDED Viewed

	@@ -0,0 +1,117 @@

+import numpy as np
+from typing import Optional
+BOUNDARY_TOL = 1e-9
+VERTEX_TOL = 1e-9
+class CreaseGraph:
+    """
+    Planar graph representing an origami crease pattern on a unit square.
+    Vertices: points in [0,1]x[0,1], deduplicated by proximity.
+    Edges: segments between vertices, labeled M (mountain), V (valley), or B (boundary).
+    """
+    def __init__(self):
+        self.vertices: dict[int, tuple[float, float]] = {}
+        self.edges: dict[int, tuple[int, int, str]] = {}
+        self.vertex_edges: dict[int, list[int]] = {}
+        self._next_vertex_id: int = 0
+        self._next_edge_id: int = 0
+        corners = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
+        for x, y in corners:
+            vid = self._next_vertex_id
+            self.vertices[vid] = (x, y)
+            self.vertex_edges[vid] = []
+            self._next_vertex_id += 1
+        boundary_pairs = [(0, 1), (1, 2), (2, 3), (3, 0)]
+        for v1, v2 in boundary_pairs:
+            eid = self._next_edge_id
+            self.edges[eid] = (v1, v2, 'B')
+            self.vertex_edges[v1].append(eid)
+            self.vertex_edges[v2].append(eid)
+            self._next_edge_id += 1
+    def add_vertex(self, x: float, y: float) -> int:
+        for vid, (vx, vy) in self.vertices.items():
+            if abs(vx - x) < VERTEX_TOL and abs(vy - y) < VERTEX_TOL:
+                return vid
+        vid = self._next_vertex_id
+        self.vertices[vid] = (float(x), float(y))
+        self.vertex_edges[vid] = []
+        self._next_vertex_id += 1
+        return vid
+    def add_edge(self, v1_id: int, v2_id: int, assignment: str) -> int:
+        pair = frozenset((v1_id, v2_id))
+        for eid, (ev1, ev2, _) in self.edges.items():
+            if frozenset((ev1, ev2)) == pair:
+                return eid
+        eid = self._next_edge_id
+        self.edges[eid] = (v1_id, v2_id, assignment)
+        self.vertex_edges[v1_id].append(eid)
+        self.vertex_edges[v2_id].append(eid)
+        self._next_edge_id += 1
+        return eid
+    def get_cyclic_edges(self, vertex_id: int) -> list[int]:
+        vx, vy = self.vertices[vertex_id]
+        edge_ids = self.vertex_edges[vertex_id]
+        def angle_of_edge(eid: int) -> float:
+            ev1, ev2, _ = self.edges[eid]
+            other_id = ev2 if ev1 == vertex_id else ev1
+            ox, oy = self.vertices[other_id]
+            return float(np.arctan2(oy - vy, ox - vx))
+        return sorted(edge_ids, key=angle_of_edge)
+    def interior_vertices(self) -> list[int]:
+        result = []
+        for vid, (x, y) in self.vertices.items():
+            if (
+                x > BOUNDARY_TOL
+                and x < 1.0 - BOUNDARY_TOL
+                and y > BOUNDARY_TOL
+                and y < 1.0 - BOUNDARY_TOL
+            ):
+                result.append(vid)
+        return result
+    def split_edge(self, edge_id: int, new_vertex_id: int) -> tuple[int, int]:
+        ev1, ev2, assignment = self.edges[edge_id]
+        del self.edges[edge_id]
+        if edge_id in self.vertex_edges[ev1]:
+            self.vertex_edges[ev1].remove(edge_id)
+        if edge_id in self.vertex_edges[ev2]:
+            self.vertex_edges[ev2].remove(edge_id)
+        eid1 = self._next_edge_id
+        self.edges[eid1] = (ev1, new_vertex_id, assignment)
+        self.vertex_edges[ev1].append(eid1)
+        self.vertex_edges[new_vertex_id].append(eid1)
+        self._next_edge_id += 1
+        eid2 = self._next_edge_id
+        self.edges[eid2] = (new_vertex_id, ev2, assignment)
+        self.vertex_edges[new_vertex_id].append(eid2)
+        self.vertex_edges[ev2].append(eid2)
+        self._next_edge_id += 1
+        return (eid1, eid2)
+    def crease_edges(self) -> list[int]:
+        return [eid for eid, (_, _, a) in self.edges.items() if a in ('M', 'V')]
+    def boundary_midpoints(self) -> list[tuple[float, float]]:
+        midpoints = []
+        for eid, (v1, v2, assignment) in self.edges.items():
+            if assignment == 'B':
+                x1, y1 = self.vertices[v1]
+                x2, y2 = self.vertices[v2]
+                midpoints.append(((x1 + x2) / 2.0, (y1 + y2) / 2.0))
+        return midpoints

env/paper_state.py ADDED Viewed

	@@ -0,0 +1,150 @@

+import numpy as np
+from shapely.geometry import LineString, Point, Polygon
+from shapely.ops import unary_union
+from typing import Optional
+from .graph import CreaseGraph, VERTEX_TOL
+UNIT_SQUARE_CORNERS = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)]
+_UNIT_SQUARE = Polygon(UNIT_SQUARE_CORNERS)
+class PaperState:
+    """
+    Represents the evolving crease pattern on a unit square [0,1]x[0,1].
+    Uses CreaseGraph for the underlying data structure.
+    """
+    def __init__(self):
+        self.graph = CreaseGraph()
+        self.fold_history: list[dict] = []
+    def anchor_points(self) -> list[tuple[float, float]]:
+        points: dict[tuple[float, float], None] = {}
+        for corner in UNIT_SQUARE_CORNERS:
+            points[corner] = None
+        for vid, (x, y) in self.graph.vertices.items():
+            points[(float(x), float(y))] = None
+        return list(points.keys())
+    def _is_anchor(self, pt: tuple[float, float]) -> bool:
+        px, py = pt
+        for ax, ay in self.anchor_points():
+            if abs(ax - px) < VERTEX_TOL and abs(ay - py) < VERTEX_TOL:
+                return True
+        return False
+    def add_crease(self, p1: list, p2: list, assignment: str) -> dict:
+        errors: list[str] = []
+        if assignment not in ('M', 'V'):
+            return {
+                'valid': False,
+                'anchored': False,
+                'new_vertices': [],
+                'errors': ['invalid_assignment'],
+            }
+        p1 = (float(p1[0]), float(p1[1]))
+        p2 = (float(p2[0]), float(p2[1]))
+        anchored = self._is_anchor(p1) and self._is_anchor(p2)
+        seg_len = np.hypot(p2[0] - p1[0], p2[1] - p1[1])
+        if seg_len < VERTEX_TOL:
+            errors.append('zero_length')
+            return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors}
+        new_line = LineString([p1, p2])
+        if not _UNIT_SQUARE.contains(new_line) and not _UNIT_SQUARE.boundary.contains(new_line):
+            clipped = new_line.intersection(_UNIT_SQUARE)
+            if clipped.is_empty:
+                errors.append('outside_bounds')
+                return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors}
+        intersection_points: list[tuple[float, float]] = []
+        for eid, (ev1, ev2, _) in list(self.graph.edges.items()):
+            ex1, ey1 = self.graph.vertices[ev1]
+            ex2, ey2 = self.graph.vertices[ev2]
+            existing_line = LineString([(ex1, ey1), (ex2, ey2)])
+            inter = new_line.intersection(existing_line)
+            if inter.is_empty:
+                continue
+            if inter.geom_type == 'Point':
+                ix, iy = inter.x, inter.y
+                ep1 = (ex1, ey1)
+                ep2 = (ex2, ey2)
+                if (
+                    abs(ix - ep1[0]) < VERTEX_TOL and abs(iy - ep1[1]) < VERTEX_TOL
+                    or abs(ix - ep2[0]) < VERTEX_TOL and abs(iy - ep2[1]) < VERTEX_TOL
+                ):
+                    continue
+                intersection_points.append((ix, iy))
+            # MultiPoint or LineString intersections (collinear) are skipped
+        new_vertex_coords: list[tuple[float, float]] = []
+        for ix, iy in intersection_points:
+            before = set(self.graph.vertices.keys())
+            vid = self.graph.add_vertex(ix, iy)
+            if vid not in before:
+                new_vertex_coords.append((ix, iy))
+            for eid in list(self.graph.edges.keys()):
+                if eid not in self.graph.edges:
+                    continue
+                ev1, ev2, _ = self.graph.edges[eid]
+                ex1, ey1 = self.graph.vertices[ev1]
+                ex2, ey2 = self.graph.vertices[ev2]
+                seg = LineString([(ex1, ey1), (ex2, ey2)])
+                pt = Point(ix, iy)
+                if seg.distance(pt) < VERTEX_TOL:
+                    if ev1 != vid and ev2 != vid:
+                        self.graph.split_edge(eid, vid)
+        v1_id = self.graph.add_vertex(p1[0], p1[1])
+        v2_id = self.graph.add_vertex(p2[0], p2[1])
+        waypoints = [p1] + sorted(
+            intersection_points,
+            key=lambda pt: np.hypot(pt[0] - p1[0], pt[1] - p1[1]),
+        ) + [p2]
+        waypoint_ids = []
+        for wp in waypoints:
+            wid = self.graph.add_vertex(wp[0], wp[1])
+            waypoint_ids.append(wid)
+        for i in range(len(waypoint_ids) - 1):
+            wa = waypoint_ids[i]
+            wb = waypoint_ids[i + 1]
+            if wa != wb:
+                self.graph.add_edge(wa, wb, assignment)
+        record = {
+            'p1': p1,
+            'p2': p2,
+            'assignment': assignment,
+            'anchored': anchored,
+            'new_vertices': new_vertex_coords,
+        }
+        self.fold_history.append(record)
+        return {
+            'valid': True,
+            'anchored': anchored,
+            'new_vertices': new_vertex_coords,
+            'errors': errors,
+        }
+    def crease_edges(self) -> list[dict]:
+        result = []
+        for eid in self.graph.crease_edges():
+            v1, v2, assignment = self.graph.edges[eid]
+            x1, y1 = self.graph.vertices[v1]
+            x2, y2 = self.graph.vertices[v2]
+            result.append({'v1': (x1, y1), 'v2': (x2, y2), 'assignment': assignment})
+        return result

env/prompts.py ADDED Viewed

	@@ -0,0 +1,235 @@

+import json
+import re
+from typing import Optional
+_CORNERS = {(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)}
+_BOUNDARY_X = {0.0, 1.0}
+_BOUNDARY_Y = {0.0, 1.0}
+def _is_corner(x: float, y: float) -> bool:
+    return (round(x, 4), round(y, 4)) in _CORNERS
+def _is_boundary(x: float, y: float) -> bool:
+    return x in _BOUNDARY_X or y in _BOUNDARY_Y
+def format_target_for_prompt(target: dict) -> str:
+    vertices = target["vertices_coords"]
+    edges_v = target["edges_vertices"]
+    edges_a = target["edges_assignment"]
+    lines = []
+    for (v1, v2), assignment in zip(edges_v, edges_a):
+        if assignment not in ("M", "V"):
+            continue
+        x1, y1 = vertices[v1]
+        x2, y2 = vertices[v2]
+        label = "Mountain" if assignment == "M" else "Valley"
+        lines.append(
+            f"{label} fold: ({round(x1, 4)}, {round(y1, 4)}) -> ({round(x2, 4)}, {round(y2, 4)})"
+        )
+    return "\n".join(lines)
+def format_anchor_points(paper_state) -> str:
+    corners = []
+    boundary_pts = []
+    intersections = []
+    for x, y in paper_state.anchor_points():
+        rx, ry = round(x, 4), round(y, 4)
+        if _is_corner(rx, ry):
+            corners.append((rx, ry))
+        elif _is_boundary(rx, ry):
+            boundary_pts.append((rx, ry))
+        else:
+            intersections.append((rx, ry))
+    def fmt_pts(pts: list[tuple[float, float]]) -> str:
+        return "  ".join(f"({x},{y})" for x, y in pts)
+    lines = []
+    if corners:
+        lines.append(f"  Corners:       {fmt_pts(corners)}")
+    if boundary_pts:
+        lines.append(f"  Boundary pts:  {fmt_pts(boundary_pts)}")
+    if intersections:
+        lines.append(f"  Intersections: {fmt_pts(intersections)}")
+    return "\n".join(lines)
+def format_crease_history(paper_state) -> str:
+    history = paper_state.fold_history
+    if not history:
+        return "none"
+    lines = []
+    for i, fold in enumerate(history, 1):
+        p1, p2 = fold["p1"], fold["p2"]
+        assignment = fold["assignment"]
+        label = "Mountain" if assignment == "M" else "Valley"
+        x1, y1 = round(p1[0], 4), round(p1[1], 4)
+        x2, y2 = round(p2[0], 4), round(p2[1], 4)
+        lines.append(f"  {i}. {label} fold: ({x1}, {y1}) -> ({x2}, {y2})")
+    return "\n".join(lines)
+def format_reward_feedback(reward: Optional[dict]) -> str:
+    if not reward:
+        return "(no feedback yet)"
+    keys = ["kawasaki", "maekawa", "blb", "progress", "economy", "total"]
+    parts = []
+    for k in keys:
+        if k in reward:
+            parts.append(f"{k}={reward[k]:.2f}")
+    for k, v in reward.items():
+        if k not in keys:
+            parts.append(f"{k}={v:.2f}")
+    return "  " + "  ".join(parts)
+def code_as_policy_prompt(target: dict, max_folds: int = 8) -> str:
+    formatted_target = format_target_for_prompt(target)
+    return f"""You are an origami designer. Generate a fold sequence for a unit square [0,1]x[0,1].
+TARGET CREASE PATTERN:
+{formatted_target}
+RULES (must hold at every interior vertex):
+  - Kawasaki: alternating sector angles sum equally (each half = 180 degrees)
+  - Maekawa: |mountain_count - valley_count| = 2
+  - Big-Little-Big: folds bounding the smallest sector must have opposite types (one M, one V)
+INITIAL ANCHOR POINTS (valid fold endpoints — new ones appear when creases intersect):
+  Corners:      (0.0,0.0)  (1.0,0.0)  (1.0,1.0)  (0.0,1.0)
+  Midpoints:    (0.0,0.5)  (0.5,0.0)  (1.0,0.5)  (0.5,1.0)
+  Note: new anchor points are created at crease intersections.
+Output at most {max_folds} folds. Both endpoints must be valid anchor points.
+Output ONLY the JSON list, wrapped in <folds> tags:
+<folds>
+[
+  {{"instruction": "Describe the fold in plain English", "from": [x1, y1], "to": [x2, y2], "assignment": "V"}},
+  {{"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M"}}
+]
+</folds>"""
+def step_level_prompt(
+    target: dict,
+    paper_state,
+    step: int,
+    max_steps: int,
+    last_reward: Optional[dict] = None,
+) -> str:
+    formatted_target = format_target_for_prompt(target)
+    formatted_history = format_crease_history(paper_state)
+    formatted_anchors = format_anchor_points(paper_state)
+    formatted_reward = format_reward_feedback(last_reward)
+    return f"""You are an origami designer building a crease pattern step by step.
+TARGET:
+{formatted_target}
+CURRENT STATE (step {step} of {max_steps}):
+  Creases placed:
+{formatted_history}
+AVAILABLE ANCHOR POINTS:
+{formatted_anchors}
+LAST REWARD:
+{formatted_reward}
+Add the NEXT crease. Both endpoints must be listed anchor points above.
+Output ONLY valid JSON (no extra text):
+{{"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M" or "V"}}"""
+def parse_fold_list(completion: str) -> list[dict]:
+    match = re.search(r"<folds>(.*?)</folds>", completion, re.IGNORECASE | re.DOTALL)
+    if not match:
+        raise ValueError("No <folds>...</folds> tags found in completion")
+    raw = match.group(1).strip()
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON inside <folds> tags: {e}") from e
+    if not isinstance(data, list):
+        raise ValueError(f"Expected a JSON list inside <folds> tags, got {type(data).__name__}")
+    cleaned = []
+    for i, item in enumerate(data):
+        if not isinstance(item, dict):
+            raise ValueError(f"Fold {i} is not a dict: {item!r}")
+        for field in ("from", "to", "assignment"):
+            if field not in item:
+                raise ValueError(f"Fold {i} missing required field '{field}'")
+        from_pt = item["from"]
+        to_pt = item["to"]
+        if (
+            not isinstance(from_pt, list)
+            or len(from_pt) != 2
+            or not all(isinstance(v, (int, float)) for v in from_pt)
+        ):
+            raise ValueError(f"Fold {i} 'from' must be a list of 2 numbers, got {from_pt!r}")
+        if (
+            not isinstance(to_pt, list)
+            or len(to_pt) != 2
+            or not all(isinstance(v, (int, float)) for v in to_pt)
+        ):
+            raise ValueError(f"Fold {i} 'to' must be a list of 2 numbers, got {to_pt!r}")
+        if not isinstance(item["assignment"], str):
+            raise ValueError(f"Fold {i} 'assignment' must be a string")
+        cleaned.append(
+            {
+                "from": [float(from_pt[0]), float(from_pt[1])],
+                "to": [float(to_pt[0]), float(to_pt[1])],
+                "assignment": item["assignment"],
+                "instruction": item.get("instruction", ""),
+            }
+        )
+    return cleaned
+def parse_single_fold(completion: str) -> dict:
+    start = completion.find("{")
+    end = completion.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError("No JSON object found in completion")
+    raw = completion[start : end + 1]
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON from completion: {e}") from e
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected a JSON object, got {type(data).__name__}")
+    for field in ("from", "to", "assignment"):
+        if field not in data:
+            raise ValueError(f"Missing required field '{field}' in fold JSON")
+    return data

env/rewards.py ADDED Viewed

	@@ -0,0 +1,93 @@

+import json
+from .verifier import check_all_vertices, geometric_crease_coverage
+from .paper_state import PaperState
+def load_target(target_path: str) -> dict:
+    """Load a .fold target file and return it as a dict."""
+    with open(target_path) as f:
+        return json.load(f)
+def target_crease_edges(target: dict) -> list[dict]:
+    """
+    Extract crease edges from a FOLD target dict as list of
+    {'v1': (x1,y1), 'v2': (x2,y2), 'assignment': 'M'|'V'} dicts.
+    """
+    verts = target['vertices_coords']
+    result = []
+    for i, (v1_idx, v2_idx) in enumerate(target['edges_vertices']):
+        assignment = target['edges_assignment'][i]
+        if assignment in ('M', 'V'):
+            result.append({
+                'v1': tuple(verts[v1_idx]),
+                'v2': tuple(verts[v2_idx]),
+                'assignment': assignment,
+            })
+    return result
+def compute_reward(
+    state: PaperState,
+    action_result: dict,
+    target: dict,
+) -> dict:
+    """
+    Compute the full reward dict for a fold action.
+    Args:
+        state: current PaperState AFTER the action was applied
+        action_result: {'valid': bool, 'anchored': bool, 'new_vertices': list, 'errors': list}
+        target: FOLD target dict
+    Returns dict with keys:
+        format, anchored, kawasaki, maekawa, blb, progress, economy, completion, efficiency, total
+    """
+    r = {}
+    # Gate 1: format — did the action parse and apply?
+    r['format'] = 1.0 if action_result.get('valid', False) else 0.0
+    if not r['format']:
+        r['total'] = -0.1
+        return r
+    # Gate 2: anchoring — were endpoints valid anchor points?
+    r['anchored'] = 1.0 if action_result.get('anchored', False) else 0.3
+    # Vertex-level validity checks (all interior vertices)
+    vertex_scores = check_all_vertices(state.graph)
+    r['kawasaki'] = vertex_scores['kawasaki']
+    r['maekawa'] = vertex_scores['maekawa']
+    r['blb'] = vertex_scores['blb']
+    # Geometric progress
+    t_edges = target_crease_edges(target)
+    coverage, economy = geometric_crease_coverage(state, t_edges)
+    r['progress'] = coverage
+    r['economy'] = economy
+    # Completion bonus: high coverage + all vertex conditions satisfied
+    all_valid = (r['kawasaki'] == 1.0 and r['maekawa'] == 1.0 and r['blb'] == 1.0)
+    r['completion'] = 10.0 if (r['progress'] > 0.9 and all_valid) else 0.0
+    # Step cost
+    r['efficiency'] = -0.01
+    # Weighted total
+    r['total'] = (
+        0.05 * r['anchored'] +
+        0.08 * r['kawasaki'] +
+        0.07 * r['maekawa'] +
+        0.05 * r['blb'] +
+        0.45 * r['progress'] +
+        0.10 * r['economy'] +
+        r['completion'] +
+        r['efficiency']
+    )
+    return r
+def compute_terminal_reward(state: PaperState, target: dict) -> dict:
+    """Compute reward for the final state after a complete fold sequence."""
+    fake_result = {'valid': True, 'anchored': True, 'new_vertices': [], 'errors': []}
+    return compute_reward(state, fake_result, target)

env/targets/__init__.py ADDED Viewed

File without changes

env/targets/accordion_3h.fold ADDED Viewed

	@@ -0,0 +1,67 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.25],
+    [1.0, 0.25],
+    [0.0, 0.5],
+    [1.0, 0.5],
+    [0.0, 0.75],
+    [1.0, 0.75]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 9],
+    [9, 2],
+    [2, 3],
+    [3, 8],
+    [8, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7],
+    [8, 9]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "M",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 9, 8],
+    [8, 9, 2, 3]
+  ],
+  "level": 3,
+  "description": "Three alternating horizontal folds at y=0.25 (valley), y=0.5 (mountain), y=0.75 (valley) forming an accordion"
+}

env/targets/accordion_4h.fold ADDED Viewed

	@@ -0,0 +1,79 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.2],
+    [1.0, 0.2],
+    [0.0, 0.4],
+    [1.0, 0.4],
+    [0.0, 0.6],
+    [1.0, 0.6],
+    [0.0, 0.8],
+    [1.0, 0.8]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 9],
+    [9, 11],
+    [11, 2],
+    [2, 3],
+    [3, 10],
+    [10, 8],
+    [8, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7],
+    [8, 9],
+    [10, 11]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "M",
+    "V",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 9, 8],
+    [8, 9, 11, 10],
+    [10, 11, 2, 3]
+  ],
+  "level": 3,
+  "description": "Four alternating horizontal folds at y=0.2 (valley), y=0.4 (mountain), y=0.6 (valley), y=0.8 (mountain) forming an accordion"
+}

env/targets/diagonal_anti.fold ADDED Viewed

	@@ -0,0 +1,35 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [1, 3]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 3],
+    [1, 2, 3]
+  ],
+  "level": 1,
+  "description": "One mountain fold along the anti-diagonal from (1,0) to (0,1)"
+}

env/targets/diagonal_main.fold ADDED Viewed

	@@ -0,0 +1,35 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [3, 0],
+    [0, 2]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 2],
+    [0, 2, 3]
+  ],
+  "level": 1,
+  "description": "One valley fold along the main diagonal from (0,0) to (1,1)"
+}

env/targets/half_horizontal.fold ADDED Viewed

	@@ -0,0 +1,43 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.5],
+    [1.0, 0.5]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 2],
+    [2, 3],
+    [3, 4],
+    [4, 0],
+    [4, 5]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 2, 3]
+  ],
+  "level": 1,
+  "description": "One valley fold along y=0.5, folding the paper in half horizontally"
+}

env/targets/half_vertical.fold ADDED Viewed

	@@ -0,0 +1,43 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.5, 0.0],
+    [0.5, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 4],
+    [4, 1],
+    [1, 2],
+    [2, 5],
+    [5, 3],
+    [3, 0],
+    [4, 5]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 4, 5, 3],
+    [4, 1, 2, 5]
+  ],
+  "level": 1,
+  "description": "One mountain fold along x=0.5, folding the paper in half vertically"
+}

env/targets/thirds_h.fold ADDED Viewed

	@@ -0,0 +1,55 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.0, 0.3333333333333333],
+    [1.0, 0.3333333333333333],
+    [0.0, 0.6666666666666666],
+    [1.0, 0.6666666666666666]
+  ],
+  "edges_vertices": [
+    [0, 1],
+    [1, 5],
+    [5, 7],
+    [7, 2],
+    [2, 3],
+    [3, 6],
+    [6, 4],
+    [4, 0],
+    [4, 5],
+    [6, 7]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "V",
+    "V"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 1, 5, 4],
+    [4, 5, 7, 6],
+    [6, 7, 2, 3]
+  ],
+  "level": 2,
+  "description": "Two parallel valley folds at y=1/3 and y=2/3, dividing the paper into horizontal thirds"
+}

env/targets/thirds_v.fold ADDED Viewed

	@@ -0,0 +1,55 @@

+{
+  "vertices_coords": [
+    [0.0, 0.0],
+    [1.0, 0.0],
+    [1.0, 1.0],
+    [0.0, 1.0],
+    [0.3333333333333333, 0.0],
+    [0.6666666666666666, 0.0],
+    [0.3333333333333333, 1.0],
+    [0.6666666666666666, 1.0]
+  ],
+  "edges_vertices": [
+    [0, 4],
+    [4, 5],
+    [5, 1],
+    [1, 2],
+    [2, 7],
+    [7, 6],
+    [6, 3],
+    [3, 0],
+    [4, 6],
+    [5, 7]
+  ],
+  "edges_assignment": [
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "B",
+    "M",
+    "M"
+  ],
+  "edges_foldAngle": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    -180,
+    -180
+  ],
+  "faces_vertices": [
+    [0, 4, 6, 3],
+    [4, 5, 7, 6],
+    [5, 1, 2, 7]
+  ],
+  "level": 2,
+  "description": "Two parallel mountain folds at x=1/3 and x=2/3, dividing the paper into vertical thirds"
+}

env/targets/validator.py ADDED Viewed

	@@ -0,0 +1,119 @@

+"""
+Validates all .fold target files against origami theorems.
+Run directly: python -m env.targets.validator
+"""
+import json
+import os
+import sys
+from pathlib import Path
+from ..graph import CreaseGraph
+from ..verifier import check_kawasaki_at_vertex, check_maekawa_at_vertex, check_blb_at_vertex
+def build_graph_from_fold(fold_data: dict) -> CreaseGraph:
+    """
+    Reconstruct a CreaseGraph from a FOLD JSON dict.
+    Used to validate target files.
+    """
+    graph = CreaseGraph()
+    verts = fold_data['vertices_coords']
+    edges = fold_data['edges_vertices']
+    assignments = fold_data['edges_assignment']
+    # Map file vertex indices to graph vertex IDs
+    vert_map = {}
+    for i, (x, y) in enumerate(verts):
+        vid = graph.add_vertex(float(x), float(y))
+        vert_map[i] = vid
+    # Add edges (boundary edges from init may already exist, add_edge handles dedup)
+    for i, (v1_idx, v2_idx) in enumerate(edges):
+        v1_id = vert_map[v1_idx]
+        v2_id = vert_map[v2_idx]
+        assignment = assignments[i]
+        graph.add_edge(v1_id, v2_id, assignment)
+    return graph
+def validate_target(fold_path: str) -> dict:
+    """
+    Validate a single .fold target file.
+    Returns {'file': str, 'valid': bool, 'issues': list[str], 'interior_vertices': int}
+    """
+    with open(fold_path) as f:
+        fold_data = json.load(f)
+    issues = []
+    # Basic structure checks
+    required = ['vertices_coords', 'edges_vertices', 'edges_assignment', 'edges_foldAngle']
+    for field in required:
+        if field not in fold_data:
+            issues.append(f"Missing field: {field}")
+    if issues:
+        return {'file': os.path.basename(fold_path), 'valid': False, 'issues': issues, 'interior_vertices': -1}
+    n_edges = len(fold_data['edges_vertices'])
+    if len(fold_data['edges_assignment']) != n_edges:
+        issues.append("edges_assignment length mismatch")
+    if len(fold_data['edges_foldAngle']) != n_edges:
+        issues.append("edges_foldAngle length mismatch")
+    # Build graph and check theorems
+    graph = build_graph_from_fold(fold_data)
+    interior = graph.interior_vertices()
+    for v_id in interior:
+        ok, alt_sum = check_kawasaki_at_vertex(v_id, graph)
+        if not ok:
+            issues.append(f"Kawasaki violated at vertex {v_id} (alt_sum={alt_sum:.6f})")
+        if not check_maekawa_at_vertex(v_id, graph):
+            issues.append(f"Maekawa violated at vertex {v_id}")
+        blb_violations = check_blb_at_vertex(v_id, graph)
+        if blb_violations:
+            issues.append(f"BLB violated at vertex {v_id}: {blb_violations}")
+    return {
+        'file': os.path.basename(fold_path),
+        'valid': len(issues) == 0,
+        'issues': issues,
+        'interior_vertices': len(interior),
+    }
+def validate_all(targets_dir: str = None) -> bool:
+    """Validate all .fold files in the targets directory. Returns True if all pass."""
+    if targets_dir is None:
+        targets_dir = Path(__file__).parent
+    all_pass = True
+    fold_files = sorted(Path(targets_dir).glob('*.fold'))
+    if not fold_files:
+        print("No .fold files found")
+        return False
+    for fold_path in fold_files:
+        result = validate_target(str(fold_path))
+        status = "OK" if result['valid'] else "FAIL"
+        n_interior = result['interior_vertices']
+        print(f"  [{status}] {result['file']} — {n_interior} interior vertices")
+        if result['issues']:
+            for issue in result['issues']:
+                print(f"         ! {issue}")
+        if not result['valid']:
+            all_pass = False
+    return all_pass
+if __name__ == '__main__':
+    print("Validating targets...")
+    ok = validate_all()
+    sys.exit(0 if ok else 1)

env/targets/validator_check.py ADDED Viewed

	@@ -0,0 +1,19 @@

+import json, sys, os
+targets_dir = "/Users/ianalin/Desktop/optigami/env/targets"
+for fname in os.listdir(targets_dir):
+    if not fname.endswith(".fold"):
+        continue
+    with open(os.path.join(targets_dir, fname)) as f:
+        d = json.load(f)
+    n_v = len(d["vertices_coords"])
+    n_e = len(d["edges_vertices"])
+    assert len(d["edges_assignment"]) == n_e, f"{fname}: assignment length mismatch"
+    assert len(d["edges_foldAngle"]) == n_e, f"{fname}: foldAngle length mismatch"
+    for e in d["edges_vertices"]:
+        assert e[0] < n_v and e[1] < n_v, f"{fname}: edge references invalid vertex"
+    for face in d["faces_vertices"]:
+        for vi in face:
+            assert vi < n_v, f"{fname}: face references invalid vertex"
+    creases = [i for i,a in enumerate(d["edges_assignment"]) if a in ('M','V')]
+    print(f"{fname}: {n_v} vertices, {n_e} edges, {len(creases)} creases, level={d.get('level','?')} OK")

env/verifier.py ADDED Viewed

	@@ -0,0 +1,221 @@

+import numpy as np
+from .graph import CreaseGraph
+from .paper_state import PaperState
+def _compute_sector_angles(vertex_id: int, graph: CreaseGraph) -> list[float]:
+    """Compute consecutive sector angles (CCW) at a vertex from its cyclic edges."""
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    vx, vy = graph.vertices[vertex_id]
+    angles = []
+    for eid in cyclic_edges:
+        ev1, ev2, _ = graph.edges[eid]
+        other_id = ev2 if ev1 == vertex_id else ev1
+        ox, oy = graph.vertices[other_id]
+        angles.append(np.arctan2(oy - vy, ox - vx))
+    sectors = []
+    for i in range(n):
+        diff = angles[(i + 1) % n] - angles[i]
+        if diff < 0:
+            diff += 2 * np.pi
+        if diff > 2 * np.pi:
+            diff -= 2 * np.pi
+        sectors.append(diff)
+    return sectors
+def check_kawasaki_at_vertex(vertex_id: int, graph: CreaseGraph) -> tuple[bool, float]:
+    """
+    Checks Kawasaki-Justin theorem at a single vertex.
+    Kawasaki: at an interior vertex with 2n creases, the alternating sum
+    of consecutive sector angles = 0.
+    Equivalently: sum(odd-indexed sectors) == sum(even-indexed sectors) == π.
+    Returns (satisfied: bool, |alternating_sum|: float).
+    Returns (True, 0.0) for vertices with degree < 4 (not an interior fold vertex yet).
+    Returns (False, inf) for odd-degree vertices (impossible for flat folds).
+    """
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    if n % 2 != 0:
+        return (False, float('inf'))
+    if n < 4:
+        return (True, 0.0)
+    sectors = _compute_sector_angles(vertex_id, graph)
+    alt_sum = sum(s * ((-1) ** i) for i, s in enumerate(sectors))
+    return (abs(alt_sum) < 1e-9, abs(alt_sum))
+def check_maekawa_at_vertex(vertex_id: int, graph: CreaseGraph) -> bool:
+    """
+    Checks Maekawa-Justin theorem at a single vertex.
+    Maekawa: |M - V| == 2 where M, V are counts of mountain/valley fold edges
+    at the vertex. BOUNDARY edges ('B') are NOT counted.
+    Returns True if satisfied or if vertex has fewer than 4 fold edges (not yet active).
+    """
+    edge_ids = graph.vertex_edges[vertex_id]
+    fold_edges = [
+        eid for eid in edge_ids
+        if graph.edges[eid][2] in ('M', 'V')
+    ]
+    if len(fold_edges) < 4:
+        return True
+    m_count = sum(1 for eid in fold_edges if graph.edges[eid][2] == 'M')
+    v_count = sum(1 for eid in fold_edges if graph.edges[eid][2] == 'V')
+    return abs(m_count - v_count) == 2
+def check_blb_at_vertex(vertex_id: int, graph: CreaseGraph) -> list[tuple[int, int]]:
+    """
+    Checks Big-Little-Big lemma at a single vertex.
+    BLB: if sector angle i is a strict local minimum (smaller than both neighbors),
+    the fold edges bounding that sector must have OPPOSITE MV assignments.
+    Returns list of (edge_a_id, edge_b_id) pairs where BLB is violated.
+    Empty list = no violations.
+    """
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    if n < 4:
+        return []
+    sectors = _compute_sector_angles(vertex_id, graph)
+    violations = []
+    for i in range(n):
+        prev_sector = sectors[(i - 1) % n]
+        next_sector = sectors[(i + 1) % n]
+        if sectors[i] < prev_sector and sectors[i] < next_sector:
+            edge_a = cyclic_edges[i]
+            edge_b = cyclic_edges[(i + 1) % n]
+            assign_a = graph.edges[edge_a][2]
+            assign_b = graph.edges[edge_b][2]
+            if assign_a in ('M', 'V') and assign_b in ('M', 'V'):
+                if assign_a == assign_b:
+                    violations.append((edge_a, edge_b))
+    return violations
+def _angle_diff(a1: float, a2: float) -> float:
+    """Minimum angle difference between two directed lines (considering 180° symmetry)."""
+    diff = abs(a1 - a2) % np.pi
+    return min(diff, np.pi - diff)
+def geometric_crease_coverage(
+    state: PaperState,
+    target_edges: list[dict],
+    tol_pos: float = 0.05,
+    tol_angle_deg: float = 5.0,
+) -> tuple[float, float]:
+    """
+    Computes how well the current crease pattern matches the target.
+    Args:
+        target_edges: list of {'v1': (x1,y1), 'v2': (x2,y2), 'assignment': 'M'|'V'}
+    Returns:
+        (coverage, economy)
+        coverage: fraction of target creases matched [0, 1]
+        economy: penalty for excess creases [0, 1], 1.0 = no excess
+    """
+    current_edges = state.crease_edges()
+    tol_angle_rad = np.deg2rad(tol_angle_deg)
+    matched = 0
+    for target in target_edges:
+        tx1, ty1 = target['v1']
+        tx2, ty2 = target['v2']
+        t_mid = ((tx1 + tx2) / 2.0, (ty1 + ty2) / 2.0)
+        t_angle = np.arctan2(ty2 - ty1, tx2 - tx1)
+        for current in current_edges:
+            cx1, cy1 = current['v1']
+            cx2, cy2 = current['v2']
+            c_mid = ((cx1 + cx2) / 2.0, (cy1 + cy2) / 2.0)
+            c_angle = np.arctan2(cy2 - cy1, cx2 - cx1)
+            mid_dist = np.hypot(c_mid[0] - t_mid[0], c_mid[1] - t_mid[1])
+            angle_distance = _angle_diff(c_angle, t_angle)
+            if mid_dist <= tol_pos and angle_distance <= tol_angle_rad:
+                matched += 1
+                break
+    coverage = matched / max(len(target_edges), 1)
+    n_excess = max(0, len(current_edges) - len(target_edges))
+    economy = max(0.0, 1.0 - n_excess / max(len(target_edges), 1))
+    return (coverage, economy)
+def check_all_vertices(graph: CreaseGraph) -> dict:
+    """
+    Run all vertex-level checks on every interior vertex.
+    Returns dict with:
+        'kawasaki': float  # fraction of interior vertices passing Kawasaki [0,1]
+        'maekawa': float   # fraction passing Maekawa [0,1]
+        'blb': float       # fraction with no BLB violations [0,1]
+        'n_interior': int  # number of interior vertices checked
+        'per_vertex': list[dict]  # per-vertex details
+    """
+    interior = graph.interior_vertices()
+    if not interior:
+        return {
+            'kawasaki': 1.0,
+            'maekawa': 1.0,
+            'blb': 1.0,
+            'n_interior': 0,
+            'per_vertex': [],
+        }
+    per_vertex = []
+    kaw_pass = 0
+    mae_pass = 0
+    blb_pass = 0
+    for vid in interior:
+        kaw_ok, kaw_val = check_kawasaki_at_vertex(vid, graph)
+        mae_ok = check_maekawa_at_vertex(vid, graph)
+        blb_violations = check_blb_at_vertex(vid, graph)
+        blb_ok = len(blb_violations) == 0
+        kaw_pass += int(kaw_ok)
+        mae_pass += int(mae_ok)
+        blb_pass += int(blb_ok)
+        per_vertex.append({
+            'vertex_id': vid,
+            'kawasaki_ok': kaw_ok,
+            'kawasaki_error': kaw_val,
+            'maekawa_ok': mae_ok,
+            'blb_violations': blb_violations,
+        })
+    n = len(interior)
+    return {
+        'kawasaki': kaw_pass / n,
+        'maekawa': mae_pass / n,
+        'blb': blb_pass / n,
+        'n_interior': n,
+        'per_vertex': per_vertex,
+    }

openenv.yaml ADDED Viewed

	@@ -0,0 +1,6 @@

+spec_version: 1
+name: optigami
+type: space
+runtime: fastapi
+app: openenv_server.app:app
+port: 8000

openenv_runtime/__init__.py ADDED Viewed

	@@ -0,0 +1,11 @@

+"""OpenEnv integration runtime for Optigami."""
+from .environment import OpenEnvOrigamiEnvironment
+from .models import OrigamiAction, OrigamiObservation, OrigamiState
+__all__ = [
+    "OpenEnvOrigamiEnvironment",
+    "OrigamiAction",
+    "OrigamiObservation",
+    "OrigamiState",
+]

openenv_runtime/environment.py ADDED Viewed

	@@ -0,0 +1,183 @@

+from __future__ import annotations
+from typing import Any, Optional
+from openenv.core.env_server.interfaces import Environment
+from env.environment import OrigamiEnvironment
+from .models import OrigamiAction, OrigamiObservation, OrigamiState
+class OpenEnvOrigamiEnvironment(Environment[OrigamiAction, OrigamiObservation, OrigamiState]):
+    """OpenEnv adapter over the existing OrigamiEnvironment implementation."""
+    SUPPORTS_CONCURRENT_SESSIONS = True
+    def __init__(
+        self,
+        default_mode: str = "step",
+        max_steps: int = 8,
+        targets_dir: Optional[str] = None,
+    ):
+        super().__init__()
+        self.default_mode = default_mode
+        self.max_steps = max_steps
+        self.targets_dir = targets_dir
+        self._env: Optional[OrigamiEnvironment] = None
+        self._episode_id: Optional[str] = None
+    def _new_env(self, mode: Optional[str] = None) -> OrigamiEnvironment:
+        return OrigamiEnvironment(
+            mode=mode or self.default_mode,
+            max_steps=self.max_steps,
+            targets_dir=self.targets_dir,
+        )
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> OrigamiObservation:
+        del seed  # deterministic seed plumbing can be added later
+        mode = kwargs.get("mode", self.default_mode)
+        target_name = kwargs.get("target_name")
+        self._env = self._new_env(mode=mode)
+        self._episode_id = episode_id
+        obs_dict = self._env.reset(target_name=target_name)
+        return OrigamiObservation(
+            done=False,
+            reward=None,
+            metadata={"available_targets": self._env.available_targets()},
+            prompt=obs_dict.get("prompt", ""),
+            target_name=obs_dict.get("target_name"),
+            step=obs_dict.get("step", 0),
+            paper_state=self._paper_state_snapshot(),
+            info=self._env._info(),
+            reward_components={},
+        )
+    def step(
+        self,
+        action: OrigamiAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> OrigamiObservation:
+        del timeout_s, kwargs
+        if self._env is None:
+            self.reset(target_name=action.target_name)
+        assert self._env is not None
+        if action.target_name and action.target_name != self._env.target_name:
+            self.reset(target_name=action.target_name, mode=self._env.mode)
+        try:
+            if action.mode == "sequence":
+                if not action.completion:
+                    return self._error_observation("sequence mode requires completion")
+                seq_env = self._new_env(mode="code_as_policy")
+                seq_env.reset(target_name=self._env.target_name)
+                obs_dict, reward_dict, done, info = seq_env.step(action.completion)
+                self._env = seq_env
+            else:
+                if action.fold is not None:
+                    fold_payload = {
+                        "from": list(action.fold.from_point),
+                        "to": list(action.fold.to_point),
+                        "assignment": action.fold.assignment,
+                        "instruction": action.fold.instruction,
+                    }
+                    env_action: Any = fold_payload
+                elif action.completion:
+                    env_action = action.completion
+                else:
+                    return self._error_observation("single mode requires fold or completion")
+                obs_dict, reward_dict, done, info = self._env.step(env_action)
+            total = reward_dict.get("total") if isinstance(reward_dict, dict) else None
+            return OrigamiObservation(
+                done=bool(done),
+                reward=float(total) if isinstance(total, (int, float)) else None,
+                metadata={"target_name": self._env.target_name},
+                prompt=obs_dict.get("prompt", ""),
+                target_name=obs_dict.get("target_name", self._env.target_name),
+                step=obs_dict.get("step", self._env.step_count),
+                paper_state=self._paper_state_snapshot(),
+                info=info or {},
+                reward_components=reward_dict or {},
+            )
+        except Exception as exc:  # pragma: no cover - defensive path
+            return self._error_observation(str(exc))
+    @property
+    def state(self) -> OrigamiState:
+        if self._env is None:
+            tmp_env = self._new_env(mode=self.default_mode)
+            return OrigamiState(
+                episode_id=self._episode_id,
+                step_count=0,
+                mode=tmp_env.mode,
+                target_name=None,
+                paper={},
+                last_reward={},
+                available_targets=tmp_env.available_targets(),
+            )
+        env_state = self._env.state()
+        return OrigamiState(
+            episode_id=self._episode_id,
+            step_count=env_state.get("step", self._env.step_count),
+            mode=env_state.get("mode", self._env.mode),
+            target_name=env_state.get("target", self._env.target_name),
+            paper=env_state.get("paper", {}),
+            last_reward=self._env.last_reward or {},
+            available_targets=self._env.available_targets(),
+        )
+    def close(self) -> None:
+        if self._env is not None:
+            self._env.close()
+            self._env = None
+    def _paper_state_snapshot(self) -> dict[str, Any]:
+        if self._env is None or self._env.paper is None:
+            return {"vertices": {}, "edges": [], "anchor_points": []}
+        graph = self._env.paper.graph
+        return {
+            "vertices": {str(k): [float(v[0]), float(v[1])] for k, v in graph.vertices.items()},
+            "edges": [
+                {
+                    "id": int(eid),
+                    "v1": [float(graph.vertices[v1][0]), float(graph.vertices[v1][1])],
+                    "v2": [float(graph.vertices[v2][0]), float(graph.vertices[v2][1])],
+                    "assignment": assignment,
+                }
+                for eid, (v1, v2, assignment) in graph.edges.items()
+            ],
+            "anchor_points": [
+                [float(x), float(y)] for (x, y) in self._env.paper.anchor_points()
+            ],
+        }
+    def _error_observation(self, message: str) -> OrigamiObservation:
+        return OrigamiObservation(
+            done=False,
+            reward=-0.1,
+            metadata={"error": True},
+            prompt="",
+            target_name=self._env.target_name if self._env else None,
+            step=self._env.step_count if self._env else 0,
+            paper_state=self._paper_state_snapshot(),
+            info=self._env._info() if self._env else {},
+            reward_components={"format": 0.0, "total": -0.1, "error": message},
+            error=message,
+        )

openenv_runtime/models.py ADDED Viewed

	@@ -0,0 +1,63 @@

+from __future__ import annotations
+from typing import Any, Literal, Optional
+from pydantic import BaseModel, Field, field_validator
+from openenv.core.env_server.types import Action, Observation, State
+class OrigamiFold(BaseModel):
+    """Single fold action payload for step-level execution."""
+    from_point: list[float] = Field(..., description="Fold line start [x, y]")
+    to_point: list[float] = Field(..., description="Fold line end [x, y]")
+    assignment: Literal["M", "V"] = Field(..., description="Mountain or valley")
+    instruction: str = Field(default="", description="Optional natural language instruction")
+    @field_validator("from_point", "to_point")
+    @classmethod
+    def _validate_point(cls, point: list[float]) -> list[float]:
+        if len(point) != 2:
+            raise ValueError("Point must contain exactly 2 coordinates")
+        return [float(point[0]), float(point[1])]
+class OrigamiAction(Action):
+    """
+    OpenEnv action for Optigami.
+    Modes:
+    - single: execute one fold (pass `fold` or JSON `completion` for a single-fold object)
+    - sequence: execute a full <folds>[...]</folds> completion in one step
+    """
+    mode: Literal["single", "sequence"] = Field(default="single")
+    fold: Optional[OrigamiFold] = Field(default=None)
+    completion: Optional[str] = Field(default=None)
+    target_name: Optional[str] = Field(
+        default=None,
+        description="Optional target override; reset to this target before stepping",
+    )
+class OrigamiObservation(Observation):
+    """OpenEnv observation payload returned by Optigami."""
+    prompt: str = Field(default="")
+    target_name: Optional[str] = Field(default=None)
+    step: int = Field(default=0)
+    paper_state: dict[str, Any] = Field(default_factory=dict)
+    info: dict[str, Any] = Field(default_factory=dict)
+    reward_components: dict[str, float | int | str] = Field(default_factory=dict)
+    error: Optional[str] = Field(default=None)
+class OrigamiState(State):
+    """OpenEnv state payload for Optigami."""
+    mode: str = Field(default="step")
+    target_name: Optional[str] = Field(default=None)
+    paper: dict[str, Any] = Field(default_factory=dict)
+    last_reward: dict[str, Any] = Field(default_factory=dict)
+    available_targets: list[str] = Field(default_factory=list)

openenv_server/__init__.py ADDED Viewed

	@@ -0,0 +1 @@


1	+ """OpenEnv FastAPI app package."""

openenv_server/app.py ADDED Viewed

	@@ -0,0 +1,150 @@

+from __future__ import annotations
+from pathlib import Path
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from openenv.core.env_server.http_server import create_app
+from openenv_runtime.environment import OpenEnvOrigamiEnvironment
+from openenv_runtime.models import OrigamiAction, OrigamiObservation
+app = create_app(
+    env=lambda: OpenEnvOrigamiEnvironment(),
+    action_cls=OrigamiAction,
+    observation_cls=OrigamiObservation,
+    env_name="optigami",
+)
+# ---------------------------------------------------------------------------
+# Demo fold sequences — new format: type, line {start, end}, angle
+# ---------------------------------------------------------------------------
+DEMO_SEQUENCES: dict[str, list[dict]] = {
+    "half_fold": [
+        {"type": "valley", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180.0},
+    ],
+    "quarter_fold": [
+        {"type": "valley", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180.0},
+        {"type": "valley", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180.0},
+    ],
+    "letter_fold": [
+        {"type": "valley", "line": {"start": [0.0, 0.333], "end": [1.0, 0.333]}, "angle": 180.0},
+        {"type": "mountain", "line": {"start": [0.0, 0.667], "end": [1.0, 0.667]}, "angle": 180.0},
+    ],
+    "map_fold": [
+        {"type": "valley", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180.0},
+        {"type": "mountain", "line": {"start": [0.5, 0.0], "end": [0.5, 1.0]}, "angle": 180.0},
+    ],
+    "solar_panel": [
+        {"type": "valley", "line": {"start": [0.0, 0.25], "end": [1.0, 0.25]}, "angle": 180.0},
+        {"type": "mountain", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 180.0},
+        {"type": "valley", "line": {"start": [0.0, 0.75], "end": [1.0, 0.75]}, "angle": 180.0},
+    ],
+    "shelter_wall": [
+        {"type": "valley", "line": {"start": [0.0, 0.333], "end": [1.0, 0.333]}, "angle": 180.0},
+        {"type": "valley", "line": {"start": [0.0, 0.667], "end": [1.0, 0.667]}, "angle": 180.0},
+    ],
+    "stent": [
+        {"type": "valley", "line": {"start": [0.0, 0.25], "end": [1.0, 0.25]}, "angle": 90.0},
+        {"type": "mountain", "line": {"start": [0.0, 0.5], "end": [1.0, 0.5]}, "angle": 90.0},
+        {"type": "valley", "line": {"start": [0.0, 0.75], "end": [1.0, 0.75]}, "angle": 90.0},
+        {"type": "stop", "line": {"start": [0.0, 0.0], "end": [1.0, 1.0]}, "angle": 0.0},
+    ],
+}
+# ---------------------------------------------------------------------------
+# API routes — must be registered BEFORE the StaticFiles catch-all mount
+# ---------------------------------------------------------------------------
+@app.get("/targets", include_in_schema=True)
+def get_targets() -> dict:
+    """Return available task names and metadata for the frontend."""
+    from server.tasks import get_task_by_name, available_task_names
+    result: dict[str, dict] = {}
+    for name in available_task_names():
+        t = get_task_by_name(name)
+        result[name] = {
+            "name": name,
+            "level": t.get("difficulty", 1),
+            "description": t.get("description", ""),
+            "n_creases": t.get("max_folds", 3),
+            "difficulty": t.get("difficulty", 1),
+            "material": t.get("material", "paper"),
+        }
+    return result
+@app.get("/episode/demo", include_in_schema=True)
+def demo_episode(target: str = "half_fold") -> dict:
+    """Return a pre-solved demo episode for the given task."""
+    from server.origami_environment import OrigamiEnvironment
+    from server.models import OrigamiAction as NewOrigamiAction
+    from server.tasks import get_task_by_name
+    # Fall back to half_fold if target not found
+    folds = DEMO_SEQUENCES.get(target, DEMO_SEQUENCES["half_fold"])
+    env = OrigamiEnvironment()
+    obs = env.reset(task_name=target)
+    steps: list[dict] = []
+    for i, fold_dict in enumerate(folds):
+        if fold_dict.get("type") == "stop":
+            break
+        action = NewOrigamiAction(
+            fold_type=fold_dict["type"],
+            fold_line=fold_dict["line"],
+            fold_angle=float(fold_dict.get("angle", 180.0)),
+        )
+        obs = env.step(action)
+        steps.append({
+            "step": i + 1,
+            "fold": fold_dict,
+            "paper_state": obs.paper_state,
+            "metrics": obs.metrics,
+            "done": obs.done,
+        })
+        if obs.done:
+            break
+    task_def = get_task_by_name(target) if target else {}
+    return {
+        "task_name": target,
+        "task": task_def,
+        "steps": steps,
+        "final_metrics": obs.metrics if steps else {},
+    }
+# ---------------------------------------------------------------------------
+# Static file serving — must come LAST so API routes take priority
+# ---------------------------------------------------------------------------
+_BUILD_DIR = Path(__file__).resolve().parent.parent / "build"
+if _BUILD_DIR.exists():
+    app.mount("/", StaticFiles(directory=str(_BUILD_DIR), html=True), name="renderer")
+else:
+    @app.get("/", include_in_schema=False)
+    def missing_renderer_build() -> HTMLResponse:
+        return HTMLResponse(
+            """
+            <html><body style="font-family: sans-serif; margin: 24px;">
+            <h3>Renderer build not found</h3>
+            <p>No <code>build/</code> directory is present in the container.</p>
+            <p>OpenEnv API docs are available at <a href="/docs">/docs</a>.</p>
+            </body></html>
+            """,
+            status_code=200,
+        )

package-lock.json ADDED Viewed

The diff for this file is too large to render. See raw diff

plans/implementation_plan.md ADDED Viewed

	@@ -0,0 +1,485 @@

+# Optigami — Implementation Plan
+> Derived from handoff doc critique, origami math/physics research, and plan review.
+> Last updated: 2026-03-07
+---
+## Resolved Architectural Decisions
+### 1. Code-as-policy for training, step-level for demo
+GRPO samples N completions for a fixed prompt, evaluates each independently, computes group advantages. That maps cleanly to **code-as-policy**: the model outputs a complete fold sequence as a JSON list, the environment executes it sequentially, terminal reward is computed once.
+Step-level breaks GRPO's assumption: at step k, the prompt is conditioned on prior steps which differ across rollouts, so you're no longer comparing N completions to the same situation.
+**Resolution:** Training is code-as-policy (full sequence → single reward). Demo is step-by-step (one fold at a time with live feedback). Same environment, different prompt wrapper. Same model at inference — you just prompt it one fold at a time for the demo.
+### 2. 2D crease pattern is Phase 1, engineering metrics are Phase 2
+**Phase 1 (hackathon MVP):** Build the crease pattern graph, check local foldability, use geometric coverage as progress proxy. Self-contained, can show reward improvement.
+**Phase 2 (if time permits):** Apply fold angles to compute the 3D folded state, compute deployment ratio and bounding box. These become the primary reward, with crease coverage as scaffolding. This is where the "model discovers Miura-ori" story lives.
+If the deadline forces a cut, Phase 1 ships and Phase 2 is explicitly called out as the next step.
+### 3. Scope to local flat-foldability (NP-hardness acknowledged)
+Global flat-foldability (layer ordering) is NP-complete (Bern-Hayes 1996). We target **local flat-foldability** at each vertex, which is polynomial. This is a feature, not a limitation — the pitch: "our rewards check the conditions every origami designer verifies. Global layer ordering is provably NP-complete."
+### 4. Symmetry masking is a noted risk
+For Level 1-2 targets the anchor set is small (≤8 points), manageable. For Level 3+, intersection vertices accumulate to 15-20+ points, giving O(300+) candidate fold lines. The unit square has dihedral-4 symmetry (4 rotations + 4 reflections). For Level 3+, if training shows no convergence after 500 steps, add explicit symmetry-based action pruning.
+---
+## File Structure
+```
+optigami/
+  env/
+    __init__.py
+    graph.py            # CreaseGraph: vertices, edges, cyclic ordering
+    paper_state.py      # PaperState using CreaseGraph, add_crease
+    verifier.py         # Kawasaki, Maekawa, BLB, coverage, deployment ratio
+    rewards.py          # compute_reward (Phase 1 + Phase 2 extension)
+    environment.py      # OpenEnv wrapper, code-as-policy and step modes
+    prompts.py          # LLM observation formatting
+    fold_engine.py      # Phase 2: apply fold angles, compute 3D bounding box
+    targets/
+      validator.py      # crimp-check all .fold files before training
+      half_horizontal.fold
+      half_vertical.fold
+      diagonal.fold
+      cross_fold.fold
+      x_fold.fold
+      pinwheel_base.fold
+      preliminary_base.fold
+      fish_base.fold
+  train.py
+  requirements.txt
+  src/                  # React demo visualizer (existing)
+  plans/
+    implementation_plan.md
+```
+---
+## Phase 1: CreaseGraph (`env/graph.py`)
+Everything builds on this. Get it right first.
+**Data:**
+- `vertices`: `dict[vertex_id → (x, y)]`
+- `edges`: `dict[edge_id → (v1, v2, assignment)]` where assignment ∈ `{M, V, B}`
+- `vertex_edges`: `dict[vertex_id → [edge_ids]]`
+**Key operations:**
+- `add_vertex(x, y, tol=1e-9)` — deduplicated by proximity
+- `add_edge(v1, v2, assignment)` — no duplicates
+- `get_cyclic_edges(vertex_id)` — incident edge IDs sorted by angle of the other endpoint around the vertex (the cyclic order Kawasaki requires)
+- `interior_vertices()` — vertices not on the unit square boundary
+- `split_edge(edge_id, new_vertex_id)` — splits an edge at a vertex, used when a new crease intersects an existing one
+**`add_crease(p1, p2, assignment)` in `PaperState`:**
+1. Validate both endpoints are in the anchor set (within tolerance)
+2. Find all intersections with existing edges
+3. Add intersection vertices and split existing edges at them
+4. Add the new crease edge(s) (possibly split by intersections)
+5. Return `{valid, anchored, new_vertices, errors}`
+**Anchor point set** (grows as creases are added):
+- Boundary corners: `(0,0), (1,0), (1,1), (0,1)`
+- Boundary midpoints of any existing boundary edge
+- All crease-crease intersection vertices
+- Midpoints of existing crease edges
+---
+## Phase 2: Verifiers (`env/verifier.py`)
+### Even-degree fast-fail
+```python
+def has_even_degree(vertex_id, graph) -> bool:
+    return len(graph.get_cyclic_edges(vertex_id)) % 2 == 0
+```
+Runs before Kawasaki. Odd-degree interior vertices are impossible — short-circuit immediately.
+### Kawasaki-Justin
+Sector angles must be computed in **cyclic angular order** around each vertex — not by magnitude, not arbitrarily. The handoff's sorted-angle approach was wrong; cyclic order is recovered by sorting incident edge directions by `arctan2`.
+```python
+def check_kawasaki_at_vertex(vertex_id, graph) -> tuple[bool, float]:
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)  # sorted by angle
+    n = len(cyclic_edges)
+    if n % 2 != 0:
+        return False, float('inf')
+    if n < 4:
+        return True, 0.0  # boundary vertex, not an interior fold vertex
+    v = graph.vertices[vertex_id]
+    angles = []
+    for eid in cyclic_edges:
+        v1, v2, _ = graph.edges[eid]
+        other = v2 if v1 == vertex_id else v1
+        other_pos = graph.vertices[other]
+        angles.append(np.arctan2(other_pos[1] - v[1], other_pos[0] - v[0]))
+    # angles is already in cyclic order (cyclic_edges sorted by angle)
+    sectors = []
+    for i in range(n):
+        diff = angles[(i+1) % n] - angles[i]
+        if diff < 0:
+            diff += 2 * np.pi
+        sectors.append(diff)
+    alt_sum = sum(s * ((-1)**i) for i, s in enumerate(sectors))
+    return abs(alt_sum) < 1e-9, abs(alt_sum)
+```
+### Maekawa-Justin
+Boundary edges (`B`) must not be counted — only fold edges (`M`, `V`). The handoff counted boundary edges, which breaks Maekawa for any crease touching the paper edge.
+```python
+def check_maekawa_at_vertex(vertex_id, graph) -> bool:
+    fold_edges = [eid for eid in graph.vertex_edges[vertex_id]
+                  if graph.edges[eid][2] in ('M', 'V')]
+    if len(fold_edges) < 4:
+        return True  # not an interior fold vertex yet
+    M = sum(1 for eid in fold_edges if graph.edges[eid][2] == 'M')
+    V = len(fold_edges) - M
+    return abs(M - V) == 2
+```
+### Big-Little-Big (BLB)
+At any interior vertex, if a sector angle is a strict local minimum, the two crease lines bounding that sector must have **opposite MV parity**. This is the key pruning rule between Maekawa and layer-ordering — a pattern can satisfy Maekawa while violating BLB, meaning no valid layer ordering exists.
+```python
+def check_blb_at_vertex(vertex_id, graph) -> list[tuple]:
+    """Returns list of (edge_a, edge_b) pairs where BLB is violated."""
+    cyclic_edges = graph.get_cyclic_edges(vertex_id)
+    n = len(cyclic_edges)
+    if n < 4:
+        return []
+    sectors = _compute_sectors(vertex_id, cyclic_edges, graph)
+    violations = []
+    for i in range(n):
+        prev_s = sectors[(i-1) % n]
+        next_s = sectors[(i+1) % n]
+        if sectors[i] < prev_s and sectors[i] < next_s:  # strict local min
+            left_eid = cyclic_edges[i]
+            right_eid = cyclic_edges[(i+1) % n]
+            a_left = graph.edges[left_eid][2]
+            a_right = graph.edges[right_eid][2]
+            if a_left in ('M', 'V') and a_right in ('M', 'V') and a_left == a_right:
+                violations.append((left_eid, right_eid))
+    return violations
+```
+### Geometric Coverage (with excess penalty)
+One-sided coverage alone rewards placing target creases but doesn't penalize surplus creases. Both are returned separately so the reward function can weight them independently.
+```python
+def geometric_coverage(state, target_edges, tol_pos=0.05, tol_angle=5.0) -> tuple[float, float]:
+    """
+    Returns (coverage, economy).
+    coverage: fraction of target creases matched by current creases [0, 1]
+    economy:  penalty for excess creases [0, 1], 1.0 = no excess
+    """
+    matched = 0
+    for t_edge in target_edges:
+        for c_edge in state.crease_edges():
+            if _edges_match(t_edge, c_edge, tol_pos, tol_angle):
+                matched += 1
+                break
+    n_target = max(len(target_edges), 1)
+    n_current = len(state.crease_edges())
+    coverage = matched / n_target
+    economy = max(0.0, 1.0 - max(0, n_current - n_target) / n_target)
+    return coverage, economy
+```
+---
+## Phase 3: Reward Function (`env/rewards.py`)
+### Phase 1 reward
+Single consistent definition. `progress` carries 45% — it's the only signal with real geometric content at every step. Validity signals split 20% total. Economy penalizes excess creases.
+```python
+def compute_reward_phase1(state, action_result, target) -> dict:
+    r = {}
+    r['format'] = 1.0 if action_result['valid'] else 0.0
+    if not r['format']:
+        return {**r, 'total': -0.1}
+    r['anchored'] = 1.0 if action_result['anchored'] else 0.3
+    interior = state.graph.interior_vertices()
+    n = max(len(interior), 1)
+    kaw = [check_kawasaki_at_vertex(v, state.graph) for v in interior]
+    mae = [check_maekawa_at_vertex(v, state.graph) for v in interior]
+    blb = [check_blb_at_vertex(v, state.graph) for v in interior]
+    r['kawasaki'] = sum(ok for ok, _ in kaw) / n
+    r['maekawa']  = sum(mae) / n
+    r['blb']      = 1.0 - sum(len(v) > 0 for v in blb) / n
+    coverage, economy = geometric_coverage(state, target['edges'])
+    r['progress'] = coverage
+    r['economy']  = economy
+    all_valid = (r['kawasaki'] == 1.0 and r['maekawa'] == 1.0 and r['blb'] == 1.0)
+    r['completion'] = 10.0 if (r['progress'] > 0.9 and all_valid) else 0.0
+    r['efficiency'] = -0.01
+    r['total'] = (
+        0.05 * r['anchored'] +
+        0.08 * r['kawasaki'] +
+        0.07 * r['maekawa'] +
+        0.05 * r['blb'] +
+        0.45 * r['progress'] +
+        0.10 * r['economy'] +
+        r['completion'] +
+        r['efficiency']
+    )
+    return r
+```
+### Phase 2 reward extension
+When `fold_engine.py` is available, replace `progress` and `economy` with engineering metrics. No pre-specified target pattern required — the model optimizes objectives directly and can discover that Miura-ori is optimal.
+```python
+def compute_reward_phase2(state, action_result, folded_state) -> dict:
+    # ... same gates as phase 1 ...
+    r['deployment_ratio'] = compute_deployment_ratio(folded_state)
+    # = unfolded_area / folded_bounding_box_area
+    r['bbox_compactness'] = 1.0 - (folded_bbox_area / unfolded_area)
+    # higher = more compact fold
+    r['total'] = (
+        0.05 * r['anchored'] +
+        0.08 * r['kawasaki'] +
+        0.07 * r['maekawa'] +
+        0.05 * r['blb'] +
+        0.30 * r['deployment_ratio'] +
+        0.20 * r['bbox_compactness'] +
+        0.05 * r['economy'] +
+        r['completion'] +
+        r['efficiency']
+    )
+    return r
+```
+---
+## Phase 4: Prompts (`env/prompts.py`)
+### Code-as-policy prompt (training mode)
+```
+You are an origami designer. Generate a complete fold sequence for a unit square [0,1]x[0,1].
+TARGET CREASE PATTERN:
+  Valley fold: (0.0, 0.5) -> (1.0, 0.5)
+  Mountain fold: (0.5, 0.0) -> (0.5, 1.0)
+RULES (your sequence must satisfy at every interior vertex):
+  - Kawasaki: alternating sector angles sum equally (each half = 180 degrees)
+  - Maekawa: |mountain_count - valley_count| = 2
+  - Big-Little-Big: folds bounding the smallest sector must have opposite types
+ANCHOR POINTS (valid fold endpoints):
+  Corners:   (0,0)  (1,0)  (1,1)  (0,1)
+  Midpoints: (0.5,0)  (1,0.5)  (0.5,1)  (0,0.5)
+  Note: the square has 4-fold dihedral symmetry — symmetric fold sequences are equivalent.
+Output a JSON list of fold operations in order. Both endpoints must be anchor points.
+<folds>
+[
+  {"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M"|"V"},
+  ...
+]
+</folds>
+```
+### Step-level prompt (demo mode)
+Same information, but shows only the current step's observation with prior fold history and last-step reward appended. Same model, different prompt wrapper.
+```
+... [same header] ...
+CURRENT STATE (step 2 of 8):
+  Creases placed:
+    1. Mountain fold: (0.5, 0.0) -> (0.5, 1.0)
+AVAILABLE ANCHOR POINTS:
+  Corners:       (0.0,0.0)  (1.0,0.0)  (1.0,1.0)  (0.0,1.0)
+  Edge midpoints:(0.5,0.0)  (1.0,0.5)  (0.5,1.0)  (0.0,0.5)
+  Intersections: (0.5,0.5)
+LAST REWARD: format=1.0  kawasaki=1.0  maekawa=1.0  blb=1.0  progress=0.32  total=0.33
+Add the next crease. Output JSON only:
+{"instruction": "...", "from": [x1, y1], "to": [x2, y2], "assignment": "M"|"V"}
+```
+---
+## Phase 5: Target Files + Validator (`env/targets/`)
+Targets are hand-authored `.fold` JSON. Before any target enters training, `validator.py` runs:
+1. Parse FOLD JSON, reconstruct the CreaseGraph
+2. For each interior vertex: even-degree → Kawasaki → Maekawa → BLB
+3. Enumerate at least one valid MV assignment via the crimp algorithm
+4. Fail loudly with vertex + violation details if any check fails
+**Target set:**
+| File | Creases | Level | Interior vertices |
+|------|---------|-------|-------------------|
+| `half_horizontal.fold` | 1 | 1 | 0 |
+| `half_vertical.fold` | 1 | 1 | 0 |
+| `diagonal.fold` | 1 | 1 | 0 |
+| `cross_fold.fold` | 2 | 2 | 1 (degree 4) |
+| `x_fold.fold` | 2 | 2 | 1 (degree 4) |
+| `pinwheel_base.fold` | 4 | 2 | 4 |
+| `preliminary_base.fold` | 4 | 3 | 4 |
+| `fish_base.fold` | 6 | 3 | 6 |
+Level 1 targets have zero interior vertices — Kawasaki/Maekawa are vacuously satisfied, the only reward signal is `progress`. The model learns to place geometrically correct folds before worrying about vertex constraints.
+---
+## Phase 6: OpenEnv Wrapper (`env/environment.py`)
+Both modes supported. The `info` dict explicitly labels what is and isn't checked.
+```python
+class OrigamiEnvironment(Environment):
+    async def step(self, action):
+        if isinstance(action, list):
+            return self._execute_sequence(action)  # code-as-policy
+        else:
+            return self._execute_single(action)    # step mode
+    def _execute_sequence(self, folds):
+        for fold in folds:
+            result = self.paper.add_crease(
+                fold['from'], fold['to'], fold['assignment']
+            )
+            if not result['valid']:
+                break  # partial credit: reward up to failure point
+        reward = compute_reward_phase1(self.paper, result, self.target)
+        return self._get_observation(), reward, True, self._info()
+    def _info(self):
+        interior = self.paper.graph.interior_vertices()
+        return {
+            'local_foldability': all(
+                check_kawasaki_at_vertex(v, self.paper.graph)[0] and
+                check_maekawa_at_vertex(v, self.paper.graph)
+                for v in interior
+            ),
+            'blb_satisfied': all(
+                len(check_blb_at_vertex(v, self.paper.graph)) == 0
+                for v in interior
+            ),
+            'global_foldability': 'not_checked',  # NP-complete (Bern-Hayes 1996)
+            'n_interior_vertices': len(interior),
+        }
+```
+---
+## Phase 7: Training Script (`train.py`)
+Code-as-policy GRPO. Each completion is a complete fold sequence. N=8 completions per prompt evaluated in parallel, each with its own fresh `PaperState`. Terminal reward only.
+```python
+def origami_reward_fn(completions, prompts, targets):
+    rewards = []
+    for completion, target in zip(completions, targets):
+        try:
+            folds = parse_fold_list(completion)  # extract JSON from <folds> tags
+            paper = PaperState()
+            for fold in folds:
+                paper.add_crease(fold['from'], fold['to'], fold['assignment'])
+            r = compute_reward_phase1(paper, {'valid': True, 'anchored': True}, target)
+            rewards.append(r['total'])
+        except Exception:
+            rewards.append(-0.1)
+    return rewards
+```
+Log all reward components separately (kawasaki, maekawa, blb, progress, economy) — the decomposed curves are the demo artifact showing the model learning to satisfy geometric constraints.
+---
+## Phase 8: Fold Engine / Phase 2 (`env/fold_engine.py`)
+For flat-folded patterns (all creases at 180°), the folded bounding box is computable from crease pattern + simplified layer assignment. For Level 1-3 targets the layer assignment is tractable (polynomial for single-vertex, and our simple patterns have at most a few interior vertices).
+Apply fold angles via reflection transforms, project to get 2D bounding box of the folded state, compute:
+```
+deployment_ratio = 1.0 / (folded_bbox_area / unfolded_area)
+```
+Higher = more compact = better engineering. With this signal the model can discover optimal fold patterns (Miura-ori, accordion folds) without a pre-specified target.
+---
+## Build Order
+```
+[ ] 1.  requirements.txt (shapely, numpy, pytest)
+[ ] 2.  env/graph.py — CreaseGraph with cyclic ordering, split_edge
+[ ] 3.  Unit test: two crossing creases -> 1 interior vertex of degree 4, correct cyclic order
+[ ] 4.  env/paper_state.py — PaperState.add_crease with intersection handling
+[ ] 5.  env/verifier.py — even-degree, Kawasaki, Maekawa, BLB, geometric_coverage
+[ ] 6.  Unit test: degree-4 vertex with known valid/invalid angles -> Kawasaki pass/fail
+[ ] 7.  Unit test: single crease -> zero interior vertices -> verifiers return defaults (True)
+[ ] 8.  Unit test: excess crease penalty activates correctly
+[ ] 9.  targets/validator.py — crimp-check routine
+[ ] 10. env/targets/*.fold — 4 Level 1 + 4 Level 2 targets, all passing validator
+[ ] 11. env/rewards.py — Phase 1 compute_reward
+[ ] 12. env/prompts.py — code-as-policy prompt + step-level prompt
+[ ] 13. env/environment.py — both sequence and step modes + info dict
+[ ] 14. Integration test: known valid sequence on half_horizontal, reward >= 0.9
+[ ] 15. Integration test: invalid MV assignment on cross_fold, BLB fires
+[ ] 16. train.py — GRPO with code-as-policy reward fn
+[ ] 17. First training run on Level 1 targets, log all reward components to W&B
+[ ] 18. env/fold_engine.py — Phase 2: fold angles -> 3D state -> deployment ratio
+[ ] 19. Visualizer (React): render crease graph from FOLD JSON, animate fold history
+```
+Steps 2-3 and 5-8 are highest risk. Get the graph data structure and cyclic Kawasaki check correct before building anything on top of them. Steps 14-15 are the checkpoint before touching the training script.
+---
+## Key Risks
+| Risk | Likelihood | Mitigation |
+|------|-----------|------------|
+| Cyclic sector angle computation incorrect | High | Explicit unit tests with known valid/invalid patterns |
+| Level 3+ action space too large to learn | Medium | Dihedral symmetry hints in prompt; hard masking if no convergence after 500 steps |
+| GRPO reward signal too sparse (no interior vertices on Level 1) | Medium | Level 1 reward is purely `progress`; works without vertex constraints |
+| fold_engine Phase 2 infeasible in hackathon time | Medium | Phase 1 ships independently; Phase 2 is an extension |
+| Layer ordering required for deployment ratio on complex patterns | Low | Level 1-3 patterns are tractable; flag NP-hardness in info dict |

pyproject.toml ADDED Viewed

	@@ -0,0 +1,20 @@

+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+[project]
+name = "optigami"
+version = "0.1.0"
+description = "Optigami OpenEnv origami environment"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "fastapi>=0.100.0",
+  "numpy>=1.24.0",
+  "openenv-core[core]>=0.2.1",
+  "pydantic>=2.0.0",
+  "shapely>=2.0.0",
+]
+[tool.pytest.ini_options]
+pythonpath = ["."]

requirements.txt ADDED Viewed

	@@ -0,0 +1,5 @@

+shapely>=2.0.0
+numpy>=1.24.0
+fastapi>=0.100.0
+uvicorn>=0.23.0
+pydantic>=2.0.0