programasweights 0.3.2__tar.gz → 0.4.1__tar.gz

{programasweights-0.3.2 → programasweights-0.4.1}/AGENTS.md

@@ -5,27 +5,35 @@ PAW compiles natural language specifications into tiny neural functions that run
 Website: https://programasweights.com
 Full documentation: https://programasweights.readthedocs.io
 
+## When to Use PAW
+
+- **Fuzzy search** — typo-tolerant matching, semantic search, near-duplicate detection
+- **Format repair** — fix broken JSON, normalize dates, repair malformed inputs
+- **Classification** — sentiment, urgency, categories defined in your own words
+- **Extraction** — emails, names, dates from messy unstructured text
+- **Log triage** — extract errors from verbose output, filter noise
+- **Intent routing** — map user descriptions to the closest URL, menu item, or setting
+- **Agent preprocessing** — parse tool calls, validate outputs, route tasks
+
 ## Install
 
 ```bash
 pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
 ```
 
-## Usage
+## Quickstart
 
 ```python
 import programasweights as paw
 
 # Use a pre-compiled function (downloads once, runs locally forever)
-# "email-triage" is an official pre-compiled program (slug)
 fn = paw.function("email-triage")
 fn("Urgent: server is down!")  # "immediate"
 fn("Newsletter: spring picnic")  # "wait"
 
 # Compile your own from a description
 program = paw.compile(
-    "Fix malformed JSON: repair missing quotes and trailing commas",
-    compiler="paw-4b-qwen3-0.6b"  # or "paw-4b-gpt2" for smaller/faster
+    "Fix malformed JSON: repair missing quotes and trailing commas"
 )
 fn = paw.function(program.id)
 fn("{name: 'Alice',}")  # '{"name":"Alice"}'
@@ -35,20 +43,18 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you want the smaller browser-compatible runtime explicitly, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
-- **Standard** (`paw-4b-qwen3-0.6b`) — higher accuracy, 594 MB base + ~22 MB/program. Default.
+- **Standard** (`paw-4b-qwen3-0.6b`) — higher accuracy, 594 MB base + ~22 MB/program. This is the current server default.
 - **Compact** (`paw-4b-gpt2`) — smaller (134 MB base + ~5 MB/program), runs in browser via WebAssembly.
 
-## When to Use PAW
+Best practice:
 
-- **Fuzzy search** — typo-tolerant matching, semantic search, near-duplicate detection
-- **Format repair** — fix broken JSON, normalize dates, repair malformed inputs
-- **Classification** — sentiment, urgency, categories defined in your own words
-- **Extraction** — emails, names, dates from messy unstructured text
-- **Log triage** — extract errors from verbose output, filter noise
-- **Intent routing** — map user descriptions to the closest URL, menu item, or setting
-- **Agent preprocessing** — parse tool calls, validate outputs, route tasks
+- For quickstarts and reusable agent workflows, prefer `paw.compile(spec)` with no explicit compiler.
+- If you need to target a specific runtime, pass `compiler="paw-4b-gpt2"` or another supported alias explicitly.
+- If you need to inspect current server-supported compiler names at runtime, call `paw.list_compilers()`.
 
 ## Writing Good Specs
 
@@ -73,58 +79,30 @@ Output: delete
 
 **Spec-tuning tips:**
 
-- Each function is stateless: one text input, one text output. No conversation history.
 - **State output constraints explicitly**: "Return ONLY one of: X, Y, Z". Without this the model may produce free-form text.
 - **Include examples from your actual data**: Examples outperform prose-only descriptions.
 - **Debug failures before sweeping**: Look at specific failing examples and understand WHY before trying many variants.
 
-## Context Window
+## Constraints And Runtime Behavior
 
+- Each PAW function is stateless: one text input, one text output. No conversation history.
 - Spec + input + output share a ~2048 token context window. Inputs that exceed it will error.
 - `max_tokens` defaults to `None`: generation runs until EOS or the context limit.
+- Compile runs on the hosted PAW API. Inference should usually run locally through the SDK.
+- **GPU acceleration** is enabled by default (`n_gpu_layers=-1`). Uses Metal on Mac, CUDA on Linux, and falls back to CPU automatically. If GPU causes issues, set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0`.
+- **First call** is usually ~1-5s because it loads the base model. Subsequent calls are typically ~0.05-0.5s depending on input length and GPU availability.
+- **Base model files are shared** across programs on disk. Each Standard LoRA adapter is ~22 MB; each Compact LoRA adapter is ~5 MB.
+- Cache root is `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
+- After the first download, inference works offline.
 
-## Chaining Functions
-
-Multiple PAW functions can be composed for multi-step tasks:
-
-```python
-classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
-fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")
-
-label = classifier(code_snippet)
-if label != "other":
-    fix = fixer(f"{label}: {code_snippet}")
-```
-
-Chain them with regular Python logic.
-
-## Log Monitoring
-
-PAW functions can classify log output. Compile once with examples from your specific logs, then reuse the function locally forever:
-
-```python
-program = paw.compile("""
-Classify log lines. Return ONLY one word: ALERT or QUIET.
-
-Input: [step 100] loss=0.05 lr=0.0001
-Output: QUIET
-
-Input: [Checkpoint] Saved model at step 1000
-Output: ALERT
-
-Input: Traceback (most recent call last):
-Output: ALERT
-
-Input: Training complete. Final loss: 0.11
-Output: ALERT
-""")
-
-fn = paw.function(program.id)  # reuse with saved program.id
-fn("[step 200] loss=0.04")           # "QUIET"
-fn("[Checkpoint] Saved model")       # "ALERT"
-```
+## Common Errors
 
-Full tool with file watching, truncation, and stall detection: [examples/paw_monitor.py](https://github.com/programasweights/programasweights-python/blob/main/examples/paw_monitor.py)
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `RuntimeError: assets not ready` on download | Program is still generating after compile | The SDK polls automatically for up to 30s. If it still fails, retry shortly or recompile. |
+| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) or request validation failed | Adjust spec length or request shape. |
+| `httpx.HTTPStatusError: 429` | Hosted compile API limit exceeded | Wait, or sign in for higher compile limits. |
+| GPU/Metal errors on load | GPU backend not available or incompatible | Set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0` to force CPU. |
 
 ## Browser / JavaScript SDK
 
@@ -137,11 +115,13 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: server is down!');
 // result: "immediate"
 ```
 
+The browser SDK resolves slugs through the PAW API, then downloads browser assets from Hugging Face and runs inference client-side. If you load by program ID, browser inference stays independent of the PAW API at runtime.
+
 ## Authentication (optional)
 
 Sign in for higher rate limits and program naming. Everything works without it.
@@ -155,8 +135,11 @@ Generate API keys at https://programasweights.com/settings.
 | | Anonymous | Authenticated |
 |---|---|---|
 | Compile rate limit | 20/hr | 60/hr |
+| Concurrent compile requests | 1 | 2 |
 | Name programs (slugs) | No | Yes |
 
+Hosted API limits apply to compile requests. Most inference should run locally through the SDK.
+
 ## CLI
 
 Commands: `paw compile --spec "..." --json`, `paw run --program <id> --input "..."`, `paw info <id>`, `paw rename <id> <slug>`, `paw login`. All support `--json` for structured output.
@@ -175,14 +158,14 @@ fn = paw.function("da03/word-counter@v1")  # pinned to v1
 versions = paw.list_versions("da03/word-counter")  # all versions
 ```
 
-Pinned versions (`@v1`) are immutable and cached locally forever. Bare slugs always check the server for the latest main version (falls back to cache if offline).
+Pinned versions (`@v1`) are immutable and cached locally forever. Bare slugs always check the server for the latest main version and fall back to cache if offline.
 
 ## Full API Reference
 
 ```python
 program = paw.compile(
     spec,                               # natural language specification (str)
-    compiler="paw-4b-qwen3-0.6b",
+    compiler=None,                      # omit to use the current server default (today: paw-4b-qwen3-0.6b)
     slug=None,                          # URL-safe handle (requires auth)
     public=True,                        # list on public hub
 )
@@ -196,30 +179,57 @@ fn = paw.function("da03/my-classifier", offline=True)  # skip server check
 
 result: str = fn(input_text: str, max_tokens=None, temperature=0.0)
 
-fn = paw.compile_and_load(spec, compiler="paw-4b-qwen3-0.6b")
+fn = paw.compile_and_load(spec)
 
 versions = paw.list_versions("da03/my-classifier")  # version history
 programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
+compilers = paw.list_compilers()  # discover available compilers at runtime
 
 paw.login()
 ```
 
-## Common Errors
+## Chaining Functions
 
-| Error | Cause | Fix |
-|-------|-------|-----|
-| `RuntimeError: assets not ready` on download | Program still generating after compile | SDK polls automatically for up to 30s. If persistent, recompile. |
-| `httpx.HTTPStatusError: 422` on compile | Spec too short (<10 chars) | Adjust spec length. |
-| `httpx.HTTPStatusError: 429` | Rate limit exceeded | Wait, or sign in for higher limits. |
-| GPU/Metal errors on load | GPU backend not available or incompatible | Set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0` to force CPU. |
+Multiple PAW functions can be composed for multi-step tasks:
+
+```python
+classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
+fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")
 
-## Performance
+label = classifier(code_snippet)
+if label != "other":
+    fix = fixer(f"{label}: {code_snippet}")
+```
+
+Chain them with regular Python logic.
 
-- **GPU acceleration** enabled by default (`n_gpu_layers=-1`). Uses Metal on Mac, CUDA on Linux, falls back to CPU automatically. If GPU causes issues, set `PAW_GPU_LAYERS=0` or pass `n_gpu_layers=0`.
-- **First call** ~1-5s (loads base model). Subsequent calls ~0.05-0.5s depending on input length and GPU availability.
-- **Base model shared** across functions on disk. Each LoRA adapter adds ~22 MB.
-- **Cache**: `~/.cache/programasweights/`. Override with `PAW_CACHE_DIR`.
-- **Offline** after first download.
+## Worked Example: Log Monitoring
+
+PAW functions can classify log output. Compile once with examples from your specific logs, then reuse the function locally forever:
+
+```python
+program = paw.compile("""
+Classify log lines. Return ONLY one word: ALERT or QUIET.
+
+Input: [step 100] loss=0.05 lr=0.0001
+Output: QUIET
+
+Input: [Checkpoint] Saved model at step 1000
+Output: ALERT
+
+Input: Traceback (most recent call last):
+Output: ALERT
+
+Input: Training complete. Final loss: 0.11
+Output: ALERT
+""")
+
+fn = paw.function(program.id)  # reuse with saved program.id
+fn("[step 200] loss=0.04")           # "QUIET"
+fn("[Checkpoint] Saved model")       # "ALERT"
+```
+
+Full tool with file watching, truncation, and stall detection: [examples/paw_monitor.py](https://github.com/programasweights/programasweights-python/blob/main/examples/paw_monitor.py)
 
 ## Case Studies
 

{programasweights-0.3.2 → programasweights-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programasweights
-Version: 0.3.2
+Version: 0.4.1
 Summary: Compile natural language specifications into neural programs that run locally via llama.cpp.
 Project-URL: Homepage, https://programasweights.com
 Project-URL: Repository, https://github.com/programasweights/programasweights-python
@@ -53,7 +53,6 @@ fn("Newsletter: spring picnic")          # "wait"
 # Compile your own from a description
 program = paw.compile(
     "Fix malformed JSON: repair missing quotes and trailing commas",
-    compiler="paw-4b-qwen3-0.6b",  # or "paw-4b-gpt2" for smaller/faster
     slug="json-fixer"              # optional: creates username/json-fixer handle
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
@@ -64,7 +63,9 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you specifically want the smaller browser-compatible runtime, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
 
 |                 | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
@@ -76,13 +77,15 @@ fn("I love this!")  # "positive"
 | Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
 | Runs in browser | No                    | Yes (WebAssembly)    |
 
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
+
+If you need to inspect available compiler aliases programmatically, use `paw.list_compilers()`.
 
 GPU acceleration is enabled by default (Metal on Mac, CUDA on Linux, falls back to CPU). Set `PAW_GPU_LAYERS=0` to force CPU if GPU causes issues.
 
 ## Browser SDK
 
-Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
+Programs compiled with GPT-2 also run in the browser via WebAssembly. The initial model and program assets download automatically; inference then runs client-side.
 
 ```bash
 npm install @programasweights/web
@@ -91,11 +94,15 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: the server is down!');
 // result: "immediate"
 ```
 
+If you load by program ID, browser inference only depends on Hugging Face-hosted assets. Slugs still need one PAW API lookup.
+
+New browser-compatible programs are uploaded to Hugging Face asynchronously after compile. They are usually ready within a minute or two, but under load can take a few minutes, so a freshly compiled browser program may need a short wait before the JS SDK can load it.
+
 See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
 
 ## Use with AI Agents

{programasweights-0.3.2 → programasweights-0.4.1}/PYPI_README.md

@@ -23,7 +23,6 @@ fn("Newsletter: spring picnic")          # "wait"
 # Compile your own from a description
 program = paw.compile(
     "Fix malformed JSON: repair missing quotes and trailing commas",
-    compiler="paw-4b-qwen3-0.6b",  # or "paw-4b-gpt2" for smaller/faster
     slug="json-fixer"              # optional: creates username/json-fixer handle
 )
 fn = paw.function(program.slug)    # or paw.function(program.id)
@@ -34,7 +33,9 @@ fn = paw.compile_and_load("Classify sentiment as positive or negative")
 fn("I love this!")  # "positive"
 ```
 
-## Two Compilers
+If you specifically want the smaller browser-compatible runtime, pass `compiler="paw-4b-gpt2"`. Otherwise, omit `compiler` and let the server default decide.
+
+## Current Public Compilers
 
 
 |                 | Standard (Qwen3 0.6B) | Compact (GPT-2 124M) |
@@ -46,13 +47,15 @@ fn("I love this!")  # "positive"
 | Local inference | ~0.05-0.5s per call   | ~0.03-0.3s per call  |
 | Runs in browser | No                    | Yes (WebAssembly)    |
 
-Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
+The current server default is Standard (`paw-4b-qwen3-0.6b`). Use Compact (`paw-4b-gpt2`) when you need smaller files or browser deployment.
+
+If you need to inspect available compiler aliases programmatically, use `paw.list_compilers()`.
 
 GPU acceleration is enabled by default (Metal on Mac, CUDA on Linux, falls back to CPU). Set `PAW_GPU_LAYERS=0` to force CPU if GPU causes issues.
 
 ## Browser SDK
 
-Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
+Programs compiled with GPT-2 also run in the browser via WebAssembly. The initial model and program assets download automatically; inference then runs client-side.
 
 ```bash
 npm install @programasweights/web
@@ -61,11 +64,15 @@ npm install @programasweights/web
 ```javascript
 import paw from '@programasweights/web';
 
-const fn = await paw.function('programasweights/email-triage');
+const fn = await paw.function('email-triage-browser');
 const result = await fn('Urgent: the server is down!');
 // result: "immediate"
 ```
 
+If you load by program ID, browser inference only depends on Hugging Face-hosted assets. Slugs still need one PAW API lookup.
+
+New browser-compatible programs are uploaded to Hugging Face asynchronously after compile. They are usually ready within a minute or two, but under load can take a few minutes, so a freshly compiled browser program may need a short wait before the JS SDK can load it.
+
 See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
 
 ## Use with AI Agents

programasweights-0.4.1/README.md

@@ -0,0 +1,186 @@
+# ProgramAsWeights
+
+Programs as small weight blobs; a fixed interpreter runs them.
+
+## Development
+
+```
+pip install -e .
+```
+
+```
+python test_compile.py
+```
+
+```
+python test_execute.py
+```
+
+
+## Quickstart
+
+```bash
+pip install programasweights
+```
+
+```python
+import programasweights
+f = programasweights.function("/path/to/weights")
+print(f("Hello"))
+```
+
+- weights = programs; base model = interpreter.
+- Deterministic by default (greedy generation).
+
+## 🌐 Web Interface
+
+ProgramAsWeights includes a modern web interface for easy interaction with the system. The web app provides a user-friendly way to compile specifications, test neural programs, and manage models without writing code.
+
+### Features
+
+- **Interactive Model Selection**: Choose from available compiler and interpreter models
+- **Natural Language Specifications**: Describe your program in plain English
+- **GPT-Powered Examples**: Auto-generate test data using OpenAI's API
+- **Real-time Compilation**: Compile specs into neural programs instantly
+- **Interactive Testing**: Test compiled programs with custom inputs
+- **Model Downloads**: Download compiled models as `.tgz` files
+- **Community Sharing**: Publish and discover programs on the leaderboard
+
+### Quick Start
+
+1. **Prerequisites**: Ensure you have Python 3.8+, Node.js 16+, and npm installed
+
+2. **Start the application**:
+   ```bash
+   cd web-app
+   ./start.sh
+   ```
+
+3. **Access the interface**:
+   - **Web App**: http://localhost:5173
+   - **API Docs**: http://localhost:8000/docs
+
+The startup script automatically:
+- Installs Python and Node.js dependencies
+- Starts the FastAPI backend server
+- Starts the React frontend development server
+
+### Manual Setup (Alternative)
+
+If you prefer manual setup:
+
+```bash
+# Backend
+cd web-app/backend
+pip install -r requirements.txt
+python run_server.py
+
+# Frontend (in another terminal)
+cd web-app/frontend  
+npm install
+npm run dev
+```
+
+### Configuration
+
+Create `web-app/backend/.env` with:
+```bash
+OPENAI_API_KEY=your_openai_api_key_here  # Optional: for GPT test generation
+CHECKPOINT_DIR=../../outputs_1spec/prefix_kv  # Path to trained models
+```
+
+### Example Workflow
+
+1. Select "Qwen 2.5 Coder 0.5B" as compiler and "PAW Interpreter" as interpreter
+2. Enter specification: *"Parse a string like '(A) cat (B) dog' into a JSON list"*
+3. Generate examples with GPT or add manually
+4. Click "Compile" to create your neural program
+5. Test with input: *"(A) red apple (B) green banana"*
+6. Download or publish your compiled model
+
+For detailed documentation, see [`web-app/README.md`](web-app/README.md).
+
+## Train a compiler→KV prefix→interpreter (defaults)
+
+```bash
+# installs training extras
+pip install -e .[train]
+
+# trains on data/samples_train.jsonl with Qwen defaults
+paw-train
+```
+
+- Produces checkpoint under `outputs/prefix_kv/checkpoint/`.
+
+## Compile then run (qualitative eval)
+
+```bash
+# compile a prompt into a KV-prefix artifact
+paw-eval
+```
+
+Or programmatically:
+
+```python
+import programasweights as paw
+
+prompt = (
+    "Parse a string like '(A) ... (B) ... (C) ...' into a JSON list of options. "
+    "Be robust to noise: extra spaces, bullets, and phrases like 'both (A) and (B)'."
+)
+
+artifact_dir = paw.compile(
+    out_dir="outputs/prefix_kv/demo_program",
+    spec=prompt,
+    checkpoint_dir="outputs/prefix_kv/checkpoint",
+)
+
+f = paw.function(artifact_dir, interpreter_name="Qwen/Qwen2.5-Coder-0.5B-Instruct", max_new_tokens=128)
+print(f("(A) cat  (B) dog  (C) both (A) and (B) are possible"))
+```
+
+- The dummy compiler is still available as `compile_dummy` for tests and demos.
+
+## API
+
+```python
+import programasweights
+parse_func = programasweights.function(
+    "/path/to/weights.safetensors",
+    interpreter_name="google/flan-t5-small",
+    max_new_tokens=128,
+)
+output = parse_func("input string")
+```
+
+- Accepts `str` or `List[str]` and returns the same shape.
+- Aliasing works: `import programasweights as paw`.
+
+## Local development
+
+```bash
+pip install -e .[test]
+pytest -q
+```
+
+```bash
+# smoke check
+python -c "import programasweights as paw; print(paw.__version__)"
+```
+
+- `pip install -e .` installs in editable mode so code changes are picked up without reinstalling.
+- If you do not need editable mode: `pip install .` (you must reinstall after changes).
+
+## Notes
+
+- MVP runtime uses a single in-process interpreter (loads the base model once and stays warm).
+- Program artifact can be a prompt/prefix (text file) or a KV-prefix directory with `program.json` and `kv_prefix.pt`.
+- Device selection: CUDA if available, else CPU. Override with env var `PROGRAMASWEIGHTS_DEVICE`.
+- Simple global lock around `generate()` for thread safety.
+
+## Roadmap
+
+- Compiler: spec → weights
+- LoRA support
+- JSON-constrained decoding
+- Server mode (multi-tenant)

{programasweights-0.3.2 → programasweights-0.4.1}/docs/case-studies/site-navigation.md

@@ -21,20 +21,20 @@ Pages: /playground, /hub, /browser, /docs, /settings, /about
 
 ### Attempt 2: Reframe as classification
 
-Instead of generating URLs, output a digit: 1 = Playground, 2 = Hub, 3 = Browser, etc. The frontend maps digits to actual routes.
+Instead of generating URLs, output a short semantic label such as `playground`, `docs`, or `feedback`. The frontend maps those labels to actual destinations.
 
 ```
-Classify the user's intent. Return ONLY a single digit.
-1 = Create or compile a new program
-2 = Browse or search existing programs
-3 = Run a program in the browser
+Classify the user's intent. Return ONLY a single label.
+playground = Create or compile a new program
+hub = Browse or search existing programs
+browser = Run a program in the browser
 ...
-0 = None of the above
+none = None of the above
 ```
 
 **Result:** Accuracy jumped from ~67% to ~88%. Classification is far more reliable than generation for routing.
 
-**Lesson:** Reframe generation tasks as classification whenever possible. Output a label or digit, map it to the real value in your code.
+**Lesson:** Reframe generation tasks as classification whenever possible. Output a short label, map it to the real value in your code.
 
 ### Attempt 3: Add Q&A support
 
@@ -71,8 +71,8 @@ validator = paw.function("my-answer-validator")
 
 def handle_query(user_query: str):
     destination = router(user_query)
-    if destination != "0":
-        return {"action": "navigate", "page": PAGES[int(destination)]}
+    if destination != "none":
+        return {"action": "navigate", "page": PAGE_MAP[destination]}
 
     category = q_type(user_query)
     if category == "yes_no":
@@ -92,36 +92,36 @@ Each program has a focused spec. For example, the page classifier:
 
 ```python
 router = paw.compile("""
-Classify the user's intent. Return ONLY a single digit.
-1 = Create or compile something new
-2 = Browse or search existing items
-3 = Run something in the browser
-4 = Read documentation
-5 = Manage account or API keys
-0 = None of the above (likely a question)
+Classify the user's intent. Return ONLY a single label.
+playground = Create or compile something new
+hub = Browse or search existing items
+browser = Run something in the browser
+docs = Read documentation
+settings = Manage account or API keys
+none = None of the above (likely a question)
 
 Input: how do I get started
-Output: 4
+Output: docs
 
 Input: browse community programs
-Output: 2
+Output: hub
 
 Input: is it free?
-Output: 0
+Output: none
 """)
 ```
 
 ## Adapting this for your site
 
 1. **List your pages** with short descriptions of what users do there
-2. **Compile a classifier** that maps intents to page numbers
+2. **Compile a classifier** that maps intents to short labels
 3. **Test with 20-30 real queries** your users would type — iterate on the spec wording
 4. If users also ask questions, add Q&A programs and a validator
 5. Each program compiles once and is cached forever — the pipeline runs locally with no API calls
 
 ## Takeaways
 
-- **Classification beats generation** for routing. Output a label, map it in code.
+- **Classification beats generation** for routing. Output a short label, map it in code.
 - **Multiple small programs beat one complex program.** When accuracy drops, split.
 - **A validator catches failures** the other programs miss — cheap insurance.
 - **Iterate with real queries.** Build a small test set, measure, adjust wording, repeat.