diag: add verbose network listener logging to trace command delivery

Manager logs: listener start, every modem_message received, channel match/mismatch, command acceptance count, handler result. Client logs: every sendToMaster call with type and commandId.
fix: point package repository to stable branch
2026-03-29 16:39:29 -04:00 · 2026-03-29 16:22:25 -04:00
25 changed files with 944 additions and 2677 deletions
--- a/.package
+++ b/.package
@@ -1,10 +1,7 @@
 {
-  required = {
-    'platform',
-  },
-  title = "Inventory Manager (Unstable)",
-  description = "UNSTABLE/DEV — Automated inventory management system for CC:Tweaked. Uses cc-platform-core. May have breaking changes. Install 'inventory-manager' for the stable version.",
-  repository = "gitea://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/main/",
+  title = "Inventory Manager",
+  description = "Automated inventory management system for CC:Tweaked. Tracks items across networked storage, crafting turtles, furnaces, and alerts. Includes web dashboard via bridge computer.",
+  repository = "gitea://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/stable/",
  exclude = {
    "^web/", "^__tests__/", "^startup/",
    "%.md$", "%.json$", "^%.git", "^LICENSE$", "^node_modules/",
--- a/README.md
+++ b/README.md
@@ -47,9 +47,7 @@ A Minecraft inventory management system built on [CC:Tweaked](https://tweaked.cc
 | `craftingTurtle.lua` | **Crafting Worker** | Runs on a Crafting Turtle. When the master places ingredients in its grid, it auto-crafts and reports results. Must be connected to the master via wired network. |
 | `dropperController.lua` | **Dropper Driver** | Pulses redstone to fire items out of a dropper block until empty. Runs on a computer adjacent to the dropper. |
 | `inventoryWebBridge.lua` | **Web Bridge** | Bridges the in-game modem network to the external web server over HTTP/WebSocket. Forwards state from the master and relays commands from the web dashboard back into the game. |
-| `miningTurtle.lua` | **Mining Turtle** | Runs on a mining turtle connected to the wired network. Continuously mines downward, auto-dumps inventory to networked storage, auto-refuels from storage, and triggers master scans after dumping. |
 | `listDevicesByType.lua` | **Diagnostic Utility** | Lists all peripherals on the wired network grouped by type. Useful for discovering connected chests, furnaces, etc. |
-| `autorun/startup.lua` | **Opus Autorun** | Auto-detects the computer's role from config files and launches the appropriate program. For use with [Opus OS](https://github.com/kepler155c/opus). |

 ### Web Stack (Docker)

@@ -64,27 +62,54 @@ A Minecraft inventory management system built on [CC:Tweaked](https://tweaked.cc
 ### Prerequisites

 - Minecraft with [CC:Tweaked](https://tweaked.cc/) installed
- [Opus OS](https://github.com/kepler155c/opus) installed on all CC:Tweaked computers (required for the UI framework)
 - A CC:Tweaked computer with a wired modem and monitor attached
 - HTTP access enabled in the CC:Tweaked config (for the web bridge)

-### 1. Install via Opus Package Manager (Recommended)
+### 1. Install the Master Controller

-On any CC:Tweaked computer running Opus, open the shell and run:
+On your main CC:Tweaked computer (with the monitor and wired modem), open the terminal and run:

 ```
-package install inventory-manager
+wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/inventoryManager.lua startup.lua
 ```

-An interactive setup wizard will guide you through role selection (Manager, Client, Web Bridge, or Mining Turtle) and peripheral configuration. The package installs all required files and an autorun script that launches the correct program on boot. Reboot after installation.
+This downloads `inventoryManager.lua` and saves it as `startup.lua` so it runs automatically on boot. Reboot the computer or run `startup.lua` to start.

-To update later:
+### 2. Install a Display Client (Optional)
+
+On a separate CC:Tweaked computer with a monitor:

 ```
-package update inventory-manager
+wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/inventoryClient.lua startup.lua
 ```

-### 2. Start the Web Dashboard (Optional)
+### 3. Install the Crafting Turtle (Optional)
+
+On a **Crafting Turtle** connected to the wired network:
+
+```
+wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/craftingTurtle.lua startup.lua
+```
+
+### 4. Install the Dropper Controller (Optional)
+
+On a computer adjacent to a dropper block:
+
+```
+wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/dropperController.lua startup.lua
+```
+
+### 5. Install the Web Bridge (Optional)
+
+On any CC:Tweaked computer with a wired modem and HTTP access:
+
+```
+wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/inventoryWebBridge.lua startup.lua
+```
+
+Configure the web server URL by editing `.webbridge_config` on the computer, or it will default to `http://localhost`.
+
+### 6. Start the Web Dashboard (Optional)

 On the host machine, navigate to the `web/` directory and run:

@@ -94,79 +119,14 @@ docker compose up -d --build

 The dashboard will be available at `http://localhost` on port 80.

-### Manual Install (Without Opus)
-
-If you are not using Opus, you can install individual components with `wget`. Note that the monitor dashboard requires the Opus UI framework (`opus.ui`), so Opus is still needed on computers with monitors.
-
-<details>
-<summary>Click to expand manual install instructions</summary>
-
-#### Master Controller
-
-On your main CC:Tweaked computer (with the monitor and wired modem):
-
-```
-wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/startup/manager.lua startup.lua
-```
-
-#### Display Client
-
-On a separate CC:Tweaked computer with a monitor:
-
-```
-wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/startup/client.lua startup.lua
-```
-
-#### Crafting Turtle
-
-On a **Crafting Turtle** connected to the wired network:
-
-```
-wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/startup/turtle.lua startup.lua
-```
-
-#### Mining Turtle
-
-On a **Mining Turtle** connected to the wired network:
-
-```
-wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/startup/miner.lua startup.lua
-```
-
-#### Web Bridge
-
-On any CC:Tweaked computer with a wired modem and HTTP access:
-
-```
-wget https://git.spatulaa.com/MayaTheShy/Inventory-Manager-CC/raw/branch/main/startup/bridge.lua startup.lua
-```
-
-These startup scripts auto-download all required files from the repository before launching.
-
-</details>
-
 ## Modem Channels

 | Channel | Purpose |
 |---------|---------|
 | 4200 | Master → Clients/Bridge (state broadcast) |
 | 4201 | Clients/Bridge → Master (orders & commands) |
-| 4202 | Master → Client (order/craft result replies) |
 | 4203 | Master → Crafting Turtle (craft requests) |
 | 4204 | Crafting Turtle → Master (craft results) |
-| 4205 | System channel (remote reboot all computers) |
-
-## Startup Scripts
-
-The `startup/` directory contains self-updating startup scripts that download the latest code from the git repository before launching. These are used by the manual install method above and can also be used standalone:
-
-| Script | Role |
-|--------|------|
-| `startup/manager.lua` | Master controller with auto-update for all manager modules |
-| `startup/client.lua` | Client with auto-update, first-run setup wizard, and optional dropper |
-| `startup/turtle.lua` | Crafting turtle with auto-update |
-| `startup/bridge.lua` | Web bridge with auto-update |
-| `startup/miner.lua` | Mining turtle with auto-update |

 ## License

--- a/craftingTurtle.lua
+++ b/craftingTurtle.lua
@@ -180,56 +180,30 @@ local function handleCraftCommand(message)

    for turtleSlotStr, info in pairs(slots) do
        local turtleSlot = tonumber(turtleSlotStr)
+        local chestName = info.chestName
+        local chestSlot = info.chestSlot
        local itemName = info.itemName
        local count = info.count or 1
-        local placed = 0

-        -- Try the suggested chest+slot first
-        local chest = peripheral.wrap(info.chestName)
-        if chest then
-            local ok, n = pcall(chest.pushItems, selfName, info.chestSlot, count, turtleSlot)
-            if ok and n and n > 0 then
-                placed = n
-            end
+        print(string.format("[CRAFT] Pulling %s from %s slot %d -> turtle slot %d",
+            itemName, chestName, chestSlot, turtleSlot))
+
+        local chest = peripheral.wrap(chestName)
+        if not chest then
+            print(string.format("[CRAFT] Cannot wrap chest: %s", chestName))
+            allPlaced = false
+            break
        end
-
-        -- If we didn't get enough, search ALL chests on the network for this item
-        if placed < count then
-            local remaining = count - placed
-            if placed == 0 then
-                print(string.format("[CRAFT] %s not at %s:%d, searching network...",
-                    itemName, info.chestName, info.chestSlot))
-            else
-                print(string.format("[CRAFT] Got %d/%d %s from hint, searching for %d more...",
-                    placed, count, itemName, remaining))
-            end
-
-            for _, chestName in ipairs(returnChests) do
-                if remaining <= 0 then break end
-                local ch = peripheral.wrap(chestName)
-                if ch then
-                    local contents = ch.list()
-                    if contents then
-                        for slot, slotItem in pairs(contents) do
-                            if slotItem.name == itemName then
-                                local ok, n = pcall(ch.pushItems, selfName, slot, remaining, turtleSlot)
-                                if ok and n and n > 0 then
-                                    placed = placed + n
-                                    remaining = remaining - n
-                                    if remaining <= 0 then break end
-                                end
-                            end
-                        end
-                    end
-                end
-            end
-        end
-
-        if placed > 0 then
+        local ok, n = pcall(chest.pushItems, selfName, chestSlot, count, turtleSlot)
+        if ok and n and n > 0 then
            placedItems[turtleSlot] = itemName
-            print(string.format("[CRAFT] Placed %s x%d in slot %d", itemName, placed, turtleSlot))
+            print(string.format("[CRAFT] Placed %s x%d in slot %d", itemName, n, turtleSlot))
        else
-            print(string.format("[CRAFT] Could not find %s anywhere on network!", itemName))
+            if not ok then
+                print(string.format("[CRAFT] pullItems error: %s", tostring(n)))
+            else
+                print(string.format("[CRAFT] pullItems returned %s (expected %d)", tostring(n), count))
+            end
            allPlaced = false
            break
        end
--- a/data/auto_craft.lua
+++ b/data/auto_craft.lua
@@ -1,14 +0,0 @@
-- Auto-craft rules: items that should be automatically crafted when stock exceeds reserve.
-- The system will keep `reserve` of the input item and craft all excess into the output.
-- Requires a crafting turtle to be connected.
--
-- Format: { input = "mod:item", reserve = N, output = "mod:output_item" }
-- The output item must have a recipe in data/craftable.lua (or learned via recipeBook).
-- Recursive crafting is used, so intermediate steps are handled automatically.
-
-return {
-    -- Convert excess bamboo into planks (keeps 128 raw bamboo as reserve)
-    { input = "minecraft:bamboo",       reserve = 128, output = "minecraft:bamboo_planks" },
-    -- Convert excess bamboo blocks into planks too (keeps 64 blocks as reserve)
-    { input = "minecraft:bamboo_block", reserve = 64,  output = "minecraft:bamboo_planks" },
-}
--- a/data/craftable.lua
+++ b/data/craftable.lua
@@ -31,24 +31,6 @@ return {
            nil, nil, nil,
        },
    },
-    {
-        output = "minecraft:bamboo_block",
-        count  = 1,
-        grid   = {
-            "minecraft:bamboo", "minecraft:bamboo", nil,
-            "minecraft:bamboo", "minecraft:bamboo", nil,
-            "minecraft:bamboo", "minecraft:bamboo", nil,
-        },
-    },
-    {
-        output = "minecraft:bamboo_planks",
-        count  = 2,
-        grid   = {
-            "minecraft:bamboo_block", nil, nil,
-            nil, nil, nil,
-            nil, nil, nil,
-        },
-    },
    {
        output = "minecraft:stick",
        count  = 4,
@@ -123,114 +105,6 @@ return {
            "minecraft:cobblestone", "minecraft:cobblestone", "minecraft:cobblestone",
        },
    },
-    {
-        output = "minecraft:cobblestone_slab",
-        count  = 6,
-        grid   = {
-            "minecraft:cobblestone", "minecraft:cobblestone", "minecraft:cobblestone",
-            nil, nil, nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:cobblestone_stairs",
-        count  = 4,
-        grid   = {
-            "minecraft:cobblestone", nil,                     nil,
-            "minecraft:cobblestone", "minecraft:cobblestone", nil,
-            "minecraft:cobblestone", "minecraft:cobblestone", "minecraft:cobblestone",
-        },
-    },
-    {
-        output = "minecraft:cobblestone_wall",
-        count  = 6,
-        grid   = {
-            "minecraft:cobblestone", "minecraft:cobblestone", "minecraft:cobblestone",
-            "minecraft:cobblestone", "minecraft:cobblestone", "minecraft:cobblestone",
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:stone_bricks",
-        count  = 4,
-        grid   = {
-            "minecraft:stone", "minecraft:stone", nil,
-            "minecraft:stone", "minecraft:stone", nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:stone_slab",
-        count  = 6,
-        grid   = {
-            "minecraft:stone", "minecraft:stone", "minecraft:stone",
-            nil, nil, nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:stone_stairs",
-        count  = 4,
-        grid   = {
-            "minecraft:stone", nil,              nil,
-            "minecraft:stone", "minecraft:stone", nil,
-            "minecraft:stone", "minecraft:stone", "minecraft:stone",
-        },
-    },
-    {
-        output = "minecraft:smooth_stone_slab",
-        count  = 6,
-        grid   = {
-            "minecraft:smooth_stone", "minecraft:smooth_stone", "minecraft:smooth_stone",
-            nil, nil, nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:polished_andesite",
-        count  = 4,
-        grid   = {
-            "minecraft:andesite", "minecraft:andesite", nil,
-            "minecraft:andesite", "minecraft:andesite", nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:polished_diorite",
-        count  = 4,
-        grid   = {
-            "minecraft:diorite", "minecraft:diorite", nil,
-            "minecraft:diorite", "minecraft:diorite", nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:polished_granite",
-        count  = 4,
-        grid   = {
-            "minecraft:granite", "minecraft:granite", nil,
-            "minecraft:granite", "minecraft:granite", nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:polished_deepslate",
-        count  = 4,
-        grid   = {
-            "minecraft:cobbled_deepslate", "minecraft:cobbled_deepslate", nil,
-            "minecraft:cobbled_deepslate", "minecraft:cobbled_deepslate", nil,
-            nil, nil, nil,
-        },
-    },
-    {
-        output = "minecraft:polished_tuff",
-        count  = 4,
-        grid   = {
-            "minecraft:tuff", "minecraft:tuff", nil,
-            "minecraft:tuff", "minecraft:tuff", nil,
-            nil, nil, nil,
-        },
-    },
    {
        output = "minecraft:ladder",
        count  = 3,
--- a/data/fuel.lua
+++ b/data/fuel.lua
@@ -8,6 +8,7 @@ return {
    { name = "minecraft:coal_block",   burn_time = 80 },
    { name = "minecraft:blaze_rod",    burn_time = 12 },
    { name = "minecraft:dried_kelp_block", burn_time = 20 },
+    { name = "minecraft:lava_bucket",  burn_time = 100 },
    { name = "minecraft:oak_planks",   burn_time = 1.5 },
    { name = "minecraft:spruce_planks",burn_time = 1.5 },
    { name = "minecraft:birch_planks", burn_time = 1.5 },
--- a/data/stock_limits.lua
+++ b/data/stock_limits.lua
@@ -1,20 +0,0 @@
-- Stock limits: maximum quantities to keep in storage.
-- When an item exceeds its limit, the excess is pushed to the trash dropper.
-- Set up a dropper facing lava, cactus, or void to destroy excess items.
--
-- Format: ["mod:item"] = maxCount
-- Only items listed here are subject to auto-discard; everything else is unlimited.
-
-return {
-    ["minecraft:cobblestone"]        = 8192,   -- 128 slots (~5 chests)
-    ["minecraft:stone"]              = 4096,
-    ["minecraft:smooth_stone"]       = 4096,
-    ["minecraft:cobbled_deepslate"]  = 4096,
-    ["minecraft:netherrack"]         = 2048,
-    ["minecraft:dirt"]               = 2048,
-    ["minecraft:gravel"]             = 2048,
-    ["minecraft:andesite"]           = 2048,
-    ["minecraft:diorite"]            = 2048,
-    ["minecraft:granite"]            = 2048,
-    ["minecraft:tuff"]               = 1024,
-}
--- a/inventoryClient.lua
+++ b/inventoryClient.lua
@@ -42,6 +42,7 @@ end

 -- Override dofile to load modules into our _ENV so they inherit
 -- Opus's require/package (CC:Tweaked dofile uses _G instead).
+local _ccDofile = dofile
 local function dofile(path)                     -- luacheck: ignore
    local fn, err = loadfile(path, nil, _ENV)
    if fn then return fn()
@@ -55,7 +56,6 @@ local CLIENT_CONFIG_FILE = _configPath(".client_config")
 -------------------------------------------------

 local log = dofile(_path("lib/log.lua"))
-local ui  = dofile(_path("lib/ui.lua"))

 local function loadConfig()
    if not fs.exists(CLIENT_CONFIG_FILE) then return end
@@ -105,10 +105,14 @@ end
 -------------------------------------------------

 local function sendToMaster(message)
-    if not networkModem then return end
+    if not networkModem then
+        log.warn("NET", "sendToMaster: no modem, dropping %s", tostring(message.type))
+        return
+    end
    if not message.commandId then
        message.commandId = newCommandId()
    end
+    log.info("NET", "TX -> ch %d: type=%s cmdId=%s", ORDER_CHANNEL, tostring(message.type), tostring(message.commandId))
    networkModem.transmit(ORDER_CHANNEL, CLIENT_CHANNEL, message)
 end

@@ -120,6 +124,7 @@ end
 local state = {}

 state.cache = {
+    catalogue   = {},
    itemList    = {},
    itemListDirty = false,
    grandTotal  = 0,
@@ -184,11 +189,46 @@ local function getItemTotal(itemName)
    return 0
 end

-- Delegate recipe helpers to shared lib/ui.lua with local stock lookup.
-function ops.getRecipeIngredients(recipe) return ui.getRecipeIngredients(recipe) end
-function ops.canCraftRecipe(recipe)       return ui.canCraftRecipe(recipe, getItemTotal) end
-function ops.maxCraftBatches(recipe)      return ui.maxCraftBatches(recipe, getItemTotal) end
-function ops.getMissingIngredients(recipe) return ui.getMissingIngredients(recipe, getItemTotal) end
+function ops.getRecipeIngredients(recipe)
+    local ingredients = {}
+    for _, item in ipairs(recipe.grid) do
+        if item then
+            ingredients[item] = (ingredients[item] or 0) + 1
+        end
+    end
+    return ingredients
+end
+
+function ops.canCraftRecipe(recipe)
+    local ingredients = ops.getRecipeIngredients(recipe)
+    for itemName, needed in pairs(ingredients) do
+        if (getItemTotal(itemName) or 0) < needed then return false end
+    end
+    return true
+end
+
+function ops.maxCraftBatches(recipe)
+    local ingredients = ops.getRecipeIngredients(recipe)
+    local minBatches = math.huge
+    for itemName, needed in pairs(ingredients) do
+        local batches = math.floor((getItemTotal(itemName) or 0) / needed)
+        if batches < minBatches then minBatches = batches end
+    end
+    if minBatches == math.huge then return 0 end
+    return minBatches
+end
+
+function ops.getMissingIngredients(recipe)
+    local ingredients = ops.getRecipeIngredients(recipe)
+    local missing = {}
+    for itemName, needed in pairs(ingredients) do
+        local have = getItemTotal(itemName) or 0
+        if have < needed then
+            table.insert(missing, { name = itemName, have = have, need = needed })
+        end
+    end
+    return missing
+end

 function ops.orderItem(itemName, amount)
    sendToMaster({
@@ -356,8 +396,10 @@ local function main()
                        c.barrelOk      = message.cache.barrelOk
                        c.furnaceCount  = message.cache.furnaceCount  ~= nil and message.cache.furnaceCount or c.furnaceCount
                        c.furnaceStatus = message.cache.furnaceStatus or c.furnaceStatus
-                        if message.cache.droppers then
-                            c.droppers = message.cache.droppers
+                        -- Also build catalogue from itemList so display.lua
+                        -- smelter tab can look up stock by item name
+                        if message.cache.catalogue then
+                            c.catalogue = message.cache.catalogue
                        end
                    end
                    if message.activity then
--- a/inventoryManager.lua
+++ b/inventoryManager.lua
@@ -39,6 +39,7 @@ local ok, err = xpcall(function()

 -- Override dofile to load modules into our _ENV so they inherit
 -- Opus's require/package (CC:Tweaked dofile uses _G instead).
+local _ccDofile = dofile
 local function dofile(path)                     -- luacheck: ignore
    local fn, err = loadfile(path, nil, _ENV)
    if fn then return fn()
@@ -51,13 +52,14 @@ end

 local log    = dofile(_path("lib/log.lua"))
 local ui     = dofile(_path("lib/ui.lua"))
+local itemDB = dofile(_path("lib/itemDB.lua"))
+itemDB.init(_configPath(".item_names.db"))

 -------------------------------------------------
 -- Load modules (factory pattern → shared context)
 -------------------------------------------------

 local cfg   = dofile(_path("manager/config.lua"))(log, _path)
-cfg.loadConfig()
 local state = dofile(_path("manager/state.lua"))()

 -- Shared context table (Lua tables are by-reference, so all
@@ -83,6 +85,7 @@ ctx.display = display
 local craftEngine = dofile(_path("lib/craft.lua"))
 craftEngine.init(cfg.recipeBook, ops.getItemTotal)
 ctx.craftEngine = craftEngine
+ctx.itemDB = itemDB

 -- Convenience aliases
 local cache    = state.cache
@@ -148,12 +151,9 @@ local function broadcastState()
    -- Keep ctx in sync so display.lua can check ctx.craftTurtleOk directly
    ctx.craftTurtleOk = payload.craftTurtleOk

-    -- Only include recipe tables when config has changed (they're large).
-    if state.configDirty then
-        payload.smeltable = cfg.SMELTABLE
-        payload.craftable = cfg.CRAFTABLE
-        state.configDirty = false
-    end
+    payload.smeltable = cfg.SMELTABLE
+    payload.craftable = cfg.CRAFTABLE
+    state.configDirty = false

    ctx.networkModem.transmit(cfg.BROADCAST_CHANNEL, cfg.ORDER_CHANNEL, payload)
    state.lastBroadcastVersion = state.stateVersion
@@ -195,14 +195,6 @@ local function main()
        log.warn("INIT", "No smelter monitor on %s", cfg.SMELTER_MONITOR_SIDE)
    end

-    -- Billboard monitor (optional — set billboardMonitorSide in .manager_config)
-    -- Billboard monitor (auto-detects any 3rd monitor, or set billboardMonitor in .manager_config)
-    if display.setupBillboardMonitor() then
-        log.info("INIT", "Billboard monitor: %s", display.billboardMonName)
-    else
-        log.info("INIT", "No billboard monitor found (optional)")
-    end
-
    -- Find wired modem for client/turtle communication
    for _, name in ipairs(peripheral.getNames()) do
        if peripheral.getType(name) == "modem" then
@@ -358,40 +350,13 @@ local function main()
    end
    print("")

-    -----------------------------------------------
-    -- Resilient task wrapper: if a task crashes, it
-    -- restarts after a brief delay instead of killing
-    -- all other parallel tasks.
-    -----------------------------------------------
-    local function resilient(name, fn)
-        return function()
-            while true do
-                local ok, err = pcall(fn)
-                if not ok then
-                    log.error("TASK", "%s crashed: %s", name, tostring(err))
-                    sleep(5)
-                    log.info("TASK", "%s restarting...", name)
-                else
-                    -- Task returned normally (shouldn't happen)
-                    log.warn("TASK", "%s exited unexpectedly, restarting...", name)
-                    sleep(1)
-                end
-            end
-        end
-    end
-
    -----------------------------------------------
    -- Parallel tasks
    -----------------------------------------------

-    -- Shared queue: capture task writes here, processor task reads.
-    -- This ensures modem_message events are never lost while the
-    -- processor yields for peripheral calls (pushItems, list, etc).
-    local networkQueue = {}
-
    parallel.waitForAny(
        -- Task 1: Background inventory scanner
-        resilient("Scanner", function()
+        function()
            if cacheLoaded then
                pcall(ops.refreshCache)
                pcall(ops.checkAlerts)
@@ -403,22 +368,23 @@ local function main()
                sleep(cfg.SCAN_INTERVAL)
                pcall(ops.refreshCache)
                pcall(ops.checkAlerts)
+                pcall(function() itemDB.flush() end)
                pcall(function() cfg.recipeBook.flush() end)
                state.needsRedraw = true
                state.smelterNeedsRedraw = true
            end
-        end),
+        end,

        -- Task 2: Barrel auto-sort
-        resilient("Barrel-sort", function()
+        function()
            while true do
                pcall(ops.sortBarrel)
                sleep(cfg.POLL_INTERVAL)
            end
-        end),
+        end,

        -- Task 3: Auto-smelt
-        resilient("Auto-smelt", function()
+        function()
            while true do
                local ok, didWork = pcall(ops.autoSmelt)
                if ok and didWork then
@@ -432,10 +398,10 @@ local function main()
                state.smelterNeedsRedraw = true
                sleep(cfg.SMELT_INTERVAL)
            end
-        end),
+        end,

        -- Task 4: Defrag (consolidate partial stacks)
-        resilient("Defrag", function()
+        function()
            sleep(10)
            while true do
                activity.defragging = true
@@ -445,10 +411,10 @@ local function main()
                state.needsRedraw = true
                sleep(cfg.DEFRAG_INTERVAL)
            end
-        end),
+        end,

        -- Task 5: Auto-compost
-        resilient("Auto-compost", function()
+        function()
            while true do
                activity.composting = true
                state.needsRedraw = true
@@ -458,57 +424,10 @@ local function main()
                pcall(ops.checkAlerts)
                sleep(cfg.COMPOST_INTERVAL)
            end
-        end),
-
-        -- Task 5b: Auto-discard excess stock
-        resilient("Auto-discard", function()
-            if #cfg.TRASH_DROPPERS == 0 then
-                while true do sleep(3600) end
-            end
-            sleep(8)  -- let initial scan finish first
-            log.info("DISCARD", "Auto-discard active with %d trash dropper(s)", #cfg.TRASH_DROPPERS)
-            while true do
-                activity.discarding = true
-                state.needsRedraw = true
-                pcall(ops.discardExcess)
-                activity.discarding = false
-                state.needsRedraw = true
-                sleep(cfg.DISCARD_INTERVAL)
-            end
-        end),
-
-        -- Task 5c: Auto-craft excess items into target products
-        resilient("Auto-craft", function()
-            sleep(12)  -- let initial scan + discard settle first
-            log.info("AUTOCRAFT", "Auto-craft active (%d explicit rule(s), smart=%s)",
-                #cfg.AUTO_CRAFT_RULES, tostring(cfg.AUTO_CRAFT_FROM_EXCESS))
-            while true do
-                if ctx.craftTurtleName then
-                    activity.autocrafting = true
-                    state.needsRedraw = true
-                    pcall(ops.autoCraft)
-                    activity.autocrafting = false
-                    state.needsRedraw = true
-                end
-                sleep(cfg.AUTO_CRAFT_INTERVAL)
-            end
-        end),
-
-        -- Task 5d: Collection hopper emptying (egg spawner, etc.)
-        resilient("Hopper-collect", function()
-            if #cfg.COLLECTION_HOPPERS == 0 then
-                while true do sleep(3600) end
-            end
-            sleep(3)
-            log.info("COLLECT", "Hopper collection active for %d hopper(s)", #cfg.COLLECTION_HOPPERS)
-            while true do
-                pcall(ops.collectHoppers)
-                sleep(cfg.COLLECTION_INTERVAL)
-            end
-        end),
+        end,

        -- Task 6: Low-stock alert checker
-        resilient("Alert-checker", function()
+        function()
            sleep(5)
            pcall(ops.checkAlerts)
            state.needsRedraw = true
@@ -517,10 +436,10 @@ local function main()
                pcall(ops.checkAlerts)
                state.needsRedraw = true
            end
-        end),
+        end,

        -- Task 7: Main dashboard redraw (event-driven, polls 0.1s)
-        resilient("Dashboard", function()
+        function()
            state.needsRedraw = true
            while true do
                if state.needsRedraw then
@@ -540,10 +459,10 @@ local function main()
                end
                sleep(0.1)
            end
-        end),
+        end,

        -- Task 8: Smelter dashboard redraw
-        resilient("Smelter-dashboard", function()
+        function()
            state.smelterNeedsRedraw = true
            while true do
                if state.smelterNeedsRedraw then
@@ -553,27 +472,10 @@ local function main()
                end
                sleep(0.1)
            end
-        end),
-
-        -- Task 8b: Billboard dashboard redraw (goals monitor)
-        resilient("Billboard", function()
-            if not display.billboardMon then
-                -- No billboard configured, sleep forever
-                while true do sleep(3600) end
-            end
-            state.billboardNeedsRedraw = true
-            while true do
-                if state.billboardNeedsRedraw then
-                    state.billboardNeedsRedraw = false
-                    local bok, berr = pcall(display.drawBillboard)
-                    if not bok then log.error("DRAW", "Billboard: %s", tostring(berr)) end
-                end
-                sleep(0.5)
-            end
-        end),
+        end,

        -- Task 9: Touch event listener (both monitors)
-        resilient("Touch-listener", function()
+        function()
            while true do
                local event, side, x, y = os.pullEvent("monitor_touch")
                if display.smelterMonName and side == display.smelterMonName then
@@ -584,20 +486,20 @@ local function main()
                    display.handleTouch(x, y)
                end
            end
-        end),
+        end,

        -- Task 10: Network state broadcast (skips if nothing changed)
-        resilient("Broadcast", function()
+        function()
            while true do
                if state.stateVersion ~= state.lastBroadcastVersion then
                    pcall(broadcastState)
                end
                sleep(cfg.BROADCAST_INTERVAL)
            end
-        end),
+        end,

        -- Task 11: Peripheral detach handler
-        resilient("Detach-handler", function()
+        function()
            while true do
                local event, name = os.pullEvent("peripheral_detach")
                if name then
@@ -610,10 +512,10 @@ local function main()
                    end
                end
            end
-        end),
+        end,

        -- Task 11b: Peripheral attach handler (auto-detect crafting turtle)
-        resilient("Attach-handler", function()
+        function()
            while true do
                local event, name = os.pullEvent("peripheral_attach")
                if name and name:match("^turtle_") and not ctx.craftTurtleName then
@@ -622,10 +524,10 @@ local function main()
                    pcall(broadcastState)
                end
            end
-        end),
+        end,

        -- Task 12: Supply chest (builder / manifest-based stocking)
-        resilient("Supply-chest", function()
+        function()
            if cfg.SUPPLY_CHEST == "" or #cfg.SUPPLY_MANIFEST == 0 then
                while true do sleep(3600) end
            end
@@ -634,55 +536,28 @@ local function main()
                pcall(ops.supplyChest)
                sleep(cfg.SUPPLY_INTERVAL)
            end
-        end),
+        end,

-        -- Task 13a: Network message capture (fast — never yields to peripheral calls)
-        -- This coroutine's filter is ALWAYS "modem_message", so it can never
-        -- miss events while other tasks yield for "task_complete" etc.
-        resilient("Network-capture", function()
+        -- Task 13: Network order/command listener
+        function()
            if not ctx.networkModem then
-                log.warn("NET-CAP", "No modem — capture task idle")
+                log.warn("NET", "No modem — listener disabled")
                while true do sleep(3600) end
            end
-            log.info("NET-CAP", "Capture task started, listening on ch %d", cfg.ORDER_CHANNEL)
+            log.info("NET", "Listener started on channel %d (modem: %s)", cfg.ORDER_CHANNEL, ctx.networkModemName or "?")
+            local cmdCount = 0
            while true do
+                log.info("NET", "Waiting for modem_message... (handled %d so far)", cmdCount)
                local event, side, channel, replyChannel, message, distance = os.pullEvent("modem_message")
+                log.info("NET", "Got modem_message: side=%s ch=%d reply=%d type=%s",
+                    tostring(side), channel or -1, replyChannel or -1,
+                    type(message) == "table" and tostring(message.type) or type(message))
                if channel == cfg.ORDER_CHANNEL and type(message) == "table" then
-                    table.insert(networkQueue, { replyChannel = replyChannel, message = message })
-                    log.debug("NET-CAP", "Queued: type=%s queue=%d", tostring(message.type), #networkQueue)
-                end
-            end
-        end),
-
-        -- Task 13b: Network message processor (drains queue — safe to yield)
-        resilient("Network-processor", function()
-            if not ctx.networkModem then
-                log.warn("NET-PROC", "No modem — processor task idle")
-                while true do sleep(3600) end
-            end
-            log.info("NET-PROC", "Processor task started")
-            while true do
-                if #networkQueue == 0 then
-                    os.pullEvent()
-                end
-                while #networkQueue > 0 do
-                    local entry = table.remove(networkQueue, 1)
-                    local message = entry.message
-                    local replyChannel = entry.replyChannel
-                    log.debug("NET-PROC", "Processing: type=%s id=%s queue=%d",
-                        tostring(message.type), tostring(message.commandId), #networkQueue)
-
                    if isCommandDuplicate(message.commandId) then
                        log.debug("NET", "Duplicate command skipped: %s", tostring(message.commandId))
-                        -- Still ACK so the sender stops retrying
-                        pcall(function()
-                            ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                type      = "command_ack",
-                                commandId = message.commandId,
-                                success   = true,
-                            })
-                        end)
                    else
+                        cmdCount = cmdCount + 1
+                        log.info("NET", "Command #%d accepted: type=%s cmdId=%s", cmdCount, tostring(message.type), tostring(message.commandId))
                        recordCommandId(message.commandId)
                        cleanupCommandIds()
                        local handlerOk, handlerErr = pcall(function()
@@ -717,13 +592,6 @@ local function main()
                                state.needsRedraw = true
                                state.smelterNeedsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "toggle_pause" then
                                state.smeltingPaused = not state.smeltingPaused
@@ -733,13 +601,6 @@ local function main()
                                state.smelterNeedsRedraw = true
                                state.needsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "toggle_recipe" and message.recipe then
                                if state.disabledRecipes[message.recipe] then
@@ -753,13 +614,6 @@ local function main()
                                state.bumpStateVersion()
                                state.smelterNeedsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "enable_all" then
                                state.disabledRecipes = {}
@@ -769,13 +623,6 @@ local function main()
                                state.bumpStateVersion()
                                state.smelterNeedsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "disable_all" then
                                for inputName in pairs(cfg.SMELTABLE) do
@@ -787,25 +634,11 @@ local function main()
                                state.bumpStateVersion()
                                state.smelterNeedsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "sort_barrel" and message.barrelName then
                                log.info("NET", "Sort barrel: %s", message.barrelName)
                                pcall(ops.sortBarrel, message.barrelName)
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "register_droppers" and message.clientId and message.droppers then
                                local cid = tostring(message.clientId)
@@ -898,13 +731,6 @@ local function main()
                                state.smelterNeedsRedraw = true
                                state.needsRedraw = true
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "learn_crafting_recipe" and message.output and message.count and message.grid then
                                cfg.recipeBook.learnCraftingRecipe(message.output, message.count, message.grid)
@@ -914,13 +740,6 @@ local function main()
                                state.configDirty = true
                                state.bumpStateVersion()
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "learn_smelting_recipe" and message.input and message.result then
                                cfg.recipeBook.learnSmeltingRecipe(message.input, message.result, message.furnaces)
@@ -930,13 +749,6 @@ local function main()
                                state.configDirty = true
                                state.bumpStateVersion()
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "forget_recipe" and message.recipe then
                                local forgot = cfg.recipeBook.forgetCraftingRecipe(message.recipe) or
@@ -949,13 +761,6 @@ local function main()
                                    state.bumpStateVersion()
                                end
                                pcall(broadcastState)
-                                pcall(function()
-                                    ctx.networkModem.transmit(replyChannel, cfg.ORDER_CHANNEL, {
-                                        type      = "command_ack",
-                                        commandId = message.commandId,
-                                        success   = true,
-                                    })
-                                end)

                            elseif message.type == "find_item" and message.items then
                                -- Return chest+slot locations for the first matching item
@@ -998,11 +803,15 @@ local function main()
                        end) -- pcall handler
                        if not handlerOk then
                            log.error("NET", "Handler error: %s", tostring(handlerErr))
+                        else
+                            log.info("NET", "Command #%d handled OK", cmdCount)
                        end
                    end -- idempotency else
-                end -- queue loop
+                else
+                    log.info("NET", "Ignored: ch=%d (want %d) or not table", channel or -1, cfg.ORDER_CHANNEL)
+                end
            end
-        end)
+        end
    )
 end

--- a/inventoryWebBridge.lua
+++ b/inventoryWebBridge.lua
@@ -3,51 +3,55 @@
 -- Listens to the inventory master's broadcasts via modem and
 -- forwards state to the web server via HTTP.
 -- Also polls the web server for commands and sends them to the master.
--
-- Uses cc-platform-core for shared infrastructure (config, HTTP, modem, WS).
-- Service-specific logic (command dispatch, state forwarding) remains here.
--
-- Transport: WebSocket (primary) with HTTP polling (fallback).
-- When a WS connection to /ws/bridge is active, commands arrive in
-- real-time and state/results are pushed over the socket. If the WS
-- drops, the bridge seamlessly falls back to HTTP polling until
-- reconnection.
--
-- Channel mode: 'current' by default (legacy channels active).
-- Set channelMode = 'dual' or 'target' in platform config to migrate.
-
-local WebBridge = require('platform.webbridge')
-local Channels  = require('platform.channels')

 -------------------------------------------------
-- Configuration (via platform)
+-- Configuration
+-------------------------------------------------
+
+-- Web server URL (change to your Docker host IP/hostname)
+local SERVER_URL     = "http://localhost"
+local POLL_INTERVAL  = 0.5  -- seconds between command polls
+local STATE_INTERVAL = 1    -- seconds between state forwards
+
+-- Modem channels (must match inventoryManager.lua)
+local BROADCAST_CHANNEL  = 4200
+local ORDER_CHANNEL      = 4201
+
+-------------------------------------------------
+-- Load config from file if present
 -------------------------------------------------

 local _baseDir = fs.getDir(shell.getRunningProgram())
+local function _path(rel) return fs.combine(_baseDir, rel) end

-local config, configSource = WebBridge.loadConfig({
-    serverUrl     = "http://localhost",
-    pollInterval  = 0.5,
-    stateInterval = 1,
-    apiKey        = nil,
-}, {
-    "usr/config/inventory-manager/.webbridge_config",
-    fs.combine(_baseDir, ".webbridge_config"),
-})
-
-local SERVER_URL     = config.serverUrl
-local POLL_INTERVAL  = config.pollInterval
-local STATE_INTERVAL = config.stateInterval
-local API_KEY        = config.apiKey
-
-if configSource then
-    print("[CONFIG] Loaded from " .. configSource)
+-- Persistent config path: survives Opus package updates
+local _PERSIST_DIR = "usr/config/inventory-manager"
+local function _configPath(rel)
+    if fs.isDir(_PERSIST_DIR) or fs.isDir("packages/inventory-manager") then
+        if not fs.isDir(_PERSIST_DIR) then fs.makeDir(_PERSIST_DIR) end
+        return fs.combine(_PERSIST_DIR, rel)
+    end
+    return _path(rel)
 end

-- Channels from platform registry (matches inventoryManager.lua)
-local BROADCAST_CHANNEL    = Channels.get('inventory.broadcast')
-local ORDER_CHANNEL        = Channels.get('inventory.order')
-local BRIDGE_REPLY_CHANNEL = Channels.get('inventory.bridge')
+local CONFIG_FILE = _configPath(".webbridge_config")
+local API_KEY = nil  -- optional API key for server auth
+
+local function loadConfig()
+    if fs.exists(CONFIG_FILE) then
+        local f = fs.open(CONFIG_FILE, "r")
+        local data = f.readAll()
+        f.close()
+        local ok, cfg = pcall(textutils.unserialiseJSON, data)
+        if ok and cfg then
+            if cfg.serverUrl then SERVER_URL = cfg.serverUrl end
+            if cfg.pollInterval then POLL_INTERVAL = cfg.pollInterval end
+            if cfg.stateInterval then STATE_INTERVAL = cfg.stateInterval end
+            if cfg.apiKey then API_KEY = cfg.apiKey end
+            print("[CONFIG] Loaded from " .. CONFIG_FILE)
+        end
+    end
+end

 -------------------------------------------------
 -- State
@@ -58,42 +62,64 @@ local modem = nil
 local modemName = nil
 local running = true

-- WebSocket state (real-time transport, with HTTP polling fallback)
-local ws = nil            -- active WebSocket handle (nil when not connected)
-local wsConnected = false -- gates WS vs HTTP transport selection
-local wsHasSynced = false -- true after first command_batch received from server
+-------------------------------------------------
+-- Find modem
+-------------------------------------------------

-- Reliable modem delivery: pending commands awaiting manager acknowledgment.
-- processCommand() inserts here; modemListener removes on result receipt.
-- A retry task periodically re-transmits unacknowledged commands.
-local pendingModem = {}     -- commandId -> { payload, channel, replyChannel, sent, retries }
-local MODEM_RETRY_INTERVAL = 2   -- seconds between retry sweeps
-local MODEM_RETRY_MAX      = 5   -- max retransmissions before giving up
-local MODEM_RETRY_DELAY    = 2   -- seconds before first retry (per command)
+local function findModem()
+    for _, name in ipairs(peripheral.getNames()) do
+        if peripheral.getType(name) == "modem" then
+            modem = peripheral.wrap(name)
+            modemName = name
+            modem.open(BROADCAST_CHANNEL)
+            return true
+        end
+    end
+    return false
+end

 -------------------------------------------------
-- HTTP helpers (thin wrappers around platform)
+-- HTTP helpers
 -------------------------------------------------

 local function httpPost(path, body)
-    local result, err = WebBridge.httpPost(SERVER_URL .. path, body,
-        WebBridge.authHeaders(API_KEY))
-    if not result and err then
-        print(string.format("[ERR] HTTP POST %s: %s", path, tostring(err)))
+    local url = SERVER_URL .. path
+    local data = textutils.serialiseJSON(body)
+    local headers = { ["Content-Type"] = "application/json" }
+    if API_KEY then headers["Authorization"] = "Bearer " .. API_KEY end
+
+    local ok, result = pcall(function()
+        local response = http.post(url, data, headers)
+        if response then
+            local responseData = response.readAll()
+            response.close()
+            return responseData
+        end
+    end)
+
+    if ok then
+        return result
    end
-    return result
+    return nil
 end

 local function httpGet(path)
-    local rawBody, err = WebBridge.httpGet(SERVER_URL .. path,
-        WebBridge.authHeaders(API_KEY))
-    if not rawBody then
-        if err then
-            print(string.format("[ERR] HTTP GET %s: %s", path, tostring(err)))
+    local url = SERVER_URL .. path
+    local headers = nil
+    if API_KEY then headers = { ["Authorization"] = "Bearer " .. API_KEY } end
+    local ok, result = pcall(function()
+        local response = http.get(url, headers)
+        if response then
+            local data = response.readAll()
+            response.close()
+            return textutils.unserialiseJSON(data)
        end
-        return nil
+    end)
+
+    if ok then
+        return result
    end
-    return textutils.unserialiseJSON(rawBody)
+    return nil
 end

 -------------------------------------------------
@@ -105,32 +131,6 @@ local function forwardState()
    httpPost("/api/bridge/state", latestState)
 end

-------------------------------------------------
-- WebSocket helpers (real-time transport)
-------------------------------------------------
-
--- Build the WebSocket bridge URL from server config.
-- Converts http(s):// to ws(s):// and appends /ws/bridge path.
-- @return string  WebSocket URL with optional API key
-local function getWsUrl()
-    local wsUrl = SERVER_URL:gsub("^http", "ws") .. "/ws/bridge"
-    if API_KEY then
-        wsUrl = wsUrl .. "?key=" .. textutils.urlEncode(API_KEY)
-    end
-    return wsUrl
-end
-
--- Send a JSON message via WebSocket if connected.
-- @param data table  Data to send (serialized to JSON automatically)
-- @return boolean  true if sent successfully, false if WS unavailable
-local function wsSend(data)
-    if ws and wsConnected then
-        local ok = pcall(ws.send, textutils.serialiseJSON(data))
-        return ok
-    end
-    return false
-end
-
 -------------------------------------------------
 -- Process commands from web server
 -------------------------------------------------
@@ -143,55 +143,60 @@ local function processCommand(cmd)

    print(string.format("[CMD] %s", action))

-    -- Build the modem payload from the server command
-    local payload
    if action == "order" then
-        payload = {
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
            type        = "order",
            commandId   = cmd.commandId,
            itemName    = cmd.itemName,
            amount      = cmd.amount,
            dropperName = cmd.dropperName,
-        }
+        })
    elseif action == "scan" then
-        payload = { type = "scan", commandId = cmd.commandId }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "scan",
+            commandId = cmd.commandId,
+        })
    elseif action == "toggle_pause" then
-        payload = { type = "toggle_pause", commandId = cmd.commandId }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "toggle_pause",
+            commandId = cmd.commandId,
+        })
    elseif action == "toggle_recipe" then
-        payload = { type = "toggle_recipe", commandId = cmd.commandId, recipe = cmd.recipe }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "toggle_recipe",
+            commandId = cmd.commandId,
+            recipe    = cmd.recipe,
+        })
    elseif action == "enable_all" then
-        payload = { type = "enable_all", commandId = cmd.commandId }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "enable_all",
+            commandId = cmd.commandId,
+        })
    elseif action == "disable_all" then
-        payload = { type = "disable_all", commandId = cmd.commandId }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "disable_all",
+            commandId = cmd.commandId,
+        })
    elseif action == "sort_barrel" then
-        payload = { type = "sort_barrel", commandId = cmd.commandId, barrelName = cmd.barrelName }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type       = "sort_barrel",
+            commandId  = cmd.commandId,
+            barrelName = cmd.barrelName,
+        })
    elseif action == "craft" then
-        payload = { type = "craft", commandId = cmd.commandId, recipeIdx = cmd.recipeIdx }
-    elseif action == "recursive_craft" then
-        payload = { type = "recursive_craft", commandId = cmd.commandId, itemName = cmd.itemName, count = cmd.count }
-    elseif action == "learn_crafting_recipe" then
-        payload = { type = "learn_crafting_recipe", commandId = cmd.commandId, output = cmd.output, count = cmd.count, grid = cmd.grid }
-    elseif action == "learn_smelting_recipe" then
-        payload = { type = "learn_smelting_recipe", commandId = cmd.commandId, input = cmd.input, result = cmd.result, furnaces = cmd.furnaces }
-    elseif action == "forget_recipe" then
-        payload = { type = "forget_recipe", commandId = cmd.commandId, recipe = cmd.recipe }
-    elseif action == "sync_disabled_recipes" then
-        payload = { type = "sync_disabled_recipes", commandId = cmd.commandId, disabledRecipes = cmd.disabledRecipes, smeltingPaused = cmd.smeltingPaused }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "craft",
+            commandId = cmd.commandId,
+            recipeIdx = cmd.recipeIdx,
+        })
    elseif action == "reboot" then
-        payload = { type = "reboot", commandId = cmd.commandId, target = cmd.target or "all" }
+        modem.transmit(ORDER_CHANNEL, BROADCAST_CHANNEL, {
+            type      = "reboot",
+            commandId = cmd.commandId,
+            target    = cmd.target or "all",
+        })
    else
        print("[CMD] Unknown action: " .. tostring(action))
-        return
-    end
-
-    -- Transmit and track for reliable delivery
-    modem.transmit(ORDER_CHANNEL, BRIDGE_REPLY_CHANNEL, payload)
-    if payload.commandId then
-        pendingModem[payload.commandId] = {
-            payload      = payload,
-            sent         = os.clock(),
-            retries      = 0,
-        }
    end
 end

@@ -207,95 +212,45 @@ local function modemListener()
            if message.type == "state" then
                latestState = message
            end
-        elseif channel == BRIDGE_REPLY_CHANNEL and type(message) == "table" then
-            -- Clear pending retry on any response matching a commandId
-            if message.commandId and pendingModem[message.commandId] then
-                pendingModem[message.commandId] = nil
-            end
-            -- Forward command results back to web server
-            local resultType = message.type
-            if resultType == "order_result" or resultType == "craft_result"
-               or resultType == "recursive_craft_result" or resultType == "find_item_result" then
-                local resultPayload = {
-                    action    = resultType,
-                    commandId = message.commandId,
-                    success   = message.success,
-                    message   = message.message,
-                    error     = message.error,
-                }
-                -- WS-first: send as command_result via WebSocket if connected
-                local sent = wsSend({
-                    type      = "command_result",
-                    action    = resultPayload.action,
-                    commandId = resultPayload.commandId,
-                    success   = resultPayload.success,
-                    message   = resultPayload.message,
-                    error     = resultPayload.error,
-                })
-                -- HTTP fallback: POST to /api/bridge/result if WS unavailable
-                if not sent then
-                    local fwdOk, fwdErr = pcall(httpPost, "/api/bridge/result", resultPayload)
-                    if not fwdOk then
-                        print(string.format("[ERR] Forward result %s: %s", resultType, tostring(fwdErr)))
-                    end
-                end
-            end
        end
    end
 end

 -- Task 2: Forward state to web server periodically
-- Uses WebSocket if connected; falls back to HTTP POST.
 local function stateForwarder()
    while running do
-        if latestState then
-            -- WS-first: send state directly via WebSocket
-            if not wsSend(latestState) then
-                -- HTTP fallback: POST to /api/bridge/state
-                local ok, err = pcall(forwardState)
-                if not ok then
-                    print(string.format("[ERR] State forward: %s", tostring(err)))
-                end
-            end
+        local ok, err = pcall(forwardState)
+        if not ok then
+            -- Connection error, will retry
        end
        sleep(STATE_INTERVAL)
    end
 end

-- Task 3: Poll web server for commands (HTTP fallback)
-- Active when WS is disconnected, or as safety net until first WS sync.
+-- Task 3: Poll web server for commands
 local lastProcessedId = 0  -- track highest processed command ID for dedup

 local function commandPoller()
    while running do
-        -- HTTP polling is a fallback; also runs until WS initial sync completes
-        if not wsConnected or not wsHasSynced then
-            local ok, err = pcall(function()
-                local result = httpGet("/api/bridge/commands")
-                if result and result.commands and #result.commands > 0 then
-                    local maxId = lastProcessedId
-                    -- Process each command, skipping already-processed ones
-                    for _, cmd in ipairs(result.commands) do
-                        local cmdId = cmd.id or 0
-                        if cmdId > lastProcessedId then
-                            local cmdOk, cmdErr = pcall(processCommand, cmd)
-                            if not cmdOk then
-                                print(string.format("[ERR] Process cmd %s: %s", tostring(cmd.action), tostring(cmdErr)))
-                            end
-                            if cmdId > maxId then maxId = cmdId end
-                        end
-                    end
-                    -- Acknowledge up to the highest processed ID
-                    if maxId > lastProcessedId then
-                        lastProcessedId = maxId
-                        httpPost("/api/bridge/commands/ack", { lastProcessedId = lastProcessedId })
+        local ok, err = pcall(function()
+            local result = httpGet("/api/bridge/commands")
+            if result and result.commands and #result.commands > 0 then
+                local maxId = lastProcessedId
+                -- Process each command, skipping already-processed ones
+                for _, cmd in ipairs(result.commands) do
+                    local cmdId = cmd.id or 0
+                    if cmdId > lastProcessedId then
+                        pcall(processCommand, cmd)
+                        if cmdId > maxId then maxId = cmdId end
                    end
                end
-            end)
-            if not ok then
-                print(string.format("[ERR] Command poll: %s", tostring(err)))
+                -- Acknowledge up to the highest processed ID
+                if maxId > lastProcessedId then
+                    lastProcessedId = maxId
+                    httpPost("/api/bridge/commands/ack", { lastProcessedId = lastProcessedId })
+                end
            end
-        end
+        end)
        sleep(POLL_INTERVAL)
    end
 end
@@ -320,91 +275,6 @@ local function heartbeat()
    end
 end

-- Task 5: WebSocket real-time connection (primary transport)
-- Maintains a persistent WebSocket link to the server for:
--   - Receiving commands in real-time (replaces HTTP polling when active)
--   - Sending state updates and command results via wsSend()
-- Reconnects automatically on failure; HTTP polling resumes as fallback.
-- Channel mode: 'current' by default — dual/target configurable via platform.
-local function wsConnector()
-    local wsUrl = getWsUrl()
-    print("[WS] Connecting to " .. wsUrl)
-
-    WebBridge.wsConnect(wsUrl, {
-        onConnect = function(wsHandle)
-            ws = wsHandle
-            wsConnected = true
-            print("[WS] Connected — real-time mode active")
-            -- Push current state immediately on reconnect
-            if latestState then
-                wsSend(latestState)
-            end
-        end,
-
-        onMessage = function(wsHandle, data)
-            -- Initial sync: server sends pending commands as a batch on connect
-            if data.type == 'command_batch' and data.commands then
-                wsHasSynced = true
-                for _, cmd in ipairs(data.commands) do
-                    local cmdOk, cmdErr = pcall(processCommand, cmd)
-                    if not cmdOk then
-                        print(string.format("[ERR] WS batch cmd %s: %s",
-                            tostring(cmd.action), tostring(cmdErr)))
-                    end
-                end
-                if #data.commands > 0 then
-                    print(string.format("[WS] Processed %d synced command(s)", #data.commands))
-                end
-            -- Server pushes commands via WebSocket (replaces HTTP polling)
-            elseif data.action then
-                local cmdOk, cmdErr = pcall(processCommand, data)
-                if not cmdOk then
-                    print(string.format("[ERR] WS cmd %s: %s",
-                        tostring(data.action), tostring(cmdErr)))
-                end
-            end
-        end,
-
-        onDisconnect = function()
-            ws = nil
-            wsConnected = false
-            wsHasSynced = false
-            print("[WS] Disconnected — HTTP polling fallback active")
-        end,
-
-        onError = function(err)
-            print(string.format("[WS] Connection error: %s", tostring(err)))
-        end,
-    }, {
-        reconnectDelay = 5,
-        receiveTimeout = 30,
-    })
-end
-
-- Task 6: Retry unacknowledged modem commands
-- The manager deduplicates by commandId, so retransmits are safe.
-local function modemRetry()
-    while running do
-        local now = os.clock()
-        for cmdId, entry in pairs(pendingModem) do
-            if now - entry.sent >= MODEM_RETRY_DELAY then
-                if entry.retries >= MODEM_RETRY_MAX then
-                    print(string.format("[RETRY] Giving up on %s after %d retries",
-                        tostring(cmdId), entry.retries))
-                    pendingModem[cmdId] = nil
-                else
-                    entry.retries = entry.retries + 1
-                    entry.sent = now
-                    print(string.format("[RETRY] Re-transmit %s (attempt %d/%d)",
-                        tostring(cmdId), entry.retries, MODEM_RETRY_MAX))
-                    pcall(modem.transmit, ORDER_CHANNEL, BRIDGE_REPLY_CHANNEL, entry.payload)
-                end
-            end
-        end
-        sleep(MODEM_RETRY_INTERVAL)
-    end
-end
-
 -------------------------------------------------
 -- Main
 -------------------------------------------------
@@ -415,16 +285,10 @@ local function main()
    print("===================================")
    print("")

-    -- Config already loaded at require-time via WebBridge.loadConfig above
+    loadConfig()

-    modem, modemName = WebBridge.findModem()
-    if modem then
-        WebBridge.openChannels(modem,
-            { 'inventory.broadcast', 'inventory.bridge' })
-        local modemType = modem.isWireless and (modem.isWireless() and "wireless" or "wired") or "unknown"
-        print(string.format("[OK]   Modem: %s (%s)", modemName, modemType))
-        print(string.format("[OK]   TX ch %d, listen ch %d/%d",
-            ORDER_CHANNEL, BROADCAST_CHANNEL, BRIDGE_REPLY_CHANNEL))
+    if findModem() then
+        print("[OK]   Modem: " .. modemName)
    else
        print("[WARN] No modem found! Bridge needs a modem.")
        print("       Attach a modem and restart.")
@@ -439,7 +303,6 @@ local function main()
    else
        print("[WARN] No API key set (open access)")
    end
-    print("[OK]   Transport: WebSocket (primary) + HTTP polling (fallback)")
    print("")
    print("Bridge is running. Press Ctrl+T to stop.")
    print("Listening for master broadcasts on ch " .. BROADCAST_CHANNEL)
@@ -449,9 +312,7 @@ local function main()
        modemListener,
        stateForwarder,
        commandPoller,
-        heartbeat,
-        wsConnector,
-        modemRetry
+        heartbeat
    )
 end

--- a/lib/craft.lua
+++ b/lib/craft.lua
@@ -168,8 +168,7 @@ end
 -- @param recipe  crafting recipe table
 -- @param ctx     context table with ops, cfg, state, log, craftTurtleName, networkModem
 -- @return success, error_message
-function craft.executeSingleCraft(recipe, ctx, batches)
-    batches = batches or 1
+function craft.executeSingleCraft(recipe, ctx)
    local ops = ctx.ops
    local cfg = ctx.cfg
    local st  = ctx.state
@@ -178,14 +177,11 @@ function craft.executeSingleCraft(recipe, ctx, batches)
    if not ctx.networkModem    then return false, "No modem" end
    if not peripheral.isPresent(ctx.craftTurtleName) then return false, "Turtle offline" end

-    -- Clamp batches to 64 (max stack size per slot)
-    batches = math.min(batches, 64)
-
    local chests = ops.getChests()
    local slotMap = {}
    local reserved = {}

-    -- Map each grid position to a chest slot, pulling `batches` items per slot
+    -- Map each grid position to a chest slot
    for gridPos = 1, 9 do
        local itemName = recipe.grid[gridPos]
        if itemName then
@@ -199,12 +195,11 @@ function craft.executeSingleCraft(recipe, ctx, batches)
                        for slot, si in pairs(chest.list()) do
                            local key = src.chest .. ":" .. slot
                            if si.name == itemName and not reserved[key] then
-                                local pullCount = math.min(batches, si.count)
                                slotMap[tostring(tSlot)] = {
                                    chestName = src.chest,
                                    chestSlot = slot,
                                    itemName  = itemName,
-                                    count     = pullCount,
+                                    count     = 1,
                                }
                                reserved[key] = true
                                found = true
@@ -303,20 +298,16 @@ function craft.executeChain(targetItem, count, ctx)
        ctx.state.needsRedraw = true
        ctx.state.smelterNeedsRedraw = true

-        -- Batch in chunks of 64 (max stack per turtle slot)
-        local remaining = step.count
-        while remaining > 0 do
-            local chunk = math.min(remaining, 64)
-            local ok, batchErr = craft.executeSingleCraft(step.recipe, ctx, chunk)
+        for batch = 1, step.count do
+            local ok, batchErr = craft.executeSingleCraft(step.recipe, ctx)
            if not ok then
                ctx.state.activity.crafting = false
                ctx.state.needsRedraw = true
-                ctx.log.error("CRAFT", "Chain failed at step %d: %s", i, batchErr)
+                ctx.log.error("CRAFT", "Chain failed at step %d batch %d: %s", i, batch, batchErr)
                return false, string.format("Step %d/%d failed: %s", i, #steps, batchErr)
            end
-            remaining = remaining - chunk
-            -- Brief pause between chunks to let turtle finish
-            if remaining > 0 then os.sleep(0.3) end
+            -- Brief pause between batches to let turtle finish
+            if batch < step.count then os.sleep(0.3) end
        end

        ctx.log.info("CRAFT", "Step %d/%d complete: %s x%d", i, #steps, step.output, step.outputCount)
--- a/lib/recipeBook.lua
+++ b/lib/recipeBook.lua
@@ -245,22 +245,4 @@ function recipeBook.count()
    return cc, sc
 end

--- Find all crafting recipes that use a given item as an ingredient.
-- @param ingredientName string — the input item to search for
-- @return array of recipe tables
-function recipeBook.findRecipesUsing(ingredientName)
-    local results = {}
-    for _, recipe in pairs(recipes.crafting) do
-        if recipe.grid then
-            for _, item in ipairs(recipe.grid) do
-                if item == ingredientName then
-                    table.insert(results, recipe)
-                    break
-                end
-            end
-        end
-    end
-    return results
-end
-
 return recipeBook
--- a/manager/config.lua
+++ b/manager/config.lua
@@ -34,9 +34,6 @@ C.COMPOST_INTERVAL  = 3
 C.ALERT_INTERVAL    = 15
 C.CACHE_FILE        = _configPath(".inventory_cache")
 C.SMELTER_MONITOR_SIDE = "top"
-C.BILLBOARD_MONITOR     = ""        -- network name e.g. "monitor_0"; auto-detects if empty
-C.BILLBOARD_TOP_ITEMS   = 20        -- max items in billboard bar chart
-C.BILLBOARD_TEXT_SCALE  = 1          -- 0.5 = tiny, 1 = normal, 2 = large, 5 = huge
 C.DISABLED_RECIPES_FILE = _configPath(".disabled_recipes")

 -- Network
@@ -56,26 +53,6 @@ C.COMPOST_RESERVE    = 128
 C.COMPOST_DROPPER    = "minecraft:dropper_10"
 C.COMPOST_HOPPER     = "minecraft:hopper_0"

-- Collection hoppers: periodically emptied into storage (e.g. egg spawner, mob farm)
-C.COLLECTION_HOPPERS  = { "minecraft:hopper_1" }
-C.COLLECTION_INTERVAL = 3            -- seconds between hopper collection
-
-- Stock limits / auto-discard (overridable via config file)
-C.TRASH_DROPPERS     = {             -- droppers facing lava/void for destroying excess items
-    "minecraft:dropper_11",
-    "minecraft:dropper_12",
-    "minecraft:dropper_13",
-    "minecraft:dropper_14",
-    "minecraft:dropper_15",
-    "minecraft:dropper_16",
-}
-C.DISCARD_INTERVAL   = 5            -- seconds between discard checks
-
-- Auto-craft (overridable via config file)
-C.AUTO_CRAFT_INTERVAL   = 10          -- seconds between auto-craft checks
-C.AUTO_CRAFT_OUTPUT_CAP = 512         -- max items of any output before smart-craft stops crafting it
-C.AUTO_CRAFT_FROM_EXCESS = true       -- auto-discover recipes for over-stocked items
-
 -- Peripheral
 C.PERIPHERAL_CACHE_TTL = 5

@@ -120,10 +97,7 @@ function C.loadConfig()
    if cfg.dropperName        then C.DROPPER_NAME        = cfg.dropperName        end
    if cfg.barrelName         then C.BARREL_NAME          = cfg.barrelName         end
    if cfg.monitorSide        then C.MONITOR_SIDE         = cfg.monitorSide        end
-    if cfg.smelterMonitorSide    then C.SMELTER_MONITOR_SIDE    = cfg.smelterMonitorSide    end
-    if cfg.billboardMonitor       then C.BILLBOARD_MONITOR        = cfg.billboardMonitor       end
-    if cfg.billboardTopItems      then C.BILLBOARD_TOP_ITEMS      = cfg.billboardTopItems      end
-    if cfg.billboardTextScale     then C.BILLBOARD_TEXT_SCALE     = cfg.billboardTextScale     end
+    if cfg.smelterMonitorSide then C.SMELTER_MONITOR_SIDE = cfg.smelterMonitorSide end
    if cfg.pollInterval       then C.POLL_INTERVAL        = cfg.pollInterval       end
    if cfg.scanInterval       then C.SCAN_INTERVAL        = cfg.scanInterval       end
    if cfg.smeltInterval      then C.SMELT_INTERVAL       = cfg.smeltInterval      end
@@ -139,18 +113,6 @@ function C.loadConfig()
    if cfg.compostReserve     then C.COMPOST_RESERVE      = cfg.compostReserve     end
    if cfg.compostDropper     then C.COMPOST_DROPPER      = cfg.compostDropper     end
    if cfg.compostHopper      then C.COMPOST_HOPPER       = cfg.compostHopper      end
-    if cfg.collectionHoppers  then C.COLLECTION_HOPPERS   = cfg.collectionHoppers  end
-    if cfg.collectionInterval then C.COLLECTION_INTERVAL  = cfg.collectionInterval end
-    if cfg.trashDroppers      then C.TRASH_DROPPERS       = cfg.trashDroppers      end
-    if cfg.discardInterval    then C.DISCARD_INTERVAL     = cfg.discardInterval    end
-    if cfg.autoCraftInterval   then C.AUTO_CRAFT_INTERVAL  = cfg.autoCraftInterval  end
-    if cfg.autoCraftOutputCap   then C.AUTO_CRAFT_OUTPUT_CAP = cfg.autoCraftOutputCap end
-    if cfg.autoCraftFromExcess ~= nil then C.AUTO_CRAFT_FROM_EXCESS = cfg.autoCraftFromExcess end
-    if cfg.stockLimits        then
-        for item, limit in pairs(cfg.stockLimits) do
-            C.STOCK_LIMITS[item] = limit  -- merge / override per-item
-        end
-    end
    if cfg.parallelScanChunks then C.PARALLEL_SCAN_CHUNKS = cfg.parallelScanChunks end
    if cfg.chestPriority      then C.CHEST_PRIORITY       = cfg.chestPriority      end
    if cfg.supplyChest        then C.SUPPLY_CHEST         = cfg.supplyChest        end
@@ -168,8 +130,6 @@ C.FUEL_LIST        = dofile(_path("data/fuel.lua"))
 local _compostData = dofile(_path("data/compostable.lua"))
 C.COMPOSTABLE      = _compostData.items
 C.COMPOST_TRASH    = _compostData.trash
-C.STOCK_LIMITS     = dofile(_path("data/stock_limits.lua"))
-C.AUTO_CRAFT_RULES = dofile(_path("data/auto_craft.lua"))
 C.LOW_STOCK_ALERTS = dofile(_path("data/alerts.lua"))

 -- Recipe book: merges built-in recipes + user-learned recipes
@@ -224,10 +184,6 @@ for _, f in ipairs(C.FUEL_LIST) do C.FUEL_SET[f.name] = true end
 C.COMPOSTABLE_SET = {}
 for _, name in ipairs(C.COMPOSTABLE) do C.COMPOSTABLE_SET[name] = true end

-- Build stock limits set for quick lookup
-C.STOCK_LIMITS_SET = {}
-for name, _ in pairs(C.STOCK_LIMITS) do C.STOCK_LIMITS_SET[name] = true end
-
 return C

 end
--- a/manager/display.lua
+++ b/manager/display.lua
@@ -26,8 +26,6 @@ D.mon = nil
 D.monName = nil
 D.smelterMon = nil
 D.smelterMonName = nil
-D.billboardMon = nil
-D.billboardMonName = nil

 -- Opus UI devices and pages
 local mainDevice = nil
@@ -80,9 +78,7 @@ local function getActivityString()
    if activity.smelting   then table.insert(parts, "SMELTING")   end
    if activity.scanning   then table.insert(parts, "SCANNING")   end
    if activity.defragging then table.insert(parts, "DEFRAG")     end
-    if activity.composting  then table.insert(parts, "COMPOST")    end
-    if activity.discarding then table.insert(parts, "DISCARD")    end
-    if activity.autocrafting then table.insert(parts, "AUTOCRAFT") end
+    if activity.composting then table.insert(parts, "COMPOST")    end
    if #parts > 0 then
        return table.concat(parts, " | ")
    end
@@ -95,8 +91,6 @@ local function getBottomMessage()
    elseif activity.sorting then return "SORTING BARREL..."
    elseif activity.defragging then return "DEFRAGMENTING..."
    elseif activity.composting then return "COMPOSTING..."
-    elseif activity.discarding then return "DISCARDING EXCESS..."
-    elseif activity.autocrafting then return "AUTO-CRAFTING..."
    end
    return "Tap item to order"
 end
@@ -120,142 +114,48 @@ end
 -- Monitor setup
 -------------------------------------------------

--- Track peripheral names already assigned to a role.
-- A single physical monitor can appear under multiple names (e.g. "left"
-- AND "monitor_0") when it is both side-attached and on a wired modem.
-- We detect aliases by mutating text scale on one name and checking
-- whether a known monitor's getSize() changes.
-D._usedMonitorNames = {}   -- set of names known to be taken
-
--- Detect whether 'candidateName' is the same physical block as 'knownMon'
-- (a wrapped peripheral table).  We temporarily set the candidate's text
-- scale to an extreme value and check whether the known monitor reports a
-- size change.  If it does, they share the same hardware.
-local function isMonitorAlias(candidateName, knownMon)
-    if not candidateName or not knownMon then return false end
-    local refW, refH = knownMon.getSize()
-    -- Save candidate's current scale (getTextScale available CC:T 1.94+)
-    local ok, origScale = pcall(peripheral.call, candidateName, "getTextScale")
-    if not ok then origScale = 1 end
-    -- Pick a test scale far from the current one
-    local testScale = (origScale >= 3) and 0.5 or 5
-    pcall(peripheral.call, candidateName, "setTextScale", testScale)
-    local newW, newH = knownMon.getSize()
-    -- Restore
-    pcall(peripheral.call, candidateName, "setTextScale", origScale)
-    return newW ~= refW or newH ~= refH
-end
-
--- Register all peripheral names that refer to the same physical block as
-- 'knownName' / 'knownMon'.  This populates D._usedMonitorNames so that
-- later auto-detection can skip aliases by simple table lookup.
-local function registerMonitorAliases(knownName, knownMon)
-    D._usedMonitorNames[knownName] = true
-    for _, name in ipairs(peripheral.getNames()) do
-        if name ~= knownName and peripheral.getType(name) == "monitor" then
-            if isMonitorAlias(name, knownMon) then
-                D._usedMonitorNames[name] = true
-                log.debug("DISPLAY", "Monitor alias: %s => %s", name, knownName)
+local function findMonitor(side, excludeSide)
+    local mon = peripheral.wrap(side)
+    local monName
+    if mon and mon.setTextScale then
+        monName = side
+    else
+        mon = nil
+    end
+    if not mon then
+        for _, name in ipairs(peripheral.getNames()) do
+            if peripheral.getType(name) == "monitor" and name ~= excludeSide then
+                mon = peripheral.wrap(name)
+                monName = name
+                break
            end
        end
    end
+    return mon, monName
 end

 function D.setupMonitor()
-    local mon = peripheral.wrap(cfg.MONITOR_SIDE)
-    if not mon or not mon.setTextScale then
-        -- Fallback: find any monitor
-        for _, name in ipairs(peripheral.getNames()) do
-            if peripheral.getType(name) == "monitor" then
-                mon = peripheral.wrap(name)
-                if mon and mon.setTextScale then
-                    D.mon = mon
-                    D.monName = name
-                    break
-                end
-                mon = nil
-            end
-        end
-    else
-        D.mon = mon
-        D.monName = cfg.MONITOR_SIDE
-    end
+    D.mon, D.monName = findMonitor(cfg.MONITOR_SIDE, cfg.SMELTER_MONITOR_SIDE)
    if not D.mon then return false end

    mainDevice = UI.Device({
        device = D.mon,
        textScale = 0.5,
    })
-
-    -- Register this monitor and all its aliases as taken
-    registerMonitorAliases(D.monName, D.mon)
    return true
 end

 function D.setupSmelterMonitor()
-    -- Try configured side first
-    local mon = peripheral.wrap(cfg.SMELTER_MONITOR_SIDE)
-    local monName = cfg.SMELTER_MONITOR_SIDE
-    if not mon or not mon.setTextScale or D._usedMonitorNames[monName] then
-        mon = nil
-        monName = nil
-        -- Fallback: find any unused monitor
-        for _, name in ipairs(peripheral.getNames()) do
-            if peripheral.getType(name) == "monitor" and not D._usedMonitorNames[name] then
-                mon = peripheral.wrap(name)
-                if mon and mon.setTextScale then
-                    monName = name
-                    break
-                end
-                mon = nil
-            end
-        end
-    end
-    if not mon then return false end
-
-    D.smelterMon = mon
-    D.smelterMonName = monName
+    D.smelterMon, D.smelterMonName = findMonitor(cfg.SMELTER_MONITOR_SIDE, D.monName)
+    if not D.smelterMon then return false end

    smelterDevice = UI.Device({
        device = D.smelterMon,
        textScale = 0.5,
    })
-
-    -- Register this monitor and all its aliases as taken
-    registerMonitorAliases(D.smelterMonName, D.smelterMon)
    return true
 end

-function D.setupBillboardMonitor()
-    local scale = cfg.BILLBOARD_TEXT_SCALE or 1
-    -- If explicitly configured, use that name
-    if cfg.BILLBOARD_MONITOR and cfg.BILLBOARD_MONITOR ~= "" then
-        local mon = peripheral.wrap(cfg.BILLBOARD_MONITOR)
-        if mon and mon.setTextScale then
-            D.billboardMon = mon
-            D.billboardMonName = cfg.BILLBOARD_MONITOR
-            D.billboardMon.setTextScale(scale)
-            registerMonitorAliases(D.billboardMonName, D.billboardMon)
-            return true
-        end
-        return false
-    end
-    -- Auto-detect: find any monitor not already used by main/smelter
-    for _, name in ipairs(peripheral.getNames()) do
-        if peripheral.getType(name) == "monitor" and not D._usedMonitorNames[name] then
-            local mon = peripheral.wrap(name)
-            if mon and mon.setTextScale then
-                D.billboardMon = mon
-                D.billboardMonName = name
-                D.billboardMon.setTextScale(scale)
-                registerMonitorAliases(D.billboardMonName, D.billboardMon)
-                return true
-            end
-        end
-    end
-    return false
-end
-
 -------------------------------------------------
 -- Build main dashboard page
 -------------------------------------------------
@@ -1512,500 +1412,6 @@ function D.handleSmelterTouch(x, y)
    end
 end

-------------------------------------------------
-- Billboard rendering (raw monitor API, no Opus UI)
-- Visual goals display with pie chart, storage
-- gauge, stock alerts, and activity indicators.
-------------------------------------------------
-
-local BB = {}     -- billboard color theme
-BB.bg          = colors.black
-BB.headerBg    = colors.blue
-BB.headerFg    = colors.white
-BB.border      = colors.gray
-BB.label       = colors.lightGray
-BB.value       = colors.white
-BB.barFull     = colors.lime
-BB.barEmpty    = colors.gray
-BB.barWarn     = colors.yellow
-BB.barCrit     = colors.red
-BB.alertOk     = colors.lime
-BB.alertLow    = colors.red
-BB.alertWarn   = colors.orange
-BB.activityOn  = colors.lime
-BB.activityOff = colors.gray
-BB.sectionHead = colors.yellow
-
-- Pie chart slice colors (12 distinct CC colors)
-local PIE_COLORS = {
-    colors.red,
-    colors.orange,
-    colors.yellow,
-    colors.lime,
-    colors.green,
-    colors.cyan,
-    colors.lightBlue,
-    colors.blue,
-    colors.purple,
-    colors.magenta,
-    colors.pink,
-    colors.brown,
-}
-
-local function bbFormatNumber(n)
-    if n >= 1000000 then
-        return string.format("%.1fM", n / 1000000)
-    elseif n >= 10000 then
-        return string.format("%.1fK", n / 1000)
-    elseif n >= 1000 then
-        return string.format("%d,%03d", math.floor(n / 1000), n % 1000)
-    end
-    return tostring(n)
-end
-
-local function bbPadRight(s, w)
-    if #s >= w then return s:sub(1, w) end
-    return s .. string.rep(" ", w - #s)
-end
-
-local function bbPadLeft(s, w)
-    if #s >= w then return s:sub(1, w) end
-    return string.rep(" ", w - #s) .. s
-end
-
-- Billboard drawing primitives (operate on D.billboardMon)
-local bbW, bbH = 0, 0
-
-local function bbSetColors(fg, bg)
-    D.billboardMon.setTextColor(fg)
-    D.billboardMon.setBackgroundColor(bg)
-end
-
-local function bbClearLine(y, bg)
-    D.billboardMon.setCursorPos(1, y)
-    D.billboardMon.setBackgroundColor(bg or BB.bg)
-    D.billboardMon.write(string.rep(" ", bbW))
-end
-
-local function bbWriteAt(x, y, text, fg, bg)
-    bbSetColors(fg or BB.value, bg or BB.bg)
-    D.billboardMon.setCursorPos(x, y)
-    D.billboardMon.write(text)
-end
-
-local function bbHLine(y, fg)
-    bbClearLine(y)
-    bbSetColors(fg or BB.border, BB.bg)
-    D.billboardMon.setCursorPos(1, y)
-    D.billboardMon.write(string.rep("\x8c", bbW))
-end
-
-local function bbDrawBar(x, y, width, filled, fgColor, bgColor)
-    local fillW = math.floor(filled * width + 0.5)
-    if fillW > width then fillW = width end
-    if fillW < 0 then fillW = 0 end
-    D.billboardMon.setCursorPos(x, y)
-    D.billboardMon.setBackgroundColor(fgColor or BB.barFull)
-    D.billboardMon.write(string.rep(" ", fillW))
-    D.billboardMon.setBackgroundColor(bgColor or BB.barEmpty)
-    D.billboardMon.write(string.rep(" ", width - fillW))
-    D.billboardMon.setBackgroundColor(BB.bg)
-end
-
--- Draw a pie chart using colored character cells.
--- slices = { { fraction=0.0-1.0, color=colors.X }, ... }
--- Draws into the rectangle (x1,y1) to (x1+size-1, y1+rows-1)
---   size = width in chars, rows = height in chars
-local function bbDrawPie(x1, y1, size, rows, slices)
-    local cx = size / 2          -- center in char coords
-    local cy = rows / 2
-    local radius = math.min(cx, cy) - 0.5
-    -- Character cells are ~1.5x taller than wide; squish Y
-    local aspect = 1.5
-
-    -- Build cumulative angle boundaries
-    local angles = {}
-    local cumulative = 0
-    for i, slice in ipairs(slices) do
-        angles[i] = { start = cumulative, stop = cumulative + slice.fraction, color = slice.color }
-        cumulative = cumulative + slice.fraction
-    end
-
-    for row = 0, rows - 1 do
-        D.billboardMon.setCursorPos(x1, y1 + row)
-        for col = 0, size - 1 do
-            local dx = (col + 0.5 - cx)
-            local dy = (row + 0.5 - cy) * aspect
-            local dist = math.sqrt(dx * dx + dy * dy)
-
-            if dist <= radius then
-                -- Compute angle 0-1 (0 = top, clockwise)
-                local angle = math.atan2(dx, -dy)   -- top = 0, clockwise
-                if angle < 0 then angle = angle + 2 * math.pi end
-                local frac = angle / (2 * math.pi)
-
-                -- Find which slice
-                local cellColor = BB.bg
-                for _, s in ipairs(angles) do
-                    if frac >= s.start and frac < s.stop then
-                        cellColor = s.color
-                        break
-                    end
-                end
-                -- Catch rounding at the very end
-                if cellColor == BB.bg and #angles > 0 then
-                    cellColor = angles[#angles].color
-                end
-
-                D.billboardMon.setBackgroundColor(cellColor)
-                D.billboardMon.write(" ")
-            else
-                D.billboardMon.setBackgroundColor(BB.bg)
-                D.billboardMon.write(" ")
-            end
-        end
-    end
-    D.billboardMon.setBackgroundColor(BB.bg)
-end
-
--- Draw a storage ring/donut gauge.
--- Draws a ring showing used vs free with percentage in center.
-local function bbDrawStorageRing(x1, y1, size, rows)
-    local cx = size / 2
-    local cy = rows / 2
-    local outerR = math.min(cx, cy) - 0.5
-    local innerR = outerR * 0.55
-    local aspect = 1.5
-    local ratio = cache.usedRatio or 0
-
-    local usedColor = BB.barFull
-    if ratio > 0.9 then usedColor = BB.barCrit
-    elseif ratio > 0.75 then usedColor = BB.barWarn end
-
-    for row = 0, rows - 1 do
-        D.billboardMon.setCursorPos(x1, y1 + row)
-        for col = 0, size - 1 do
-            local dx = (col + 0.5 - cx)
-            local dy = (row + 0.5 - cy) * aspect
-            local dist = math.sqrt(dx * dx + dy * dy)
-
-            if dist <= outerR and dist >= innerR then
-                -- In the ring — determine angle (top = 0, clockwise)
-                local angle = math.atan2(dx, -dy)
-                if angle < 0 then angle = angle + 2 * math.pi end
-                local frac = angle / (2 * math.pi)
-
-                if frac < ratio then
-                    D.billboardMon.setBackgroundColor(usedColor)
-                else
-                    D.billboardMon.setBackgroundColor(BB.barEmpty)
-                end
-                D.billboardMon.write(" ")
-            else
-                D.billboardMon.setBackgroundColor(BB.bg)
-                D.billboardMon.write(" ")
-            end
-        end
-    end
-
-    -- Write percentage in center of ring
-    local pct = tostring(math.floor(ratio * 100 + 0.5)) .. "%"
-    local textY = y1 + math.floor(cy)
-    local textX = x1 + math.floor(cx - #pct / 2)
-    bbWriteAt(textX, textY, pct, usedColor)
-end
-
-- Billboard section: header
-local function bbDrawHeader(y)
-    bbClearLine(y, BB.headerBg)
-    bbSetColors(BB.headerFg, BB.headerBg)
-    local title = " INVENTORY BILLBOARD "
-    D.billboardMon.setCursorPos(math.floor((bbW - #title) / 2) + 1, y)
-    D.billboardMon.write(title)
-    return y + 1
-end
-
-- Billboard section: storage ring + stats (side by side)
-local function bbDrawStorageSection(y)
-    bbHLine(y)
-    y = y + 1
-
-    -- Ring takes up a square area
-    local ringSize = math.min(math.floor(bbW * 0.35), bbH - y - 6)
-    if ringSize < 5 then ringSize = 5 end
-    local ringRows = math.floor(ringSize / 1.5)  -- aspect correction
-    if ringRows < 3 then ringRows = 3 end
-
-    -- Draw ring on the left
-    bbDrawStorageRing(2, y, ringSize, ringRows)
-
-    -- Stats text to the right of the ring
-    local statsX = ringSize + 4
-    local statsY = y + 1
-
-    bbWriteAt(statsX, statsY, "STORAGE", BB.sectionHead)
-    statsY = statsY + 1
-
-    local ratio = cache.usedRatio or 0
-    local usedColor = BB.barFull
-    if ratio > 0.9 then usedColor = BB.barCrit
-    elseif ratio > 0.75 then usedColor = BB.barWarn end
-
-    bbWriteAt(statsX, statsY, string.format("%s / %s slots",
-        bbFormatNumber(cache.usedSlots), bbFormatNumber(cache.totalSlots)), BB.value)
-    statsY = statsY + 1
-
-    bbWriteAt(statsX, statsY, string.format("%s total items",
-        bbFormatNumber(cache.grandTotal)), BB.label)
-    statsY = statsY + 1
-
-    bbWriteAt(statsX, statsY, string.format("%d chests", cache.chestCount), BB.label)
-    statsY = statsY + 1
-
-    -- Mini capacity bar
-    local barW = bbW - statsX - 1
-    if barW > 3 then
-        bbWriteAt(statsX, statsY, "", BB.label)
-        bbDrawBar(statsX, statsY, barW, ratio, usedColor, BB.barEmpty)
-    end
-
-    return y + ringRows + 1
-end
-
-- Billboard section: pie chart + legend
-local function bbDrawPieSection(y, maxH)
-    bbHLine(y)
-    y = y + 1
-    bbWriteAt(2, y, "ITEM DISTRIBUTION", BB.sectionHead)
-    y = y + 1
-
-    state.ensureItemList()
-    local items = cache.itemList
-    if not items or #items == 0 then
-        bbWriteAt(2, y, "No items in storage", BB.label)
-        return y + 1
-    end
-
-    -- Sort and pick top N for pie slices
-    local sorted = {}
-    for i, item in ipairs(items) do sorted[i] = item end
-    table.sort(sorted, function(a, b) return a.total > b.total end)
-
-    local maxSlices = math.min(#PIE_COLORS, cfg.BILLBOARD_TOP_ITEMS or 12, #sorted)
-    local topTotal = 0
-    for i = 1, maxSlices do
-        topTotal = topTotal + sorted[i].total
-    end
-    -- "Other" bucket for remaining items
-    local otherTotal = (cache.grandTotal or 0) - topTotal
-    local total = cache.grandTotal or 1
-    if total < 1 then total = 1 end
-
-    -- Build slices
-    local slices = {}
-    local legendItems = {}
-    for i = 1, maxSlices do
-        local frac = sorted[i].total / total
-        if frac < 0.005 then break end  -- skip tiny slices
-        table.insert(slices, { fraction = frac, color = PIE_COLORS[i] })
-        table.insert(legendItems, {
-            name  = shortName(sorted[i].name),
-            count = sorted[i].total,
-            pct   = math.floor(frac * 100 + 0.5),
-            color = PIE_COLORS[i],
-        })
-    end
-    if otherTotal > 0 then
-        table.insert(slices, { fraction = otherTotal / total, color = BB.border })
-        table.insert(legendItems, {
-            name  = "Other",
-            count = otherTotal,
-            pct   = math.floor(otherTotal / total * 100 + 0.5),
-            color = BB.border,
-        })
-    end
-
-    -- Layout: pie on left, legend on right
-    local pieSize = math.min(math.floor(bbW * 0.4), maxH - 1)
-    if pieSize < 5 then pieSize = 5 end
-    local pieRows = math.floor(pieSize / 1.5)
-    if pieRows < 3 then pieRows = 3 end
-    if pieRows > maxH - 1 then pieRows = maxH - 1 end
-
-    -- Draw pie
-    if #slices > 0 then
-        bbDrawPie(2, y, pieSize, pieRows, slices)
-    end
-
-    -- Draw legend to the right
-    local legX = pieSize + 4
-    local legY = y
-    local legW = bbW - legX - 1
-
-    for i, item in ipairs(legendItems) do
-        if legY >= y + pieRows then break end
-        if legW < 10 then break end
-
-        -- Color swatch
-        D.billboardMon.setCursorPos(legX, legY)
-        D.billboardMon.setBackgroundColor(item.color)
-        D.billboardMon.write("  ")
-        D.billboardMon.setBackgroundColor(BB.bg)
-        D.billboardMon.write(" ")
-
-        -- Name + count
-        local label = item.name
-        local countStr = bbFormatNumber(item.count)
-        local pctStr = item.pct .. "%"
-        local infoW = legW - 4  -- 2 swatch + 1 space + padding
-        local detail = string.format("%s %s", pctStr, countStr)
-        local nameW = infoW - #detail - 1
-        if nameW < 4 then nameW = 4 end
-        if #label > nameW then label = label:sub(1, nameW - 1) .. "." end
-
-        bbWriteAt(legX + 3, legY, bbPadRight(label, nameW), BB.value)
-        bbWriteAt(legX + 3 + nameW + 1, legY, detail, BB.label)
-
-        legY = legY + 1
-    end
-
-    return y + pieRows
-end
-
-- Billboard section: stock alerts (compact)
-local function bbDrawAlerts(y, maxRows)
-    bbHLine(y)
-    y = y + 1
-
-    local alerts = state.activeAlerts
-    if not alerts or #alerts == 0 then
-        bbWriteAt(2, y, "* All stocks OK", BB.alertOk)
-        return y + 1
-    end
-
-    bbWriteAt(2, y, "ALERTS", BB.sectionHead)
-    local countStr = string.format("(%d)", #alerts)
-    bbWriteAt(9, y, countStr, BB.alertWarn)
-    y = y + 1
-
-    local colW = math.floor(bbW / 2)
-    local twoCol = (bbW >= 30)
-    local row = 0
-
-    for i, alert in ipairs(alerts) do
-        if row >= maxRows then
-            bbWriteAt(2, y, string.format("  +%d more", #alerts - i + 1), BB.alertWarn)
-            y = y + 1
-            break
-        end
-
-        local label = alert.label or shortName(alert.name or "?")
-        local current = alert.current or 0
-        local minVal = alert.min or 0
-        local ratio = minVal > 0 and (current / minVal) or 1
-
-        local color = ratio < 0.5 and BB.alertLow or BB.alertWarn
-        local text = string.format("! %s %s/%s", label, bbFormatNumber(current), bbFormatNumber(minVal))
-
-        if twoCol then
-            local col = ((i - 1) % 2 == 0) and 2 or (colW + 1)
-            if col == 2 then bbClearLine(y) end
-            bbWriteAt(col, y, bbPadRight(text, colW - 1), color)
-            if (i - 1) % 2 == 1 or i == #alerts then
-                y = y + 1
-                row = row + 1
-            end
-        else
-            bbClearLine(y)
-            bbWriteAt(2, y, text, color)
-            y = y + 1
-            row = row + 1
-        end
-    end
-    return y
-end
-
-- Billboard section: activity bar (single line)
-local function bbDrawActivityBar(y)
-    bbClearLine(y, BB.headerBg)
-    bbSetColors(BB.headerFg, BB.headerBg)
-
-    local labels = {
-        { key = "sorting",      label = "SORT" },
-        { key = "scanning",     label = "SCAN" },
-        { key = "smelting",     label = "SMLT" },
-        { key = "dispensing",   label = "DISP" },
-        { key = "defragging",   label = "DEFR" },
-        { key = "composting",   label = "COMP" },
-        { key = "crafting",     label = "CRFT" },
-        { key = "autocrafting", label = "AUTO" },
-        { key = "discarding",   label = "DISC" },
-    }
-
-    local parts = {}
-    for _, entry in ipairs(labels) do
-        if activity[entry.key] then
-            table.insert(parts, entry.label)
-        end
-    end
-
-    local text
-    if #parts > 0 then
-        text = " " .. table.concat(parts, " | ") .. " "
-    else
-        text = " IDLE "
-    end
-
-    D.billboardMon.setCursorPos(math.floor((bbW - #text) / 2) + 1, y)
-    if #parts > 0 then
-        bbSetColors(colors.white, colors.green)
-    else
-        bbSetColors(BB.label, BB.headerBg)
-    end
-    D.billboardMon.write(text)
-
-    return y + 1
-end
-
-- Main billboard draw entry point
-function D.drawBillboard()
-    if not D.billboardMon then return end
-    bbW, bbH = D.billboardMon.getSize()
-
-    D.billboardMon.setBackgroundColor(BB.bg)
-    D.billboardMon.clear()
-
-    local y = 1
-
-    -- Header bar
-    y = bbDrawHeader(y)
-
-    -- Storage ring + stats
-    y = bbDrawStorageSection(y)
-
-    -- Pie chart + legend (gets remaining space minus alerts + footer)
-    local alertCount = state.activeAlerts and #state.activeAlerts or 0
-    local alertH = math.max(2, math.min(5, math.ceil(alertCount / 2) + 2))
-    local footerH = 1  -- activity bar
-    local pieH = bbH - y - alertH - footerH
-    if pieH < 5 then pieH = 5 end
-    y = bbDrawPieSection(y, pieH)
-
-    -- Alerts
-    local alertMaxRows = bbH - y - footerH - 1
-    if alertMaxRows < 1 then alertMaxRows = 1 end
-    y = bbDrawAlerts(y, alertMaxRows)
-
-    -- Fill gap before footer
-    while y < bbH do
-        bbClearLine(y)
-        y = y + 1
-    end
-
-    -- Activity bar at very bottom
-    bbDrawActivityBar(bbH)
-end
-
 return D

 end
--- a/manager/operations.lua
+++ b/manager/operations.lua
@@ -765,279 +765,6 @@ function O.autoCompost()
    return didWork
 end

-------------------------------------------------
-- Collection hopper emptying (egg spawner, mob farm, etc.)
-------------------------------------------------
-
-function O.collectHoppers()
-    if #cfg.COLLECTION_HOPPERS == 0 then return false end
-
-    local didWork = false
-    local chests = O.getChestsByPriority()
-    local catalogue = cache.catalogue
-
-    for _, hopperName in ipairs(cfg.COLLECTION_HOPPERS) do
-        local hopper = O.wrapCached(hopperName)
-        if hopper then
-            local contents = hopper.list()
-            if contents and next(contents) then
-                for slot, item in pairs(contents) do
-                    local moved = 0
-                    local triedChests = {}
-
-                    -- Prefer chests where item already exists
-                    if catalogue[item.name] then
-                        for _, entry in ipairs(catalogue[item.name]) do
-                            triedChests[entry.chest] = true
-                            local n = hopper.pushItems(entry.chest, slot)
-                            if n and n > 0 then
-                                moved = moved + n
-                                state.adjustCache(item.name, entry.chest, n)
-                                didWork = true
-                                log.info("COLLECT", "%s x%d -> %s (from %s)", item.name, n, entry.chest, hopperName)
-                            end
-                            if moved >= item.count then break end
-                        end
-                    end
-
-                    -- Overflow to any chest with space
-                    if moved < item.count then
-                        for _, chest in ipairs(chests) do
-                            if not triedChests[chest] then
-                                local n = hopper.pushItems(chest, slot)
-                                if n and n > 0 then
-                                    moved = moved + n
-                                    state.adjustCache(item.name, chest, n)
-                                    didWork = true
-                                    log.info("COLLECT", "%s x%d -> %s (from %s)", item.name, n, chest, hopperName)
-                                end
-                                if moved >= item.count then break end
-                            end
-                        end
-                    end
-                end
-            end
-        end
-    end
-
-    return didWork
-end
-
-------------------------------------------------
-- Auto-discard excess stock
-------------------------------------------------
-
-function O.discardExcess()
-    if #cfg.TRASH_DROPPERS == 0 then return false end
-
-    local catalogue = cache.catalogue
-    local didWork = false
-
-    -- Build a flat list of dropper handles + free capacity
-    local droppers = {}
-    for _, dName in ipairs(cfg.TRASH_DROPPERS) do
-        local d = O.wrapCached(dName)
-        if d then
-            local used = 0
-            local contents = d.list()
-            if contents then
-                for _, item in pairs(contents) do used = used + item.count end
-            end
-            local free = (d.size() * 64) - used
-            if free > 0 then
-                table.insert(droppers, { name = dName, handle = d, free = free })
-            else
-                log.debug("DISCARD", "Dropper %s is full, skipping", dName)
-            end
-        end
-    end
-    if #droppers == 0 then
-        log.debug("DISCARD", "All trash droppers full or offline, cannot discard")
-        return false
-    end
-
-    -- Round-robin index across droppers
-    local dIdx = 1
-
-    for itemName, maxCount in pairs(cfg.STOCK_LIMITS) do
-        if catalogue[itemName] then
-            local totalInStorage = 0
-            for _, src in ipairs(catalogue[itemName]) do
-                totalInStorage = totalInStorage + src.total
-            end
-
-            local excess = totalInStorage - maxCount
-            if excess > 0 then
-                log.info("DISCARD", "%s: %d in stock, limit %d, discarding %d",
-                    itemName, totalInStorage, maxCount, excess)
-                local discarded = 0
-                local srcSnapshot = { table.unpack(catalogue[itemName]) }
-                for _, source in ipairs(srcSnapshot) do
-                    if discarded >= excess then break end
-                    if source.total > 0 then
-                        local chest = O.wrapCached(source.chest)
-                        if chest then
-                            for slot, slotItem in pairs(chest.list()) do
-                                if slotItem.name == itemName then
-                                    -- Find a dropper with free space (round-robin)
-                                    local startIdx = dIdx
-                                    local dropper = nil
-                                    repeat
-                                        if droppers[dIdx].free > 0 then
-                                            dropper = droppers[dIdx]
-                                        end
-                                        dIdx = (dIdx % #droppers) + 1
-                                    until dropper or dIdx == startIdx
-                                    if not dropper then break end  -- all droppers full
-
-                                    local batch = math.min(slotItem.count, excess - discarded, dropper.free)
-                                    local n = chest.pushItems(dropper.name, slot, batch)
-                                    if n and n > 0 then
-                                        state.adjustCache(itemName, source.chest, -n)
-                                        dropper.free = dropper.free - n
-                                        discarded = discarded + n
-                                        didWork = true
-                                    end
-                                    if discarded >= excess then break end
-                                end
-                            end
-                        end
-                    end
-                end
-                if discarded > 0 then
-                    log.info("DISCARD", "Discarded %s x%d", itemName, discarded)
-                end
-            end
-        end
-    end
-
-    return didWork
-end
-
-------------------------------------------------
-- Auto-craft excess stock into target items
-------------------------------------------------
-
-function O.autoCraft()
-    if not ctx.craftEngine then return false end
-    if not ctx.craftTurtleName then return false end
-
-    local catalogue = cache.catalogue
-    local didWork = false
-
-    -- Phase 1: Explicit rules from auto_craft.lua
-    for _, rule in ipairs(cfg.AUTO_CRAFT_RULES) do
-        local inputName = rule.input
-        local reserve   = rule.reserve or 0
-        local outputName = rule.output
-
-        if catalogue[inputName] then
-            local totalInStorage = 0
-            for _, src in ipairs(catalogue[inputName]) do
-                totalInStorage = totalInStorage + src.total
-            end
-
-            local excess = totalInStorage - reserve
-            if excess > 0 then
-                local recipe = cfg.recipeBook.getCraftingRecipe(outputName)
-                if recipe then
-                    local ingredients = cfg.recipeBook.getIngredients(recipe)
-                    local inputPerCraft = ingredients[inputName] or 0
-                    if inputPerCraft > 0 then
-                        local batches = math.floor(excess / inputPerCraft)
-                        batches = math.min(batches, 64)
-                        if batches > 0 then
-                            local craftCount = batches * recipe.count
-                            log.info("AUTOCRAFT", "%s: %d excess (reserve %d), crafting %d x %s",
-                                inputName, excess, reserve, craftCount, outputName)
-                            local ok, err = O.recursiveCraft(outputName, craftCount)
-                            if ok then
-                                didWork = true
-                                log.info("AUTOCRAFT", "Crafted %s x%d", outputName, craftCount)
-                            else
-                                log.warn("AUTOCRAFT", "Failed to craft %s: %s", outputName, tostring(err))
-                            end
-                        end
-                    end
-                else
-                    log.warn("AUTOCRAFT", "No recipe found for output: %s", outputName)
-                end
-            end
-        end
-    end
-
-    -- Phase 2: Smart excess-to-craft — auto-discover recipes for over-stocked items
-    if cfg.AUTO_CRAFT_FROM_EXCESS then
-        -- Track outputs we've already handled via explicit rules to avoid duplicates
-        local handledOutputs = {}
-        for _, rule in ipairs(cfg.AUTO_CRAFT_RULES) do
-            handledOutputs[rule.output] = true
-        end
-
-        for itemName, maxCount in pairs(cfg.STOCK_LIMITS) do
-            if catalogue[itemName] then
-                local totalInStorage = 0
-                for _, src in ipairs(catalogue[itemName]) do
-                    totalInStorage = totalInStorage + src.total
-                end
-
-                local excess = totalInStorage - maxCount
-                if excess > 0 then
-                    -- Find all crafting recipes that use this item
-                    local usingRecipes = cfg.recipeBook.findRecipesUsing(itemName)
-                    for _, recipe in ipairs(usingRecipes) do
-                        if not handledOutputs[recipe.output] then
-                            -- Check how much of the output we already have
-                            local outputTotal = O.getItemTotal(recipe.output)
-                            if outputTotal < cfg.AUTO_CRAFT_OUTPUT_CAP then
-                                local ingredients = cfg.recipeBook.getIngredients(recipe)
-                                local inputPerCraft = ingredients[itemName] or 0
-                                if inputPerCraft > 0 then
-                                    -- Only craft up to the output cap
-                                    local outputRoom = cfg.AUTO_CRAFT_OUTPUT_CAP - outputTotal
-                                    local maxBatches = math.floor(excess / inputPerCraft)
-                                    local batchesByRoom = math.ceil(outputRoom / recipe.count)
-                                    local batches = math.min(maxBatches, batchesByRoom, 64)
-                                    if batches > 0 then
-                                        -- Check all other ingredients are available
-                                        local canCraft = true
-                                        for ingr, needed in pairs(ingredients) do
-                                            if ingr ~= itemName then
-                                                local have = O.getItemTotal(ingr)
-                                                if have < needed * batches then
-                                                    canCraft = false
-                                                    break
-                                                end
-                                            end
-                                        end
-                                        if canCraft then
-                                            local craftCount = batches * recipe.count
-                                            log.info("AUTOCRAFT", "Smart: %s over limit, crafting %d x %s",
-                                                itemName, craftCount, recipe.output)
-                                            local ok, err = O.recursiveCraft(recipe.output, craftCount)
-                                            if ok then
-                                                didWork = true
-                                                handledOutputs[recipe.output] = true
-                                                log.info("AUTOCRAFT", "Smart-crafted %s x%d", recipe.output, craftCount)
-                                                -- Recalculate excess after crafting
-                                                break
-                                            else
-                                                log.warn("AUTOCRAFT", "Smart craft failed %s: %s", recipe.output, tostring(err))
-                                            end
-                                        end
-                                    end
-                                end
-                            end
-                        end
-                    end
-                end
-            end
-        end
-    end
-
-    return didWork
-end
-
 -------------------------------------------------
 -- Low-stock alert checker
 -------------------------------------------------
@@ -1225,8 +952,7 @@ function O.getMissingIngredients(recipe)
    return ui.getMissingIngredients(recipe, O.getItemTotal)
 end

-function O.craftItem(recipeIdx, batches)
-    batches = batches or 1
+function O.craftItem(recipeIdx)
    local recipe = cfg.CRAFTABLE[recipeIdx]
    if not recipe then
        log.error("CRAFT", "Invalid recipe index: %s", tostring(recipeIdx))
@@ -1245,11 +971,7 @@ function O.craftItem(recipeIdx, batches)
        return false, "Turtle offline"
    end

-    -- Clamp batches to 64 (max stack size per slot)
-    batches = math.min(batches, 64)
-
-    log.info("CRAFT", "Starting craft: %s x%d (%d batches, turtle: %s)",
-        recipe.output, batches * recipe.count, batches, ctx.craftTurtleName)
+    log.info("CRAFT", "Starting craft: %s (turtle: %s)", recipe.output, ctx.craftTurtleName)

    activity.crafting = true
    state.needsRedraw = true
@@ -1259,27 +981,6 @@ function O.craftItem(recipeIdx, batches)
    local slotMap = {}
    local reservedSlots = {}

-    -- Sum how many of each ingredient we need total
-    local ingredientTotals = {}
-    for gridPos = 1, 9 do
-        local itemName = recipe.grid[gridPos]
-        if itemName then
-            ingredientTotals[itemName] = (ingredientTotals[itemName] or 0) + batches
-        end
-    end
-
-    -- Check we have enough of each ingredient
-    for itemName, needed in pairs(ingredientTotals) do
-        local have = O.getItemTotal(itemName)
-        if have < needed then
-            log.error("CRAFT", "Not enough %s: have %d, need %d", itemName, have, needed)
-            activity.crafting = false
-            state.needsRedraw = true
-            state.smelterNeedsRedraw = true
-            return false, string.format("Need %d %s, have %d", needed, itemName, have)
-        end
-    end
-
    for gridPos = 1, 9 do
        local itemName = recipe.grid[gridPos]
        if itemName then
@@ -1293,12 +994,11 @@ function O.craftItem(recipeIdx, batches)
                        for slot, slotItem in pairs(chest.list()) do
                            local key = source.chest .. ":" .. slot
                            if slotItem.name == itemName and not reservedSlots[key] then
-                                local pullCount = math.min(batches, slotItem.count)
                                slotMap[tostring(turtleSlot)] = {
                                    chestName = source.chest,
                                    chestSlot = slot,
                                    itemName  = itemName,
-                                    count     = pullCount,
+                                    count     = 1,
                                }
                                reservedSlots[key] = true
                                found = true
@@ -1338,6 +1038,7 @@ function O.craftItem(recipeIdx, batches)
    log.info("CRAFT", "Waiting for turtle reply (timeout: %ds)...", cfg.CRAFT_TIMEOUT)
    local deadline = os.clock() + cfg.CRAFT_TIMEOUT
    local result = nil
+    local bufferedMessages = {}

    while os.clock() < deadline do
        local timerId = os.startTimer(math.max(0.1, deadline - os.clock()))
@@ -1349,13 +1050,18 @@ function O.craftItem(recipeIdx, batches)
            if channel == cfg.CRAFT_REPLY_CHANNEL and type(message) == "table" and message.type == "craft_result" then
                result = message
                break
+            elseif channel == cfg.ORDER_CHANNEL then
+                table.insert(bufferedMessages, {event, p1, p2, p3, p4, p5})
            end
-            -- ORDER_CHANNEL messages are captured by the Network-capture task
        elseif event == "timer" and p1 == timerId then
            -- Timeout tick
        end
    end

+    for _, msg in ipairs(bufferedMessages) do
+        os.queueEvent(table.unpack(msg))
+    end
+
    activity.crafting = false
    state.needsRedraw = true
    state.smelterNeedsRedraw = true
--- a/manager/state.lua
+++ b/manager/state.lua
@@ -41,8 +41,6 @@ S.activity = {
    defragging = false,
    composting = false,
    crafting   = false,
-    discarding = false,
-    autocrafting = false,
 }

 -------------------------------------------------
@@ -55,7 +53,6 @@ S.configDirty = true

 function S.bumpStateVersion()
    S.stateVersion = S.stateVersion + 1
-    S.billboardNeedsRedraw = true
 end

 -------------------------------------------------
@@ -64,7 +61,6 @@ end

 S.needsRedraw = true
 S.smelterNeedsRedraw = true
-S.billboardNeedsRedraw = true
 S.statusMessage = ""
 S.statusColor = colors.white
 S.statusTimer = 0
--- a/startup/manager.lua
+++ b/startup/manager.lua
@@ -12,16 +12,11 @@ local FILES = {
    ["manager/display.lua"]       = "manager/display.lua",
    ["lib/log.lua"]               = "lib/log.lua",
    ["lib/ui.lua"]                = "lib/ui.lua",
-    ["lib/itemDB.lua"]            = "lib/itemDB.lua",
-    ["lib/craft.lua"]             = "lib/craft.lua",
-    ["lib/recipeBook.lua"]        = "lib/recipeBook.lua",
    ["data/smeltable.lua"]        = "data/smeltable.lua",
    ["data/fuel.lua"]             = "data/fuel.lua",
    ["data/compostable.lua"]      = "data/compostable.lua",
    ["data/craftable.lua"]        = "data/craftable.lua",
    ["data/alerts.lua"]           = "data/alerts.lua",
-    ["data/stock_limits.lua"]     = "data/stock_limits.lua",
-    ["data/auto_craft.lua"]       = "data/auto_craft.lua",
 }

 -------------------------------------------------
--- a/startup/miner.lua
+++ b/startup/miner.lua
@@ -55,28 +55,4 @@ print("")
 print("Starting miningTurtle...")
 sleep(1)

-- Reboot listener: reboots this turtle on remote command
-local SYSTEM_CHANNEL = 4205
-local ROLE = "miner"
-
-local function rebootListener()
-    local m = peripheral.find("modem")
-    if not m then return end
-    m.open(SYSTEM_CHANNEL)
-    while true do
-        local _, _, channel, _, message = os.pullEvent("modem_message")
-        if channel == SYSTEM_CHANNEL and type(message) == "table" and message.type == "reboot" then
-            local target = message.target or "all"
-            if target == "all" or target == ROLE or target == tostring(os.getComputerID()) then
-                print("[SYSTEM] Reboot command received. Rebooting...")
-                sleep(0.5)
-                os.reboot()
-            end
-        end
-    end
-end
-
-parallel.waitForAny(
-    function() shell.run("miningTurtle.lua") end,
-    rebootListener
-)
+shell.run("miningTurtle.lua")
--- a/web/client/src/components/ItemIcon.jsx
+++ b/web/client/src/components/ItemIcon.jsx
@@ -2,47 +2,274 @@ import React, { useState } from 'react';
 import { getItemEmoji } from '../utils/itemUtils';
 import './ItemIcon.css';

-// Server-side smart resolution endpoint — handles aliases, animated frames,
-// carpet→wool, wood→log, derivatives, CC:Tweaked, Create, and prefix matching.
-const RESOLVE_BASE = '/api/texture/resolve';
+// All textures are proxied & cached through our server
+const TEXTURE_PROXY_BASE = '/api/texture';

-// Items rendered as 3D entities in-game — no flat texture exists.
-// Skip to emoji immediately to avoid a wasted network request.
-const ENTITY_ONLY = new Set([
-  'chest', 'ender_chest', 'trapped_chest', 'shield', 'conduit',
-  'bell', 'decorated_pot', 'trident',
+// Items whose texture file name differs from their registry name
+const TEXTURE_ALIASES = {
+  // Renamed items in 1.20+
+  grass: 'short_grass',
+  scute: 'turtle_scute',
+};
+
+// CC:Tweaked texture paths (registry name → actual file in the CC repo)
+const CC_TEXTURE_MAP = {
+  turtle_normal: 'block/turtle_normal_front',
+  turtle_advanced: 'block/turtle_advanced_front',
+  computer_normal: 'block/computer_normal_front',
+  computer_advanced: 'block/computer_advanced_front',
+  computer_command: 'block/computer_command_front',
+  monitor_normal: 'block/monitor_normal_0',
+  monitor_advanced: 'block/monitor_advanced_0',
+  wired_modem: 'block/wired_modem_face',
+  wired_modem_full: 'block/wired_modem_face',
+  wireless_modem_normal: 'block/wireless_modem_normal_face',
+  wireless_modem_advanced: 'block/wireless_modem_advanced_face',
+  speaker: 'block/speaker_front',
+  disk_drive: 'block/disk_drive_front',
+  printer: 'block/printer_front_empty',
+  cable: 'block/cable_core',
+  // CC item textures
+  pocket_computer_normal: 'item/pocket_computer_normal',
+  pocket_computer_advanced: 'item/pocket_computer_advanced',
+  disk: 'item/disk_frame',
+  printed_book: 'item/printed_book',
+  printed_page: 'item/printed_page',
+  printed_pages: 'item/printed_pages',
+};
+
+// Items whose texture lives in the block/ folder instead of item/
+const BLOCK_TEXTURES = new Set([
+  'stone', 'granite', 'polished_granite', 'diorite', 'polished_diorite', 'andesite',
+  'polished_andesite', 'cobblestone', 'oak_planks', 'spruce_planks', 'birch_planks',
+  'jungle_planks', 'acacia_planks', 'dark_oak_planks', 'mangrove_planks', 'cherry_planks',
+  'bamboo_planks', 'crimson_planks', 'warped_planks', 'oak_log', 'spruce_log', 'birch_log',
+  'jungle_log', 'acacia_log', 'dark_oak_log', 'mangrove_log', 'cherry_log', 'bamboo_block',
+  'stripped_oak_log', 'stripped_spruce_log', 'stripped_birch_log', 'stripped_jungle_log',
+  'stripped_acacia_log', 'stripped_dark_oak_log', 'stripped_mangrove_log', 'stripped_cherry_log',
+  'sand', 'red_sand', 'gravel', 'dirt', 'coarse_dirt', 'rooted_dirt', 'mud',
+  'cobblestone', 'mossy_cobblestone', 'obsidian', 'crying_obsidian',
+  'netherrack', 'soul_sand', 'soul_soil', 'basalt', 'polished_basalt', 'smooth_basalt',
+  'glowstone', 'glass', 'tinted_glass',
+
+  'bricks', 'stone_bricks', 'mossy_stone_bricks', 'cracked_stone_bricks',
+  'chiseled_stone_bricks', 'deepslate_bricks', 'nether_bricks', 'red_nether_bricks',
+  'bookshelf', 'clay', 'pumpkin', 'carved_pumpkin', 'jack_o_lantern', 'melon',
+  'sponge', 'wet_sponge', 'sandstone', 'red_sandstone', 'prismarine', 'dark_prismarine',
+  'sea_lantern', 'hay_block', 'terracotta', 'packed_ice', 'blue_ice',
+  'snow_block', 'ice', 'mycelium', 'podzol', 'grass_block', 'moss_block',
+  'deepslate', 'cobbled_deepslate', 'polished_deepslate', 'calcite', 'tuff', 'dripstone_block',
+  'coal_ore', 'iron_ore', 'gold_ore', 'diamond_ore', 'emerald_ore', 'lapis_ore', 'redstone_ore',
+  'copper_ore', 'nether_gold_ore', 'nether_quartz_ore', 'ancient_debris',
+  'deepslate_coal_ore', 'deepslate_iron_ore', 'deepslate_gold_ore', 'deepslate_diamond_ore',
+  'deepslate_emerald_ore', 'deepslate_lapis_ore', 'deepslate_redstone_ore', 'deepslate_copper_ore',
+  'coal_block', 'iron_block', 'gold_block', 'diamond_block', 'emerald_block',
+  'lapis_block', 'redstone_block', 'copper_block', 'raw_iron_block', 'raw_gold_block',
+  'raw_copper_block', 'netherite_block', 'amethyst_block', 'quartz_block',
+  'tnt', 'end_stone', 'end_stone_bricks', 'purpur_block', 'purpur_pillar',
+  'magma_block', 'bone_block', 'dried_kelp_block', 'honeycomb_block',
+  'slime_block', 'honey_block', 'note_block', 'jukebox',
+  'white_wool', 'orange_wool', 'magenta_wool', 'light_blue_wool', 'yellow_wool',
+  'lime_wool', 'pink_wool', 'gray_wool', 'light_gray_wool', 'cyan_wool',
+  'purple_wool', 'blue_wool', 'brown_wool', 'green_wool', 'red_wool', 'black_wool',
+  'white_concrete', 'orange_concrete', 'magenta_concrete', 'light_blue_concrete',
+  'yellow_concrete', 'lime_concrete', 'pink_concrete', 'gray_concrete',
+  'light_gray_concrete', 'cyan_concrete', 'purple_concrete', 'blue_concrete',
+  'brown_concrete', 'green_concrete', 'red_concrete', 'black_concrete',
+  'white_terracotta', 'orange_terracotta', 'magenta_terracotta', 'light_blue_terracotta',
+  'yellow_terracotta', 'lime_terracotta', 'pink_terracotta', 'gray_terracotta',
+  'light_gray_terracotta', 'cyan_terracotta', 'purple_terracotta', 'blue_terracotta',
+  'brown_terracotta', 'green_terracotta', 'red_terracotta', 'black_terracotta',
+  'white_glazed_terracotta', 'orange_glazed_terracotta', 'magenta_glazed_terracotta',
+  'light_blue_glazed_terracotta', 'yellow_glazed_terracotta', 'lime_glazed_terracotta',
+  'pink_glazed_terracotta', 'gray_glazed_terracotta', 'light_gray_glazed_terracotta',
+  'cyan_glazed_terracotta', 'purple_glazed_terracotta', 'blue_glazed_terracotta',
+  'brown_glazed_terracotta', 'green_glazed_terracotta', 'red_glazed_terracotta',
+  'black_glazed_terracotta',
+  'white_stained_glass', 'orange_stained_glass', 'magenta_stained_glass',
+  'light_blue_stained_glass', 'yellow_stained_glass', 'lime_stained_glass',
+  'pink_stained_glass', 'gray_stained_glass', 'light_gray_stained_glass',
+  'cyan_stained_glass', 'purple_stained_glass', 'blue_stained_glass',
+  'brown_stained_glass', 'green_stained_glass', 'red_stained_glass',
+  'black_stained_glass',
+  'crafting_table', 'furnace', 'blast_furnace', 'smoker', 'smithing_table',
+  'fletching_table', 'cartography_table', 'loom', 'stonecutter', 'grindstone',
+  'anvil', 'chipped_anvil', 'damaged_anvil', 'enchanting_table',
+  'brewing_stand', 'cauldron', 'composter', 'barrel',
+  'shulker_box', 'dispenser', 'dropper', 'hopper', 'observer',
+  'piston', 'sticky_piston', 'redstone_lamp', 'target', 'lever',
+  'beacon', 'conduit', 'lodestone', 'respawn_anchor',
+  'cactus', 'sugar_cane', 'bamboo',
+  'mushroom_stem', 'brown_mushroom_block', 'red_mushroom_block',
+  'oak_leaves', 'spruce_leaves', 'birch_leaves', 'jungle_leaves',
+  'acacia_leaves', 'dark_oak_leaves', 'mangrove_leaves', 'cherry_leaves', 'azalea_leaves',
+  // Additional blocks commonly seen as items
+  'smooth_stone', 'smooth_sandstone', 'smooth_red_sandstone', 'smooth_quartz',
+  'chiseled_sandstone', 'cut_sandstone', 'chiseled_red_sandstone', 'cut_red_sandstone',
+  'quartz_pillar', 'chiseled_quartz_block', 'quartz_bricks',
+  'ladder', 'cobweb', 'torch', 'soul_torch', 'lantern', 'soul_lantern',
+  'redstone_torch', 'chain',
+  'rail', 'powered_rail', 'detector_rail', 'activator_rail',
+  'brown_mushroom', 'red_mushroom',
+  'oak_sapling', 'spruce_sapling', 'birch_sapling', 'jungle_sapling',
+  'acacia_sapling', 'dark_oak_sapling', 'cherry_sapling',
+  'dandelion', 'poppy', 'blue_orchid', 'allium', 'azure_bluet',
+  'red_tulip', 'orange_tulip', 'white_tulip', 'pink_tulip',
+  'oxeye_daisy', 'cornflower', 'lily_of_the_valley', 'sunflower',
+  'lilac', 'rose_bush', 'peony', 'wither_rose', 'torchflower',
+  'dead_bush', 'fern', 'short_grass', 'tall_grass', 'large_fern',
+  'vine', 'lily_pad', 'seagrass', 'kelp', 'hanging_roots', 'spore_blossom',
+  'tube_coral', 'brain_coral', 'bubble_coral', 'fire_coral', 'horn_coral',
+  'tube_coral_block', 'brain_coral_block', 'bubble_coral_block', 'fire_coral_block', 'horn_coral_block',
+  'tube_coral_fan', 'brain_coral_fan', 'bubble_coral_fan', 'fire_coral_fan', 'horn_coral_fan',
+  'white_concrete_powder', 'orange_concrete_powder', 'magenta_concrete_powder',
+  'light_blue_concrete_powder', 'yellow_concrete_powder', 'lime_concrete_powder',
+  'pink_concrete_powder', 'gray_concrete_powder', 'light_gray_concrete_powder',
+  'cyan_concrete_powder', 'purple_concrete_powder', 'blue_concrete_powder',
+  'brown_concrete_powder', 'green_concrete_powder', 'red_concrete_powder', 'black_concrete_powder',
+  'sculk', 'sculk_catalyst', 'sculk_shrieker', 'sculk_sensor', 'sculk_vein',
+  'mud_bricks', 'packed_mud', 'muddy_mangrove_roots',
+  'crimson_stem', 'warped_stem', 'stripped_crimson_stem', 'stripped_warped_stem',
+  'crimson_nylium', 'warped_nylium', 'shroomlight', 'nether_wart_block', 'warped_wart_block',
+  'crying_obsidian', 'blackstone', 'polished_blackstone', 'polished_blackstone_bricks',
+  'chiseled_polished_blackstone', 'gilded_blackstone', 'cracked_polished_blackstone_bricks',
+  'lodestone', 'respawn_anchor',
+  'pointed_dripstone', 'moss_carpet', 'azalea', 'flowering_azalea',
+  'powder_snow', 'mangrove_roots',
+  'copper_block', 'exposed_copper', 'weathered_copper', 'oxidized_copper',
+  'cut_copper', 'exposed_cut_copper', 'weathered_cut_copper', 'oxidized_cut_copper',
+  'waxed_copper_block', 'waxed_exposed_copper', 'waxed_weathered_copper', 'waxed_oxidized_copper',
 ]);

-const DYE_COLORS = new Set([
-  'white', 'orange', 'magenta', 'light_blue', 'yellow', 'lime',
-  'pink', 'gray', 'light_gray', 'cyan', 'purple', 'blue',
-  'brown', 'green', 'red', 'black',
-]);
+// Some blocks need a specific texture suffix (e.g. furnace_front, oak_log_top)
+// We use _front, _top, or _side variants for recognizable look
+const BLOCK_TEXTURE_SUFFIXES = {
+  furnace: '_front',
+  blast_furnace: '_front',
+  smoker: '_front',
+  dispenser: '_front',
+  dropper: '_front',
+  observer: '_front',
+  piston: '_top',
+  sticky_piston: '_top',
+  barrel: '_top',
+  crafting_table: '_top',
+  cartography_table: '_top',
+  fletching_table: '_top',
+  smithing_table: '_top',
+  grass_block: '_top',
+  mycelium: '_top',
+  podzol: '_top',
+  pumpkin: '_side',
+  carved_pumpkin: '_front',
+  jack_o_lantern: '_front',
+  jukebox: '_top',
+  loom: '_front',
+  bee_nest: '_front',
+  beehive: '_front',
+  respawn_anchor: '_top',
+  bone_block: '_side',
+  basalt: '_side',
+  polished_basalt: '_side',
+  quartz_pillar: '_side',
+  purpur_pillar: '_side',
+  tnt: '_side',
+  composter: '_side',
+  enchanting_table: '_top',
+};

-/**
- * Check if an item is known to have no flat texture (entity/model-only).
- */
-function isEntityOnly(name) {
-  if (ENTITY_ONLY.has(name)) return true;
-  if (name.endsWith('_bed') && DYE_COLORS.has(name.slice(0, -'_bed'.length))) return true;
-  if (name.endsWith('_banner') && DYE_COLORS.has(name.slice(0, -'_banner'.length))) return true;
-  if (name.endsWith('_skull') || name.endsWith('_head')) return true;
-  return false;
+// Resolve derivative blocks (stairs, slabs, fences, walls, buttons) to parent block texture
+const WOOD_TYPES = new Set([
+  'oak', 'spruce', 'birch', 'jungle', 'acacia', 'dark_oak',
+  'mangrove', 'cherry', 'bamboo', 'crimson', 'warped',
+]);
+const STONE_ALIASES = {
+  brick: 'bricks', stone_brick: 'stone_bricks', mossy_stone_brick: 'mossy_stone_bricks',
+  nether_brick: 'nether_bricks', red_nether_brick: 'red_nether_bricks',
+  end_stone_brick: 'end_stone_bricks', deepslate_brick: 'deepslate_bricks',
+  deepslate_tile: 'deepslate_tiles', polished_blackstone_brick: 'polished_blackstone_bricks',
+  mud_brick: 'mud_bricks', quartz: 'quartz_block', purpur: 'purpur_block',
+  smooth_stone: 'smooth_stone',
+};
+
+function resolveDerivativeTexture(name) {
+  const suffixes = ['_stairs', '_slab', '_fence_gate', '_fence', '_wall', '_button', '_pressure_plate'];
+  for (const suffix of suffixes) {
+    if (!name.endsWith(suffix)) continue;
+    const base = name.slice(0, -suffix.length);
+    if (BLOCK_TEXTURES.has(base)) return base;
+    if (WOOD_TYPES.has(base)) return `${base}_planks`;
+    if (STONE_ALIASES[base]) return STONE_ALIASES[base];
+    return null;
+  }
+  return null;
 }

 /**
- * Build the single resolve URL for an item.
- * The server handles all name resolution (aliases, suffixes, derivatives, etc.)
+ * Generate texture URLs to try in order.
+ * - CC:Tweaked → curated texture map (1 request)
+ * - Create → item/ then block/ (2 requests max)
+ * - Unknown mods → empty (instant emoji, no wasted requests)
+ * - Vanilla derivatives → parent block texture (1 request)
+ * - Vanilla → block/ or item/ with fallback
 */
-function getTextureUrl(fullItemName) {
+function getTextureUrls(fullItemName) {
  const colonIdx = (fullItemName || '').indexOf(':');
  const namespace = colonIdx >= 0 ? fullItemName.substring(0, colonIdx) : 'minecraft';
  const shortName = colonIdx >= 0 ? fullItemName.substring(colonIdx + 1) : fullItemName;
+  const urls = [];

-  // Entity-only items → instant emoji, no network request
-  if (namespace === 'minecraft' && isEntityOnly(shortName)) return null;
+  // CC:Tweaked → use curated texture map
+  if (namespace === 'computercraft') {
+    const mapped = CC_TEXTURE_MAP[shortName];
+    if (mapped) {
+      urls.push(`${TEXTURE_PROXY_BASE}/computercraft/${mapped}.png`);
+    } else {
+      urls.push(`${TEXTURE_PROXY_BASE}/computercraft/item/${shortName}.png`);
+      urls.push(`${TEXTURE_PROXY_BASE}/computercraft/block/${shortName}.png`);
+    }
+    return urls;
+  }

-  return `${RESOLVE_BASE}/${namespace}/${shortName}.png`;
+  // Create mod → item/ then block/
+  if (namespace === 'create') {
+    urls.push(`${TEXTURE_PROXY_BASE}/create/item/${shortName}.png`);
+    urls.push(`${TEXTURE_PROXY_BASE}/create/block/${shortName}.png`);
+    return urls;
+  }
+
+  // Unknown mod namespace → no textures available, instant emoji fallback
+  if (namespace !== 'minecraft') {
+    return urls;
+  }
+
+  // === Vanilla (minecraft) ===
+  const alias = TEXTURE_ALIASES[shortName] || shortName;
+
+  // Derivative blocks (stairs, slabs, fences, walls, buttons) → parent texture
+  const parent = resolveDerivativeTexture(alias);
+  if (parent) {
+    const suffix = BLOCK_TEXTURE_SUFFIXES[parent] || '';
+    urls.push(`${TEXTURE_PROXY_BASE}/minecraft/block/${parent}${suffix}.png`);
+    return urls;
+  }
+
+  // Known block → try block/ first (with suffix if applicable)
+  if (BLOCK_TEXTURES.has(alias)) {
+    const suffix = BLOCK_TEXTURE_SUFFIXES[alias] || '';
+    urls.push(`${TEXTURE_PROXY_BASE}/minecraft/block/${alias}${suffix}.png`);
+    if (suffix) urls.push(`${TEXTURE_PROXY_BASE}/minecraft/block/${alias}.png`);
+  }
+
+  // Try item/ texture
+  urls.push(`${TEXTURE_PROXY_BASE}/minecraft/item/${alias}.png`);
+
+  // If not a known block, also try block/ as last resort
+  if (!BLOCK_TEXTURES.has(alias)) {
+    urls.push(`${TEXTURE_PROXY_BASE}/minecraft/block/${alias}.png`);
+  }
+
+  return urls;
 }

 // Cache of resolved icon URLs (avoid re-fetching on every render)
@@ -50,20 +277,21 @@ const iconCache = new Map();

 /**
 * Renders a Minecraft item icon using the official game textures.
- * The server's /api/texture/resolve endpoint does all the smart matching.
- * Falls back to emoji when no texture is found.
+ * Cascading fallback: mod texture → item texture → block texture → emoji
 */
 function ItemIcon({ itemName, size = 32 }) {
-  const [failed, setFailed] = useState(false);
+  const [urlIndex, setUrlIndex] = useState(0);
+  const [allFailed, setAllFailed] = useState(false);

  if (!itemName) {
    return <span className="item-icon-emoji" style={{ fontSize: size * 0.7 }}>📦</span>;
  }

+  // Use full item name as cache key (handles mod namespaces correctly)
  const cacheKey = itemName.replace(/^minecraft:/, '');

  // Check if we already know this item has no texture
-  if (iconCache.get(cacheKey) === 'none' || failed) {
+  if (iconCache.get(cacheKey) === 'none' || allFailed) {
    return (
      <span className="item-icon-emoji" style={{ fontSize: size * 0.7 }}>
        {getItemEmoji(itemName)}
@@ -86,9 +314,10 @@ function ItemIcon({ itemName, size = 32 }) {
    );
  }

-  const url = getTextureUrl(itemName);
+  const urls = getTextureUrls(itemName);
+  const currentUrl = urls[urlIndex];

-  if (!url) {
+  if (!currentUrl) {
    iconCache.set(cacheKey, 'none');
    return (
      <span className="item-icon-emoji" style={{ fontSize: size * 0.7 }}>
@@ -100,17 +329,21 @@ function ItemIcon({ itemName, size = 32 }) {
  return (
    <img
      className="item-icon-img"
-      src={url}
+      src={currentUrl}
      alt={cacheKey}
      width={size}
      height={size}
      loading="lazy"
      onLoad={() => {
-        iconCache.set(cacheKey, url);
+        iconCache.set(cacheKey, currentUrl);
      }}
      onError={() => {
-        iconCache.set(cacheKey, 'none');
-        setFailed(true);
+        if (urlIndex + 1 < urls.length) {
+          setUrlIndex(urlIndex + 1);
+        } else {
+          iconCache.set(cacheKey, 'none');
+          setAllFailed(true);
+        }
      }}
    />
  );
--- a/web/server/Dockerfile
+++ b/web/server/Dockerfile
@@ -1,12 +1,4 @@
-# Stage 1: Fetch platform server package from git
-FROM alpine:3.20 AS platform
-RUN apk add --no-cache git
-ARG PLATFORM_REPO=https://git.spatulaa.com/MayaTheShy/cc-platform-core.git
-ARG PLATFORM_BRANCH=master
-RUN git clone --depth 1 --branch "$PLATFORM_BRANCH" "$PLATFORM_REPO" /src \
-    && rm -rf /src/server/node_modules /src/.git
-
-# Stage 2: Node.js backend
+# Node.js backend
 FROM node:20-alpine

 # Build tools needed for better-sqlite3 native compilation
@@ -16,15 +8,8 @@ RUN apk add --no-cache python3 make g++ su-exec libstdc++

 WORKDIR /app

-# Copy platform server package from the git-clone stage
-COPY --from=platform /src/server /app/platform-server/
-
 COPY package*.json ./

-# Rewrite file: dependency to use the local copy inside the container
-RUN sed -i 's|file:../../../cc-platform-core/server|file:./platform-server|' package.json \
-    && rm -f package-lock.json
-
 RUN npm install --omit=dev

 # Remove build tools after install to keep image small
--- a/web/server/docker-entrypoint.sh
+++ b/web/server/docker-entrypoint.sh
@@ -8,16 +8,6 @@ mkdir -p /data
 chown -R node:node /data
 echo "[entrypoint] /data permissions fixed"

-# Download textures if cache is empty (first run)
-TEXTURE_DIR="/data/texture-cache/minecraft"
-if [ ! -d "$TEXTURE_DIR" ] || [ -z "$(ls -A "$TEXTURE_DIR" 2>/dev/null)" ]; then
-  echo "[entrypoint] Downloading textures (first run)..."
-  su-exec node node /app/download-textures.js /data/texture-cache
-  echo "[entrypoint] Texture download complete"
-else
-  echo "[entrypoint] Texture cache exists, skipping download"
-fi
-
 # Drop privileges and exec the CMD
 echo "[entrypoint] Dropping to user 'node', running: $*"
 exec su-exec node "$@"
--- a/web/server/download-textures.js
+++ b/web/server/download-textures.js
@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-/**
- * download-textures.js — Bulk-download item/block textures for all supported
- * mods into the local texture cache.
- *
- * Supported mods (Prominence Hasturian Era II modpack):
- *   Minecraft, Create, CC:Tweaked, Mythic Metals, Farmer's Delight,
- *   Ad Astra, BetterEnd, Applied Energistics 2, Twilight Forest
- *
- * Run once (or on container start) to pre-populate the cache so the proxy
- * never needs to hit upstream for known textures.
- *
- * Usage:   node download-textures.js [cacheDir]
- * Default: /data/texture-cache  (matches server.js)
- */
-
-import fs from 'fs';
-import path from 'path';
-
-const CACHE_DIR = process.argv[2] || process.env.TEXTURE_CACHE_DIR || '/data/texture-cache';
-
-// ── Upstream repos (same namespaces as TEXTURE_UPSTREAMS in server.js) ─────
-
-const REPOS = {
-  minecraft: {
-    api: 'https://api.github.com/repos/InventivetalentDev/minecraft-assets/git/trees/1.21.4?recursive=1',
-    raw: 'https://cdn.jsdelivr.net/gh/InventivetalentDev/minecraft-assets@1.21.4',
-    prefix: 'assets/minecraft/textures/',
-    folders: ['item/', 'block/'],
-  },
-  create: {
-    api: 'https://api.github.com/repos/Creators-of-Create/Create/git/trees/mc1.20.1/dev?recursive=1',
-    raw: 'https://raw.githubusercontent.com/Creators-of-Create/Create/mc1.20.1/dev',
-    prefix: 'src/main/resources/assets/create/textures/',
-    folders: ['item/', 'block/'],
-  },
-  computercraft: {
-    api: 'https://api.github.com/repos/cc-tweaked/CC-Tweaked/git/trees/mc-1.20.x?recursive=1',
-    raw: 'https://raw.githubusercontent.com/cc-tweaked/CC-Tweaked/mc-1.20.x',
-    prefix: 'projects/common/src/main/resources/assets/computercraft/textures/',
-    folders: ['item/', 'block/'],
-  },
-  mythicmetals: {
-    api: 'https://api.github.com/repos/Noaaan/MythicMetals/git/trees/1.20?recursive=1',
-    raw: 'https://raw.githubusercontent.com/Noaaan/MythicMetals/1.20',
-    prefix: 'src/main/resources/assets/mythicmetals/textures/',
-    folders: ['item/', 'block/'],
-  },
-  farmersdelight: {
-    api: 'https://api.github.com/repos/vectorwing/FarmersDelight/git/trees/1.20?recursive=1',
-    raw: 'https://raw.githubusercontent.com/vectorwing/FarmersDelight/1.20',
-    prefix: 'src/main/resources/assets/farmersdelight/textures/',
-    folders: ['item/', 'block/'],
-  },
-  ad_astra: {
-    api: 'https://api.github.com/repos/terrarium-earth/Ad-Astra/git/trees/1.20.1?recursive=1',
-    raw: 'https://raw.githubusercontent.com/terrarium-earth/Ad-Astra/1.20.1',
-    prefix: 'common/src/main/resources/assets/ad_astra/textures/',
-    folders: ['item/', 'block/'],
-  },
-  betterend: {
-    api: 'https://api.github.com/repos/quiqueck/BetterEnd/git/trees/1.20?recursive=1',
-    raw: 'https://raw.githubusercontent.com/quiqueck/BetterEnd/1.20',
-    prefix: 'src/main/resources/assets/betterend/textures/',
-    folders: ['item/', 'block/'],
-  },
-  ae2: {
-    api: 'https://api.github.com/repos/AppliedEnergistics/Applied-Energistics-2/git/trees/fabric/1.20.1?recursive=1',
-    raw: 'https://raw.githubusercontent.com/AppliedEnergistics/Applied-Energistics-2/fabric/1.20.1',
-    prefix: 'src/main/resources/assets/ae2/textures/',
-    folders: ['item/', 'block/'],
-  },
-  twilightforest: {
-    api: 'https://api.github.com/repos/TeamTwilight/twilightforest/git/trees/1.20.1?recursive=1',
-    raw: 'https://raw.githubusercontent.com/TeamTwilight/twilightforest/1.20.1',
-    prefix: 'src/main/resources/assets/twilightforest/textures/',
-    folders: ['item/', 'block/'],
-  },
-};
-
-// ── Rate-limit-friendly parallel downloader ────────────────────────────────
-
-const CONCURRENCY = 10;
-const RETRY_DELAY = 1000;
-const MAX_RETRIES = 3;
-
-async function downloadFile(url, dest, retries = 0) {
-  try {
-    const res = await fetch(url);
-    if (res.status === 404) return false;          // genuinely missing
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    const buffer = Buffer.from(await res.arrayBuffer());
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.writeFileSync(dest, buffer);
-    return true;
-  } catch (err) {
-    if (retries < MAX_RETRIES) {
-      await new Promise(r => setTimeout(r, RETRY_DELAY * (retries + 1)));
-      return downloadFile(url, dest, retries + 1);
-    }
-    console.error(`  ✗ ${url}: ${err.message}`);
-    return false;
-  }
-}
-
-async function runPool(tasks) {
-  let idx = 0;
-  let ok = 0;
-  let fail = 0;
-  async function worker() {
-    while (idx < tasks.length) {
-      const task = tasks[idx++];
-      const success = await downloadFile(task.url, task.dest);
-      if (success) ok++;
-      else fail++;
-    }
-  }
-  const workers = Array.from({ length: Math.min(CONCURRENCY, tasks.length) }, () => worker());
-  await Promise.all(workers);
-  return { ok, fail };
-}
-
-// ── Main ───────────────────────────────────────────────────────────────────
-
-async function downloadNamespace(name, repo) {
-  console.log(`\n⬇  ${name}: fetching file list…`);
-
-  const res = await fetch(repo.api, {
-    headers: { 'User-Agent': 'inventory-manager-texture-dl' },
-  });
-  if (!res.ok) {
-    console.error(`  ✗ GitHub API ${res.status}: ${await res.text()}`);
-    return;
-  }
-  const data = await res.json();
-
-  // Filter to only PNG files in the target folders under the prefix
-  const tasks = [];
-  for (const entry of data.tree || []) {
-    if (entry.type !== 'blob') continue;
-    if (!entry.path.startsWith(repo.prefix)) continue;
-    if (!entry.path.endsWith('.png')) continue;
-
-    const relPath = entry.path.slice(repo.prefix.length);   // e.g. "item/diamond.png"
-    const inFolder = repo.folders.some(f => relPath.startsWith(f));
-    if (!inFolder) continue;
-
-    const dest = path.join(CACHE_DIR, name, relPath);
-    if (fs.existsSync(dest)) continue;                      // already cached
-
-    tasks.push({
-      url: `${repo.raw}/${entry.path}`,
-      dest,
-    });
-  }
-
-  if (tasks.length === 0) {
-    console.log(`  ✓ ${name}: all textures already cached`);
-    return;
-  }
-
-  console.log(`  ↓ downloading ${tasks.length} textures…`);
-  const { ok, fail } = await runPool(tasks);
-  console.log(`  ✓ ${name}: ${ok} downloaded, ${fail} failed`);
-}
-
-async function main() {
-  console.log(`Texture cache dir: ${CACHE_DIR}`);
-  fs.mkdirSync(CACHE_DIR, { recursive: true });
-
-  for (const [name, repo] of Object.entries(REPOS)) {
-    await downloadNamespace(name, repo);
-  }
-
-  // Clean up any .miss files so newly-downloaded textures take effect
-  let cleared = 0;
-  function cleanMiss(dir) {
-    try {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) cleanMiss(full);
-        else if (entry.name.endsWith('.miss')) { fs.unlinkSync(full); cleared++; }
-      }
-    } catch (_) { /* ignore */ }
-  }
-  cleanMiss(CACHE_DIR);
-  if (cleared) console.log(`\n🗑  Cleared ${cleared} negative-cache entries`);
-
-  // Build and print index stats
-  const stats = {};
-  function countPngs(dir, ns) {
-    try {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) countPngs(full, ns);
-        else if (entry.name.endsWith('.png')) stats[ns] = (stats[ns] || 0) + 1;
-      }
-    } catch (_) { /* ignore */ }
-  }
-  for (const ns of Object.keys(REPOS)) {
-    countPngs(path.join(CACHE_DIR, ns), ns);
-  }
-  console.log('\n📊 Cache totals:');
-  for (const [ns, count] of Object.entries(stats)) {
-    console.log(`   ${ns}: ${count} textures`);
-  }
-  console.log('\n✅ Done');
-}
-
-main().catch(err => {
-  console.error('Fatal:', err);
-  process.exit(1);
-});
--- a/web/server/package-lock.json
+++ b/web/server/package-lock.json
@@ -8,7 +8,6 @@
      "name": "inventory-manager-server",
      "version": "1.0.0",
      "dependencies": {
-        "@cc-platform/server": "file:../../../cc-platform-core/server",
        "better-sqlite3": "^11.7.0",
        "cors": "^2.8.5",
        "express": "^4.18.2",
@@ -19,23 +18,6 @@
        "vitest": "^3.2.1"
      }
    },
-    "../../../cc-platform-core/server": {
-      "name": "@cc-platform/server",
-      "version": "0.1.0",
-      "license": "MIT",
-      "dependencies": {
-        "better-sqlite3": "^11.0.0",
-        "express": "^4.21.0",
-        "ws": "^8.18.0"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@cc-platform/server": {
-      "resolved": "../../../cc-platform-core/server",
-      "link": true
-    },
    "node_modules/@esbuild/aix-ppc64": {
      "version": "0.27.4",
      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.4.tgz",
--- a/web/server/package.json
+++ b/web/server/package.json
@@ -7,12 +7,10 @@
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js",
-    "download-textures": "node download-textures.js",
    "test": "vitest run",
    "test:watch": "vitest"
  },
  "dependencies": {
-    "@cc-platform/server": "file:../../../cc-platform-core/server",
    "better-sqlite3": "^11.7.0",
    "cors": "^2.8.5",
    "express": "^4.18.2",
--- a/web/server/server.js
+++ b/web/server/server.js
@@ -1,152 +1,91 @@
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
 import {
  loadFullState, saveFullState, recordItemHistory,
  saveItems, saveFurnaces, saveAlerts, saveState, loadState,
  getHistory, getHistorySummary, closeDb, flushPendingSave,
 } from './db.js';

-const require = createRequire(import.meta.url);
-const {
-  createPlatformServer,
-  createWebSocketManager,
-  setupGracefulShutdown,
-  createRateLimiter,
-  createProxyEndpoint,
-} = require('@cc-platform/server');
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

-// ========== Platform Server Setup ==========
-// Provides Express app, HTTP server, auth middleware, and health endpoint.
-// CORS intentionally disabled — nginx reverse-proxy makes all requests same-origin.
-const { app, server, auth, start, port } = createPlatformServer({
-  serviceName: 'inventory-manager',
-  cors: false,
-  rateLimit: false,  // custom rate limiting below (excludes bridge endpoints)
-  healthExtras: () => ({
-    lastUpdate,
-    bridgeConnected: bridgeClients.size > 0,
-    webClients: webClients.size,
-  }),
-});
+const app = express();
+const PORT = process.env.PORT || 3001;
+const HOST = process.env.HOST || '0.0.0.0';

-const { requireAuth } = auth;
+// CORS intentionally omitted — nginx reverse-proxy makes all requests same-origin.
+// If you need direct server access during dev, add: app.use(require('cors')())
+app.disable('x-powered-by');
+app.use(express.json({ limit: '5mb' }));
+
+// ========== API Key Authentication ==========

-// API key reference needed for WebSocket upgrade authentication
 const API_KEY = process.env.API_KEY || '';

-// Custom rate limiting: 30 mutating requests/min per IP, excluding bridge endpoints
-const commandLimiter = createRateLimiter({ windowMs: 60000, maxRequests: 30 });
+// Validate bearer token from Authorization header or ?key= query param
+function extractApiKey(req) {
+  const auth = req.headers.authorization || '';
+  if (auth.startsWith('Bearer ')) return auth.slice(7);
+  return req.query.key || '';
+}
+
+// Middleware: require API key on mutating endpoints
+function requireAuth(req, res, next) {
+  if (!API_KEY) return next(); // Auth disabled when no key configured
+  const token = extractApiKey(req);
+  if (token === API_KEY) return next();
+  return res.status(401).json({ error: 'Unauthorized — invalid or missing API key' });
+}
+
+// Apply auth to all POST/PUT/DELETE routes
 app.use((req, res, next) => {
-  if (req.path.startsWith('/api/bridge/')) return next();
+  if (req.method === 'GET' || req.method === 'HEAD' || req.method === 'OPTIONS') {
+    return next(); // Read-only endpoints stay open
+  }
+  return requireAuth(req, res, next);
+});
+
+// ========== Rate Limiting (in-memory, no external dependencies) ==========
+
+function createRateLimiter(windowMs, max) {
+  const hits = new Map();
+  setInterval(() => {
+    const cutoff = Date.now() - windowMs;
+    for (const [key, entry] of hits) {
+      if (entry.start < cutoff) hits.delete(key);
+    }
+  }, windowMs);
+  return (req, res, next) => {
+    const key = req.ip || req.socket.remoteAddress || 'unknown';
+    const now = Date.now();
+    const entry = hits.get(key);
+    if (!entry || now - entry.start > windowMs) {
+      hits.set(key, { start: now, count: 1 });
+      return next();
+    }
+    entry.count++;
+    if (entry.count > max) {
+      res.set('Retry-After', String(Math.ceil((entry.start + windowMs - now) / 1000)));
+      return res.status(429).json({ error: 'Too many requests — try again later' });
+    }
+    return next();
+  };
+}
+
+// 30 mutating requests per minute per IP (excludes bridge state updates)
+const commandLimiter = createRateLimiter(60_000, 30);
+app.use((req, res, next) => {
+  if (req.method !== 'POST' || req.path.startsWith('/api/bridge/')) return next();
  return commandLimiter(req, res, next);
 });

-// ========== WebSocket Manager (platform-managed) ==========
-// Replaces hand-rolled WebSocketServer with createWebSocketManager() from
-// @cc-platform/server.  Handles bridge/client URL routing, API key auth on
-// upgrade, ping/pong keepalive with stale-connection cleanup.
-//
-// Bridge path: /ws/bridge — receives state/results, pushes commands real-time
-// Client path: /ws       — receives initial_state on connect, sends commands
-//
-// HTTP polling fallback preserved via /api/bridge/* endpoints until WS
-// adoption is fully verified.
-const wsManager = createWebSocketManager(server, {
-  apiKey: API_KEY,
-
-  // ---- Bridge lifecycle ----
-  onBridgeConnect: (ws) => {
-    console.log('\u{1F309} CC:Tweaked bridge connected via WebSocket');
-    wsManager.broadcastToClients({ type: 'state_update', bridgeConnected: true });
-
-    // Flush any pending commands queued while no WS bridge was connected.
-    // Replaces the implicit sync that HTTP polling previously provided.
-    const pending = getPendingCommands();
-    if (pending.length > 0) {
-      try {
-        ws.send(JSON.stringify({ type: 'command_batch', commands: pending }));
-        console.log(`[Bridge] Flushed ${pending.length} pending command(s) via WS`);
-      } catch (e) {
-        console.error('[Bridge] Failed to flush pending commands:', e.message);
-      }
-    }
-  },
-
-  onBridgeMessage: (ws, data) => {
-    if (data.type === 'state') {
-      // Full state update from bridge (same path as POST /api/bridge/state)
-      updateStateFromBridge(data);
-    } else if (data.type === 'command_result') {
-      // Command result from bridge — forward to all web clients
-      wsManager.broadcastToClients({
-        type: 'command_result',
-        commandId: data.commandId,
-        action: data.action,
-        success: data.success,
-        message: data.message,
-        error: data.error,
-      });
-    }
-  },
-
-  onBridgeDisconnect: () => {
-    console.log('\u{1F309} CC:Tweaked bridge disconnected');
-    wsManager.broadcastToClients({
-      type: 'state_update',
-      bridgeConnected: wsManager.bridgeClients.size > 0,
-    });
-  },
-
-  // ---- Web client lifecycle ----
-  onClientConnect: (ws) => {
-    console.log('\u{1F310} New web client connected');
-    // Send full current state to newly connected dashboard
-    ws.send(JSON.stringify({
-      type: 'initial_state',
-      inventory: inventoryState,
-      activity: activityState,
-      alerts: alertsState,
-      smeltingPaused,
-      disabledRecipes,
-      smeltable: smeltableRecipes,
-      craftable: craftableRecipes,
-      craftTurtleOk,
-      lastUpdate,
-      bridgeConnected: wsManager.bridgeClients.size > 0,
-      dropperNicknames,
-    }));
-  },
-
-  onClientMessage: (ws, data) => {
-    if (data.type === 'command') {
-      // Idempotency check for WS commands
-      const cached = checkIdempotent(data.commandId);
-      if (cached) {
-        ws.send(JSON.stringify({ type: 'command_result', commandId: data.commandId, ...cached }));
-        return;
-      }
-      // Forward command to bridge (WS push or HTTP poll queue)
-      pushCommandToBridge(data);
-      if (data.commandId) {
-        recordCommand(data.commandId, { success: true, commandId: data.commandId });
-      }
-    }
-  },
-
-  onClientDisconnect: () => {
-    console.log('\u{1F44B} Web client disconnected');
-  },
-});
-
-// Aliases — backward compatibility for code referencing these Sets directly
-const { bridgeClients, webClients } = wsManager;
-
 // ========== State ==========
+const webClients = new Set();
+const bridgeClients = new Set();

 // Load persisted state from SQLite on startup
 console.log('💾 Loading persisted state from database...');
@@ -199,25 +138,31 @@ function recordCommand(commandId, result) {

 // ========== Helpers ==========

-// Broadcasts data to all connected web dashboard clients.
-// Delegates to platform WS manager (handles JSON serialization, error handling).
 function broadcastToClients(data) {
-  wsManager.broadcastToClients(data);
+  const message = JSON.stringify(data);
+  webClients.forEach((client) => {
+    if (client.readyState === 1) {
+      try {
+        client.send(message);
+      } catch (err) {
+        console.error('❌ WS send error (client):', err.message);
+      }
+    }
+  });
 }

-// Returns a filtered copy of pending commands (clears expired entries).
-// Used by both the HTTP polling endpoint and WS initial sync.
-function getPendingCommands() {
-  const now = Date.now();
-  pendingCommands = pendingCommands.filter(cmd => (now - cmd.timestamp) < 30000);
-  return [...pendingCommands];
-}
-
-// Pushes a command to the CC:Tweaked bridge.
-// Primary: real-time push via WebSocket (wsManager.sendToBridge).
-// Fallback: queues for HTTP polling if no WS bridge is connected.
 function pushCommandToBridge(command) {
-  const sent = wsManager.sendToBridge(command);
+  let sent = false;
+  for (const bridge of bridgeClients) {
+    if (bridge.readyState === 1) {
+      try {
+        bridge.send(JSON.stringify(command));
+        sent = true;
+      } catch (err) {
+        console.error('❌ WS send error (bridge):', err.message);
+      }
+    }
+  }
  if (!sent) {
    // Fallback: queue for HTTP polling with monotonic ID
    const id = nextCommandId++;
@@ -226,266 +171,27 @@ function pushCommandToBridge(command) {
  }
 }

+// ========== HTTP Server ==========
+const server = createServer(app);
+
 // ========== Texture Proxy / Cache ==========
 const TEXTURE_CACHE_DIR = process.env.TEXTURE_CACHE_DIR || path.join('/data', 'texture-cache');
 const NEGATIVE_CACHE_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days for 404s

-// Upstream CDN mapping (Prominence Hasturian Era II modpack coverage)
+// Upstream CDN mapping
 const TEXTURE_UPSTREAMS = {
  minecraft: 'https://cdn.jsdelivr.net/gh/InventivetalentDev/minecraft-assets@1.21.4/assets/minecraft/textures',
  computercraft: 'https://raw.githubusercontent.com/cc-tweaked/CC-Tweaked/mc-1.20.x/projects/common/src/main/resources/assets/computercraft/textures',
  create: 'https://raw.githubusercontent.com/Creators-of-Create/Create/mc1.20.1/dev/src/main/resources/assets/create/textures',
-  mythicmetals: 'https://raw.githubusercontent.com/Noaaan/MythicMetals/1.20/src/main/resources/assets/mythicmetals/textures',
-  farmersdelight: 'https://raw.githubusercontent.com/vectorwing/FarmersDelight/1.20/src/main/resources/assets/farmersdelight/textures',
-  ad_astra: 'https://raw.githubusercontent.com/terrarium-earth/Ad-Astra/1.20.1/common/src/main/resources/assets/ad_astra/textures',
-  betterend: 'https://raw.githubusercontent.com/quiqueck/BetterEnd/1.20/src/main/resources/assets/betterend/textures',
-  ae2: 'https://raw.githubusercontent.com/AppliedEnergistics/Applied-Energistics-2/fabric/1.20.1/src/main/resources/assets/ae2/textures',
-  twilightforest: 'https://raw.githubusercontent.com/TeamTwilight/twilightforest/1.20.1/src/main/resources/assets/twilightforest/textures',
 };

 // Ensure cache directory exists
 fs.mkdirSync(TEXTURE_CACHE_DIR, { recursive: true });

-// ── Texture index: maps base_name → relative path for smart resolution ────
-// Built on startup by scanning the texture cache.  Key = short name (no ext),
-// Value = array of relative paths (e.g. ["item/diamond.png", "block/diamond_ore.png"])
-const textureIndex = {};  // { namespace: { baseName: [relPath, ...] } }
-
-function buildTextureIndex() {
-  for (const ns of Object.keys(TEXTURE_UPSTREAMS)) {
-    textureIndex[ns] = {};
-    const nsDir = path.join(TEXTURE_CACHE_DIR, ns);
-    if (!fs.existsSync(nsDir)) continue;
-    (function walk(dir, rel) {
-      try {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-          const childRel = rel ? `${rel}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) walk(path.join(dir, entry.name), childRel);
-          else if (entry.name.endsWith('.png') && !entry.name.endsWith('.miss')) {
-            const baseName = entry.name.slice(0, -4); // strip .png
-            if (!textureIndex[ns][baseName]) textureIndex[ns][baseName] = [];
-            textureIndex[ns][baseName].push(childRel);
-          }
-        }
-      } catch (_) { /* ignore unreadable dirs */ }
-    })(nsDir, '');
-  }
-  const total = Object.values(textureIndex).reduce(
-    (sum, idx) => sum + Object.keys(idx).length, 0);
-  console.log(`[Texture Index] Indexed ${total} unique texture names`);
-}
-
-buildTextureIndex();
-
-// ── Smart texture resolution ──────────────────────────────────────────────
-// Given a Minecraft item/block registry name, find the best matching texture.
-// Returns the relative cache path or null.
-
-// Patterns for items whose textures use numbered animation frames
-const ANIMATED_ITEMS = new Set([
-  'compass', 'recovery_compass', 'clock',
-  'crossbow',    // crossbow_standby, crossbow_pulling_0, etc.
-  'light',       // light_0 .. light_15
-]);
-
-// Maps a registry short name to the actual texture base name
-const SERVER_ALIASES = {
-  // Registry name differs from texture filename
-  magma_block: 'magma',
-  grass: 'short_grass',
-  scute: 'turtle_scute',
-  enchanted_golden_apple: 'golden_apple',
-};
-
-// Preferred animation frame for animated items
-const ANIMATED_FRAME = {
-  compass: 'compass_16',
-  recovery_compass: 'recovery_compass_16',
-  clock: 'clock_22',
-  crossbow: 'crossbow_standby',
-  light: 'light_15',
-};
-
-// Dye color set for carpet/bed/banner resolution
-const DYE_COLORS = new Set([
-  'white', 'orange', 'magenta', 'light_blue', 'yellow', 'lime',
-  'pink', 'gray', 'light_gray', 'cyan', 'purple', 'blue',
-  'brown', 'green', 'red', 'black',
-]);
-
-const WOOD_TYPES = new Set([
-  'oak', 'spruce', 'birch', 'jungle', 'acacia', 'dark_oak',
-  'mangrove', 'cherry', 'bamboo', 'crimson', 'warped', 'pale_oak',
-]);
-
-// Blocks whose texture uses a suffix: name_front, name_top, etc.
-const BLOCK_SUFFIXES = {
-  furnace: '_front_on', blast_furnace: '_front_on', smoker: '_front_on',
-  dispenser: '_front', dropper: '_front', observer: '_front',
-  barrel: '_top', crafting_table: '_top', grass_block: '_top',
-  mycelium: '_top', podzol: '_top', dirt_path: '_top',
-  quartz_block: '_side',
-  pumpkin: '_side', carved_pumpkin: '_front', jack_o_lantern: '_front',
-  jukebox: '_top', loom: '_front', bee_nest: '_front', beehive: '_front',
-  respawn_anchor: '_top', bone_block: '_side',
-  basalt: '_side', polished_basalt: '_side',
-  tnt: '_side', composter: '_side', enchanting_table: '_top',
-  cartography_table: '_top', fletching_table: '_top', smithing_table: '_top',
-};
-
-// Derivative block suffixes → resolve to parent block
-const DERIVATIVE_SUFFIXES = [
-  '_stairs', '_slab', '_fence_gate', '_fence', '_wall',
-  '_button', '_pressure_plate',
-];
-const STONE_ALIASES = {
-  brick: 'bricks', stone_brick: 'stone_bricks', mossy_stone_brick: 'mossy_stone_bricks',
-  nether_brick: 'nether_bricks', red_nether_brick: 'red_nether_bricks',
-  end_stone_brick: 'end_stone_bricks', deepslate_brick: 'deepslate_bricks',
-  deepslate_tile: 'deepslate_tiles', polished_blackstone_brick: 'polished_blackstone_bricks',
-  mud_brick: 'mud_bricks', quartz: 'quartz_block', purpur: 'purpur_block',
-  smooth_stone: 'smooth_stone',
-};
-// "smooth_" blocks use the parent's top/bottom face
-const SMOOTH_ALIASES = {
-  smooth_sandstone: 'sandstone_top',
-  smooth_red_sandstone: 'red_sandstone_top',
-  smooth_quartz: 'quartz_block_bottom',
-};
-
-function resolveTexturePath(ns, itemName) {
-  const idx = textureIndex[ns];
-  if (!idx) return null;
-
-  // Helper: check if a baseName exists and return preferred path
-  function find(baseName, preferFolder) {
-    const paths = idx[baseName];
-    if (!paths || paths.length === 0) return null;
-    if (preferFolder) {
-      const match = paths.find(p => p.startsWith(preferFolder + '/'));
-      if (match) return match;
-    }
-    return paths[0];
-  }
-
-  // Helper: check if a baseName with a suffix exists in block/
-  function findBlock(baseName) {
-    const suffix = BLOCK_SUFFIXES[baseName];
-    if (suffix) {
-      const hit = find(baseName + suffix, 'block') || find(baseName, 'block');
-      if (hit) return hit;
-    }
-    return find(baseName, 'block');
-  }
-
-  // 1. Direct lookup — try item/ then block/
-  let hit = find(itemName, 'item') || findBlock(itemName);
-  if (hit) return hit;
-
-  // 2. Server-side alias
-  if (SERVER_ALIASES[itemName]) {
-    const alias = SERVER_ALIASES[itemName];
-    hit = find(alias, 'item') || findBlock(alias);
-    if (hit) return hit;
-  }
-
-  // 3. Smooth blocks
-  if (SMOOTH_ALIASES[itemName]) {
-    hit = find(SMOOTH_ALIASES[itemName], 'block');
-    if (hit) return hit;
-  }
-
-  // 4. Animated items — pick a representative frame
-  if (ANIMATED_FRAME[itemName]) {
-    hit = find(ANIMATED_FRAME[itemName], 'item');
-    if (hit) return hit;
-  }
-
-  // 5. Carpets → wool texture
-  if (itemName.endsWith('_carpet')) {
-    const color = itemName.slice(0, -'_carpet'.length);
-    if (DYE_COLORS.has(color)) {
-      hit = find(color + '_wool', 'block');
-      if (hit) return hit;
-    }
-  }
-
-  // 6. Wood → log texture
-  if (itemName.endsWith('_wood')) {
-    const base = itemName.slice(0, -'_wood'.length);
-    const stripped = base.startsWith('stripped_') ? base.slice('stripped_'.length) : null;
-    const woodType = stripped || base;
-    if (WOOD_TYPES.has(woodType)) {
-      const logName = stripped ? `stripped_${woodType}_log` : `${woodType}_log`;
-      hit = find(logName, 'block');
-      if (hit) return hit;
-    }
-  }
-
-  // 7. Derivative blocks (stairs, slabs, fences, walls…) → parent block
-  for (const suffix of DERIVATIVE_SUFFIXES) {
-    if (!itemName.endsWith(suffix)) continue;
-    const base = itemName.slice(0, -suffix.length);
-    // Try direct parent
-    hit = findBlock(base);
-    if (hit) return hit;
-    // Wood → planks
-    if (WOOD_TYPES.has(base)) {
-      hit = findBlock(base + '_planks');
-      if (hit) return hit;
-    }
-    // Stone aliases (brick → bricks, etc.)
-    if (STONE_ALIASES[base]) {
-      hit = findBlock(STONE_ALIASES[base]);
-      if (hit) return hit;
-    }
-    break; // only one derivative suffix can match
-  }
-
-  // 8. Prefix match — for items like "compass" try "compass_*"
-  const prefixMatches = Object.keys(idx).filter(k => k.startsWith(itemName + '_'));
-  if (prefixMatches.length > 0) {
-    // Sort for deterministic result, prefer item/ folder
-    prefixMatches.sort();
-    for (const m of prefixMatches) {
-      hit = find(m, 'item');
-      if (hit) return hit;
-    }
-    hit = find(prefixMatches[0]);
-    if (hit) return hit;
-  }
-
-  return null;
-}
-
-// ── Smart resolution endpoint ─────────────────────────────────────────────
-// GET /api/texture/resolve/:namespace/:itemName
-// Returns the texture PNG for a Minecraft registry item name, using smart
-// matching (aliases, animation frames, carpet→wool, etc.)
-app.get('/api/texture/resolve/:namespace/:itemName', (req, res) => {
-  const { namespace, itemName } = req.params;
-  const name = itemName.replace(/\.png$/i, '');
-
-  const resolved = resolveTexturePath(namespace, name);
-  if (!resolved) {
-    return res.status(404).send('No texture found');
-  }
-
-  const fullPath = path.join(TEXTURE_CACHE_DIR, namespace, resolved);
-  if (!fs.existsSync(fullPath)) {
-    return res.status(404).send('Texture file missing');
-  }
-
-  res.set('Content-Type', 'image/png');
-  res.set('Cache-Control', 'public, max-age=604800');
-  res.set('X-Texture-Resolved', resolved);
-  return res.sendFile(fullPath);
-});
-
-// ── Legacy texture proxy (fallback for cache misses) ──────────────────────
 app.get('/api/texture/:namespace/*', async (req, res) => {
  const { namespace } = req.params;
-  const texturePath = req.params[0];
+  const texturePath = req.params[0]; // e.g. "item/diamond.png"
+
  const upstream = TEXTURE_UPSTREAMS[namespace];
  if (!upstream) {
    return res.status(404).send('Unknown namespace');
@@ -576,7 +282,16 @@ app.delete('/api/texture-cache/negative', (req, res) => {
  res.json({ cleared });
 });

-// Health endpoint provided by platform (createPlatformServer) with custom extras
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    lastUpdate,
+    uptime: process.uptime(),
+    bridgeConnected: bridgeClients.size > 0,
+    webClients: webClients.size,
+  });
+});

 // Get current inventory state
 app.get('/api/inventory', (req, res) => {
@@ -873,122 +588,6 @@ app.post('/api/craft', (req, res) => {
  }
 });

-// Recursive craft (multi-step crafting chain)
-app.post('/api/recursive-craft', (req, res) => {
-  try {
-    const { itemName, count, commandId } = req.body;
-
-    const cached = checkIdempotent(commandId);
-    if (cached) return res.json(cached);
-
-    if (!itemName || typeof itemName !== 'string' || itemName.length > 200) {
-      return res.status(400).json({ error: 'Missing or invalid itemName' });
-    }
-    const parsedCount = parseInt(count);
-    if (!Number.isFinite(parsedCount) || parsedCount < 1 || parsedCount > 100000) {
-      return res.status(400).json({ error: 'Invalid count (1–100000)' });
-    }
-
-    pushCommandToBridge({ type: 'command', action: 'recursive_craft', commandId, itemName, count: parsedCount });
-    const result = { success: true, commandId, message: `Recursive craft sent: ${itemName} x${count}` };
-    recordCommand(commandId, result);
-    console.log(`🔨 Recursive craft: ${itemName} x${count}`);
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Learn a crafting recipe
-app.post('/api/recipes/learn-crafting', (req, res) => {
-  try {
-    const { output, count, grid, commandId } = req.body;
-
-    const cached = checkIdempotent(commandId);
-    if (cached) return res.json(cached);
-
-    if (!output || typeof output !== 'string' || output.length > 200) {
-      return res.status(400).json({ error: 'Missing or invalid output' });
-    }
-    if (!grid || !Array.isArray(grid) || grid.length !== 9) {
-      return res.status(400).json({ error: 'grid must be an array of 9 items' });
-    }
-
-    pushCommandToBridge({ type: 'command', action: 'learn_crafting_recipe', commandId, output, count: count || 1, grid });
-    const result = { success: true, commandId, message: `Learned crafting recipe: ${output}` };
-    recordCommand(commandId, result);
-    console.log(`📖 Learn crafting recipe: ${output}`);
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Learn a smelting recipe
-app.post('/api/recipes/learn-smelting', (req, res) => {
-  try {
-    const { input, result: recipeResult, furnaces, commandId } = req.body;
-
-    const cached = checkIdempotent(commandId);
-    if (cached) return res.json(cached);
-
-    if (!input || typeof input !== 'string' || input.length > 200) {
-      return res.status(400).json({ error: 'Missing or invalid input' });
-    }
-    if (!recipeResult || typeof recipeResult !== 'string' || recipeResult.length > 200) {
-      return res.status(400).json({ error: 'Missing or invalid result' });
-    }
-
-    pushCommandToBridge({ type: 'command', action: 'learn_smelting_recipe', commandId, input, result: recipeResult, furnaces });
-    const apiResult = { success: true, commandId, message: `Learned smelting recipe: ${input} → ${recipeResult}` };
-    recordCommand(commandId, apiResult);
-    console.log(`📖 Learn smelting recipe: ${input} → ${recipeResult}`);
-    res.json(apiResult);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Forget a recipe
-app.post('/api/recipes/forget', (req, res) => {
-  try {
-    const { recipe, commandId } = req.body;
-
-    const cached = checkIdempotent(commandId);
-    if (cached) return res.json(cached);
-
-    if (!recipe || typeof recipe !== 'string' || recipe.length > 200) {
-      return res.status(400).json({ error: 'Missing or invalid recipe name' });
-    }
-
-    pushCommandToBridge({ type: 'command', action: 'forget_recipe', commandId, recipe });
-    const result = { success: true, commandId, message: `Forget recipe: ${recipe}` };
-    recordCommand(commandId, result);
-    console.log(`🗑️ Forget recipe: ${recipe}`);
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
-// Sync disabled recipes state
-app.post('/api/recipes/sync', (req, res) => {
-  try {
-    const { disabledRecipes, smeltingPaused, commandId } = req.body;
-
-    const cached = checkIdempotent(commandId);
-    if (cached) return res.json(cached);
-
-    pushCommandToBridge({ type: 'command', action: 'sync_disabled_recipes', commandId, disabledRecipes, smeltingPaused });
-    const result = { success: true, commandId, message: 'Synced recipe state' };
-    recordCommand(commandId, result);
-    console.log('🔄 Sync disabled recipes');
-    res.json(result);
-  } catch (error) {
-    res.status(500).json({ error: error.message });
-  }
-});
-
 // ========== Bridge Endpoints (for HTTP polling fallback) ==========

 // Bridge sends inventory state
@@ -1006,7 +605,11 @@ app.post('/api/bridge/state', (req, res) => {
 // Bridge polls for pending commands (auth required — contains operational data)
 app.get('/api/bridge/commands', requireAuth, (req, res) => {
  try {
-    const commands = getPendingCommands();
+    const now = Date.now();
+    // Clear old commands (>30s)
+    pendingCommands = pendingCommands.filter(cmd => (now - cmd.timestamp) < 30000);
+    
+    const commands = [...pendingCommands];
    res.json({ commands });
  } catch (error) {
    res.status(500).json({ error: error.message });
@@ -1182,19 +785,187 @@ function updateStateFromBridge(data) {
  }
 }

-// ========== Server Startup Info ==========
-// WebSocket management is handled by createWebSocketManager() (initialized above).
-// Bridge: /ws/bridge | Client: /ws | Keepalive: 25s ping/pong (platform default)
+// ========== WebSocket Server ==========
+
+const wss = new WebSocketServer({ noServer: true, maxPayload: 1 * 1024 * 1024 /* 1 MB */ });

 console.log(`🚀 Inventory Manager Web Server starting...`);
-console.log(`📡 HTTP Server: http://localhost:${port}`);
-console.log(`🔌 WebSocket Server: ws://localhost:${port}/ws`);
+console.log(`📡 HTTP Server: http://localhost:${PORT}`);
+console.log(`🔌 WebSocket Server: ws://localhost:${PORT}/ws`);
 if (API_KEY) {
  console.log('🔒 API key authentication enabled');
 } else {
  console.log('⚠️  No API_KEY set \u2014 authentication disabled (open access)');
 }

+// Authenticate WebSocket upgrades
+server.on('upgrade', (req, socket, head) => {
+  if (API_KEY) {
+    // Extract key from query string: /ws?key=... or /ws/bridge?key=...
+    const urlObj = new URL(req.url, `http://${req.headers.host}`);
+    const token = urlObj.searchParams.get('key') || '';
+    if (token !== API_KEY) {
+      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+  }
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    wss.emit('connection', ws, req);
+  });
+});
+
+wss.on('connection', (ws, req) => {
+  const url = req.url || '';
+  
+  // ---- Bridge WebSocket connection ----
+  if (url.startsWith('/ws/bridge')) {
+    console.log('🌉 CC:Tweaked bridge connected via WebSocket');
+    bridgeClients.add(ws);
+    ws.isAlive = true;
+
+    // Notify web clients that the bridge is now connected
+    broadcastToClients({
+      type: 'state_update',
+      bridgeConnected: true,
+    });
+    
+    ws.on('message', (raw) => {
+      try {
+        const data = JSON.parse(raw);
+        
+        if (data.type === 'ping') {
+          ws.send(JSON.stringify({ type: 'pong' }));
+          return;
+        }
+        
+        if (data.type === 'state') {
+          // Full state update from bridge
+          updateStateFromBridge(data);
+        } else if (data.type === 'command_result') {
+          // Command result from bridge — include commandId
+          broadcastToClients({
+            type: 'command_result',
+            commandId: data.commandId,
+            action: data.action,
+            success: data.success,
+            message: data.message,
+            error: data.error,
+          });
+        }
+      } catch (error) {
+        console.error('❌ Bridge WS message error:', error.message);
+      }
+    });
+    
+    ws.on('close', () => {
+      console.log('🌉 CC:Tweaked bridge disconnected');
+      bridgeClients.delete(ws);
+
+      // Notify web clients that the bridge may be disconnected
+      broadcastToClients({
+        type: 'state_update',
+        bridgeConnected: bridgeClients.size > 0,
+      });
+    });
+
+    ws.on('pong', () => { ws.isAlive = true; });
+    
+    ws.on('error', (error) => {
+      console.error('❌ Bridge WS error:', error);
+      bridgeClients.delete(ws);
+
+      broadcastToClients({
+        type: 'state_update',
+        bridgeConnected: bridgeClients.size > 0,
+      });
+    });
+    
+    return;
+  }
+  
+  // ---- Web client WebSocket connection ----
+  console.log('🌐 New web client connected');
+  webClients.add(ws);
+  ws.isAlive = true;
+  
+  // Send current state to new client
+  ws.send(JSON.stringify({
+    type: 'initial_state',
+    inventory: inventoryState,
+    activity: activityState,
+    alerts: alertsState,
+    smeltingPaused,
+    disabledRecipes,
+    smeltable: smeltableRecipes,
+    craftable: craftableRecipes,
+    craftTurtleOk,
+    lastUpdate,
+    bridgeConnected: bridgeClients.size > 0,
+    dropperNicknames,
+  }));
+  
+  ws.on('pong', () => { ws.isAlive = true; });
+  
+  ws.on('message', (message) => {
+    try {
+      const data = JSON.parse(message);
+      
+      if (data.type === 'command') {
+        // Idempotency check for WS commands
+        const cached = checkIdempotent(data.commandId);
+        if (cached) {
+          ws.send(JSON.stringify({ type: 'command_result', commandId: data.commandId, ...cached }));
+          return;
+        }
+        // Forward command to bridge
+        pushCommandToBridge(data);
+        if (data.commandId) {
+          recordCommand(data.commandId, { success: true, commandId: data.commandId });
+        }
+      }
+    } catch (error) {
+      console.error('❌ Error processing web client message:', error);
+    }
+  });
+  
+  ws.on('close', () => {
+    console.log('👋 Web client disconnected');
+    webClients.delete(ws);
+  });
+  
+  ws.on('error', (error) => {
+    console.error('❌ WebSocket error:', error);
+  });
+});
+
+// ========== WebSocket Keep-Alive ==========
+// Ping all web clients and bridge connections every 25s to keep connections alive
+const WS_PING_INTERVAL = setInterval(() => {
+  webClients.forEach((ws) => {
+    if (!ws.isAlive) {
+      webClients.delete(ws);
+      return ws.terminate();
+    }
+    ws.isAlive = false;
+    ws.ping();
+  });
+  bridgeClients.forEach((ws) => {
+    if (!ws.isAlive) {
+      console.log('🌉 Bridge connection stale — terminating');
+      bridgeClients.delete(ws);
+      broadcastToClients({ type: 'state_update', bridgeConnected: bridgeClients.size > 0 });
+      return ws.terminate();
+    }
+    ws.isAlive = false;
+    ws.ping();
+  });
+}, 25000);
+
+wss.on('close', () => {
+  clearInterval(WS_PING_INTERVAL);
+});
+
 // ========== Cross-Project Integration API ==========
 // These endpoints allow the RemoteTurtle system to query inventory state

@@ -1254,24 +1025,53 @@ app.get('/api/integration/low-stock', (req, res) => {
 });

 // Proxy to turtle server for combined dashboard info
-createProxyEndpoint(app, '/api/integration/turtle-status', 'TURTLE_SERVER_URL', '/api/turtles');
+app.get('/api/integration/turtle-status', async (req, res) => {
+  if (!TURTLE_SERVER_URL) {
+    return res.json({ configured: false, message: 'TURTLE_SERVER_URL not configured' });
+  }
+  try {
+    const resp = await fetch(`${TURTLE_SERVER_URL}/api/turtles`);
+    const data = await resp.json();
+    res.json({ configured: true, ...data });
+  } catch (err) {
+    res.status(502).json({ configured: true, error: `Cannot reach turtle server: ${err.message}` });
+  }
+});

 // ========== Start Server ==========

-setupGracefulShutdown({
-  serviceName: 'inventory-manager',
-  cleanup: [
-    () => wsManager.close(),
-    () => server.close(),
-    () => { closeDb(); console.log('💾 Database closed'); },
-  ],
-});
-
-start(() => {
-  console.log(`\nBridge HTTP endpoint: http://localhost:${port}/api/bridge/state`);
-  console.log(`Bridge WebSocket: ws://localhost:${port}/ws/bridge`);
-  console.log(`Web client WebSocket: ws://localhost:${port}/ws`);
+server.listen(PORT, HOST, () => {
+  console.log(`✅ Inventory Manager Web Server ready on ${HOST}:${PORT}`);
+  console.log(`\nBridge HTTP endpoint: http://localhost:${PORT}/api/bridge/state`);
+  console.log(`Bridge WebSocket: ws://localhost:${PORT}/ws/bridge`);
+  console.log(`Web client WebSocket: ws://localhost:${PORT}/ws`);
  if (TURTLE_SERVER_URL) {
    console.log(`🐢 Turtle server integration: ${TURTLE_SERVER_URL}`);
  }
 });
+
+// Graceful shutdown
+function shutdown() {
+  console.log('\n🛑 Shutting down server...');
+  try {
+    wss.close();
+    server.close();
+    closeDb();
+    console.log('💾 Database closed');
+  } catch (err) {
+    console.error('❌ Error during shutdown:', err.message);
+  }
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+// Catch unhandled errors to prevent silent crashes
+process.on('unhandledRejection', (reason) => {
+  console.error('❌ Unhandled rejection:', reason);
+});
+process.on('uncaughtException', (err) => {
+  console.error('❌ Uncaught exception:', err);
+  shutdown();
+});
Author	SHA1	Message	Date
MayaTheShy	9835556e6f	diag: add verbose network listener logging to trace command delivery Manager logs: listener start, every modem_message received, channel match/mismatch, command acceptance count, handler result. Client logs: every sendToMaster call with type and commandId.	2026-03-29 16:39:29 -04:00
MayaTheShy	033da0933c	fix: point package repository to stable branch	2026-03-29 16:22:25 -04:00