readme

1 files changed, 0 insertions, 2123 deletions

diff --git a/skill_plans/farming.md b/skill_plans/farming.md
deleted file mode 100644
index 689f9ec..0000000
--- a/skill_plans/farming.md
+++ /dev/null
@@ -1,2123 +0,0 @@
-# Farming Skill Implementation Plan
-
-## 1. Overview
-
-Farming allows players to plant seeds in farming patches, water them, wait for them to grow through multiple stages, and harvest the results. It is a long-cycle skill: seeds take minutes to grow, with periodic growth ticks advancing them through stages. Disease can strike at each growth stage; watering eliminates that risk. Dead plants must be cleared with a rake before replanting.
-
-The system is simpler than RuneScape: only three tools (rake, spade, watering can), no compost system, and growth only ticks for online players.
-
-**Patch types:** herb patches, allotment patches, flower patches, bush patches, tree patches.
-
-**Core loop:** rake weeds -> plant seed (requires spade) -> water (optional but prevents disease) -> wait for growth -> harvest (requires spade) -> repeat.
-
-**Sci-fi flavor:** Seeds are "bio-engineered seeds," patches are "hydroponic plots," the tool shed is a "supply locker," watering can is a "hydration unit." But mechanically they work identically to RS farming.
-
----
-
-## 2. Architecture
-
-### Per-Player Farming State via Player Flags
-
-Each farming patch is a world object (e.g., `herb_patch`) placed in a room. However, each player sees their **own** state for that patch. This is achieved using **player flags** (`p.Flags`), not world state.
-
-**Flag naming convention:**
-
-```
-farm_{patch_type}_{patch_index}_{field}
-```
-
-**Fields per patch:**
-
-| Flag Key | Type | Description |
-|---|---|---|
-| `farm_herb_1_seed` | `string` | Seed ID planted (e.g., `"guam_seed"`), empty if unplanted |
-| `farm_herb_1_stage` | `int` | Current growth stage (0 = just planted, N = fully grown) |
-| `farm_herb_1_watered` | `bool` | Whether current stage has been watered |
-| `farm_herb_1_diseased` | `bool` | Whether plant is currently diseased |
-| `farm_herb_1_dead` | `bool` | Whether plant has died (must rake) |
-| `farm_herb_1_weeds` | `bool` | Whether patch has weeds (must rake before planting) |
-| `farm_herb_1_ready` | `bool` | Whether crop is fully grown and ready to harvest |
-
-**Patch index mapping:** Each physical patch object in a room corresponds to a unique patch index. The index is determined by the object's position in the room's `objects` list combined with a patch type prefix. For example, room 150 might have:
-
-```yaml
-objects:
-  - id: herb_patch    # farm_herb_1
-  - id: herb_patch    # farm_herb_2
-  - id: allotment_patch  # farm_allot_1
-```
-
-The mapping from object instance to flag prefix is derived at runtime:
-- Object def ID `herb_patch` with index 0 in room -> flag prefix `farm_herb_1`
-- Object def ID `herb_patch` with index 1 in room -> flag prefix `farm_herb_2`
-- Object def ID `allotment_patch` with index 0 in room -> flag prefix `farm_allot_1`
-
-**Helper function** `farmFlagPrefix(defID string, index int) string`:
-```go
-func farmFlagPrefix(defID string, index int) string {
-    switch defID {
-    case "herb_patch":
-        return fmt.Sprintf("farm_herb_%d", index+1)
-    case "allotment_patch":
-        return fmt.Sprintf("farm_allot_%d", index+1)
-    case "flower_patch":
-        return fmt.Sprintf("farm_flower_%d", index+1)
-    case "bush_patch":
-        return fmt.Sprintf("farm_bush_%d", index+1)
-    case "tree_patch":
-        return fmt.Sprintf("farm_tree_%d", index+1)
-    }
-    return ""
-}
-```
-
-**Why player flags?**
-- World flags are shared by all players. Farming patches must be per-player.
-- Player flags are already persisted to character YAML automatically via `AccountStore.SaveCharacter()`.
-- No new data structures or serialization code needed.
-- The `p.Flags` map is `map[string]any` and supports string, int, bool, and float values natively via YAML serialization.
-
-### Patch State Initialization
-
-When a player first interacts with a farming patch (via `inspect`, `plant`, `rake`, etc.), if no flags exist for that patch, initialize it with weeds:
-
-```go
-func (g *Game) ensureFarmState(p *player.Player, prefix string) {
-    if p.Flags == nil {
-        p.Flags = make(map[string]any)
-    }
-    if _, exists := p.Flags[prefix+"_seed"]; !exists {
-        p.Flags[prefix+"_weeds"] = true
-        p.Flags[prefix+"_seed"] = ""
-        p.Flags[prefix+"_stage"] = 0
-        p.Flags[prefix+"_watered"] = false
-        p.Flags[prefix+"_diseased"] = false
-        p.Flags[prefix+"_dead"] = false
-        p.Flags[prefix+"_ready"] = false
-    }
-}
-```
-
-### Seed Data Lookup
-
-Each seed item has farming-specific fields. Since `ItemDef` in `internal/object/item.go` is the canonical item definition, we add new fields to `ItemDef`:
-
-```go
-// New fields added to ItemDef struct in internal/object/item.go
-FarmPatchType  string  `yaml:"farm_patch_type"`   // "herb", "allotment", "flower", "bush", "tree"
-FarmLevel      int     `yaml:"farm_level"`         // Required farming level to plant
-FarmPlantXP    int     `yaml:"farm_plant_xp"`      // XP for planting
-FarmHarvestXP  int     `yaml:"farm_harvest_xp"`    // XP per harvest action
-FarmStages     int     `yaml:"farm_stages"`         // Number of growth stages
-FarmProduct    string  `yaml:"farm_product"`        // Item ID produced on harvest
-FarmMinYield   int     `yaml:"farm_min_yield"`      // Minimum harvest quantity
-FarmMaxYield   int     `yaml:"farm_max_yield"`      // Maximum harvest quantity
-```
-
-This keeps the data-driven pattern: seed behavior is defined in YAML, not hardcoded.
-
----
-
-## 3. Growth Tick
-
-### `FarmTick()` in `internal/game/tick.go`
-
-A new tick function that runs on a **counter-based schedule** rather than every tick. Growth is checked every 500 ticks (approximately 5 minutes at 600ms tick rate).
-
-**Implementation:**
-
-Add a counter field to `Game`:
-
-```go
-// In Game struct (game.go)
-farmTickCounter int
-```
-
-Add `FarmTick()` to `tick.go`:
-
-```go
-const FarmTickInterval = 500 // ticks between farm growth checks (~5 minutes)
-
-func (g *Game) FarmTick() {
-    g.farmTickCounter++
-    if g.farmTickCounter < FarmTickInterval {
-        return
-    }
-    g.farmTickCounter = 0
-
-    if g.Hub == nil {
-        return
-    }
-
-    for _, sess := range g.Hub.AllSessions() {
-        p, ok := sess.Player.(*player.Player)
-        if !ok || p == nil || p.Flags == nil {
-            continue
-        }
-        g.advanceFarmGrowth(sess, p)
-    }
-}
-```
-
-### `advanceFarmGrowth()` in `internal/game/action_farm.go`
-
-```go
-func (g *Game) advanceFarmGrowth(sess *net.Session, p *player.Player) {
-    // Scan all farming flag prefixes in player flags
-    prefixes := g.findActiveFarmPrefixes(p)
-    for _, prefix := range prefixes {
-        seedID, _ := p.Flags[prefix+"_seed"].(string)
-        if seedID == "" {
-            continue
-        }
-        dead, _ := p.Flags[prefix+"_dead"].(bool)
-        if dead {
-            continue
-        }
-        diseased, _ := p.Flags[prefix+"_diseased"].(bool)
-        ready, _ := p.Flags[prefix+"_ready"].(bool)
-        if ready {
-            continue
-        }
-
-        // If diseased and not cured, plant dies
-        if diseased {
-            p.Flags[prefix+"_dead"] = true
-            p.Flags[prefix+"_diseased"] = false
-            sess.WriteLine(g.colorize(sess, "farm_disease",
-                fmt.Sprintf("\nYour %s has died from disease!", seedDisplayName(g, seedID))))
-            g.AccountStore.SaveCharacter(p)
-            continue
-        }
-
-        // Advance growth stage
-        stage, _ := p.Flags[prefix+"_stage"].(int)
-        watered, _ := p.Flags[prefix+"_watered"].(bool)
-
-        seedDef, err := g.ItemStore.Load(seedID)
-        if err != nil {
-            continue
-        }
-
-        maxStages := seedDef.FarmStages
-        if maxStages <= 0 {
-            maxStages = 4
-        }
-
-        stage++
-
-        if stage >= maxStages {
-            // Fully grown!
-            p.Flags[prefix+"_stage"] = stage
-            p.Flags[prefix+"_ready"] = true
-            p.Flags[prefix+"_watered"] = false
-            sess.WriteLine(g.colorize(sess, "farm_grow",
-                fmt.Sprintf("\nYour %s is fully grown and ready to harvest!",
-                    seedDisplayName(g, seedID))))
-        } else {
-            // Disease check (10% chance if not watered)
-            if !watered && rand.Float64() < 0.10 {
-                p.Flags[prefix+"_stage"] = stage
-                p.Flags[prefix+"_diseased"] = true
-                p.Flags[prefix+"_watered"] = false
-                sess.WriteLine(g.colorize(sess, "farm_disease",
-                    fmt.Sprintf("\nYour %s has become diseased!",
-                        seedDisplayName(g, seedID))))
-            } else {
-                p.Flags[prefix+"_stage"] = stage
-                p.Flags[prefix+"_watered"] = false // Reset watered for next stage
-                sess.WriteLine(g.colorize(sess, "farm_grow",
-                    fmt.Sprintf("\nYour %s has grown to stage %d/%d.",
-                        seedDisplayName(g, seedID), stage, maxStages)))
-            }
-        }
-        g.AccountStore.SaveCharacter(p)
-    }
-}
-```
-
-### `findActiveFarmPrefixes()`
-
-Scans `p.Flags` to find all unique farm prefixes that have a planted seed:
-
-```go
-func (g *Game) findActiveFarmPrefixes(p *player.Player) []string {
-    seen := make(map[string]bool)
-    var prefixes []string
-    for key := range p.Flags {
-        if !strings.HasPrefix(key, "farm_") {
-            continue
-        }
-        if !strings.HasSuffix(key, "_seed") {
-            continue
-        }
-        prefix := strings.TrimSuffix(key, "_seed")
-        if !seen[prefix] {
-            seen[prefix] = true
-            if seedID, ok := p.Flags[key].(string); ok && seedID != "" {
-                prefixes = append(prefixes, prefix)
-            }
-        }
-    }
-    sort.Strings(prefixes)
-    return prefixes
-}
-```
-
-### Subscribe in main.go
-
-Add `g.FarmTick()` to the tick subscription in `cmd/mud/main.go`:
-
-```go
-g.Ticks.Subscribe(1, func() bool {
-    g.MoveTick()
-    g.ProcessQueuedCommands()
-    g.World.Tick()
-    g.MobStore.Tick()
-    g.RegenTick()
-    g.DisconnectTick()
-    g.WanderTick()
-    g.SharedDepletionTick()
-    g.FireTick()
-    g.AdvanceActions()
-    g.ConsumeTick()
-    g.BroadcastRespawns()
-    g.VisualTick()
-    g.FarmTick()  // <-- ADD THIS
-    return true
-})
-```
-
-### Design Decision: Online-Only Growth
-
-Growth only advances for online players. When a player logs off, their crops freeze in place. This is intentional:
-- Keeps implementation simple (no background timers)
-- Players don't return to find everything dead
-- Matches the "live state" philosophy of the codebase
-
----
-
-## 4. Commands
-
-### Command Summary
-
-| Command | Class | Description |
-|---|---|---|
-| `plant <seed>` | Active | Plant a seed in the appropriate patch in the current room |
-| `harvest [patch]` | Active | Harvest a fully grown crop from a patch |
-| `rake [patch]` | Active | Clear weeds or dead plants from a patch |
-| `water [patch]` | Active | Water a patch with a watering can |
-| `cure [patch]` | Active | Use plant cure on a diseased patch |
-| `inspect [patch]` | Instant | Check the status of farming patches in the room |
-
-### 4.1 `plant <seed>` (Active)
-
-**Classification:** Add `"plant"` to the Active case in `classifyCommand()`.
-
-**Dispatch:** Add case in `executeCommand()`:
-```go
-case "plant":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        sess.WriteLine("Plant what?")
-    } else {
-        g.doPlant(sess, strings.Join(args, " "))
-    }
-    return
-```
-
-**Handler: `doPlant()`** in `cmd_farm.go`:
-
-1. Find the seed item in player inventory by name match (`findInventoryMatches`).
-2. Load the seed's `ItemDef`. Check `FarmPatchType` is set — if not, "You can't plant that."
-3. Check farming level: `p.Level(player.Farming) >= seedDef.FarmLevel` — if not, "You need level N farming to plant that."
-4. Check the player has a spade: scan inventory and equipment for `tool_type: "spade"`. If not found, "You need a spade to plant seeds."
-5. Find a matching patch object in the room: scan `g.World.FindObjInstances(p.RoomID, seedDef.FarmPatchType+"_patch")`.
-6. If no matching patch in room, "There's no suitable patch here to plant that."
-7. If multiple patches, find the first one that is clear (no weeds, not planted, not dead) using the player's flags for each patch.
-8. If no clear patch, "All patches here have something in them. Rake them first." or "All patches are occupied."
-9. Determine the flag prefix via `farmFlagPrefix(patchDefID, patchIndex)`.
-10. Ensure farm state is initialized.
-11. Check weeds: if `prefix_weeds == true`, "You need to rake the weeds first."
-12. Check already planted: if `prefix_seed != ""`, "Something is already planted here."
-13. Remove 1 seed from inventory.
-14. Set flags: `prefix_seed = seedID`, `prefix_stage = 0`, `prefix_watered = false`, `prefix_diseased = false`, `prefix_dead = false`, `prefix_ready = false`.
-15. Award planting XP: `p.AddSkillXP(player.Farming, seedDef.FarmPlantXP)`.
-16. Save character.
-17. Output: "You plant a guam seed in the herb patch."
-18. Set ActionState: `&ActionState{Type: ActionPlanting, TargetName: seedDef.Name}`.
-19. Set Action with WaitLeft of 3 ticks (planting takes a moment).
-
-**Alternative simpler approach:** Since planting is conceptually instant (just set flags and remove seed), it can be implemented as a direct command handler without a multi-tick action. This matches how `burn` phase 0 works. However, to match the spec request for Active classification, use a 2-tick action:
-
-```go
-p.Action = &action.Action{
-    Type:       "plant",
-    TargetID:   seedID,
-    TargetName: seedDef.Name,
-    WaitLeft:   2,
-    Data: map[string]any{
-        "seed_id": seedID,
-        "prefix":  prefix,
-        "xp":      seedDef.FarmPlantXP,
-    },
-}
-p.ActionState = &ActionState{Type: ActionPlanting, TargetName: seedDef.Name}
-```
-
-Then in `advancePlant()`, do the actual flag-setting and item removal.
-
-### 4.2 `harvest [patch]` (Active)
-
-**Classification:** Add `"harvest"` to Active case in `classifyCommand()`.
-
-**Dispatch:** Add case in `executeCommand()`:
-```go
-case "harvest":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doHarvest(sess, "")
-    } else {
-        g.doHarvest(sess, strings.Join(args, " "))
-    }
-    return
-```
-
-**Handler: `doHarvest()`** in `cmd_farm.go`:
-
-1. Find farming patches in the current room.
-2. If `input != ""`, match against patch names (e.g., "herb", "allotment"). Support numbered targeting: `1.herb`.
-3. If `input == ""`, find the first patch that is ready to harvest (smart default).
-4. For the chosen patch, get flag prefix and check `prefix_ready == true`.
-5. If not ready: "There's nothing ready to harvest here."
-6. Check player has spade: "You need a spade to harvest."
-7. Check inventory space: need at least 1 free slot.
-8. Load seed def to get `FarmProduct`, `FarmMinYield`, `FarmMaxYield`, `FarmHarvestXP`.
-9. Start harvest action (3-tick duration):
-
-```go
-p.Action = &action.Action{
-    Type:       "harvest",
-    TargetID:   prefix,
-    TargetName: productName,
-    WaitLeft:   3,
-    Data: map[string]any{
-        "prefix":    prefix,
-        "seed_id":   seedID,
-        "product":   seedDef.FarmProduct,
-        "min_yield": seedDef.FarmMinYield,
-        "max_yield": seedDef.FarmMaxYield,
-        "xp":        seedDef.FarmHarvestXP,
-    },
-}
-p.ActionState = &ActionState{Type: ActionHarvesting, TargetName: "crops"}
-```
-
-10. In `advanceHarvest()`:
-    - Calculate yield: `minYield + rand.Intn(maxYield - minYield + 1)`. Bonus: `yield += farmingLevel / 20` (higher farming = slightly better yields).
-    - Cap yield by available inventory slots.
-    - Add items to inventory (stackable items merge, non-stackable use 1 slot each).
-    - Award XP: `harvestXP * yield`.
-    - Clear patch flags: set `prefix_seed = ""`, `prefix_stage = 0`, `prefix_ready = false`, `prefix_weeds = true` (weeds return after harvest).
-    - Save character.
-    - Output: "You harvest 7 guam leaves from the herb patch." with XP drop.
-
-### 4.3 `rake [patch]` (Active)
-
-**Classification:** Add `"rake"` to Active case in `classifyCommand()`.
-
-**Dispatch:**
-```go
-case "rake":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doRake(sess, "")
-    } else {
-        g.doRake(sess, strings.Join(args, " "))
-    }
-    return
-```
-
-**Handler: `doRake()`** in `cmd_farm.go`:
-
-1. Check player has a rake (tool_type "rake") in inventory or equipment.
-2. Find farming patches in room. If input given, match; otherwise find first patch with weeds or dead plants.
-3. Get flag prefix. Check `prefix_weeds == true` or `prefix_dead == true`.
-4. If neither: "The patch doesn't need raking."
-5. Start rake action (4-tick duration):
-
-```go
-p.Action = &action.Action{
-    Type:       "rake",
-    TargetID:   prefix,
-    TargetName: patchName,
-    WaitLeft:   4,
-    Data: map[string]any{
-        "prefix": prefix,
-    },
-}
-p.ActionState = &ActionState{Type: ActionRaking, TargetName: patchName}
-```
-
-6. In `advanceRake()`:
-    - If was dead: clear all flags (`prefix_seed = ""`, `prefix_dead = false`, `prefix_stage = 0`, `prefix_weeds = true`). Then set weeds false (raking clears both dead AND weeds in one go).
-    - Actually: set `prefix_weeds = false`, `prefix_dead = false`, `prefix_seed = ""`, `prefix_stage = 0`, `prefix_ready = false`, `prefix_diseased = false`.
-    - Raking gives **no farming XP** (as specified).
-    - Save character.
-    - Output: "You rake the patch clean."
-
-### 4.4 `water [patch]` (Active)
-
-**Classification:** Add `"water"` to Active case in `classifyCommand()`.
-
-**Dispatch:**
-```go
-case "water":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doWater(sess, "")
-    } else {
-        g.doWater(sess, strings.Join(args, " "))
-    }
-    return
-```
-
-**Handler: `doWater()`** in `cmd_farm.go`:
-
-1. Check player has a watering can (tool_type "watering_can") in inventory or equipment.
-2. Find farming patches in room. Match input or find first unwatered planted patch.
-3. Get flag prefix. Check there is a seed planted and it's not dead/ready.
-4. If `prefix_watered == true`: "The patch is already watered."
-5. If `prefix_ready == true`: "The crop is already fully grown."
-6. If no seed: "There's nothing planted here to water."
-7. Start water action (2-tick duration, fast):
-
-```go
-p.Action = &action.Action{
-    Type:       "water",
-    TargetID:   prefix,
-    TargetName: patchName,
-    WaitLeft:   2,
-    Data: map[string]any{
-        "prefix": prefix,
-    },
-}
-p.ActionState = &ActionState{Type: ActionWatering, TargetName: patchName}
-```
-
-8. In `advanceWater()`:
-    - Set `prefix_watered = true`.
-    - Save character.
-    - Output: "You water the herb patch."
-
-### 4.5 `cure [patch]` (Active)
-
-**Classification:** Add `"cure"` to Active case in `classifyCommand()`.
-
-**Dispatch:**
-```go
-case "cure":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doCure(sess, "")
-    } else {
-        g.doCure(sess, strings.Join(args, " "))
-    }
-    return
-```
-
-**Handler: `doCure()`** in `cmd_farm.go`:
-
-1. Check player has `plant_cure` item in inventory.
-2. Find farming patches in room. Match input or find first diseased patch.
-3. Get flag prefix. Check `prefix_diseased == true`.
-4. If not diseased: "The patch isn't diseased."
-5. Start cure action (2-tick duration):
-
-```go
-p.Action = &action.Action{
-    Type:       "cure",
-    TargetID:   prefix,
-    TargetName: patchName,
-    WaitLeft:   2,
-    Data: map[string]any{
-        "prefix": prefix,
-    },
-}
-p.ActionState = &ActionState{Type: ActionCuring, TargetName: patchName}
-```
-
-6. In `advanceCure()`:
-    - Remove 1 `plant_cure` from inventory.
-    - Set `prefix_diseased = false`.
-    - Save character.
-    - Output: "You apply the plant cure. The patch looks healthy again."
-
-### 4.6 `inspect [patch]` (Instant)
-
-**Classification:** Add `"inspect"` to Instant case in `classifyCommand()`.
-
-**Dispatch:**
-```go
-case "inspect":
-    if len(args) == 0 {
-        g.doInspect(sess, "")
-    } else {
-        g.doInspect(sess, strings.Join(args, " "))
-    }
-```
-
-**Handler: `doInspect()`** in `cmd_farm.go`:
-
-1. Find all farming patch objects in the current room.
-2. If none: "There are no farming patches here."
-3. If input is given, filter to matching patches.
-4. For each patch, load the player's flags and display:
-
-```
-=== Herb Patch 1 ===
-  Status: Growing (stage 2/4)
-  Planted: Guam seed
-  Watered: Yes
-  Diseased: No
-
-=== Herb Patch 2 ===
-  Status: Weeds
-  (Rake to clear before planting)
-
-=== Allotment Patch 1 ===
-  Status: Ready to harvest!
-  Planted: Potato seed
-```
-
-Possible statuses:
-- `Weeds` — needs raking
-- `Empty` — ready to plant
-- `Growing (stage N/M)` — in progress
-- `Watered` — growing and watered this stage
-- `Diseased!` — needs curing
-- `Dead` — needs raking
-- `Ready to harvest!` — fully grown
-
----
-
-## 5. New Files to Create
-
-### Go Files
-
-| File | Purpose |
-|---|---|
-| `internal/game/cmd_farm.go` | Command handlers: `doPlant()`, `doHarvest()`, `doRake()`, `doWater()`, `doCure()`, `doInspect()` |
-| `internal/game/action_farm.go` | Action lifecycle: `advancePlant()`, `advanceHarvest()`, `advanceRake()`, `advanceWater()`, `advanceCure()`, `advanceFarmGrowth()`, `findActiveFarmPrefixes()`, `farmFlagPrefix()`, `ensureFarmState()`, `FarmTick()`, helper functions |
-
-### YAML Files
-
-**Items (seeds):**
-- `data/items/guam_seed.yaml`
-- `data/items/marrentill_seed.yaml`
-- `data/items/tarromin_seed.yaml`
-- `data/items/harralander_seed.yaml`
-- `data/items/ranarr_seed.yaml`
-- `data/items/toadflax_seed.yaml`
-- `data/items/irit_seed.yaml`
-- `data/items/avantoe_seed.yaml`
-- `data/items/kwuarm_seed.yaml`
-- `data/items/snapdragon_seed.yaml`
-- `data/items/cadantine_seed.yaml`
-- `data/items/lantadyme_seed.yaml`
-- `data/items/dwarf_weed_seed.yaml`
-- `data/items/torstol_seed.yaml`
-- `data/items/potato_seed.yaml`
-- `data/items/onion_seed.yaml`
-- `data/items/cabbage_seed.yaml`
-- `data/items/tomato_seed.yaml`
-- `data/items/sweetcorn_seed.yaml`
-- `data/items/strawberry_seed.yaml`
-- `data/items/watermelon_seed.yaml`
-
-**Items (products — only if they don't already exist):**
-- `data/items/guam_leaf.yaml`
-- `data/items/marrentill.yaml`
-- `data/items/tarromin.yaml`
-- `data/items/harralander.yaml`
-- `data/items/ranarr_weed.yaml`
-- `data/items/toadflax.yaml`
-- `data/items/irit_leaf.yaml`
-- `data/items/avantoe.yaml`
-- `data/items/kwuarm.yaml`
-- `data/items/snapdragon.yaml`
-- `data/items/cadantine.yaml`
-- `data/items/lantadyme.yaml`
-- `data/items/dwarf_weed.yaml`
-- `data/items/torstol.yaml`
-- `data/items/potato.yaml`
-- `data/items/onion.yaml`
-- `data/items/cabbage.yaml`
-- `data/items/tomato.yaml`
-- `data/items/sweetcorn.yaml` (ear_of_sweetcorn)
-- `data/items/strawberry.yaml`
-- `data/items/watermelon.yaml`
-
-**Items (tools):**
-- `data/items/rake.yaml`
-- `data/items/spade.yaml`
-- `data/items/watering_can.yaml`
-- `data/items/plant_cure.yaml`
-
-**Objects:**
-- `data/objects/herb_patch.yaml`
-- `data/objects/allotment_patch.yaml`
-- `data/objects/flower_patch.yaml`
-- `data/objects/tool_shed.yaml`
-
-**Rooms:**
-- `data/rooms/150.yaml` — Farming Hub (repurpose room 15 description or create new room)
-- `data/rooms/151.yaml` — Herb Garden
-- `data/rooms/152.yaml` — Allotment Field
-
-**Help Files:**
-- `data/help/plant.yaml`
-- `data/help/harvest.yaml`
-- `data/help/rake.yaml`
-- `data/help/water.yaml`
-- `data/help/cure.yaml`
-- `data/help/inspect.yaml`
-- `data/help/farming.yaml`
-
----
-
-## 6. Code Changes to Existing Files
-
-### `internal/object/item.go`
-
-Add new fields to `ItemDef` struct:
-
-```go
-FarmPatchType  string  `yaml:"farm_patch_type"`
-FarmLevel      int     `yaml:"farm_level"`
-FarmPlantXP    int     `yaml:"farm_plant_xp"`
-FarmHarvestXP  int     `yaml:"farm_harvest_xp"`
-FarmStages     int     `yaml:"farm_stages"`
-FarmProduct    string  `yaml:"farm_product"`
-FarmMinYield   int     `yaml:"farm_min_yield"`
-FarmMaxYield   int     `yaml:"farm_max_yield"`
-```
-
-### `internal/game/game.go`
-
-**In `classifyCommand()`:**
-
-Add to Instant case:
-```go
-case "say", "score", "sc", "inventory", "i", "inv",
-    "look", "l", "exits", "help",
-    "map", "option", "options", "alias", "unalias",
-    "description", "desc", "queued", "color", "colors",
-    "colortable", "prompt", "style", "inspect":  // <-- ADD inspect
-```
-
-Add to Active case:
-```go
-case "get", "take", "grab", "pick", "drop",
-    "attack", "kill",
-    "north", "n", "south", "s", "east", "e",
-    "west", "w", "up", "u", "down", "d",
-    "quit", "use", "burn", "stoke", "search", "walk", "cook", "smelt", "smith", "craft",
-    "plant", "harvest", "rake", "water", "cure":  // <-- ADD THESE
-```
-
-**In `executeCommand()`:**
-
-Add cases for each farming command:
-```go
-case "plant":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        sess.WriteLine("Plant what?")
-    } else {
-        g.doPlant(sess, strings.Join(args, " "))
-    }
-    return
-case "harvest":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doHarvest(sess, "")
-    } else {
-        g.doHarvest(sess, strings.Join(args, " "))
-    }
-    return
-case "rake":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doRake(sess, "")
-    } else {
-        g.doRake(sess, strings.Join(args, " "))
-    }
-    return
-case "water":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doWater(sess, "")
-    } else {
-        g.doWater(sess, strings.Join(args, " "))
-    }
-    return
-case "cure":
-    g.CancelAction(p)
-    if len(args) == 0 {
-        g.doCure(sess, "")
-    } else {
-        g.doCure(sess, strings.Join(args, " "))
-    }
-    return
-case "inspect":
-    if len(args) == 0 {
-        g.doInspect(sess, "")
-    } else {
-        g.doInspect(sess, strings.Join(args, " "))
-    }
-```
-
-**In `Game` struct:**
-
-Add field:
-```go
-farmTickCounter int
-```
-
-### `internal/game/action_state.go`
-
-Add new ActionType constants:
-
-```go
-ActionPlanting   ActionType = "planting"
-ActionHarvesting ActionType = "harvesting_crop"
-ActionRaking     ActionType = "raking"
-ActionWatering   ActionType = "watering"
-ActionCuring     ActionType = "curing"
-```
-
-Add cases in `Description()`:
-
-```go
-case ActionPlanting:
-    return "planting " + a.TargetName
-case ActionHarvesting:
-    return "harvesting " + a.TargetName
-case ActionRaking:
-    return "raking a " + a.TargetName
-case ActionWatering:
-    return "watering a " + a.TargetName
-case ActionCuring:
-    return "curing a " + a.TargetName
-```
-
-### `internal/game/action.go`
-
-**In `AdvanceActions()`**, add cases for farming action types:
-
-```go
-case "plant":
-    g.advancePlant(sess, p)
-case "harvest":
-    g.advanceHarvest(sess, p)
-case "rake":
-    g.advanceRake(sess, p)
-case "water":
-    g.advanceWater(sess, p)
-case "cure":
-    g.advanceCure(sess, p)
-```
-
-**In `ProcessQueuedCommands()`**, add farming ActionTypes to the persistent list that should NOT be cleared after one tick:
-
-```go
-case ActionGathering, ActionCombating, ActionUsing, ActionTalking,
-    ActionToggling, ActionBurning, ActionStoking, ActionResting, ActionWalking, ActionProducing,
-    ActionPlanting, ActionHarvesting, ActionRaking, ActionWatering, ActionCuring:
-    // keep these
-```
-
-### `cmd/mud/main.go`
-
-Add `g.FarmTick()` to the tick subscription (after `g.VisualTick()`).
-
----
-
-## 7. Seeds
-
-### Herb Seeds
-
-All herb seeds: `stackable: true`, `farm_patch_type: "herb"`, `farm_stages: 4`.
-
-```yaml
-# data/items/guam_seed.yaml
-id: guam_seed
-name: guam seed
-color: "34"
-description: "A guam seed for planting in a herb patch."
-value: 1
-stackable: true
-farm_patch_type: herb
-farm_level: 9
-farm_plant_xp: 11
-farm_harvest_xp: 13
-farm_stages: 4
-farm_product: guam_leaf
-farm_min_yield: 3
-farm_max_yield: 12
-```
-
-```yaml
-# data/items/marrentill_seed.yaml
-id: marrentill_seed
-name: marrentill seed
-color: "34"
-description: "A marrentill seed for planting in a herb patch."
-value: 2
-stackable: true
-farm_patch_type: herb
-farm_level: 14
-farm_plant_xp: 14
-farm_harvest_xp: 15
-farm_stages: 4
-farm_product: marrentill
-farm_min_yield: 3
-farm_max_yield: 12
-```
-
-```yaml
-# data/items/tarromin_seed.yaml
-id: tarromin_seed
-name: tarromin seed
-color: "34"
-description: "A tarromin seed for planting in a herb patch."
-value: 3
-stackable: true
-farm_patch_type: herb
-farm_level: 19
-farm_plant_xp: 18
-farm_harvest_xp: 18
-farm_stages: 4
-farm_product: tarromin
-farm_min_yield: 3
-farm_max_yield: 12
-```
-
-```yaml
-# data/items/harralander_seed.yaml
-id: harralander_seed
-name: harralander seed
-color: "70"
-description: "A harralander seed for planting in a herb patch."
-value: 5
-stackable: true
-farm_patch_type: herb
-farm_level: 26
-farm_plant_xp: 22
-farm_harvest_xp: 24
-farm_stages: 4
-farm_product: harralander
-farm_min_yield: 3
-farm_max_yield: 12
-```
-
-```yaml
-# data/items/ranarr_seed.yaml
-id: ranarr_seed
-name: ranarr seed
-color: "28"
-description: "A ranarr seed for planting in a herb patch. Highly valued."
-value: 100
-stackable: true
-farm_patch_type: herb
-farm_level: 32
-farm_plant_xp: 27
-farm_harvest_xp: 31
-farm_stages: 4
-farm_product: ranarr_weed
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/toadflax_seed.yaml
-id: toadflax_seed
-name: toadflax seed
-color: "106"
-description: "A toadflax seed for planting in a herb patch."
-value: 50
-stackable: true
-farm_patch_type: herb
-farm_level: 38
-farm_plant_xp: 34
-farm_harvest_xp: 39
-farm_stages: 4
-farm_product: toadflax
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/irit_seed.yaml
-id: irit_seed
-name: irit seed
-color: "114"
-description: "An irit seed for planting in a herb patch."
-value: 40
-stackable: true
-farm_patch_type: herb
-farm_level: 44
-farm_plant_xp: 43
-farm_harvest_xp: 49
-farm_stages: 4
-farm_product: irit_leaf
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/avantoe_seed.yaml
-id: avantoe_seed
-name: avantoe seed
-color: "34"
-description: "An avantoe seed for planting in a herb patch."
-value: 60
-stackable: true
-farm_patch_type: herb
-farm_level: 50
-farm_plant_xp: 55
-farm_harvest_xp: 62
-farm_stages: 4
-farm_product: avantoe
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/kwuarm_seed.yaml
-id: kwuarm_seed
-name: kwuarm seed
-color: "178"
-description: "A kwuarm seed for planting in a herb patch."
-value: 80
-stackable: true
-farm_patch_type: herb
-farm_level: 56
-farm_plant_xp: 69
-farm_harvest_xp: 78
-farm_stages: 4
-farm_product: kwuarm
-farm_min_yield: 3
-farm_max_yield: 9
-```
-
-```yaml
-# data/items/snapdragon_seed.yaml
-id: snapdragon_seed
-name: snapdragon seed
-color: "161"
-description: "A snapdragon seed for planting in a herb patch."
-value: 150
-stackable: true
-farm_patch_type: herb
-farm_level: 62
-farm_plant_xp: 82
-farm_harvest_xp: 99
-farm_stages: 4
-farm_product: snapdragon
-farm_min_yield: 3
-farm_max_yield: 9
-```
-
-```yaml
-# data/items/cadantine_seed.yaml
-id: cadantine_seed
-name: cadantine seed
-color: "30"
-description: "A cadantine seed for planting in a herb patch."
-value: 120
-stackable: true
-farm_patch_type: herb
-farm_level: 67
-farm_plant_xp: 97
-farm_harvest_xp: 120
-farm_stages: 4
-farm_product: cadantine
-farm_min_yield: 3
-farm_max_yield: 9
-```
-
-```yaml
-# data/items/lantadyme_seed.yaml
-id: lantadyme_seed
-name: lantadyme seed
-color: "36"
-description: "A lantadyme seed for planting in a herb patch."
-value: 130
-stackable: true
-farm_patch_type: herb
-farm_level: 73
-farm_plant_xp: 105
-farm_harvest_xp: 135
-farm_stages: 4
-farm_product: lantadyme
-farm_min_yield: 3
-farm_max_yield: 8
-```
-
-```yaml
-# data/items/dwarf_weed_seed.yaml
-id: dwarf_weed_seed
-name: dwarf weed seed
-color: "100"
-description: "A dwarf weed seed for planting in a herb patch."
-value: 140
-stackable: true
-farm_patch_type: herb
-farm_level: 79
-farm_plant_xp: 120
-farm_harvest_xp: 150
-farm_stages: 4
-farm_product: dwarf_weed
-farm_min_yield: 3
-farm_max_yield: 8
-```
-
-```yaml
-# data/items/torstol_seed.yaml
-id: torstol_seed
-name: torstol seed
-color: "220"
-description: "A torstol seed for planting in a herb patch. Extremely rare and valuable."
-value: 500
-stackable: true
-farm_patch_type: herb
-farm_level: 85
-farm_plant_xp: 142
-farm_harvest_xp: 200
-farm_stages: 4
-farm_product: torstol
-farm_min_yield: 3
-farm_max_yield: 8
-```
-
-### Allotment Seeds
-
-All allotment seeds: `stackable: true`, `farm_patch_type: "allotment"`, `farm_stages: 4`.
-
-```yaml
-# data/items/potato_seed.yaml
-id: potato_seed
-name: potato seed
-color: "180"
-description: "A potato seed for planting in an allotment patch."
-value: 1
-stackable: true
-farm_patch_type: allotment
-farm_level: 1
-farm_plant_xp: 8
-farm_harvest_xp: 9
-farm_stages: 4
-farm_product: potato
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/onion_seed.yaml
-id: onion_seed
-name: onion seed
-color: "229"
-description: "An onion seed for planting in an allotment patch."
-value: 1
-stackable: true
-farm_patch_type: allotment
-farm_level: 5
-farm_plant_xp: 10
-farm_harvest_xp: 11
-farm_stages: 4
-farm_product: onion
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/cabbage_seed.yaml
-id: cabbage_seed
-name: cabbage seed
-color: "71"
-description: "A cabbage seed for planting in an allotment patch."
-value: 1
-stackable: true
-farm_patch_type: allotment
-farm_level: 7
-farm_plant_xp: 10
-farm_harvest_xp: 12
-farm_stages: 4
-farm_product: cabbage
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/tomato_seed.yaml
-id: tomato_seed
-name: tomato seed
-color: "196"
-description: "A tomato seed for planting in an allotment patch."
-value: 2
-stackable: true
-farm_patch_type: allotment
-farm_level: 12
-farm_plant_xp: 13
-farm_harvest_xp: 14
-farm_stages: 4
-farm_product: tomato
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/sweetcorn_seed.yaml
-id: sweetcorn_seed
-name: sweetcorn seed
-color: "220"
-description: "A sweetcorn seed for planting in an allotment patch."
-value: 5
-stackable: true
-farm_patch_type: allotment
-farm_level: 20
-farm_plant_xp: 17
-farm_harvest_xp: 19
-farm_stages: 4
-farm_product: sweetcorn
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/strawberry_seed.yaml
-id: strawberry_seed
-name: strawberry seed
-color: "197"
-description: "A strawberry seed for planting in an allotment patch."
-value: 8
-stackable: true
-farm_patch_type: allotment
-farm_level: 31
-farm_plant_xp: 26
-farm_harvest_xp: 29
-farm_stages: 4
-farm_product: strawberry
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
-```yaml
-# data/items/watermelon_seed.yaml
-id: watermelon_seed
-name: watermelon seed
-color: "34"
-description: "A watermelon seed for planting in an allotment patch."
-value: 15
-stackable: true
-farm_patch_type: allotment
-farm_level: 47
-farm_plant_xp: 49
-farm_harvest_xp: 55
-farm_stages: 4
-farm_product: watermelon
-farm_min_yield: 3
-farm_max_yield: 10
-```
-
----
-
-## 8. Tools
-
-### Rake
-
-```yaml
-# data/items/rake.yaml
-id: rake
-name: rake
-color: "94"
-description: "A sturdy rake for clearing weeds and dead plants from farming patches."
-value: 8
-stackable: false
-tool_type: rake
-```
-
-### Spade
-
-```yaml
-# data/items/spade.yaml
-id: spade
-name: spade
-color: "241"
-description: "A metal spade used for planting seeds and harvesting crops."
-value: 8
-stackable: false
-tool_type: spade
-```
-
-### Watering Can
-
-```yaml
-# data/items/watering_can.yaml
-id: watering_can
-name: watering can
-color: "39"
-description: "A watering can for hydrating farming patches. Watering eliminates disease risk."
-value: 12
-stackable: false
-tool_type: watering_can
-```
-
-### Plant Cure
-
-```yaml
-# data/items/plant_cure.yaml
-id: plant_cure
-name: plant cure
-color: "120"
-description: "A bio-engineered solution that cures diseased plants."
-value: 25
-stackable: true
-```
-
-### Tool Shed Object
-
-```yaml
-# data/objects/tool_shed.yaml
-id: tool_shed
-name: tool shed
-color: "94"
-behavior: ""
-hidden: false
-inroom_description: "A weathered tool shed stands against the wall."
-description: "A small shed for storing farming tools. Use 'use tool_shed' to store or retrieve tools."
-use_interactions:
-  - item: rake
-    message: "You store the rake in the tool shed."
-    action:
-      take_item: rake
-      set_player_flags:
-        tool_shed_rake: true
-  - item: spade
-    message: "You store the spade in the tool shed."
-    action:
-      take_item: spade
-      set_player_flags:
-        tool_shed_spade: true
-  - item: watering_can
-    message: "You store the watering can in the tool shed."
-    action:
-      take_item: watering_can
-      set_player_flags:
-        tool_shed_watering_can: true
-```
-
-**Retrieval:** For retrieving tools, the tool shed should also have interactions that are available when the player does NOT have the item but HAS the player flag. This requires adding conditional `use_interactions` on the object. Since the existing `UseInteraction` struct supports `Condition`, add retrieve entries:
-
-```yaml
-# Additional use_interactions on tool_shed.yaml
-  - item: ""
-    condition:
-      player_flag: tool_shed_rake
-    message: "You retrieve the rake from the tool shed."
-    action:
-      give_item: rake
-      set_player_flags:
-        tool_shed_rake: false
-  - item: ""
-    condition:
-      player_flag: tool_shed_spade
-    message: "You retrieve the spade from the tool shed."
-    action:
-      give_item: spade
-      set_player_flags:
-        tool_shed_spade: false
-  - item: ""
-    condition:
-      player_flag: tool_shed_watering_can
-    message: "You retrieve the watering can from the tool shed."
-    action:
-      give_item: watering_can
-      set_player_flags:
-        tool_shed_watering_can: false
-```
-
-**Note:** The current `UseInteraction` system requires an `item` field (the item being used on the object). For retrieval (no item needed), this may require either:
-1. A new `talk`-style behavior on the tool shed with dialog options, OR
-2. Adding a `talk` behavior that lists stored tools and lets the player choose, OR
-3. A new command `retrieve <tool> from shed`, OR
-4. Simply using `use shed` with no item to trigger a menu of stored tools.
-
-**Recommended approach:** Give the tool shed a `talk` behavior. When the player does `talk shed` or `use shed`, they get a dialog:
-
-```yaml
-# data/behaviors/tool_shed_talk.yaml
-id: tool_shed_talk
-type: talk
-nodes:
-  start:
-    message: "The tool shed is open. What would you like to do?"
-    options:
-      - text: "Store rake"
-        goto: store_rake
-        condition:
-          has_item: rake
-      - text: "Store spade"
-        goto: store_spade
-        condition:
-          has_item: spade
-      - text: "Store watering can"
-        goto: store_watering_can
-        condition:
-          has_item: watering_can
-      - text: "Retrieve rake"
-        goto: retrieve_rake
-        condition:
-          player_flag: tool_shed_rake
-      - text: "Retrieve spade"
-        goto: retrieve_spade
-        condition:
-          player_flag: tool_shed_spade
-      - text: "Retrieve watering can"
-        goto: retrieve_watering_can
-        condition:
-          player_flag: tool_shed_watering_can
-      - text: "Never mind"
-        end: true
-  store_rake:
-    message: "You store the rake in the tool shed."
-    action:
-      take_item: rake
-      set_player_flags:
-        tool_shed_rake: true
-    options:
-      - text: "Continue"
-        goto: start
-  store_spade:
-    message: "You store the spade in the tool shed."
-    action:
-      take_item: spade
-      set_player_flags:
-        tool_shed_spade: true
-    options:
-      - text: "Continue"
-        goto: start
-  store_watering_can:
-    message: "You store the watering can in the tool shed."
-    action:
-      take_item: watering_can
-      set_player_flags:
-        tool_shed_watering_can: true
-    options:
-      - text: "Continue"
-        goto: start
-  retrieve_rake:
-    message: "You retrieve the rake from the tool shed."
-    action:
-      give_item: rake
-      set_player_flags:
-        tool_shed_rake: false
-    options:
-      - text: "Continue"
-        goto: start
-  retrieve_spade:
-    message: "You retrieve the spade from the tool shed."
-    action:
-      give_item: spade
-      set_player_flags:
-        tool_shed_spade: false
-    options:
-      - text: "Continue"
-        goto: start
-  retrieve_watering_can:
-    message: "You retrieve the watering can from the tool shed."
-    action:
-      give_item: watering_can
-      set_player_flags:
-        tool_shed_watering_can: false
-    options:
-      - text: "Continue"
-        goto: start
-```
-
-Update `data/objects/tool_shed.yaml` to reference this behavior:
-
-```yaml
-id: tool_shed
-name: tool shed
-color: "94"
-behavior: tool_shed_talk
-hidden: false
-inroom_description: "A weathered tool shed stands against the wall."
-description: "A small shed for storing farming tools. Talk to it to store or retrieve tools."
-```
-
----
-
-## 9. Plot Objects
-
-### Herb Patch
-
-```yaml
-# data/objects/herb_patch.yaml
-id: herb_patch
-name: herb patch
-color: "28"
-behavior: ""
-hidden: false
-inroom_description: "A prepared herb patch sits in the soil."
-description: "A small patch of tilled soil suitable for growing herbs. Use 'inspect' to check its status."
-```
-
-Note: `behavior: ""` because farming patches don't use the standard behavior system. They are interacted with via the dedicated farming commands (`plant`, `harvest`, `rake`, `water`, `cure`, `inspect`).
-
-### Allotment Patch
-
-```yaml
-# data/objects/allotment_patch.yaml
-id: allotment_patch
-name: allotment patch
-color: "94"
-behavior: ""
-hidden: false
-inroom_description: "An allotment patch is marked out in the ground."
-description: "A large patch of soil for growing vegetables. Use 'inspect' to check its status."
-```
-
-### Flower Patch
-
-```yaml
-# data/objects/flower_patch.yaml
-id: flower_patch
-name: flower patch
-color: "213"
-behavior: ""
-hidden: false
-inroom_description: "A flower patch is outlined with small stones."
-description: "A small decorative patch for growing flowers. Use 'inspect' to check its status."
-```
-
-### How `look` Shows Patch State
-
-The `doLook` / `doLookTarget` functions need modification. When a player looks at a farming patch object, the system should append the player's personal patch state to the object description.
-
-**In `doLookTarget()` (likely in `cmd_look.go` or the look handler):**
-
-When the target matches a farming patch object, after displaying the base description, append:
-
-```go
-func (g *Game) farmPatchLookSuffix(p *player.Player, defID string, index int) string {
-    prefix := farmFlagPrefix(defID, index)
-    if prefix == "" {
-        return ""
-    }
-    g.ensureFarmState(p, prefix)
-
-    weeds, _ := p.Flags[prefix+"_weeds"].(bool)
-    if weeds {
-        return "\nIt is overgrown with weeds."
-    }
-
-    seedID, _ := p.Flags[prefix+"_seed"].(string)
-    if seedID == "" {
-        return "\nThe patch is empty and ready for planting."
-    }
-
-    dead, _ := p.Flags[prefix+"_dead"].(bool)
-    if dead {
-        return "\nThe plant has died. You need to rake it clean."
-    }
-
-    diseased, _ := p.Flags[prefix+"_diseased"].(bool)
-    if diseased {
-        return "\nThe plant looks diseased! Use plant cure to save it."
-    }
-
-    ready, _ := p.Flags[prefix+"_ready"].(bool)
-    if ready {
-        seedDef, _ := g.ItemStore.Load(seedID)
-        name := seedID
-        if seedDef != nil {
-            name = seedDef.Name
-        }
-        return fmt.Sprintf("\nA fully grown %s is ready to harvest!", name)
-    }
-
-    stage, _ := p.Flags[prefix+"_stage"].(int)
-    seedDef, _ := g.ItemStore.Load(seedID)
-    maxStages := 4
-    if seedDef != nil && seedDef.FarmStages > 0 {
-        maxStages = seedDef.FarmStages
-    }
-    name := seedID
-    if seedDef != nil {
-        name = seedDef.Name
-    }
-    watered, _ := p.Flags[prefix+"_watered"].(bool)
-    suffix := fmt.Sprintf("\nA %s is growing (stage %d/%d).", name, stage, maxStages)
-    if watered {
-        suffix += " It has been watered."
-    }
-    return suffix
-}
-```
-
-The room `look` listing should also reflect patch state. In the objects section of `doLook`, for each farming patch object, replace the generic `inroom_description` with a state-aware version:
-
-- Weeds: "A herb patch sits here, overgrown with weeds."
-- Empty: "An empty herb patch is ready for planting."
-- Growing: "A herb patch has a small plant growing in it."
-- Diseased: "A herb patch has a {196}sickly-looking{/} plant in it."
-- Dead: "A herb patch contains a dead, withered plant."
-- Ready: "A herb patch has a {34 bold}fully grown crop{/} ready to harvest!"
-
----
-
-## 10. Rooms
-
-### Room Layout
-
-Room 15 currently is "Alchemy Lab" with exits east:16, west:14. We will repurpose it as the farming hub entrance, or more practically, create new rooms at the end of the room list (rooms 150-152) and connect them.
-
-**Connection point:** Add a south exit from an existing hub room to room 150. Room 1 (Town Square) or another central room should connect to the farming area.
-
-Alternatively, give room 15 (Alchemy Lab) a south exit to room 150.
-
-### Room 150: Farming Hub
-
-```yaml
-# data/rooms/150.yaml
-id: 150
-name: "Hydroponics Bay"
-description: "A large enclosed area with climate-controlled growing stations. {34}Lush green patches{/} of soil are laid out in neat rows under artificial UV lamps. A {94}tool shed{/} stands near the entrance."
-map_symbol: "H"
-exits:
-  north: 15
-  east: 151
-  south: 152
-objects:
-  - id: tool_shed
-spawns:
-  - item_id: rake
-    quantity: 1
-    respawn_ticks: 120
-  - item_id: spade
-    quantity: 1
-    respawn_ticks: 120
-  - item_id: watering_can
-    quantity: 1
-    respawn_ticks: 120
-  - item_id: plant_cure
-    quantity: 3
-    respawn_ticks: 200
-  - item_id: guam_seed
-    quantity: 5
-    respawn_ticks: 300
-  - item_id: potato_seed
-    quantity: 10
-    respawn_ticks: 300
-  - item_id: onion_seed
-    quantity: 10
-    respawn_ticks: 300
-```
-
-### Room 151: Herb Garden
-
-```yaml
-# data/rooms/151.yaml
-id: 151
-name: "Herb Garden"
-description: "A dedicated section of the hydroponics bay for growing herbs. {28}Herb patches{/} are arranged in two rows under specialized grow lights."
-map_symbol: "G"
-exits:
-  west: 150
-objects:
-  - id: herb_patch
-  - id: herb_patch
-  - id: herb_patch
-  - id: herb_patch
-```
-
-### Room 152: Allotment Field
-
-```yaml
-# data/rooms/152.yaml
-id: 152
-name: "Allotment Field"
-description: "A section with larger soil beds for growing vegetables. {94}Allotment patches{/} stretch across the floor under warm overhead lamps."
-map_symbol: "A"
-exits:
-  north: 150
-objects:
-  - id: allotment_patch
-  - id: allotment_patch
-  - id: allotment_patch
-  - id: flower_patch
-```
-
-### Connect Room 15 to Room 150
-
-Update `data/rooms/15.yaml` to add a south exit:
-
-```yaml
-id: 15
-name: "Alchemy Lab"
-description: "Shelves lined with glass vials, dried herbs, and bubbling cauldrons. This area is not yet accessible."
-exits:
-  east: 16
-  west: 14
-  south: 150
-```
-
----
-
-## 11. Growth Stages
-
-### Stage Definitions
-
-Each crop type has a fixed number of growth stages. Growth advances by 1 stage per farm tick (every 500 game ticks ≈ 5 minutes).
-
-| Crop Type | Stages | Total Grow Time (online) |
-|---|---|---|
-| Herb | 4 | ~20 minutes |
-| Allotment | 4 | ~20 minutes |
-| Flower | 3 | ~15 minutes |
-| Bush | 5 | ~25 minutes |
-| Tree | 6 | ~30 minutes |
-
-All stages are equal duration (1 farm tick each). The `farm_stages` field on the seed item controls this per-seed.
-
-### Stage Progression
-
-```
-Stage 0: Just planted (seedling)
-Stage 1: Small sprout
-Stage 2: Growing plant
-Stage 3: Maturing plant
-Stage 4: Fully grown (for 4-stage crops)
-```
-
-At each stage transition, the disease check occurs (unless watered). Watering is reset each stage — you must water each stage individually if you want full protection.
-
-### Watering Reset Mechanic
-
-When growth advances a stage:
-1. The `_watered` flag is set to `false`.
-2. Disease check runs (10% chance if not watered, 0% if watered).
-3. Player must water again for the next stage.
-
-This means a 4-stage herb crop with full watering protection requires 4 watering actions spread across 4 farm ticks.
-
----
-
-## 12. Disease & Death
-
-### Disease Chance
-
-- **Base disease chance per growth stage:** 10% (0.10)
-- **If watered:** 0% (eliminated entirely)
-- **Not affected by farming level** (keep it simple for Phase 1)
-
-### Disease Flow
-
-```
-[Growth tick fires]
-    |
-    +-- Is plant diseased?
-    |     |
-    |     +-- YES: Plant DIES. Set _dead = true, _diseased = false.
-    |     |        Notify player: "Your <seed> has died from disease!"
-    |     |
-    |     +-- NO: Continue to growth check.
-    |
-    +-- Advance stage by 1.
-    |
-    +-- Is plant now fully grown?
-    |     |
-    |     +-- YES: Set _ready = true. Notify: "Your <seed> is fully grown!"
-    |     |
-    |     +-- NO: Roll disease check.
-    |           |
-    |           +-- Watered? No disease.
-    |           |
-    |           +-- Not watered? 10% chance of disease.
-    |                 |
-    |                 +-- Disease! Set _diseased = true. Notify: "Your <seed> has become diseased!"
-    |                 |
-    |                 +-- No disease. Continue growing.
-    |
-    +-- Reset _watered to false.
-```
-
-### Curing
-
-- Use `cure` command or `use plant_cure on herb patch`.
-- Consumes 1 `plant_cure` from inventory.
-- Sets `_diseased = false`.
-- Must be done **before the next farm tick** or the plant dies.
-
-### Dead Plants
-
-- Dead plants block the patch. Nothing can be planted.
-- Must be cleared with `rake` command.
-- Raking dead plants awards **no XP**.
-- After raking, the patch has weeds (must be raked again to clear before planting).
-- **Actually, simplify:** Raking a dead plant fully clears the patch (no double-rake). Set `_weeds = false`, `_dead = false`, `_seed = ""`, etc. The patch is immediately ready for replanting.
-
-### Raking Weeds
-
-- New patches start with weeds.
-- After harvesting, the patch returns to having weeds.
-- Raking weeds also awards **no XP** and takes 4 ticks.
-- After raking weeds, patch is empty and ready for planting.
-
----
-
-## 13. Harvesting
-
-### Harvest Mechanics
-
-1. Player must be in a room with a farming patch that has `_ready == true`.
-2. Player must have a spade (tool_type "spade") in inventory or equipment.
-3. Player must have at least 1 free inventory slot.
-4. Harvest action takes 3 ticks.
-
-### Yield Calculation
-
-```go
-func farmYield(minYield, maxYield, farmingLevel int) int {
-    baseYield := minYield + rand.Intn(maxYield-minYield+1)
-    bonus := farmingLevel / 20
-    return baseYield + bonus
-}
-```
-
-- Herbs: base 3-12, +1 per 20 farming levels → at level 99: 3-17
-- Allotments: base 3-10, +1 per 20 farming levels → at level 99: 3-14
-
-### Yield Capping
-
-Yield is capped by available inventory space. If the product is stackable (herbs could be), all yield goes into one slot. If not stackable, yield = min(yield, freeSlots).
-
-For simplicity, **all farm products are stackable** (herb leaves, vegetables).
-
-### Harvest XP
-
-XP is awarded per harvest action (not per item). The total XP is `farm_harvest_xp` from the seed def, awarded once when harvesting completes.
-
-### Post-Harvest
-
-After harvesting:
-- `_seed = ""`, `_stage = 0`, `_ready = false`, `_watered = false`
-- `_weeds = true` — weeds grow back after harvest (must rake before replanting)
-
-### Output Messages
-
-```
-"You harvest 7 guam leaves from the herb patch."
-" (+13xp frm)"  // if xp_drops enabled
-```
-
----
-
-## 14. XP Table
-
-### Herb Seeds
-
-| Seed | Level | Plant XP | Harvest XP | Total XP (min harvest) |
-|---|---|---|---|---|
-| Guam | 9 | 11 | 13 | 24 |
-| Marrentill | 14 | 14 | 15 | 29 |
-| Tarromin | 19 | 18 | 18 | 36 |
-| Harralander | 26 | 22 | 24 | 46 |
-| Ranarr | 32 | 27 | 31 | 58 |
-| Toadflax | 38 | 34 | 39 | 73 |
-| Irit | 44 | 43 | 49 | 92 |
-| Avantoe | 50 | 55 | 62 | 117 |
-| Kwuarm | 56 | 69 | 78 | 147 |
-| Snapdragon | 62 | 82 | 99 | 181 |
-| Cadantine | 67 | 97 | 120 | 217 |
-| Lantadyme | 73 | 105 | 135 | 240 |
-| Dwarf Weed | 79 | 120 | 150 | 270 |
-| Torstol | 85 | 142 | 200 | 342 |
-
-### Allotment Seeds
-
-| Seed | Level | Plant XP | Harvest XP | Total XP |
-|---|---|---|---|---|
-| Potato | 1 | 8 | 9 | 17 |
-| Onion | 5 | 10 | 11 | 21 |
-| Cabbage | 7 | 10 | 12 | 22 |
-| Tomato | 12 | 13 | 14 | 27 |
-| Sweetcorn | 20 | 17 | 19 | 36 |
-| Strawberry | 31 | 26 | 29 | 55 |
-| Watermelon | 47 | 49 | 55 | 104 |
-
-### XP Comparison to Other Skills
-
-These values are intentionally lower per-action than gathering skills because farming is passive — the player plants, waters, and waits. The time-gated nature means farming XP comes slowly but with minimal active effort.
-
----
-
-## 15. Tool Shed
-
-### Overview
-
-The tool shed is an object in the Farming Hub room (150). Players can interact with it to store and retrieve farming tools, freeing up inventory space while farming.
-
-### Implementation
-
-The tool shed uses the existing **talk behavior** system. When a player does `talk shed` or `talk tool_shed`, they enter a dialog that shows available storage/retrieval options based on their inventory and player flags.
-
-**Player flags for tool shed:**
-- `tool_shed_rake: true/false`
-- `tool_shed_spade: true/false`
-- `tool_shed_watering_can: true/false`
-
-**Behavior YAML:** See Section 8 above (`data/behaviors/tool_shed_talk.yaml`).
-
-**Object YAML:** See Section 8 above (`data/objects/tool_shed.yaml`).
-
-### Tool Shed in `look`
-
-When the player looks at the tool shed, the description should mention what's stored:
-
-```go
-func (g *Game) toolShedLookSuffix(p *player.Player) string {
-    var stored []string
-    if v, _ := p.Flags["tool_shed_rake"].(bool); v {
-        stored = append(stored, "a rake")
-    }
-    if v, _ := p.Flags["tool_shed_spade"].(bool); v {
-        stored = append(stored, "a spade")
-    }
-    if v, _ := p.Flags["tool_shed_watering_can"].(bool); v {
-        stored = append(stored, "a watering can")
-    }
-    if len(stored) == 0 {
-        return "\nThe shed is empty."
-    }
-    return fmt.Sprintf("\nInside: %s.", strings.Join(stored, ", "))
-}
-```
-
-This could be appended when the player does `look tool shed`. Since the description field supports `{quality}` placeholder for fire objects, a similar approach could be used, but it's simpler to handle this in the Go code for the `doLookTarget` handler.
-
----
-
-## 16. Help Files
-
-### `data/help/plant.yaml`
-
-```yaml
-name: "plant"
-category: "Skills"
-description: |
-  Plant a seed in a farming patch.
-
-  Usage: plant <seed>
-
-  Requires a spade in your inventory. The seed must match the
-  patch type in the current room (herb seeds go in herb patches,
-  vegetable seeds go in allotment patches).
-
-  The patch must be clear of weeds (use 'rake' first) and empty.
-
-  Planting awards a small amount of farming XP.
-
-  See also: help farming, help harvest, help rake, help water
-```
-
-### `data/help/harvest.yaml`
-
-```yaml
-name: "harvest"
-category: "Skills"
-description: |
-  Harvest a fully grown crop from a farming patch.
-
-  Usage: harvest [patch]
-
-  Requires a spade in your inventory. The crop must be fully
-  grown (check with 'inspect'). Yields a random amount of the
-  crop based on your farming level.
-
-  If no patch is specified, the first harvestable patch in the
-  room is targeted.
-
-  After harvesting, the patch grows weeds and must be raked
-  before replanting.
-
-  See also: help farming, help plant, help inspect
-```
-
-### `data/help/rake.yaml`
-
-```yaml
-name: "rake"
-category: "Skills"
-description: |
-  Clear weeds or dead plants from a farming patch.
-
-  Usage: rake [patch]
-
-  Requires a rake in your inventory. Patches start with weeds
-  and regrow weeds after harvesting. Dead plants from disease
-  also need to be raked before replanting.
-
-  Raking awards no farming XP.
-
-  If no patch is specified, the first patch needing raking
-  in the room is targeted.
-
-  See also: help farming, help plant, help water
-```
-
-### `data/help/water.yaml`
-
-```yaml
-name: "water"
-category: "Skills"
-description: |
-  Water a farming patch to prevent disease.
-
-  Usage: water [patch]
-
-  Requires a watering can in your inventory. Watering a patch
-  eliminates the disease chance for the current growth stage.
-  You must water each stage separately as the watering resets
-  when the plant grows.
-
-  If no patch is specified, the first unwatered patch with a
-  growing plant is targeted.
-
-  See also: help farming, help plant, help cure
-```
-
-### `data/help/cure.yaml`
-
-```yaml
-name: "cure"
-category: "Skills"
-description: |
-  Cure a diseased farming patch.
-
-  Usage: cure [patch]
-
-  Requires a plant cure item in your inventory (consumed on use).
-  Diseased plants must be cured before the next growth tick or
-  they will die.
-
-  If no patch is specified, the first diseased patch in the
-  room is targeted.
-
-  See also: help farming, help water, help inspect
-```
-
-### `data/help/inspect.yaml`
-
-```yaml
-name: "inspect"
-category: "Skills"
-description: |
-  Check the status of farming patches in the current room.
-
-  Usage: inspect [patch]
-
-  Shows the current state of each farming patch including:
-  - What is planted
-  - Growth stage
-  - Whether it has been watered
-  - Disease status
-  - Whether it is ready to harvest
-
-  If no patch is specified, all patches in the room are shown.
-
-  See also: help farming, help plant, help harvest
-```
-
-### `data/help/farming.yaml`
-
-```yaml
-name: "farming"
-category: "Skills"
-description: |
-  Farming lets you grow herbs and vegetables in patches.
-
-  The basic cycle:
-    1. Rake the patch to clear weeds (requires rake)
-    2. Plant a seed (requires spade, seed in inventory)
-    3. Water the patch to prevent disease (requires watering can)
-    4. Wait for the plant to grow through stages
-    5. Water again at each growth stage for protection
-    6. Harvest the fully grown crop (requires spade)
-
-  Growth happens every ~5 minutes while you are online.
-  Crops do not grow while you are logged off.
-
-  Disease: Each growth stage has a 10% chance of disease unless
-  the patch was watered. Diseased plants can be cured with plant
-  cure. If not cured before the next growth tick, the plant dies
-  and must be raked away.
-
-  Tool shed: Store farming tools to free inventory space.
-  Use 'talk shed' to store or retrieve tools.
-
-  Patches: Herb patches grow herb seeds. Allotment patches grow
-  vegetable seeds. Check 'inspect' for patch status.
-
-  Commands: plant, harvest, rake, water, cure, inspect
-
-  See also: help plant, help harvest, help rake, help water,
-            help cure, help inspect
-```
-
----
-
-## Implementation Order
-
-Recommended order for implementing this feature:
-
-1. **Add `ItemDef` fields** (`internal/object/item.go`) — the 8 new `farm_*` fields. Run `make vet`.
-2. **Add `ActionType` constants** (`internal/game/action_state.go`) — 5 new types + `Description()` cases.
-3. **Create `action_farm.go`** — farm state helpers, `ensureFarmState()`, `farmFlagPrefix()`, `findActiveFarmPrefixes()`, `FarmTick()`, `advanceFarmGrowth()`, and all `advanceXxx()` functions.
-4. **Create `cmd_farm.go`** — all command handlers: `doPlant()`, `doHarvest()`, `doRake()`, `doWater()`, `doCure()`, `doInspect()`, and look suffix helpers.
-5. **Update `game.go`** — `classifyCommand()`, `executeCommand()`, `farmTickCounter` field on `Game`.
-6. **Update `action.go`** — add farming cases to `AdvanceActions()` and `ProcessQueuedCommands()`.
-7. **Update `main.go`** — add `g.FarmTick()` to tick subscription.
-8. **Create tool YAML files** — rake, spade, watering_can, plant_cure in `data/items/`.
-9. **Create seed YAML files** — all 21 seeds in `data/items/`.
-10. **Create product YAML files** — all harvest products that don't already exist.
-11. **Create object YAML files** — herb_patch, allotment_patch, flower_patch, tool_shed in `data/objects/`.
-12. **Create behavior YAML** — `tool_shed_talk` in `data/behaviors/`.
-13. **Create room YAML files** — rooms 150, 151, 152 in `data/rooms/`.
-14. **Update room 15** — add south exit to room 150.
-15. **Create help YAML files** — all 7 help files.
-16. **Integrate patch state into look** — modify `doLookTarget()` and room look to show per-player patch state.
-17. **Test** — `make build && make test && make vet`.
-
----
-
-## Edge Cases & Notes
-
-- **Inventory full when harvesting:** Cap yield at available slots. If no slots available, "Your inventory is too full!"
-- **No patches in room:** "There are no farming patches here."
-- **Wrong seed for patch:** "That seed can't be planted in this type of patch."
-- **Already planted:** "Something is already growing in this patch."
-- **No tool:** "You need a rake/spade/watering can to do that."
-- **No plant cure:** "You don't have any plant cure."
-- **Multi-patch rooms:** Support numbered targeting like `plant guam seed 2.patch` or implicit "first available" logic.
-- **Cancellation:** All farming actions (plant, harvest, rake, water, cure) are cancelled by movement, combat, or other active commands (standard `CancelAction` behavior).
-- **Offline growth:** Intentionally disabled. Crops freeze when player logs off. This means farming is most effective when the player stays online and periodically waters/harvests.
-- **Multiple players:** Since state is per-player (player flags), two players can farm the same patches independently. Each sees their own state.
-- **Save frequency:** Character is saved after every state change (planting, watering, curing, harvesting, raking, growth tick). This matches the existing pattern of `g.AccountStore.SaveCharacter(p)` after mutations.
-- **Color targets:** Add `farm_grow` and `farm_disease` to the color system (in `config/colors.go` or wherever color targets are registered). Suggested defaults: `farm_grow: "34"` (green), `farm_disease: "196"` (red).
-- **Player flag cleanup:** Dead characters or deleted characters will have farming flags in their YAML files. This is harmless — the flags are simply ignored if the character is deleted. No cleanup needed.
-- **Flag type safety:** When reading flags, always use type assertions with default values: `stage, _ := p.Flags[prefix+"_stage"].(int)`. YAML deserialization may store ints as `int` or `float64` depending on the value — handle both like `OptionInt()` does.