hoodscript 1.2.0__tar.gz → 1.3.1__tar.gz

{hoodscript-1.2.0 → hoodscript-1.3.1}/CHANGELOG.md

@@ -3,6 +3,110 @@
 All notable changes to HoodScript. Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 Versioning: the keyword set is the public API; changing it is at least a minor bump.
 
+## [Unreleased]
+
+## [1.3.1] — 2026-09-12
+
+Patch release: what the fresh-machine check of 1.3.0 found, plus two audit
+leftovers. No keyword or API changes.
+
+### Fixed
+
+- Fresh-machine check of v1.3.0 (`pip install "hoodscript[all]"` in a clean
+  venv, `docs/onboarding.md` §2–§11 verbatim): everything passed except
+  `hoodfarm test` and `hoodarcade test`, which reported "No Sol" for every
+  level and **exited 0** — the reference solutions were not in the wheel and a
+  missing solution counted as a pass. The solutions now ship
+  (`hoodscript/data/solutions`, found by both CLIs after the repo checkout), a
+  missing one is a red `MISSING` row and a non-zero exit, and
+  `tests/test_wheel_contents.py` builds the wheel and asserts the runtime
+  data (curriculum, `vibe.py`, solutions) is inside it.
+
+- `hoodscript --sandbox run f.hs` now works (the flags may come before or after
+  `run`; `run` is recognised as the first positional, not only as `argv[0]`).
+- Jupyter: `%hood_tb` is honoured by the error card — the Python traceback
+  section opens by default and the plain-text fallback carries it too.
+- MANUAL §16 documents that `hoodscript fmt` writes `ain't nobody x` back as
+  `ain't x` (same Python, one canonical spelling).
+- `cli.py` had the `arcade` dispatch block twice; the copy is gone.
+
+## [1.3.0] — 2026-09-12
+
+Three features that were on `main` but not on PyPI: the two games and the
+ecosystem sprint. Keyword set unchanged (v1.1); minor bump for the new
+packages and CLI commands.
+
+### Added
+
+- `hoodarcade levels [game]`: the stage table for one game (`list` stays the
+  all-games form). Added while aligning a stale "Arcade + Ecosystem" prompt
+  with the release — the reconciliation is `PROMPTS.md` §3.5.
+
+- **The Drone Was Replaced** (`hoodfarm`, `pip install "hoodscript[farm]"`, also
+  `hoodscript farm …`): a terminal grid-automation game in the style of *The
+  Farmer Was Replaced*. Program a drone (`bot.move/harvest/plant/water/till/
+  inspect_ground/measure_water`, `bot.bag/energy/ticks_used`) in HoodScript
+  across 8 levels (single-tile harvest → loops → 2D traversal → conditional
+  weeding → irrigation → inventory quotas → companion planting → an
+  energy-budgeted supply chain). Rich TUI with emoji tiles, telemetry,
+  inventory ledger and log console (ASCII fallback); `hoodfarm play <level>`
+  hot-reloads `solution.hs` on save; `hoodfarm run --benchmark` and
+  `hoodfarm test` run headless with proper exit codes. Deterministic ticks.
+  Reference solutions for all 8 levels in `examples/solutions/`.
+- QA on acceptance (external batch): it shipped with a **private game lexicon**
+  — `cook`/`serve`/`run_thru`/`Facts` (cut under Rule Zero) and `dip`
+  remapped to `break` — so 7 of 8 solutions did not parse under `hoodscript`
+  and the game taught a different language. Removed; every starter template
+  and solution translated to v1.1 and verified to win through the real
+  transpiler. Crashes now go through the JPE engine with the player's line and
+  the game state ("drone at (2, 4), energy 0, tick 50"). Cut builtin aliases
+  injected as globals (`span`, `lineup`, `ledger`, `count_up`) removed.
+  Tests guard all of it (no cut word as a code token anywhere in the game).
+
+- **HoodArcade** (`hoodarcade`, `pip install "hoodscript[arcade]"`, also
+  `hoodscript arcade …`): three terminal games, five stages each, with Rich
+  viewports (grill rack + Spades table, 16-step 808 matrix, SNKRS drop feed),
+  hot-reload on save, and progress in `~/.hoodarcade/progress.json`:
+  *Big Mama's Cookout* (grill timing, the potato-salad exception test, aux-cord
+  sorting, a Spades rule engine, an autonomous Spades partner), *BeatLab 808*
+  (four-on-the-floor, trap-hat triplets by modulo, sample chopping, 808 glide
+  interpolation, a full arrangement), *Drop Day* (stock monitor, legit-check
+  filter, exponential backoff with `tryna`/`catch`, multi-cart, a circular
+  trade-graph search). Reference solutions for all 15 stages.
+- QA on acceptance (external batch): same defect as the farm — a **private
+  lexicon** (`cook`/`serve`/`run_thru`/`Facts`, `dip`→`break`) meant no stage
+  solution ran under `hoodscript`; removed, everything translated to v1.1.
+  **Every "starter" template was the finished solution** — a player opened a
+  stage already solved; all 15 rewritten as real scaffolds (API shown,
+  algorithm left to the player; tests assert scaffolds fail and solutions
+  pass). Crashes in player code, including ones the stage checkers catch, now
+  surface as JPE reports with the failing line; a checker fed the wrong
+  return type fails the stage in plain English instead of raising.
+
+- **HPEP 20 — The Zen of HoodScript.** `hoodscript zen` (add `--notes` to see
+  which file each line points at) and `import vibe` from any program, like
+  `import this`. Nineteen lines, each a decision this repo actually made.
+- **`docs/grammar.ebnf`** — the formal grammar as its own artifact, generated
+  from `GRAMMAR.md` by `scripts/gen_ebnf.py`; a test fails if they drift and
+  another checks every keyword has a production (that found `ask` missing).
+- **Grammar-directed fuzzing** (`tests/test_fuzz_ebnf.py`, Hypothesis): generates
+  valid programs from the grammar and asserts they transpile, compile, keep
+  their line count, contain no leaked sentinels or keywords, and that
+  `py2hood(transpile(p))` transpiles back to the same Python. Found and fixed
+  two pattern-layer bugs on its first run: `x = ask "name? "` was a syntax
+  error (R12 only fired at statement start; now anywhere), and `holla (x)` was
+  not reversible (whitespace now decides: `holla(x)` is a call, `holla (x)` is
+  the statement form). `HYPOTHESIS_PROFILE=thorough` runs 2,000 examples per
+  property.
+- **`hoodlib.disk`** — atomic, thread-safe JSON/CSV read/write and backups,
+  standard library only (`from hoodlib import disk`). Errors are the Python
+  exceptions the crash reporter already explains.
+- **ADR-0004: no regional dialect overlays.** A proposal for Bay Area / Atlanta
+  / DMV / MLE token overlays was declined under Rule Zero; a cited, single-
+  variety Tier B extension remains possible via the sourcing procedure. Two
+  companion proposals (`hoodpkg`/`hood.lock`, and a `hoodlib` with AES-GCM and
+  an async HTTP client) were dropped as duplicating Python and its packaging.
+
 ## [1.2.0] — 2026-09-11
 
 ### Added

{hoodscript-1.2.0 → hoodscript-1.3.1}/CONTRIBUTING.md

@@ -64,6 +64,15 @@ Before every push:
 ruff check && pytest
 ```
 
+Enforce it locally once per clone — the versioned pre-push hook runs exactly
+this and refuses the push if it fails:
+
+```bash
+./scripts/install-hooks.sh
+```
+
+(If you pipe `ruff check` into anything, you lose its exit code. Don't.)
+
 That is exactly what CI runs, on Ubuntu, macOS, and Windows × Python
 3.10–3.13, plus a CLI smoke test. Python's exception *messages* differ between
 versions (`was never closed` vs `EOF in multi-line statement`), so a catalog
@@ -107,6 +116,16 @@ with a gate. Commit at the gate with a message that says what changed and
 why; the changelog is written from those messages. Update `CLAUDE.md` when a
 decision changes — stale context is worse than none.
 
+## Landing changes
+
+`main` is protected: the Ubuntu/macOS/Windows test legs and the build must be
+green, force-pushes and deletions are refused, and pull requests need a
+code-owner review (`.github/CODEOWNERS`). **Work you did not write yourself —
+an agent's output included — lands as a pull request**, gets `/code-review`
+and the end-to-end audit in [`PROMPTS.md`](PROMPTS.md) §2.8, and only then
+merges. Two batches arrived on 2026-09-11 claiming completion with defects
+their own tests could not see; that is why.
+
 ## Working with an AI agent
 
 Paste the standing brief from [`PROMPTS.md`](PROMPTS.md) §0 at the top of

{hoodscript-1.2.0 → hoodscript-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hoodscript
-Version: 1.2.0
+Version: 1.3.1
 Summary: A production-grade Python 3 conlang based on AAVE with 1:1 AST parity.
 License: MIT
 License-File: LICENSE
@@ -14,10 +14,13 @@ Requires-Dist: prompt-toolkit>=3.0.40; extra == 'all'
 Requires-Dist: pygls<2,>=1.3.1; extra == 'all'
 Requires-Dist: rich>=13.7; extra == 'all'
 Requires-Dist: ruff>=0.3.0; extra == 'all'
+Provides-Extra: arcade
+Requires-Dist: rich>=13.7; extra == 'arcade'
 Provides-Extra: dev
 Requires-Dist: build>=1.1.0; extra == 'dev'
 Requires-Dist: debugpy>=1.8.0; extra == 'dev'
 Requires-Dist: hatch-vcs>=0.4.0; extra == 'dev'
+Requires-Dist: hypothesis>=6.100; extra == 'dev'
 Requires-Dist: ipykernel>=6.0.0; extra == 'dev'
 Requires-Dist: ipython>=8.0.0; extra == 'dev'
 Requires-Dist: jedi>=0.19.1; extra == 'dev'
@@ -28,6 +31,8 @@ Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: rich>=13.7; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Provides-Extra: farm
+Requires-Dist: rich>=13.7; extra == 'farm'
 Provides-Extra: jupyter
 Requires-Dist: ipykernel>=6.0.0; extra == 'jupyter'
 Requires-Dist: ipython>=8.0.0; extra == 'jupyter'
@@ -108,6 +113,7 @@ hoodscript kernel install     # Jupyter kernel (pip install "hoodscript[jupyter]
 hoodscript fmt|lint <file.hs> # formatter / linter (pip install "hoodscript[tools]")
 hoodscript learn [topic]      # interactive tutor driving docs/curriculum.md
 hoodscript                    # a short tour of all commands
+hoodscript zen                # the Zen of HoodScript (HPEP 20); or `import vibe`
 hoodscript lsp                # language server over stdio, for editors
 hoodscript make-stubs f.py    # emit a .pyi-style stub with empty bodies
 ```
@@ -167,6 +173,24 @@ Everything else — `if`, `else`, `while`, `import`, `with`, `match`, `None`,
 `self`, every builtin — is Python's own word, and every Python keyword still
 works in a `.hs` file.
 
+## Play
+
+```bash
+pip install "hoodscript[farm]"
+hoodfarm levels            # the 8 challenges
+hoodfarm play 1            # edit solution.hs in your editor; the farm re-runs on every save
+hoodfarm run my.hs -b      # headless benchmark, exit 0 on pass
+```
+
+*The Drone Was Replaced*: program a farming drone in HoodScript, one level at
+a time. Same language, same crash reports — the game just adds a `bot`.
+
+```bash
+pip install "hoodscript[arcade]"
+hoodarcade                      # Big Mama's Cookout · BeatLab 808 · Drop Day
+hoodarcade play cookout 1       # edit the solution file; the stage re-runs on save
+```
+
 ## Learn
 
 - [`docs/onboarding.md`](docs/onboarding.md) — from zero to a running program in ten minutes

{hoodscript-1.2.0 → hoodscript-1.3.1}/README.md

@@ -63,6 +63,7 @@ hoodscript kernel install     # Jupyter kernel (pip install "hoodscript[jupyter]
 hoodscript fmt|lint <file.hs> # formatter / linter (pip install "hoodscript[tools]")
 hoodscript learn [topic]      # interactive tutor driving docs/curriculum.md
 hoodscript                    # a short tour of all commands
+hoodscript zen                # the Zen of HoodScript (HPEP 20); or `import vibe`
 hoodscript lsp                # language server over stdio, for editors
 hoodscript make-stubs f.py    # emit a .pyi-style stub with empty bodies
 ```
@@ -122,6 +123,24 @@ Everything else — `if`, `else`, `while`, `import`, `with`, `match`, `None`,
 `self`, every builtin — is Python's own word, and every Python keyword still
 works in a `.hs` file.
 
+## Play
+
+```bash
+pip install "hoodscript[farm]"
+hoodfarm levels            # the 8 challenges
+hoodfarm play 1            # edit solution.hs in your editor; the farm re-runs on every save
+hoodfarm run my.hs -b      # headless benchmark, exit 0 on pass
+```
+
+*The Drone Was Replaced*: program a farming drone in HoodScript, one level at
+a time. Same language, same crash reports — the game just adds a `bot`.
+
+```bash
+pip install "hoodscript[arcade]"
+hoodarcade                      # Big Mama's Cookout · BeatLab 808 · Drop Day
+hoodarcade play cookout 1       # edit the solution file; the stage re-runs on save
+```
+
 ## Learn
 
 - [`docs/onboarding.md`](docs/onboarding.md) — from zero to a running program in ten minutes

hoodscript-1.3.1/docs/adr/0004-no-regional-dialect-overlays.md

@@ -0,0 +1,45 @@
+# ADR-0004: No Regional Dialect Overlays (Rule Zero Stands)
+
+## Status
+Accepted (2026-09-12)
+
+## Context
+A proposal asked for a "modular regional dialect engine": token overlays for
+Bay Area, Atlanta, DMV, and UK Drill / MLE slang, selectable via `hood.toml` or
+`--dialect`, resolving to standard HoodScript tokens before transpilation.
+
+## Decision
+**Not adopted.** The keyword set is governed by Rule Zero and the sourcing
+procedure in `hoodscript/docs/lexical-sourcing.md` §5. A dialect overlay is a
+keyword table; every entry in it would need the same evidence as every other
+keyword, and an owner-signed `GRAMMAR.md` revision. Four overlays of roughly
+fifteen words each is four times the size of the entire v1.1 reconciliation.
+
+Three further reasons:
+
+1. **It grows the wrong tier.** The language's thesis is Tier A — AAVE aspect
+   marking (`be`, `steady`, `BIN`, `done`) mapped onto execution semantics.
+   Overlays add only Tier B naming, which was deliberately capped small:
+   "every alias is a thing to learn, and 1:1 legibility suffers as aliases
+   grow." Regional slang is also the most perishable vocabulary there is,
+   which is exactly what Rule Zero excludes.
+2. **The mechanism is the known failure mode.** "Resolve dialect tokens to
+   standard tokens first" is the private-keyword-map pattern that three
+   external batches reintroduced in one day (2026-09-11/12), two of which
+   silently changed the meaning of `dip`. See CHANGELOG, QA sections.
+3. **A player who learns a dialect learns a language that runs nowhere else.**
+   The 1:1 promise is that what you write in HoodScript is HoodScript.
+
+## The door that stays open
+The named varieties are real objects of sociolinguistic study. A *cited*
+extension — one variety, each word through the seven steps, `UNVERIFIED`
+where the literature is thin, signed by the owner — would be a legitimate
+Tier B addition and can be proposed with `PROMPTS.md` §2.1. It is a sourcing
+sprint first and a loader second, if ever.
+
+## Consequences
+- No `--dialect` flag, no dialect section in any config, no overlay loader.
+- `constants.py` remains the single keyword table; `patterns.py` the single
+  multi-token layer.
+- Proposals that arrive with a dialect map are declined at review with a
+  pointer to this ADR.

hoodscript-1.3.1/docs/grammar.ebnf

@@ -0,0 +1,59 @@
+(* HoodScript v1.1 — formal grammar (EBNF).
+   Descriptive: the implementation is a token rewrite (src/hoodscript/transpiler.py)
+   plus the pattern rules R1–R12 (src/hoodscript/patterns.py), not a parser.
+   This file is extracted verbatim from GRAMMAR.md; tests/test_grammar_ebnf.py
+   fails if the two drift. Edit GRAMMAR.md, then regenerate:
+       python scripts/gen_ebnf.py > docs/grammar.ebnf
+*)
+
+program        = { statement } ;
+
+statement      = output_stmt | assignment | const_decl | func_def | class_def
+               | return_stmt | habitual_loop | continuative_loop | while_loop
+               | conditional | try_stmt | throw_stmt | import_stmt
+               | loop_control | pass_stmt | python_stmt | expr_stmt ;
+
+output_stmt    = "holla" [ expression { "," expression } | "(" [ args ] ")" ] ;
+input_expr     = "ask" ( expression | "(" [ args ] ")" ) ;
+assignment     = target "=" expression ;
+const_decl     = "BIN" IDENT "=" expression ;
+
+func_def       = [ "finna" ] "bet" IDENT "(" [ params ] ")" ":" block ;
+return_stmt    = ( "dip" | "return" ) [ expression ] ;
+class_def      = "fam" IDENT [ "(" IDENT { "," IDENT } ")" ] ":" block ;
+
+habitual_loop     = "be" target "in" expression ":" block ;
+continuative_loop = "steady" ":" block ;
+while_loop        = "while" expression ":" block ;
+loop_control      = "skip" | "break" ;
+pass_stmt         = "chill" ;
+
+conditional    = "if" expression ":" block
+                 { "else" "if" expression ":" block }
+                 [ "else" ":" block ] ;
+
+try_stmt       = "tryna" ":" block { handler } [ "regardless" ":" block ] ;
+handler        = "catch" [ expression [ "as" IDENT ] ] ":" block ;
+throw_stmt     = "throw" [ expression ] ;
+
+import_stmt    = "import" dotted [ "as" IDENT ]
+               | "from" dotted "import" IDENT { "," IDENT } ;
+
+python_stmt    = (* any Python statement: with, match, del, global, nonlocal,
+                   assert, yield, decorators, comprehensions — passed through *) ;
+
+block          = INDENT { statement } DEDENT ;
+
+expression     = or_expr ;
+or_expr        = and_expr { "or" and_expr } ;
+and_expr       = not_expr { "and" not_expr } ;
+not_expr       = [ "ain't" [ "nobody" ] | "not" ] comparison ;
+comparison     = term { comp_op term } ;
+primary        = NUMBER | STRING | IDENT
+               | "cap" | "no" "cap" | "None"
+               | "it's" expression
+               | "done" expression
+               | input_expr
+               | "(" expression ")"
+               | list_lit | dict_lit | range_lit | python_expr ;
+range_lit      = expression ".." expression ;

hoodscript-1.3.1/examples/solutions/beatlab/stage1.hs

@@ -0,0 +1,10 @@
+# Stage 1: Four on the Floor
+# Instructions: Load 16-step patterns for 'Kick' and 'Snare'.
+
+kicks = [0, 4, 8, 12]
+snares = [4, 12]
+
+sequencer.load_track("Kick", kicks)
+sequencer.load_track("Snare", snares)
+sequencer.play()
+holla("Classic 4-on-the-floor sequence loaded!")

hoodscript-1.3.1/examples/solutions/beatlab/stage2.hs

@@ -0,0 +1,15 @@
+# Stage 2: Trap Hat Triplets
+# Instructions: Generate hi-hat steps combining straight 8ths and a triplet roll.
+
+hats = []
+# Standard 8th notes on even steps 0 to 10
+be step in range(12):
+    if step % 2 == 0:
+        hats.append(step)
+
+# Triplet roll on turnaround steps 12 to 15
+be step in range(12, 16):
+    hats.append(step)
+
+sequencer.load_track("HiHat", hats)
+holla("Trap hats rolling across matrix: ", hats)

hoodscript-1.3.1/examples/solutions/beatlab/stage3.hs

@@ -0,0 +1,11 @@
+# Stage 3: Soul Sample Chopper
+# Instructions: Chop 16 consecutive 1000ms slices onto pads 1 to 16, reversing every 4th pad.
+
+be i in range(1, 17):
+    start_ms = (i - 1) * 1000
+    end_ms = i * 1000
+    mpc.chop_sample(start_ms, end_ms, i)
+    if i % 4 == 0:
+        mpc.reverse_pad(i)
+
+holla("Vinyl chopped and reversed into 16 quantized MPC pads!")

hoodscript-1.3.1/examples/solutions/beatlab/stage4.hs

@@ -0,0 +1,14 @@
+# Stage 4: 808 Slide Calculus
+# Instructions: Define calculate_808_glide(start_note, end_note, steps) returning linear frequency curve.
+
+bet calculate_808_glide(start_note, end_note, steps):
+    freqs = {"C1": 32.70, "D1": 36.71, "E1": 41.20, "F1": 43.65, "G1": 49.00, "A1": 55.00}
+    f_start = freqs[start_note]
+    f_end = freqs[end_note]
+    
+    result = []
+    step_delta = (f_end - f_start) / (steps - 1)
+    be i in range(steps):
+        result.append(round(f_start + (i * step_delta), 2))
+        
+    dip result

hoodscript-1.3.1/examples/solutions/beatlab/stage5.hs

@@ -0,0 +1,13 @@
+# Stage 5: The Metro Drop
+# Instructions: Assemble full track arrangement, drop producer tag, and render final WAV.
+
+bet produce_metro_drop(mpc, sequencer, mastering):
+    mpc.set_bpm(144)
+    
+    sequencer.load_track("Kick", [0, 6, 8, 14])
+    sequencer.load_track("Snare", [4, 12])
+    sequencer.load_track("808", [0, 6, 8, 14])
+    sequencer.load_track("HiHat", [0, 2, 4, 6, 8, 10, 12, 13, 14, 15])
+    
+    mastering.drop_tag("metro_tag.wav", 4)
+    mastering.render_wav("hit_single_master.wav")

hoodscript-1.3.1/examples/solutions/cookout/stage1.hs

@@ -0,0 +1,9 @@
+# Stage 1: Grill Master Basics
+# Instructions: Loop through all grill items, season with Lawry's, and flip twice so they are cooked!
+
+items = grill.get_items()
+be item in items:
+    grill.season(item, "Lawry's Seasoned Salt")
+    grill.flip(item)
+    grill.flip(item)
+    holla("Cooked to perfection: ", item)

hoodscript-1.3.1/examples/solutions/cookout/stage2.hs

@@ -0,0 +1,8 @@
+# Stage 2: The Potato Salad Litmus Test
+# Instructions: Validate ingredients. Crash out with BadValueTrip if raisins are present!
+
+bet potato_salad_check(recipe):
+    if "raisins" in recipe:
+        throw BadValueTrip("Who put raisins in Big Mama's potato salad?!")
+    else:
+        dip no cap

hoodscript-1.3.1/examples/solutions/cookout/stage3.hs

@@ -0,0 +1,5 @@
+# Stage 3: Aux Cord Rotation
+# Instructions: Sort song list descending by vibe score using sorted and quick_cook.
+
+bet curate_aux_rotation(songs):
+    dip sorted(songs, key=lambda s: s["vibe"], reverse=no cap)

hoodscript-1.3.1/examples/solutions/cookout/stage4.hs

@@ -0,0 +1,26 @@
+# Stage 4: Spades Rule Engine
+# Instructions: Determine winning card between card1 and card2 given led_suit.
+
+bet spades_trick_winner(led_suit, card1, card2):
+    suit1 = card1[-1]
+    suit2 = card2[-1]
+    
+    if suit1 == "♠" and suit2 != "♠":
+        dip card1
+    else if suit2 == "♠" and suit1 != "♠":
+        dip card2
+        
+    ranks = {"2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "10": 10, "J": 11, "Q": 12, "K": 13, "A": 14}
+    rank1 = ranks[card1[:-1]]
+    rank2 = ranks[card2[:-1]]
+    
+    if suit1 == suit2:
+        if rank1 > rank2:
+            dip card1
+        else:
+            dip card2
+            
+    if suit1 == led_suit:
+        dip card1
+    else:
+        dip card2

hoodscript-1.3.1/examples/solutions/cookout/stage5.hs

@@ -0,0 +1,13 @@
+# Stage 5: The Unbeatable Partner
+# Instructions: Count books, bid a Boston (13), and play all winning cards in sequence!
+
+bet autonomous_spades_partner(spades):
+    books = spades.count_books()
+    spades.bid(13)
+    
+    hand = spades.get_hand()
+    be c in hand:
+        if spades.verify_renege(c) == cap:
+            spades.play_card(c)
+            
+    dip 13

hoodscript-1.3.1/examples/solutions/dropday/stage1.hs

@@ -0,0 +1,13 @@
+# Stage 1: Drop Monitor
+# Instructions: Check stock. When available, solve captcha and checkout!
+
+bet monitor_and_cop(bot, sku):
+    stock = bot.listen_drop(sku)
+    if stock > 0:
+        bot.solve_captcha("TOKEN_X77")
+        billing = {"card_num": "4111222233334444", "cvv": "123"}
+        bot.add_to_cart(sku, 10.5)
+        bot.checkout(billing)
+        dip no cap
+    else:
+        dip cap

hoodscript-1.3.1/examples/solutions/dropday/stage2.hs

@@ -0,0 +1,14 @@
+# Stage 2: Legit Check AI
+# Instructions: Inspect each shoe ledger and collect all authentic pairs.
+
+bet filter_authentic_kicks(shoes):
+    legit_pairs = []
+    be s in shoes:
+        is_density_valid = s["stitch_density"] >= 8.5
+        is_uv_valid = s["uv_box_stamp"] == no cap
+        is_sku_valid = s["sku_label_matches"] == no cap
+        
+        if is_density_valid and is_uv_valid and is_sku_valid:
+            legit_pairs.append(s)
+            
+    dip legit_pairs

hoodscript-1.3.1/examples/solutions/dropday/stage3.hs

@@ -0,0 +1,12 @@
+# Stage 3: Anti-Rate Limit Backoff
+# Instructions: Query endpoint with retry loop catching RateLimitError with increasing delays.
+
+bet fetch_with_backoff(endpoint, sku, max_retries):
+    delay = 0.01
+    be attempt_num in range(max_retries):
+        tryna:
+            dip endpoint.query_stock(sku)
+        catch:
+            delay = delay * 2
+            
+    dip None

hoodscript-1.3.1/examples/solutions/dropday/stage4.hs

@@ -0,0 +1,11 @@
+# Stage 4: Asynchronous Multi-Cart Engine
+# Instructions: Add all target sizes to cart, solve captcha, and checkout.
+
+bet multi_cart_cop(bot, sku, sizes):
+    be s in sizes:
+        bot.add_to_cart(sku, s)
+        
+    bot.solve_captcha("CAPTCHA_FAST_PASS")
+    billing = {"card_num": "5500112233445566", "cvv": "999"}
+    bot.checkout(billing)
+    dip no cap

hoodscript-1.3.1/examples/solutions/dropday/stage5.hs

@@ -0,0 +1,16 @@
+# Stage 5: The 3-Way Grail Trade
+# Instructions: Trace the trade dependencies from starting item to target grail.
+
+bet solve_grail_trade_cycle(traders, start_item, target_grail):
+    cycle = []
+    current_item = start_item
+    
+    be _ in range(len(traders)):
+        be name in traders:
+            t = traders[name]
+            if t["has"] == current_item:
+                cycle.append(name)
+                current_item = t["wants"]
+                break
+                
+    dip cycle

hoodscript-1.3.1/examples/solutions/level1.hs

@@ -0,0 +1,9 @@
+# Level 1: First Harvest
+# Instructions: Step east across plots and harvest 3 hay.
+
+bot.harvest()
+bot.move("east")
+bot.harvest()
+bot.move("east")
+bot.harvest()
+holla("Level 1 complete!")

hoodscript-1.3.1/examples/solutions/level2.hs

@@ -0,0 +1,9 @@
+# Level 2: The Infinite Row
+# Instructions: Use `be` and a range to harvest all 8 plots in a single loop.
+
+be i in range(8):
+    bot.harvest()
+    if i < 7:
+        bot.move("east")
+
+holla("All 8 hay harvested!")

hoodscript-1.3.1/examples/solutions/level3.hs

@@ -0,0 +1,14 @@
+# Level 3: Field of 9
+# Instructions: Nested loops to traverse and harvest 3x3 grid.
+
+be y in range(3):
+    be x in range(3):
+        bot.harvest()
+        if x < 2:
+            bot.move("east")
+    if y < 2:
+        bot.move("south")
+        bot.move("west")
+        bot.move("west")
+
+holla("3x3 field cleared!")

hoodscript-1.3.1/examples/solutions/level4.hs

@@ -0,0 +1,18 @@
+# Level 4: Weed Control
+# Instructions: Inspect soil. If weed, till it; otherwise harvest mature hay!
+
+be y in range(4):
+    be x in range(4):
+        ground = bot.inspect_ground()
+        if ground["is_weed"]:
+            bot.till()
+        else:
+            bot.harvest()
+        if x < 3:
+            bot.move("east")
+    if y < 3:
+        bot.move("south")
+        be _ in range(3):
+            bot.move("west")
+
+holla("Level 4 weed control completed!")

hoodscript-1.3.1/examples/solutions/level5.hs

@@ -0,0 +1,38 @@
+# Level 5: Smart Irrigation & Soil
+# Instructions: Till, hydrate, and plant carrots, then harvest once mature.
+
+bet prepare_and_plant():
+    bot.till()
+    bot.water(0.40)
+    bot.plant("carrot")
+
+# Step 1: Prepare and seed the 4x4 field
+be y in range(4):
+    be x in range(4):
+        prepare_and_plant()
+        if x < 3:
+            bot.move("east")
+    if y < 3:
+        bot.move("south")
+        be _ in range(3):
+            bot.move("west")
+
+# Step 2: Return drone to top-left (0, 0)
+be _ in range(3):
+    bot.move("west")
+    bot.move("north")
+
+# Step 3: Harvest all carrots once mature
+be y in range(4):
+    be x in range(4):
+        while cap == bot.inspect_ground()["is_mature"]:
+            bot.water(0.1)
+        bot.harvest()
+        if x < 3:
+            bot.move("east")
+    if y < 3:
+        bot.move("south")
+        be _ in range(3):
+            bot.move("west")
+
+holla("All 16 carrots harvested!")