Leash Workers v0.1.31

What is Leash Workers?

Leash Workers turns the ordinary Minecraft lead into a complete gameplay, automation, progression, captivity, and trading system.

Players can leash other players and configurable entity types, move them through a controlled pull system, attach every held leash to a fence pole, transfer control, liberate captives, persist sessions through restarts, and display leash connections through a viewer-aware PacketEvents layer.

Anchored Villagers can become autonomous workers. Assign Miner, Woodcutter, Farmer, Breeder, Progenitor, or Protector roles and let them work inside the chunk controlled by their pole. Resources and combat loot are routed into a persistent owner stash instead of being lost on the ground.

Leashed players use a separate universal tier system. They progress through work actions, climb seven configurable tiers, and can earn automatic liberation after completing the final tier.

Every major rule is configurable: consent, defeat thresholds, target filters, leash strength, maximum distance, hard recovery, anchors, captivity duration, escape chance, liberation, worker budgets, job behavior, stash summaries, trade permissions, Vault money, messages, menus, visuals, and Folia scheduling behavior.


Built for Gameplay, Automation, and Server Progression

• Create real capture gameplay — require consent, low health, permissions, or any combination before a player can be leashed.
• Build worker compounds — anchor Villagers to fence poles and convert each pole chunk into a controlled production area.
• Automate survival resources — mine blocks, fell and replant trees, harvest crops, breed animals, grow Villagers, and defend the chunk.
• Reward captive activity — leashed players progress through seven tiers by breaking blocks, breeding animals, and killing mobs.
• Trade complete assets — exchange item stacks, owned leashed entities, and optional Vault money through one confirmation-based trade interface.
• Protect performance — use per-chunk worker groups, scan budgets, action caps, target limits, cooldowns, and bounded recovery rules.
• Keep visuals consistent — render virtual leash connections and worker presentation through PacketEvents without an NMS dependency.
• Run on Folia correctly — route entity, region, global, and asynchronous work through ownership-aware scheduler backends.

Core Feature Overview

• Leash players and configurable entity categories.
• Hybrid native Bukkit and virtual PacketEvents leash backends.
• Viewer-specific packet leash rendering.
• Persistent holder, target, and anchor sessions.
• Fence-pole anchoring for every currently held leash.
• Consent request menu with timeout.
• Defeat-before-leash health thresholds.
• Permission, target-state, and holder-limit enforcement.
• Automatic captivity expiration.
• Configurable escape and liberation systems.
• Holder combat and targeting protection.
• Universal seven-tier progression for leashed players.
• Six automated Villager worker jobs.
• Chunk-scoped worker movement and targeting.
• Job-specific Villager professions and visual tools.
• Persistent owner stash with paginated inventory.
• Animal and Villager baby growth tracking.
• Player-to-player trading of items, leashed entities, and optional money.
• Persistent YAML storage for all important runtime systems.
• Configurable menus, materials, aliases, messages, filters, and safety budgets.
• Full reload lifecycle with listener, task, display, worker, and service reconciliation.

Hybrid Native and Virtual Leash Engine

Every leash session receives one backend when it is created. That backend remains stable for the life of the session instead of switching unpredictably while the target moves.

• Players use virtual packet leashes — player leash visuals and control are handled without depending on Bukkit's native LivingEntity leash API.
• Supported living entities may use native Bukkit leashes — normal server leash behavior is retained when the public Bukkit API and native event path support the target.
• Unsupported or non-native targets use the virtual backend — configurable targets can still participate when Bukkit cannot create a native leash.
• No mid-session backend mixing — each session has one effective backend and one reconciliation path.
• Native break handling — native leash breaks notify the owner without duplicating plugin lead-drop behavior.
• Virtual distance recovery — virtual sessions do not silently disappear when the target exceeds normal pull distance.
• Hard recovery teleport — extreme overshoot uses a configurable safe teleport offset and then republishes one virtual attachment.
• World and teleport follow — holder teleports can carry controlled targets while optionally preserving their relative offset.

Default virtual movement values are configurable, including pull start distance, hard-pull distance, hard recovery distance, horizontal strength, vertical strength, hard-pull multiplier, and maximum velocity.


Leash Players

Players are first-class leash targets, not simulated mobs.

• Leash players with a lead interaction or the /grab command.
• Prevent self-leashing by default.
• Optionally block creative or spectator targets.
• Protect selected players with leashworkers.bypass.target.
• Limit the number of active sessions controlled by one holder.
• Use configurable pull, hard-pull, velocity, and teleport-recovery rules.
• Persist offline player captivity sessions when the configured session remains valid.
• Restore session state and visual attachments after restart or reload.
• Prevent leashed players from controlling additional leashes.
• Prevent captives from attacking or targeting their holder.

The bundled default permits up to five active leashes per holder. Operators may bypass that limit with leashworkers.bypass.limit.


Consent and Defeat Rules

Leash Workers supports peaceful, competitive, and combat-based capture models.

• Consent mode — send the target a configurable inventory request with Accept and Reject buttons.
• Request timeout — pending requests expire automatically; the bundled default is 20 seconds.
• Consent bypass control — separately enable or disable permission-based consent bypass.
• Defeat mode — require configured target types to reach a maximum health threshold before capture.
• Per-entity thresholds — use one default value and optional overrides by target type.
• Bundled player threshold — players must be at or below 4 health by default when defeat mode applies.
• Defeat bypass control — separately enable or disable permission-based defeat bypass.
• Target-state rejection — deny capture when the target is currently in a configured invalid state.

Consent and defeat are independent gates. Server owners can use either system, both systems, or disable them for unrestricted gameplay.


Fence Anchors and Pole Control

Turn fences into persistent leash poles and worker origins.

• Attach every held session — right-click a configured fence to move all currently controlled leash sessions onto that pole.
• No sneak requirement — the bundled interaction does not require the holder to sneak.
• No single-target alphabetical selection — all eligible held sessions attach in one operation.
• Configurable anchor materials — legacy fences, Nether fences, and modern wood-family fences are included by default.
• Persistent anchor location — world and coordinates survive reloads and restarts.
• Anchor visual state — packet viewers receive the correct holder or knot representation.
• Reattach to player — interact with the controlled target to take the leash back from its pole when allowed.
• Break-to-liberate flow — breaking a managed anchor can release the attached target through the configured liberation behavior.
• Worker origin — an anchored Villager's pole determines the chunk in which its automated job operates.

The allowed anchor-material list is fully configurable and includes aliases for legacy and modern servers.


Captivity, Escape, and Liberation

Leashing can be temporary, earned, or manually broken depending on server design.

• Automatic captivity expiration — release a captive after a configurable duration; the bundled default is eight hours.
• Join reminder — returning captives can be told who controls them and how much time remains.
• Capture message — immediately explain the captivity objective after a player is leashed.
• Escape mechanic — optionally require sneaking, a configured item, a permission, a cooldown, and a success chance.
• Escape disabled by default — owners explicitly opt into random or guaranteed escape gameplay.
• Liberation mechanic — open a confirmation menu before freeing another controlled player.
• Self-liberation protection — prevent a player from bypassing their own captivity through the liberation system.
• Configurable liberation items — require or consume selected materials when desired.
• Command and interaction flows — liberate by command, by looking at a valid target, or through supported direct interactions.

Universal Player Tier Progression

Leashed players do not receive one narrow worker profession. They use a universal progression contract that rewards multiple forms of productive gameplay.

• Progress by breaking valid blocks.
• Progress by breeding animals.
• Progress by killing mobs.
• View current tier and progress through the job interface.
• Receive configurable tier-up feedback.
• Complete Tier VII to earn automatic liberation.
• Keep player progression separate from automated Villager job assignment.

Bundled tier requirements:

• Tier I — 32 actions.
• Tier II — 64 actions.
• Tier III — 96 actions.
• Tier IV — 128 actions.
• Tier V — 192 actions.
• Tier VI — 256 actions.
• Tier VII — 320 actions and liberation completion.

Every requirement is configurable in config.yml.


Automated Villager Worker System

Anchored Villagers can be assigned one of six automated jobs. The Villager must belong to the owner and be attached to a valid pole before worker automation begins.

• Miner — scans the pole chunk for configured natural and ore blocks, creates bounded work plans, moves toward valid targets, breaks them, and routes drops to the owner stash.
• Woodcutter — discovers connected trees, cuts configured log structures, handles leaves within the work plan, and replants a matching sapling when replanting is enabled.
• Farmer — indexes mature crops, harvests valid targets, replants compatible crops, and sends harvested items to the stash.
• Breeder — finds compatible nearby animals, applies breeding behavior, creates one managed animal baby per worker chunk, and accelerates its growth through worker progress.
• Progenitor — creates one managed Villager baby per worker chunk, publishes live growth progress, and assigns the configured adult job when growth completes.
• Protector — tracks nearby hostile entities, approaches targets, attacks with configurable damage and cooldown, and captures combat drops plus simulated experience rewards for the stash.

Worker jobs use shared movement, target validation, chunk ownership, scan budgets, action limits, blocked-target cooldowns, and safe-return behavior.


Miner Worker

• Scans configurable columns inside the assigned pole chunk.
• Supports legacy and modern stone, soil, sand, Nether, End, and ore aliases.
• Includes coal, iron, copper, gold, redstone, lapis, diamond, emerald, quartz, and ancient debris defaults where supported.
• Skips configured unbreakable, command, portal, structure, barrier, and moving-piston blocks.
• Can prevent unsafe digging above blocked-below materials such as lava.
• Can deny container blocks and preserve unsafe support blocks.
• Uses bounded plans and blocked-target cooldowns instead of repeatedly attacking impossible blocks.
• Routes actual block drops into the owner's persistent stash.

Woodcutter Worker

• Discovers nearby tree bases and connected log structures.
• Supports modern logs, wood, Nether stems, hyphae, and legacy LOG/LOG_2 aliases.
• Limits maximum log, leaf, inspection, and branch-probe work per tree.
• Breaks the discovered tree through a queued work plan.
• Replants after completion when replanting is enabled.
• Can require a sapling from the owner stash or allow configured free replant behavior.
• Returns unused saplings to the stash when placement cannot complete.
• Routes harvested drops into persistent owner storage.

Farmer Worker

• Indexes mature crops inside the assigned chunk.
• Uses incremental scanning and per-cycle budgets.
• Claims valid mature targets before another worker duplicates the action.
• Harvests through the shared block-break pipeline.
• Replants compatible crop material after harvesting.
• Supports legacy and modern crop aliases.
• Routes harvest drops to the stash.
• Applies blocked-target cooldowns when a crop cannot be processed safely.

Breeder Worker

• Searches for compatible adult animal pairs near the pole chunk.
• Uses configurable feeding range, pair distance, love-mode duration, scan interval, and pair budget.
• Creates one managed animal baby state per chunk.
• Tracks baby type, owner, creator worker, growth progress, and storage identity.
• Displays live Baby %type% progress when enabled.
• Accelerates growth according to the number of active Breeder workers and configured points per cycle.
• Persists managed animal babies in storage/animal-babies.yml.

Progenitor Worker

• Creates a managed Villager baby at a safe position near the pole.
• Maintains one managed Progenitor baby state per chunk.
• Automatically creates an anchored leash session for the new Villager baby.
• Displays Baby Villager progress above the growing Villager when enabled.
• Persists progress across reloads and restarts.
• Uses 1,800 required growth points in the bundled configuration.
• Assigns Miner as the bundled default adult job after growth completes.
• Allows the owner to inspect the baby through a dedicated status menu.

Protector Worker

• Maintains a per-chunk hostile target index.
• Detects targets inside a configurable range.
• Moves toward a preferred combat distance.
• Attacks inside the configured attack range.
• Uses configurable damage, cooldown, movement speed, retreat speed, sounds, and particles.
• Tracks kill credit for worker-caused combat.
• Captures hostile drops for the owner stash.
• Converts rewarded experience into configurable bottle-equivalent stash output.

Chunk-Scoped Work Zones

Each Villager worker belongs to the chunk containing its assigned pole.

• Chunk origin authority — scans, targets, paths, and work plans remain inside the assigned chunk.
• Boundary cancellation — targets outside the work chunk are rejected instead of creating uncontrolled cross-world movement.
• Soft return — workers outside the allowed margin move back toward a safe position.
• Hard return — workers that remain outside too long or exceed the configured distance are recovered safely.
• Safe-location search — configurable horizontal and vertical search budgets find a legal return point.
• Chunk unload handling — active worker state is reconciled when the server unloads the owning chunk.
• Shared chunk budgets — workers cooperate through a grouped action and scanning budget instead of multiplying unrestricted work.

Bundled safety defaults include up to 64 workers per chunk, 16 actions per chunk per cycle, 512 scan blocks per chunk per cycle, two scan tasks per chunk per cycle, and 1,024 targets per plan. Every value is configurable.


Villager Professions and Worker Presentation

Assigned workers receive job-specific public Bukkit Villager professions and configurable visual equipment.

• Miner — Toolsmith with Armorer, Blacksmith, and Farmer fallbacks.
• Woodcutter — Fletcher with Toolsmith, Blacksmith, and Farmer fallbacks.
• Farmer — Farmer.
• Breeder — Shepherd with Farmer fallback.
• Progenitor — Cleric with Priest, Librarian, and Farmer fallbacks.
• Protector — Weaponsmith with Armorer, Blacksmith, and Farmer fallbacks.
• Unassigned — None with Nitwit and Farmer fallbacks.

The display layer can show a configurable job name and visual work tool. The bundled tools are an Iron Pickaxe, Iron Axe, Iron Hoe, Wheat, Villager Spawn Egg, and Iron Sword.

Cached display templates avoid rebuilding unchanged names and equipment on every worker cycle. Display publication occurs when state changes or when a viewer needs reconciliation.


Persistent Owner Stash

Worker resources are collected into a per-owner inventory instead of being scattered or lost.

• Persistent YAML file per owner under storage/stash/.
• Automatic collection from Miner, Woodcutter, Farmer, and Protector workflows.
• Material-aware stacking with configurable maximum stack size.
• Paginated stash inventory opened with /leashworkers stash [page].
• Join notification when new stored items are waiting.
• Periodic collection summary with configurable interval and maximum lines.
• Immediate and shutdown flush paths for queued state.
• Worker-name, amount, and material placeholders in feedback messages.

The bundled configuration uses normal 64-item stacks and a ten-minute collection-summary interval.


Player-to-Player Trading

Leash Workers includes a full trade session rather than a simple ownership command.

• Trade request — invite another online player with /leashworkers trade <player>.
• Shared trade inventory — both players view their side and the other side in one interface.
• Item offers — offer selected inventory stacks up to the configured limit.
• Leashed entity offers — select active owned leash sessions and transfer control after completion.
• Optional Vault money — enable economy offers when Vault and an economy provider are installed.
• Permission separation — independently allow trading, item offers, entity offers, and money offers.
• Offer revision safety — changing any offer resets both approvals.
• Two-stage agreement — both players approve the current offer and then confirm completion.
• Asset revalidation — the trade fails if an offered entity, item, or balance is no longer available.
• Ownership transfer — successful entity offers update the leash holder and optionally teleport the entity to its new owner.
• Timeout handling — request and active-session timeouts prevent abandoned trades from remaining open.
• Rollback path — failed money operations are reversed when possible during transaction recovery.

Vault money trading is optional and disabled in the bundled configuration. Item and entity trading remain available without Vault.


Inventory Menus

• Consent Menu — accept or reject a leash request.
• Liberation Menu — confirm releasing another controlled target.
• Job Target Menu — browse owned player and Villager leash sessions with pagination.
• Job Chooser — assign or unassign Villager worker roles.
• Player Tier View — inspect universal tier progress without exposing Villager-only assignment controls.
• Job Target Teleport — right-click an eligible worker entry to teleport when leashworkers.job.teleport is granted.
• Stash Menu — withdraw stored worker resources from paginated owner storage.
• Trade Menu — manage item, entity, and money offers plus approval state.
• Trade Entity Selector — choose exactly which owned leash sessions are offered.
• Progenitor Baby Menu — inspect managed Villager baby growth state.

Menu titles, slots, filler materials, icons, names, and lore are configurable with legacy material fallbacks.


Target Filters, Limits, and Safety Controls

• Whitelist or blacklist leashable entity types.
• Separate visual target filter for packet-rendered leash display.
• Case-normalized target categories and friendly display labels.
• Maximum active leashes per holder.
• Optional maximum session duration.
• Same-world policy for normal leash operation.
• Velocity caps for horizontal, vertical, total, and per-tick changes.
• Configurable packet view distance in chunks.
• Permission-enforcement master switch.
• Creative and spectator target rules.
• Lead consumption and return-on-release or break settings.
• Drop behavior when a holder is offline.
• Per-chunk worker, action, scan, task, target, callback, and recovery budgets.
• Rate-limited debug categories for display, physics, jobs, viewer tracking, and packet suppression.

Persistent Storage

Leash Workers uses readable YAML storage owned by the plugin.

• leashes.yml — active holder, target, backend, mode, and anchor sessions.
• storage/jobs.yml — player tier state and Villager job assignments.
• storage/stash/<uuid>.yml — persistent owner inventory contents.
• storage/progenitor-babies.yml — managed Villager baby growth state.
• storage/animal-babies.yml — managed animal baby growth state.
• config.yml — behavior, filters, jobs, safety, menus, visuals, stash, trade, escape, liberation, combat, and anchors.
• lang.yml — user-facing messages and command help.

Active leash sessions are loaded during startup and then reconciled with online entities, packet viewers, anchors, and the selected backend.


Commands

• /leashworkers help — show plugin help.
• /leashworkers status [player] — view personal or permitted target status.
• /leashworkers release [target|all] — release owned sessions or use administrative release access.
• /leashworkers grab <player> — leash a player by command.
• /leashworkers leash <player> — alias of the grab flow.
• /leashworkers liberate [player] — open the liberation flow.
• /leashworkers free [player] — alias of liberation.
• /leashworkers unleash [player] — alias of liberation.
• /leashworkers job [target] [unassign] — open a player tier view or manage an owned Villager worker.
• /leashworkers jobs [target] — job-management alias.
• /leashworkers list [target] — exact alias of the jobs route.
• /leashworkers stash [page] — open the owner stash.
• /leashworkers trade <player> — create a trade request and open the trade interface.
• /leashworkers escape — attempt the configured escape mechanic.
• /leashworkers reload — reload configuration and rebuild runtime services.
• /grab <player> — standalone player-grab command.
• /liberate [player] — standalone liberation command.
• /release [player] — standalone look-or-name liberation command.
• /leashjob [target] [unassign] — standalone job and tier interface.

Main-command aliases:


Additional aliases are included for the standalone grab, liberation, release, and job commands.


Permissions

• leashworkers.use — base plugin access when permission enforcement is enabled.
• leashworkers.leash.player — attempt to leash players.
• leashworkers.leash.entity — attempt to leash entities.
• leashworkers.anchor — attach active sessions to fence poles.
• leashworkers.status — view personal leash status.
• leashworkers.release — release owned active sessions.
• leashworkers.escape — use configured escape mechanics.
• leashworkers.liberate — liberate other leashed targets.
• leashworkers.grab — use grab command routes.
• leashworkers.job — view player tiers and manage owned Villager jobs.
• leashworkers.job.teleport — teleport to a worker from the jobs menu.
• leashworkers.stash — open the persistent owner stash.
• leashworkers.trade — start and participate in leash trades.
• leashworkers.items — offer inventory items in trades.
• leashworkers.entities — offer owned leashed entities in trades.
• leashworkers.money — offer Vault money in trades.
• leashworkers.consent.bypass — bypass consent when that bypass is enabled.
• leashworkers.defeat.bypass — bypass defeat requirements when that bypass is enabled.
• leashworkers.status.others — inspect another player's status.
• leashworkers.release.others — release sessions outside normal ownership restrictions.
• leashworkers.bypass.limit — ignore the maximum-holder limit.
• leashworkers.bypass.target — prevent the player from becoming a leash target.
• leashworkers.reload — reload the plugin.
• leashworkers.debug — access debug status output.
• leashworkers.admin — operator-default administrative permission root.

Public gameplay permissions default to true. Administrative and bypass permissions default to operators.


Configuration

The bundled config.yml separates the system into clear sections:

• settings.* — lead aliases, consumption, return behavior, target states, holder limit, duration, and tick period.
• permissions.* — global permission enforcement.
• persistence.* — leash-session storage.
• display.* — category and leash-mode labels.
• leash.* — pull distances, recovery teleport, strengths, velocity, same-world behavior, and entity filters.
• velocity-safety.* — horizontal, vertical, total, and delta caps.
• visual.* — packet display enablement, viewer distance, and target filter.
• debug.* — debug categories, trace options, and rate limiting.
• consent.* — request timeout and menu layout.
• defeat.* — target filter and health thresholds.
• captivity.* — automatic release and notifications.
• teleport-follow.* — holder teleport behavior and offset preservation.
• jobs.* — player tiers, worker jobs, movement, safety budgets, tools, names, descriptions, menus, babies, and combat.
• stash.* — persistence, stacking, summaries, notifications, and menu styling.
• trade.* — timeouts, item limits, entity transfer, Vault, and menu styling.
• escape.* — permission, sneak, item, cooldown, and chance requirements.
• liberation.* — permissions, items, consumption, self-release rules, and menu layout.
• combat.* — holder attack and targeting protection.
• anchor.* — fence materials and knot height.

All user-facing text is stored in lang.yml and supports the plugin's MiniMessage-style tags plus legacy ampersand color formatting.


Reload and Lifecycle Safety

• Merges missing bundled config defaults without requiring a full config reset.
• Reloads config.yml and lang.yml.
• Stops the previous Villager work runtime before rebuilding it.
• Flushes and reloads job, baby, and stash persistence services.
• Cancels active trades during reload.
• Unregisters and replaces event listeners.
• Rebuilds menus and trade interfaces.
• Invalidates cached worker display templates and publication stamps.
• Removes old display states and republishes current sessions.
• Reattaches active leash sessions after service reconstruction.
• Reconciles all online viewers after reload.
• Cancels plugin-owned tasks during shutdown.
• Unregisters PacketEvents and Bukkit listeners deterministically.

Folia and Threading Support

Leash Workers declares Folia support and selects its scheduler backend through runtime capability detection.

• Entity scheduler — player and Villager mutation, movement, inventory, messaging, damage, equipment, and teleport follow.
• Region scheduler — block, chunk, crop, tree, mining, spawning, and location-owned operations.
• Global scheduler — detached coordination, maps, lifecycle work, and global repeating control.
• Async scheduler — storage and non-Bukkit background operations where configured by the service.
• Classic Bukkit fallback — non-Folia servers use the Bukkit scheduler backend.
• Capability validation — partial Folia scheduler availability is rejected instead of silently selecting an unsafe mixed mode.
• Real teleport ownership — entity teleport operations stay associated with the entity-owned execution path.
• No raw thread creation — work remains owned by the plugin scheduler lifecycle.

Legacy and Modern Compatibility

• Java 8 bytecode target.
• Spigot/Paper-family support from 1.8.x through 1.21.x.
• Folia support for modern region-threaded servers.
• Legacy and modern lead aliases.
• Legacy and modern fence aliases.
• Legacy and modern menu glass aliases.
• Legacy and modern entity icons.
• Legacy and modern crop access bridges.
• Public Bukkit Villager profession mapping with fallback chains.
• Reflection isolated inside compatibility utilities and scheduler bridges.
• PacketEvents 2.13.0 for packet rendering and suppression.
• No mandatory Vault dependency.
• No direct NMS dependency.

Unsupported modern materials are resolved through configured fallback chains where the relevant menu, tool, crop, fence, or entity icon provides an alias.


Dependencies

Required:

• PacketEvents 2.13.0 — packet leash rendering, viewer synchronization, and packet-side display control.

Optional:

• Vault — enables money offers when a compatible Vault economy provider is installed and trade.vault.enabled is true.

Leashing, workers, stash, jobs, progression, anchors, item trading, and entity trading remain available without Vault.


Installation

1. Install PacketEvents 2.13.0 in the server's plugins folder.
2. Place Leash-Workers-0.1.31.jar in the plugins folder.
3. Start the server and allow plugins/LeashWorkers to be created.
4. Review config.yml and lang.yml.
5. Set your target filters, consent/defeat model, anchor materials, worker settings, and permissions.
6. Run /leashworkers reload after configuration changes.
7. Install Vault and an economy provider only when money trading is required.

Data folder:



Best Uses

• Survival SMP Servers — automate resource collection without adding command-only worker NPCs.
• Roleplay Servers — build captor, prisoner, worker, liberation, and trade stories with real persistent state.
• Factions and Kingdom Servers — capture opponents, establish worker compounds, and trade controlled assets.
• Prison Servers — use tier progression and earned liberation as a server-native objective.
• Economy Servers — collect worker output into owner storage and trade items, entities, and optional money.
• Automation Servers — use chunk-bounded Villager jobs instead of unrestricted global scanners.
• Legacy Networks — retain Java 8 and material fallbacks while exposing modern worker behavior where supported.
• Folia Servers — use entity and region ownership instead of unsafe universal-main-thread assumptions.

Why Server Owners Choose Leash Workers

• One connected system — leashes, anchors, workers, stash, progression, trading, captivity, and liberation share one ownership model.
• Actual gameplay value — leads become a persistent mechanic rather than a cosmetic command.
• Six useful workers — mining, logging, farming, breeding, Villager growth, and defense cover the major survival loops.
• Controlled automation — every worker remains tied to one pole chunk and one shared safety budget.
• Owner-focused storage — drops reach a persistent stash instead of filling the ground with loose entities.
• Flexible capture rules — peaceful consent, combat defeat, permissions, exemptions, and time limits are independently configurable.
• Broad compatibility — legacy aliases, Java 8 bytecode, PacketEvents visuals, and Folia scheduler ownership are handled in one product.
• Operational recovery — persisted sessions, backend reconciliation, display republishing, and reload cleanup reduce broken leash states.
• No NMS dependency — the plugin uses Bukkit compatibility bridges and PacketEvents instead of a version-locked NMS implementation.

FAQ

Can Leash Workers leash players?
Yes. Players use the virtual packet leash backend with configurable pull, recovery, consent, defeat, captivity, escape, and liberation rules.

Can it leash non-player entities?
Yes. Configurable entity targets use native Bukkit leashes where supported or the virtual PacketEvents backend when native leashing is unavailable.

Does it require the target's consent?
Consent is enabled by default and uses an Accept/Reject menu. It can be disabled, combined with defeat requirements, or bypassed through an explicitly enabled permission rule.

Can players be captured only after combat?
Yes. Defeat mode can require selected target types to be below a configured health threshold. Players default to 4 health.

How do fence anchors work?
Right-click a configured fence while controlling active sessions. All eligible held sessions attach to that pole. Anchored Villagers use the pole chunk as their work zone.

Can a captive escape?
Yes when the escape module is enabled. You can require a permission, sneaking, a specific item, a cooldown, and a configurable success chance. Escape is disabled by default.

Can another player free a captive?
Yes. Liberation supports command, look-target, interaction, item, permission, and confirmation-menu rules.

What happens to leashed players who work?
They progress through a universal seven-tier system. The bundled requirements scale from 32 to 320 actions, and Tier VII grants liberation.

Can players receive Miner or Farmer jobs?
No. Specific automated jobs are for anchored Villagers. Leashed players use universal tier progression.

Which Villager jobs are included?
Miner, Woodcutter, Farmer, Breeder, Progenitor, and Protector.

What is the difference between Breeder and Progenitor?
Breeder manages animal reproduction and animal baby growth. Progenitor creates and grows Villager babies, anchors them, and assigns a configured adult worker job.

Where do worker drops go?
Into the leash owner's persistent stash. The owner can open it with /leashworkers stash.

Can workers leave their assigned chunk?
The system prevents out-of-chunk work targets and returns workers toward the pole chunk. A configurable hard recovery handles prolonged or extreme exits.

Can I trade leashed entities?
Yes. The trade menu supports owned leash sessions and transfers ownership after both players approve and confirm the current offer.

Does trading require Vault?
No. Vault is only required for money offers. Item and entity trades work without it.

Does it support Folia?
Yes. The plugin declares Folia support and separates entity-owned, region-owned, global, and asynchronous work through a scheduler compatibility layer.

Does it use NMS?
No direct NMS dependency is used. PacketEvents handles packet visuals, while compatibility bridges isolate version-sensitive Bukkit behavior.

Can it be reloaded?
Yes. /leashworkers reload rebuilds configuration, language, worker services, baby registries, menus, listeners, displays, trades, and active-session reconciliation.

Which files are persistent?
Active leashes, jobs, owner stashes, Progenitor babies, and animal babies are stored in readable YAML files under plugins/LeashWorkers.




SEO keywords: Leash Workers, Minecraft leash plugin, player leash plugin, leash players Minecraft, Villager worker plugin, Minecraft worker plugin, Villager automation plugin, Minecraft Miner Villager, Woodcutter Villager plugin, Farmer Villager plugin, animal breeder plugin, Villager breeder plugin, Protector Villager plugin, Minecraft captivity plugin, Minecraft liberation plugin, Minecraft prisoner plugin, fence anchor plugin, leash pole plugin, PacketEvents leash plugin, Folia leash plugin, Bukkit leash plugin, Spigot leash plugin, Paper leash plugin, Purpur leash plugin, Java 8 Minecraft plugin, Minecraft 1.8 leash plugin, Minecraft 1.21 leash plugin, YAML worker storage, Minecraft entity trade plugin, Vault entity trade, persistent stash plugin, chunk worker plugin, automated survival workers.