-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

--[[
    Cul De Sac RPG — Aura Suite  (Rayfield Gen2)

    Combat   : one-shots every monster in range (money + Fighting XP)
    Chop     : zeroes Hearts on trees (wood + Chopping XP)
    Mine     : zeroes Hearts on ore  (ore + Mining XP)
    Forage   : dissolves plants      (items + Foraging XP)
    Catch    : fires the critter catch batch (Catching XP)
    Fishing  : asks the server for a fishing session, then reports every
               fish in that table as caught. Pays fish + Fishing XP from
               anywhere on the map, no rod, no water, no minigame.

    The character is NEVER moved. Every proven payout here breaks the
    moment the server thinks the player teleported, so this script only
    reads positions and never writes CFrame.
]]

-- stop a previous copy of this script's loops (live-reload does the rest)
if type(getgenv) == "function" and type(getgenv().CDS_AURA) == "table" then
    pcall(function() getgenv().CDS_AURA.stop() end)
end

local Players = game:GetService("Players")
local RS = game:GetService("ReplicatedStorage")
local lp = Players.LocalPlayer

-- drop the interface a previous run of this script left behind
if getgenv().CDS_GUI then
    pcall(function() getgenv().CDS_GUI:Destroy() end)
    getgenv().CDS_GUI = nil
end

local containers = {}
local function addContainer(c)
    if c then containers[#containers + 1] = c end
end
pcall(function() addContainer(game:GetService("CoreGui")) end)
pcall(function() addContainer(gethui()) end)
addContainer(lp:FindFirstChild("PlayerGui"))

for _, container in ipairs(containers) do
    for _, gui in ipairs(container:GetChildren()) do
        if gui:IsA("ScreenGui") then
            local n = gui.Name:lower()
            if n:find("rayfield") or n:find("sirius") then
                pcall(function() gui:Destroy() end)
            end
        end
    end
end

local okLoad, Rayfield = pcall(function()
    return loadstring(game:HttpGet("https://sirius.menu/gen2"))()
end)
if not okLoad or not Rayfield then
    warn("[CulDeSac] Rayfield failed to load: " .. tostring(Rayfield))
    return
end

-- game modules (loaded defensively: the script may run mid-teleport)
local Modules = RS:WaitForChild("Modules", 30)
local Combat, PhysicalEffects
if Modules then
    local cm = Modules:FindFirstChild("Combat")
    if cm then pcall(function() Combat = require(cm) end) end
    local pm = Modules:FindFirstChild("PhysicalEffects")
    if pm then pcall(function() PhysicalEffects = require(pm) end) end
end

local EReplication
do
    local ok, ev = pcall(function()
        return RS.ClientToServer.DataEvents.EReplication
    end)
    if ok then EReplication = ev end
end

-- fishing / economy remotes
local GenerateFishing, SellItem, LoadItemData
do
    local ok, v = pcall(function()
        return RS.LocalReplicated.FishingHandlerReplicated.GenerateFishing
    end)
    if ok then GenerateFishing = v end

    local ok2, v2 = pcall(function()
        return RS.LocalReplicated.Items.SellItem
    end)
    if ok2 then SellItem = v2 end

    local m = Modules and Modules:FindFirstChild("LoadItemData")
    if m then pcall(function() LoadItemData = require(m) end) end
end

if not Combat then warn("[CulDeSac] Combat module missing — the kill aura will idle.") end
if not EReplication then warn("[CulDeSac] EReplication missing — catching will idle.") end
if not GenerateFishing then warn("[CulDeSac] GenerateFishing missing — auto fishing will idle.") end
if not SellItem then warn("[CulDeSac] SellItem missing — auto sell will idle.") end

--------------------------------------------------------------------------------
-- state
--------------------------------------------------------------------------------

local cfg = {
    combat = { on = false, radius = 200, damage = 100000, speed = 6 },
    chop   = { on = false, radius = 300, speed = 5 },
    mine   = { on = false, radius = 300, speed = 5 },
    forage = { on = false, radius = 300, speed = 2 },
    catch  = { on = false, radius = 250, speed = 2 },
    fish   = { on = false, table = "CrystalCave", delay = 1.2, gap = 0.15, sell = false, sellEvery = 8 },
}

local stats = { kills = 0, chops = 0, mines = 0, forages = 0, catches = 0, cycles = 0, sold = 0 }
local hitAt = setmetatable({}, { __mode = "k" })     -- per-instance cooldown
local pendingForage = setmetatable({}, { __mode = "k" })
local running = true

--------------------------------------------------------------------------------
-- helpers
--------------------------------------------------------------------------------

local function getRoot()
    local ch = lp.Character
    if not ch then return nil end
    local hum = ch:FindFirstChildOfClass("Humanoid")
    if hum and hum.Health <= 0 then return nil end
    local hrp = ch:FindFirstChild("HumanoidRootPart")
    if hrp and hrp:IsA("BasePart") then return hrp end
    return nil
end

local function partOf(v)
    if v:IsA("BasePart") then return v end
    local p = v.PrimaryPart
    if p and p:IsA("BasePart") then return p end
    p = v:FindFirstChild("HumanoidRootPart")
    if p and p:IsA("BasePart") then return p end
    if v:IsA("Model") then return v:FindFirstChildWhichIsA("BasePart") end
    return nil
end

-- children of a container (plus one level of sub-folders), filtered by an
-- attribute and sorted nearest-first
local function scan(container, attr, radius)
    local root = getRoot()
    local out = {}
    if not root or not container then return out end

    local function consider(v)
        if v:GetAttribute(attr) == true then
            local p = partOf(v)
            if p then
                local d = (p.Position - root.Position).Magnitude
                if d <= radius then
                    out[#out + 1] = { obj = v, d = d, part = p }
                end
            end
        end
    end

    for _, v in ipairs(container:GetChildren()) do
        if v:IsA("Folder") then
            for _, c in ipairs(v:GetChildren()) do consider(c) end
        else
            consider(v)
        end
    end
    table.sort(out, function(a, b) return a.d < b.d end)
    return out
end

local function anyContainer(names)
    local list = {}
    for _, n in ipairs(names) do
        local v = workspace:FindFirstChild(n)
        if v then list[#list + 1] = v end
    end
    return list
end

--------------------------------------------------------------------------------
-- modes
--------------------------------------------------------------------------------

local function tickCombat(budget, now)
    if not Combat then return end
    local list = scan(workspace:FindFirstChild("EntityHandler"), "Entity", cfg.combat.radius)
    local acted = 0
    for _, e in ipairs(list) do
        if acted >= budget then break end
        local o = e.obj
        if o:GetAttribute("Critter") ~= true and o:GetAttribute("Death") ~= true then
            local last = hitAt[o]
            if not last or now - last > 0.6 then
                hitAt[o] = now
                local ok = pcall(function()
                    Combat:AttackMain(lp, o, { Damage = cfg.combat.damage, ItemName = "OldSword" }, nil)
                end)
                if ok then
                    acted = acted + 1
                    stats.kills = stats.kills + 1
                end
            end
        end
    end
end

local function tickHarvest(attr, containerNames, radius, budget, now, counter)
    local acted = 0
    for _, cname in ipairs(containerNames) do
        if acted >= budget then return end
        for _, e in ipairs(scan(workspace:FindFirstChild(cname), attr, radius)) do
            if acted >= budget then return end
            local o = e.obj
            local hearts = o:GetAttribute("Hearts")
            local last = hitAt[o]
            if o:GetAttribute("Death") ~= true
                and type(hearts) == "number"
                and hearts > 0
                and (not last or now - last > 1) then
                hitAt[o] = now
                if pcall(function() o:SetAttribute("Hearts", 0) end) then
                    acted = acted + 1
                    stats[counter] = stats[counter] + 1
                end
            end
        end
    end
end

local function tickForage(budget, now)
    if not PhysicalEffects then return end
    local list = scan(workspace:FindFirstChild("Collectables"), "Foragable", cfg.forage.radius)
    local acted = 0
    for _, e in ipairs(list) do
        if acted >= budget then break end
        local o = e.obj
        if o:GetAttribute("Used") == nil
            and o:GetAttribute("Death") ~= true
            and not pendingForage[o] then
            local tag = o:GetAttribute("Tag")
            local part = e.part
            if tag and part then
                pendingForage[o] = true
                task.spawn(function()
                    pcall(function()
                        -- dot call: the function takes the player as its first argument
                        PhysicalEffects.DissolveForagableItem(lp, o, tag, nil, part, nil)
                    end)
                    pendingForage[o] = nil
                end)
                acted = acted + 1
                stats.forages = stats.forages + 1
            end
        end
    end
end

local function tickCatch(budget, now)
    if not EReplication then return end
    local list = scan(workspace:FindFirstChild("EntityHandler"), "Critter", cfg.catch.radius)
    local acted = 0
    for _, e in ipairs(list) do
        if acted >= budget then break end
        local o = e.obj
        local hrp = o:FindFirstChild("HumanoidRootPart")
        if hrp and o:GetAttribute("Death") ~= true then
            local last = hitAt[o]
            if not last or now - last > 3 then
                hitAt[o] = now
                local payload = { {
                    "Entity",
                    o.Name,
                    hrp.Position,
                    o.Parent,
                    o:GetAttribute("Tag"),
                    nil,
                    o:GetAttribute("Shiny") == true,
                    nil,
                } }
                if pcall(function() EReplication:FireServer("Batch", payload) end) then
                    acted = acted + 1
                    stats.catches = stats.catches + 1
                end
            end
        end
    end
end

local function tickMode(mode, budget, now)
    local c = cfg[mode]
    if mode == "combat" then
        tickCombat(budget, now)
    elseif mode == "chop" then
        tickHarvest("Choppable", { "Collectables", "EventParts" }, c.radius, budget, now, "chops")
    elseif mode == "mine" then
        tickHarvest("Minable", { "MineHandler", "EventParts" }, c.radius, budget, now, "mines")
    elseif mode == "forage" then
        tickForage(budget, now)
    elseif mode == "catch" then
        tickCatch(budget, now)
    end
end

-------------------------------------------------------------------------------
-- fishing + selling
-------------------------------------------------------------------------------

-- Verified live from ReplicatedStorage.Modules.LoadItemData:GetRandomFish.
-- The list is topped up at runtime anyway, so a game update cannot leave us
-- firing a stale set of names.
local FISH_TABLES = {
    CrystalCave = { "GemstoneNarwhal", "Glowmaw", "RuneSquid" },
    RainbowGrove = { "RainbowTuna", "PeanutButterCrab" },
    FairyPond = {
        "Starfish", "Plumplet", "Glimmer", "Shimmerfin",
        "FlutterFish", "SolarSchool", "FairyDolphin",
    },
    IceLake = {
        "Shimmerfin", "IcyEel", "FrostbiteBarracuda", "GleeGill",
        "StoneFish", "SnowSpottedChar", "GlacierShark",
    },
    Beach = {
        "Bass", "Shrubfin", "Piranha", "CherrySalmon", "CiderTrout",
        "DandelionDart", "GleeGill", "MossCarp", "SunFish", "Leech",
        "Glimmer", "Splashtail", "Glassyray", "LilacSnapper",
        "SolarSchool", "IcyEel", "FrostbiteBarracuda", "StoneFish",
    },
    Mountain = { "GlitchFish", "ELGGOB", "ToxicFish", "NuclearBass", "LotusSerpent" },
    CaveLake = {
        "Bass", "CherrySalmon", "CiderTrout", "Crawfish", "DandelionDart",
        "Fluke", "FlutterFish", "FrostbiteBarracuda", "GleeGill", "Glimmer",
        "Guppy", "IcyEel", "Leech", "LilacSnapper", "MossCarp", "Petalfin",
        "Shrubfin", "SkeletonCatFish", "SolarSchool", "Splashtail",
        "StoneFish", "Tadpole",
    },
    CityLake = { "Bass", "Crawfish", "GleeGill", "Guppy", "Leech", "MoltenBoxfish", "StoneFish", "SunkenShark", "Tadpole" },
    River = { "Guppy", "Crawfish", "Bass", "StoneFish", "Tadpole" },
}

local FISH_ORDER = {
    "CrystalCave", "RainbowGrove", "FairyPond", "IceLake",
    "Beach", "Mountain", "CaveLake", "CityLake", "River",
}

local LOOT = {
    "Wood", "Stone", "Coal", "IronOre", "GoldOre", "CrystalOre",
    "FirestoneOre", "WaterstoneOre", "RubyOre", "FrostOre", "DryOre",
    "Fur", "String", "Ichor", "EvilFang", "RockScale", "RockFang",
}

local fishLists = {}
local function fishList(tbl)
    local cached = fishLists[tbl]
    if cached then return cached end

    local seen, list = {}, {}
    for _, n in ipairs(FISH_TABLES[tbl] or {}) do
        seen[n] = true
        list[#list + 1] = n
    end

    if LoadItemData then
        for _, rarity in ipairs({
            "Common", "Uncommon", "Unique", "Rare",
            "Mythic", "Legendary", "Divine", "Fabled",
        }) do
            for _ = 1, 8 do
                local ok, n = pcall(function()
                    return LoadItemData:GetRandomFish("Summer", rarity, tbl)
                end)
                if ok and type(n) == "string" and not seen[n] then
                    seen[n] = true
                    list[#list + 1] = n
                end
            end
        end
    end

    fishLists[tbl] = list
    return list
end

local function sellName(name)
    if not SellItem or type(name) ~= "string" then return end
    pcall(function() SellItem:FireServer(name, 999999, "Fawn") end)
    stats.sold = stats.sold + 1
end

local function sellFish()
    local seen = {}
    for _, tbl in ipairs(FISH_ORDER) do
        for _, n in ipairs(fishList(tbl)) do
            if not seen[n] then
                seen[n] = true
                sellName(n)
                task.wait(0.04)
            end
        end
    end
end

local function sellLoot()
    for _, n in ipairs(LOOT) do
        sellName(n)
        task.wait(0.04)
    end
end

local fishToken = 0
local function fishLoop()
    local token = fishToken
    while running and cfg.fish.on and token == fishToken do
        local tbl = cfg.fish.table
        if GenerateFishing and EReplication then
            pcall(function() GenerateFishing:FireServer(tbl) end)
            task.wait(math.max(cfg.fish.delay, 0.4))

            for _, n in ipairs(fishList(tbl)) do
                if not (running and cfg.fish.on and token == fishToken) then break end
                pcall(function() EReplication:FireServer("Fishing", n, tbl, nil, nil, nil) end)
                task.wait(cfg.fish.gap)
            end
            stats.cycles = stats.cycles + 1
        end
        task.wait(0.4)
    end
end

--------------------------------------------------------------------------------
-- interface
--------------------------------------------------------------------------------

-- remember what was already in gethui so we can spot the GUI Rayfield builds
local preExisting = {}
pcall(function()
    local h = gethui()
    if h then
        for _, v in ipairs(h:GetChildren()) do preExisting[v] = true end
    end
end)

local window = Rayfield:CreateWindow({
    name = "Cul De Sac",
    subtitle = "Aura Suite",
    configuration = {
        autoSave = true,
        autoLoad = false,
        fileName = "CulDeSacAura",
    },
    sidebarLayout = true,
})

-- track that ScreenGui so the next reload replaces it instead of stacking
pcall(function()
    local h = gethui()
    if h then
        for _, v in ipairs(h:GetChildren()) do
            if v:IsA("ScreenGui") and not preExisting[v] then
                getgenv().CDS_GUI = v
            end
        end
    end
end)

local combatTab = window:CreateTab({ name = "Combat" })
local skillsTab = window:CreateTab({ name = "Skills" })
local fishingTab = window:CreateTab({ name = "Fishing" })
local settingsTab = window:CreateTab({ name = "Settings" })

-- Combat -----------------------------------------------------------------------
local statusText = combatTab:CreateText({ name = "Live stats", text = "Starting…" })
combatTab:CreateDivider()

local auraToggle
auraToggle = combatTab:CreateToggle({
    name = "Kill aura",
    description = "One-shots every monster in range. Money + Fighting XP.",
    value = false,
    flag = "CombatAura",
    callback = function(v)
        cfg.combat.on = v
        if v then window:Notify({ title = "Kill aura", content = "On — clearing monsters in " .. cfg.combat.radius .. " studs." }) end
    end,
})
local radiusSlider = combatTab:CreateSlider({
    name = "Aura radius",
    range = { 20, 600 },
    increment = 10,
    value = 200,
    suffix = " studs",
    flag = "CombatRadius",
    callback = function(v) cfg.combat.radius = v end,
})
local damageSlider = combatTab:CreateSlider({
    name = "Damage",
    range = { 1000, 100000 },
    increment = 1000,
    value = 100000,
    flag = "CombatDamage",
    callback = function(v) cfg.combat.damage = v end,
})
local combatSpeedSlider = combatTab:CreateSlider({
    name = "Hits per second",
    range = { 1, 20 },
    increment = 1,
    value = 6,
    flag = "CombatSpeed",
    callback = function(v) cfg.combat.speed = v end,
})
combatTab:CreateKeybind({
    name = "Toggle aura",
    value = Enum.KeyCode.Z,
    callback = function()
        auraToggle:Set(not cfg.combat.on)
    end,
})

-- Skills -----------------------------------------------------------------------
skillsTab:CreateText({
    name = "Harvesting",
    text = "Same trick as the aura: the client owns the Hearts attribute and the reward packet, so the server pays for every node cleared in range.",
})

local chopToggle, mineToggle, forageToggle, catchToggle
chopToggle = skillsTab:CreateToggle({
    name = "Chop trees",
    description = "Wood + Chopping XP.",
    value = false,
    flag = "ChopOn",
    callback = function(v) cfg.chop.on = v end,
})
mineToggle = skillsTab:CreateToggle({
    name = "Mine ore",
    description = "Ore + Mining XP.",
    value = false,
    flag = "MineOn",
    callback = function(v) cfg.mine.on = v end,
})
forageToggle = skillsTab:CreateToggle({
    name = "Forage plants",
    description = "Items + Foraging XP.",
    value = false,
    flag = "ForageOn",
    callback = function(v) cfg.forage.on = v end,
})
catchToggle = skillsTab:CreateToggle({
    name = "Catch critters",
    description = "Catching XP. Re-catches the same critter every few seconds.",
    value = false,
    flag = "CatchOn",
    callback = function(v) cfg.catch.on = v end,
})
local skillRadiusSlider = skillsTab:CreateSlider({
    name = "Skill radius",
    range = { 50, 800 },
    increment = 10,
    value = 300,
    suffix = " studs",
    flag = "SkillRadius",
    callback = function(v)
        for _, m in ipairs({ "chop", "mine", "forage", "catch" }) do cfg[m].radius = v end
    end,
})
local skillSpeedSlider = skillsTab:CreateSlider({
    name = "Actions per second",
    range = { 1, 12 },
    increment = 1,
    value = 4,
    flag = "SkillSpeed",
    callback = function(v)
        for _, m in ipairs({ "chop", "mine", "forage", "catch" }) do cfg[m].speed = v end
    end,
})

-- Fishing ----------------------------------------------------------------------
local fishStatus = fishingTab:CreateText({ name = "Live stats", text = "Idle." })
fishingTab:CreateText({
    name = "How this pays",
    text = "The server opens a fishing session the moment the client asks for one, then trusts the client's catch report. Ask, wait ~1s, report every fish in that table: no rod, no cast, no minigame. Crystal Cave pays best (Gemstone Narwhal is the 400k-XP fish and the table only has three). If catches ever stop paying, stand near any water and try again — every test that failed did so away from a bank.",
})
fishingTab:CreateDivider()

local fishToggle
fishToggle = fishingTab:CreateToggle({
    name = "Auto fish",
    description = "Fish + Fishing XP forever. Levels hand out money on their own.",
    value = false,
    flag = "FishOn",
    callback = function(v)
        cfg.fish.on = v
        fishToken = fishToken + 1
        if v then
            if not GenerateFishing or not EReplication then
                cfg.fish.on = false
                window:Notify({ title = "Auto fish", content = "Fishing remotes not found — rejoin and reload." })
                return
            end
            window:Notify({ title = "Auto fish", content = "On — casting on " .. cfg.fish.table .. "." })
            task.spawn(fishLoop)
        end
    end,
})
fishingTab:CreateDropdown({
    name = "Fishing spot",
    options = FISH_ORDER,
    value = "CrystalCave",
    flag = "FishSpot",
    callback = function(v)
        if type(v) == "table" then v = v[1] end
        if type(v) == "string" and v ~= "" then cfg.fish.table = v end
    end,
})
fishingTab:CreateSlider({
    name = "Cast delay",
    description = "Time between asking for a session and reporting the catch.",
    range = { 0.5, 2.5 },
    increment = 0.1,
    value = 1.2,
    suffix = " s",
    flag = "FishDelay",
    callback = function(v) cfg.fish.delay = v end,
})
fishingTab:CreateDivider()
local fishSellToggle
fishSellToggle = fishingTab:CreateToggle({
    name = "Auto-sell fish",
    description = "Sells every fish in the bag so the money keeps climbing.",
    value = false,
    flag = "FishSell",
    callback = function(v)
        cfg.fish.sell = v
        if v and not SellItem then
            cfg.fish.sell = false
            window:Notify({ title = "Auto-sell", content = "SellItem not found — rejoin and reload." })
        end
    end,
})
fishingTab:CreateSlider({
    name = "Auto-sell every",
    range = { 3, 30 },
    increment = 1,
    value = 8,
    suffix = " s",
    flag = "FishSellEvery",
    callback = function(v) cfg.fish.sellEvery = v end,
})
fishingTab:CreateButton({
    name = "Sell all fish now",
    callback = function()
        task.spawn(function()
            sellFish()
            window:Notify({ title = "Sold", content = "Every fish in the bag, at full price." })
        end)
    end,
})
fishingTab:CreateButton({
    name = "Sell all ore / wood / drops",
    callback = function()
        task.spawn(function()
            sellLoot()
            window:Notify({ title = "Sold", content = "Raw materials sold." })
        end)
    end,
})

-- Settings ---------------------------------------------------------------------
settingsTab:CreateText({
    name = "The one rule",
    text = "Never teleport. Kills made after a CFrame teleport are silently ignored by the server; everything here works from wherever you actually stand. Walk or use the game's own portals.",
})

local function stopAll(announce)
    for _, h in ipairs({ auraToggle, chopToggle, mineToggle, forageToggle, catchToggle, fishToggle, fishSellToggle }) do
        pcall(function() h:Set(false) end)
    end
    if announce then
        window:Notify({ title = "Stopped", content = "All modes off." })
    end
end

settingsTab:CreateButton({
    name = "Stop everything",
    callback = function() stopAll(true) end,
})
settingsTab:CreateKeybind({
    name = "Panic — stop all",
    value = Enum.KeyCode.End,
    callback = function() stopAll(true) end,
})
settingsTab:CreateDivider()
settingsTab:CreateText({
    name = "Session",
    text = "Reload this script with the same live-reload label to replace it cleanly. Closing the window does not stop the loops.",
})

-- saving can restore element values without firing their callbacks, so make
-- the runtime state agree with whatever the interface is actually showing
do
    local function num(handle, fallback)
        local ok, v = pcall(function() return handle.value end)
        if ok and type(v) == "number" then return v end
        return fallback
    end
    local function bool(handle)
        local ok, v = pcall(function() return handle.value end)
        return (ok and v) and true or false
    end

    cfg.combat.on = bool(auraToggle)
    cfg.chop.on = bool(chopToggle)
    cfg.mine.on = bool(mineToggle)
    cfg.forage.on = bool(forageToggle)
    cfg.catch.on = bool(catchToggle)
    cfg.fish.on = bool(fishToggle)
    cfg.fish.sell = bool(fishSellToggle)

    if cfg.fish.on then
        fishToken = fishToken + 1
        task.spawn(fishLoop)
    end

    cfg.combat.radius = num(radiusSlider, cfg.combat.radius)
    cfg.combat.damage = num(damageSlider, cfg.combat.damage)
    cfg.combat.speed = num(combatSpeedSlider, cfg.combat.speed)

    local sr = num(skillRadiusSlider, 300)
    local ss = num(skillSpeedSlider, 4)
    for _, m in ipairs({ "chop", "mine", "forage", "catch" }) do
        cfg[m].radius = sr
        cfg[m].speed = ss
    end
end

--------------------------------------------------------------------------------
-- loops
--------------------------------------------------------------------------------

getgenv().CDS_AURA = {
    stop = function()
        running = false
        pcall(function() stopAll(false) end)
    end,
    cfg = cfg,
    stats = stats,
    -- same path the Fishing tab uses, for scripted runs
    fish = function(on)
        cfg.fish.on = on and true or false
        fishToken = fishToken + 1
        pcall(function() fishToggle:Set(cfg.fish.on) end)
        if cfg.fish.on then task.spawn(fishLoop) end
    end,
    sellFish = function() task.spawn(sellFish) end,
    sellLoot = function() task.spawn(sellLoot) end,
}

-- main ticker: 10 Hz, per-mode token bucket
task.spawn(function()
    local acc = { combat = 0, chop = 0, mine = 0, forage = 0, catch = 0 }
    local last = os.clock()
    while running do
        task.wait(0.1)
        if not running then break end
        local now = os.clock()
        local dt = math.min(now - last, 0.5)
        last = now

        if getRoot() then
            for _, mode in ipairs({ "combat", "chop", "mine", "forage", "catch" }) do
                local c = cfg[mode]
                if c.on then
                    acc[mode] = math.min(acc[mode] + dt * c.speed, 12)
                    local n = math.floor(acc[mode])
                    if n > 0 then
                        acc[mode] = acc[mode] - n
                        local ok, err = pcall(tickMode, mode, n, now)
                        if not ok then warn("[CulDeSac] " .. mode .. ": " .. tostring(err)) end
                    end
                else
                    acc[mode] = 0
                end
            end
        else
            for k in pairs(acc) do acc[k] = 0 end
        end
    end
end)

-- auto-sell watchdog (kept out of the fishing loop so a slow sell run cannot
-- stall the catches)
task.spawn(function()
    local lastSale = 0
    while running do
        task.wait(1)
        if not running then break end
        if cfg.fish.sell and SellItem and os.clock() - lastSale >= cfg.fish.sellEvery then
            lastSale = os.clock()
            local ok, err = pcall(sellFish)
            if not ok then warn("[CulDeSac] sell: " .. tostring(err)) end
        end
    end
end)

-- live stats
task.spawn(function()
    while running do
        task.wait(1)
        if not running then break end
        local function a(k) return tostring(lp:GetAttribute(k) or 0) end
        local ok = pcall(function()
            statusText:Set(string.format(
                "Money %s     Fight Lv %s (%s xp)\nChop Lv %s (%s xp)     Mine Lv %s (%s xp)\nForage Lv %s (%s xp)     Catch Lv %s (%s xp)\nFish Lv %s (%s xp)\n\nKills %d  ·  Trees %d  ·  Ore %d  ·  Plants %d  ·  Critters %d",
                a("Money"),
                a("Fighting"), a("FightingExp"),
                a("Chopping"), a("ChoppingExp"),
                a("Mining"), a("MiningExp"),
                a("Foraging"), a("ForagingExp"),
                a("Catching"), a("CatchingExp"),
                a("Fishing"), a("FishingExp"),
                stats.kills, stats.chops, stats.mines, stats.forages, stats.catches
            ))
        end)
        if not ok then break end

        pcall(function()
            fishStatus:Set(string.format(
                "%s   ·   cycles %d\nMoney %s   ·   Fish Lv %s (%s xp)\nSells fired %d",
                cfg.fish.on and ("Fishing " .. cfg.fish.table .. "…") or "Idle.",
                stats.cycles,
                a("Money"),
                a("Fishing"), a("FishingExp"),
                stats.sold
            ))
        end)
    end
end)

window:Notify({
    title = "Aura Suite ready",
    content = "Z = kill aura · End = stop all · Fishing tab = money printer.",
})