Import a Path of Exile 2 build for analysis and theorycrafting.

source may be a Path of Building import/share code, a pobb.in or pastebin link, or raw PoB XML. Returns the selected main skill and a summary of engine-computed stats. The imported build becomes the active build for subsequent tool calls.

Shared PoBs are often aspirational, so the result carries importCaveats when the build has author-added custom mods, an over-budget tree, or uncapped resists — don't read its raw numbers as achieved-as-shown without accounting for those.

Return Path-of-Building-computed stats for the currently loaded build.

Pass keys to request specific stats (e.g. ["TotalDPS", "Life", "EnergyShield"]); omit it for a default summary. Every value is computed by the real PoB engine.

Full read-back of the active build.

Returns class/level/ascendancy, the main skill group (gems + levels), allocated notables/keystones/ascendancy nodes, equipped gear by slot, passive points used, and summary stats — so you can see the whole build you've assembled.

Defensive summary for the active build: life/ES/mana/ward, armour/evasion, block, elemental + chaos resistances (with over-cap), and TotalEHP. Elemental resists are shown net of PoB's configurable area penalty (default Endgame -60%); the response includes the active resistPenalty and a note. Cap is 75%; aim at or just over it.

Export the active build as a Path of Building import code.

Paste the returned code into Path of Building (Import/Export → Import) or share it.

Reset to a blank build — clears gear, skills, passives, and config.

Use this to start a build truly from scratch mid-session: set_class re-roots the tree but KEEPS existing gear/skills/config, which can carry leftovers from a prior build. Call new_build first, then set_class → set_level → … for a clean slate.

Set the active build's character class and (optionally) ascendancy.

class_name is a base class (e.g. "Mercenary", "Witch", "Ranger"); ascendancy is one of its ascendancies (e.g. "Witchhunter"). This re-roots the passive tree at that class's start, so subsequent passive search/allocate/optimize operate on the correct class. It does NOT clear existing gear/skills/config — call new_build first if you want a clean slate. Returns stats.

Set the active build's character level (1-100). Returns updated stats.

Set the active build's MAIN skill (gem + its support gems) in PoB paste format.

Format: " / ", e.g. " 20/0 1". List the main skill first, then its supports — one gem per line, OR separated inline by " / ", "," or "|" (all accepted); a bare support name gets a default level/quality (supports are fixed-effect in PoE2, so it's cosmetic). This REPLACES the current main skill group; auras/heralds/reservation buffs added via add_skill_group are separate groups and are preserved. If nothing parses (or the main gem name isn't a real skill) the build is left UNCHANGED and ok:false is returned — it won't silently drop supports or corrupt the skill. Returns updated stats, plus ProjectileCount + a dpsNote for multi-projectile skills. For persistent buffs, use add_skill_group.

Add an ENABLED secondary skill group (aura, herald, or persistent buff) WITHOUT changing the main skill — so its buff/reservation applies to the active build.

This is how you model the damage layers that carry endgame casters/attackers: auras, heralds, and reservation/mana-scaling buffs, etc. Same paste format as set_skill (" / ", supports newline-separated). The group is added enabled and its effect is reflected in the returned stats; the main skill is preserved. Mind Spirit reservation — check it still fits (get_build_stats / list_config_options) after stacking auras.

Set in_full_dps=True only for a second DAMAGE skill (clear+boss combo, a trigger/totem) so it aggregates into FullDPS. Leave it False for auras/heralds/buffs (otherwise their standalone damage inflates the combined number).

Set combat/configuration options and/or extra modifiers on the active build.

options are Path of Building config keys, e.g. {"enemyIsBoss": "Boss"}, {"usePowerCharges": true}. custom_mods is free-form modifier text applied to the character, e.g. "100% increased Fire Damage\n+2 to Level of all Fire Skills". Recomputes and returns stats.

Apply a realistic boss-combat profile in one call, so DPS reflects an actual fight.

The engine's enemy-condition levers are OFF by default, so a bare get_build_stats understates a build that, in play, keeps shock/curse/charges up. This sets the common ones at once (enemyIsBoss=tier plus the toggles) and returns the resulting stats.

IMPORTANT — these are ASSUMPTIONS the build must actually produce: only keep shocked if the build shocks, cursed if it runs a curse, the charge flags if it generates them. Turn off the ones that don't apply (they'd otherwise inflate DPS with effects the build can't sustain). The response lists what was assumed. Tiers: None / Boss / Pinnacle / Uber.

List Path of Building configuration options usable with set_config.

Covers combat conditions, charges, enemy settings, exposure, etc. Filter with query (matches the option's key or label), e.g. "boss", "charge", "exposure". Returns each option's var (the key for set_config), type, label, and valid values for dropdowns.

Equip an item on the active build from raw Path of Building item text.

Replaces whatever is currently in the target slot. slot optionally forces the slot; otherwise the item's primary slot is used — which for a PAIRED slot is the first one, so pass an explicit slot for "Ring 2"/"Weapon 2" or it silently overwrites Ring 1/Weapon 1. Returns updated stats.

Hand-written items are checked against the real mod pool: if an affix can't roll on the base type (e.g. flat/% maximum Mana on a body armour), the result carries illegalAffixes + a legalityWarning — the computed stats then include invented mods and aren't achievable. Ground gear in real mods (optimize_item, parse_item, search_mods) to avoid this.

Clear an equipment slot on the active build (e.g. "Ring 2", "Body Armour", "Weapon 1").

Weapon-swap slots ("Weapon 1 Swap"/"Weapon 2 Swap") and jewel sockets are valid slots too; use equip_item/equip_jewel to fill them.

List the passive tree's jewel sockets: each socket's id, whether it's allocated, and whether it's already filled. A jewel only contributes when its socket is allocated (allocate a Socket node with alloc_passive first). Use a socket id with equip_jewel.

Socket a jewel (raw PoB item text) into a passive-tree jewel socket.

socket is a socket id from list_jewel_sockets; if omitted, the first allocated empty socket is used. The jewel only applies in an ALLOCATED socket (the result warns otherwise). Ground the jewel's mods in real jewel rolls (search_mods) — jewels aren't covered by the equip legality check. Mana/ES/damage stat jewels are a meaningful chunk of mana-stacker power.

Check the active build against named numeric goals.

goals maps a stat to a constraint: a bare number (treated as a minimum) or an object like {"min": 500000, "max": 1000000}. Example: {"TotalDPS": {"min": 500000}, "Life": {"min": 5000}, "TotalEHP": 20000}. Returns per-goal pass/fail with actual values and an overall pass.

Gate a build against the endgame/pinnacle checklist — defense beyond raw EHP, plus a DPS bar.

Engine-computed pass/fail for: elemental resists capped, chaos handled (capped OR Chaos Inoculation), a resist over-cap buffer (advisory, vs penetration/curses), EHP ≥ min_ehp, and DPS ≥ min_dps (uses FullDPS when higher). Defaults are a generic pinnacle bar — set them to the player's content. (For reference, real imported ~1M-DPS pinnacle builds often run only ~17–20k EHP and lean on Mageblood + charms + dodge, so EHP breadth/recovery matters more than a huge pool.) pass covers the critical criteria; the buffer is advisory. Verify recovery (regen/leech/recoup), ailment/stun handling, and DPS uptime in-game.

Compare the active build against another build (code/link/XML) without losing it.

Snapshots the current build, loads source to read its stats, then restores the current build. Returns the current stats, the other build's stats, and per-stat deltas (other - current).

Solve for the magnitude of one modifier needed to reach a stat target on the active build.

Holds the build fixed and binary-searches lever until metric reaches target — every probe is a real engine evaluation, so the answer is computed, not estimated. Example: solve_for("TotalDPS", 1000000, "increased fire damage") → "you need ≈ +N% increased Fire Damage."

lever is a named lever (e.g. "increased fire damage", "attack speed", "maximum life", "increased critical strike chance") or a raw custom-mod template containing "{}" for the magnitude (e.g. "+{} to Level of all Fire Skills"). Returns the required magnitude, or flags the target unreachable with the best achievable value (and alreadyMet if you're past it).

Scope: ONE lever, ONE (increasing) metric. It does not balance survivability or cost and reports a requirement — verify with get_defenses / evaluate_build and confirm the magnitude is attainable via search_mods / find_supports_for.

Rank which stat levers give the most metric per unit on the active build — the min/max direction-finder ("where do I invest next?").

Applies each lever at unit (default 10 = "10%" or "+10") and measures the real Δmetric, ranked high→low — so you can see, e.g., that lightning penetration beats increased lightning damage for this build. Defaults to a broad damage+defense set; pass build-specific levers (custom-mod templates containing "{}", e.g. "{}% increased Lightning Damage", "Damage Penetrates {}% Lightning Resistance") for sharper guidance. Greedy/marginal — levers are measured independently, so verify combined picks (more-multiplier stacking, breakpoints) together. Every value is engine-computed; use it to direct gear/tree/support choices.

List the named levers accepted by solve_for and rank_levers (discoverability).

Returns the recognized lever names plus guidance: names are forgiving (a directional phrase like "increased lightning damage" works even if unlisted), and you can pass any PoB mod text containing "{}" as a custom lever. A lever only moves a metric if it actually applies to the build (crit needs a crit build, attack speed needs an attack skill, the damage type must match).

Search the active build's passive tree by node name or stat text.

node_type filters by kind: "Notable", "Keystone", "Mastery", or "Normal" (small nodes). Returns nodes with their id, stats, whether they're allocated, and pathDist (points to reach from the current tree; absent if unreachable). Use the id with alloc/dealloc.

Return a passive node's details by id (preferred) or exact name.

Allocate a passive node (and the shortest path to it) by id or name.

Returns points spent and the resulting stat deltas. Fails if the node isn't reachable from the currently allocated tree.

Deallocate a passive node (and nodes that depend on it) by id or name.

Returns points freed and the resulting stat deltas.

Greedily allocate passive points to maximize a goal on the active build.

Three goal modes:

• single metric (e.g. "TotalDPS", "Life", "TotalEHP") — maximizes that stat;

• metric="balanced" — raises offense AND defense (relative TotalDPS + TotalEHP);

• goals={"TotalDPS":0.5,"Life":0.3,"CritChance":0.2} — a WEIGHTED mix (relative gains, so stats on different scales combine). A goal whose base is ~0 (e.g. crit on a non-crit build) contributes nothing — fix the base first.

require=[node ids/names] allocates those nodes (+ shortest path) first, then optimizes the rest — but only as far as the budget allows (it never over-allocates; skipped requires are reported in requireSkipped). reset=True first deallocates the current tree (keeping ascendancy) so you can RE-PLAN from scratch — e.g. reset=True, require=[jewel socket ids] to rebuild the tree around jewel sockets instead of piling onto a full tree. points defaults to 0 = the FULL remaining passive budget (the usual intent — allocate the whole tree); pass a positive number only to CAP allocation. Ascendancy is a SEPARATE 8-point pool, auto-allocated on top regardless of points. Returns chosen nodes with per-step gains; pointsRemaining is the build's TRUE unspent passive points. Bounded greedy search, not a global optimum.

Fill the active build's EMPTY armour/jewellery slots with placeholder BASELINE gear.

Closes the build's actual defensive gaps so a from-scratch skeleton becomes engine- evaluable: it adds only the resistances that are below target_resist (default 75 — a build already capping a resist gets none) and a hit pool. pool is "auto" (Energy Shield for an ES/CI build, else Life), "life", "energy_shield", or "none". slots limits which empty slots to fill (default all). The items are an explicit BASELINE — NOT the player's real gear and NOT optimal; the assistant still chooses the weapon and offense/identity gear (via equip_item). Use this to complete a build's defenses, then re-check with get_defenses / evaluate_build and price the real versions with get_prices — and never present scaffolded gear as finished.

Craft the best-in-slot rare for a slot — one metric, or a weighted blend via goals.

Searches the slot's REAL craftable affix pool (from the base's mod restrictions) and greedily fills prefixes/suffixes — respecting the 3/3 limits and mod-group exclusivity. Every candidate is engine-computed. base defaults to the currently-equipped base in that slot (so a wand build stays a wand); pass it to try a different base. rolls: "realistic" (default) or "max" (idealized T1). thorough=true adds a swap pass. Returns the crafted item (equip with equip_item), the before/after numbers, and a warning if it breaks a resistance cap.

For realistic gear, pass goals — a weight map like {"TotalDPS": 0.6, "TotalEHP": 0.4} — and the craft balances offense AND defense in one piece (real endgame gear is blended). Without goals it maximizes the single metric, which strips the other axis (a TotalDPS craft carries no life/resists). A blended craft returns metricsBefore/metricsAfter per goal. Either way, re-check get_defenses after equipping.

Each result also reports attainability (per chosen affix: required ilvl + tier depth, e.g. top tier of 8) and a coarse craft effort rating — a realism check from tier depth, NOT a market price (the data has no spawn-weights). The crafted item is a theoretical best-in-slot target; verify price with get_prices. Bounded greedy search, not a global optimum.

Rank gear slots by upgrade potential — "what should I craft/upgrade next?".

Recrafts each gear slot to its best (same crafter as optimize_item — a single metric or a weighted goals blend like {"TotalDPS":0.6,"TotalEHP":0.4}) and ranks slots by the gain over your CURRENT item there, so the top slot is where the next upgrade buys the most. Read-only — every probe is snapshotted and restored. Gains are NOT additive (recrafting one slot shifts the others): recraft the top slot, equip it, then re-run. Empty slots with no base are skipped — explore those with optimize_item(slot, base=…). Targets are theoretical; price with get_prices.

Choose the best support-gem set for the active main skill (engine-measured).

Supports are usually a build's biggest "more" multiplier, but the corpus stores no support MAGNITUDES — so this values them empirically. It picks the candidate pool by MEASUREMENT, not tags (solo-measuring each tag-relevant support and keeping the strongest, so premier levers like penetration aren't missed just because they share few tags), then greedily adds the support that most raises the goal on the REAL build, round by round, until the sockets are full or nothing helps. Pass goals (weighted, e.g. {"TotalDPS":0.7,"TotalEHP":0.3}) to blend objectives; omit for a single metric. Read-only (the build is restored); raise candidates for a wider greedy search. Apply the result with set_skill. Greedy, not a global optimum.

Craft the best-in-slot rare JEWEL for the active build (one metric or a weighted goals blend).

A jewel's explicit mods apply globally, so each candidate is measured as a real modifier on the build and ranked by marginal gain (jewel mods are ~independent, so the top picks ≈ the best jewel). Pick a base matching the socket's attribute — Emerald=dex, Ruby=str, Sapphire=int, Diamond=all. Returns a jewel to socket with equip_jewel into an ALLOCATED tree socket (list_jewel_sockets); verify the base's affix limit. Radius/Time-Lost jewels aren't modelled here (their effect is positional). Read-only: the build is restored.

Plan a whole gear set that maximizes damage while capping resistances (budget allocation).

The cross-slot trade-off: limited suffix slots for resistances, so put them where they cost the least damage. This crafts OFFENSE slots damage-leaning and DEFENSE slots EHP-leaning (which pulls the missing resists onto the defensive pieces), building each slot on the previous so the plan is coherent. dps_weight (0..1) tilts the offense slots. auto_base (default on) fills EMPTY armour/jewellery slots with a sensible attribute-appropriate base, so it builds a WHOLE set from scratch (weapons stay yours — they define the archetype). min_ehp sets a survivability floor: defensive slots are re-crafted toward pure EHP until TotalEHP reaches it (reports ehpFloorMet). metric is the offense stat to chase — use "FullDPS" for minion/DoT/trigger builds (whose TotalDPS is ~0), else the default TotalDPS. Returns the per-slot plan + projected whole-build DPS/EHP/resists; equip the items with equip_item. A heavier call (~10-20s); greedy heuristic.

Craft the best-in-slot item using the FULL crafting system — beyond a plain rare.

Where optimize_item crafts the best rare from the standard affix pool, this adds the three real PoE2 power sources, each valued on the engine (PoB owns the crafting data — nothing is invented): runes / soul cores (mods socketed on top of the affixes), essences (force a mod — Perfect essences grant mods the normal pool can't roll, e.g. % Life on body armour, "damage as extra" on weapons), and corruptions (a corrupted implicit, e.g. +1 to all skills on an amulet). Pass a single metric or a weighted goals blend; rune_sockets is how many the base is assumed to support (Artificer's Orb — martial weapons/armour typically allow up to 2). Returns the item + the craftSteps to make it (the corruption is a Vaal gamble — do it last). A theoretical best-in-slot target with idealized rolls; price the steps. Read-only.

Assemble a complete, engine-verified, high-DPS build for the ACTIVE archetype — the holistic optimizer that does the synthesis the greedy per-slot tools can't (STATE tool: leaves the best build LOADED in the session).

Set up the archetype first (class + ascendancy + main skill, plus a weapon base for attack skills — it's archetype-defining), then call this. It SEEDS the dominant levers from the reference set for the build's delivery, and for each runs "commit-and-max": REQUIRE the lever's tree clusters

• nearest jewel sockets (the over-commitment greedy won't make), then maximize metric across gear (plan_gear), jewels, supports and the weapon as a whole — iterating passes times — and keeps the best build that caps resistances and meets min_ehp. Reports what it committed + the reference-set placement so it's transparent.

levers forces explicit reference lever names (omit to auto-seed). try_uniques adds a unique-item pass. crafting applies the FULL crafting system (runes + Perfect essences + corruption) to every gear slot of the winner — the "awesome gear" boost (heavier; adds ~1-2 min). uniques EQUIPS named build-defining uniques and PRESERVES them (never recrafted); if one scales damage off an attribute (e.g. Hand of Wisdom and Action → lightning per Intelligence) that attribute is auto-committed as a lever, so the search builds the unique-enabled archetype (e.g. the Int-stack) the greedy can't find on its own. archetypes (list of {class, ascendancy, skill, weapon}) also evaluates alternative configs and keeps the best. parallel spreads the search across engine subprocesses (faster, more memory). A heavy call (~1-3 min, more with crafting). The one thing it can't model is energy-meta triggers (upstream PoB); run apply_combat_profile with the build's real conditions and validate_build.

Report engine + install diagnostics: liveness, LuaJIT and passive-tree versions, the installed data/server versions, and whether data is served from the auto-updated user-data copy or the bundled seed — so you can confirm exactly what's running.

Search Path of Exile 2 item bases by name/tags, optionally filtered by item class.

Returns matching bases (name, item_class, drop_level, tags). Use get_item for full detail.

Return full data for a single item base by exact name or metadata id.

Find skill/support gems by text, tag, color, or type.

gem_type is one of "active", "support", "spirit". tag filters by gem tag (e.g. "fire", "projectile", "minion"). color is "r"/"g"/"b". Returns gems with recommended supports.

Return full data for a single gem by name or id (tags, granted skills, supports, types).

List support gems for a skill: curated recommendations + tag-compatible supports (most relevant first). This only LISTS candidates — to actually pick the best set, use optimize_supports, which measures each on the engine (the corpus has no support magnitudes).

Explain a Path of Exile 2 mechanic (corpus — offline, deterministic).

Returns our evergreen principle (hand-authored) plus the matching auto-refreshed wiki page when one exists (attributed: PoE2 Wiki, CC BY-NC-SA 3.0 — cite it when you use it). Curated principle topics include: resistances, ailments, armour, evasion, energy_shield, spirit, critical_strike, ehp, accuracy, recovery. If nothing matches, use search_mechanics to browse, or lookup_mechanic to fetch a page live from the wiki.

Full-text search the bundled wiki mechanics tier (corpus — offline, deterministic).

Returns matching page titles + snippets + source links so you can pick one to read with explain_mechanic. Wiki content is PoE2 Wiki, CC BY-NC-SA 3.0 — attribute it when quoting. For a page not bundled here, use lookup_mechanic (live wiki fetch).

The mechanics worth understanding for the ACTIVE build (corpus + engine).

Reads the current build's signals — main skill + its tags (and the ailment its damage type builds), keystones, ascendancy notables, plus staples — and points each at its best corpus mechanics page. Also surfaces the engine's damage diagnostic, so an uncomputable layer (reservation buff, undamageable minion, %-life/corpse detonation) is called out up front. Use it when starting/auditing a build to read up before theorycrafting.

Evergreen PoE2 build-optimization principles — durable rules, not a meta snapshot.

Omit topic for the framing + section list; pass a topic (e.g. "defense", "offense", "resistances", "crit", "spirit", "red flags") to get that section. These are principles for deciding what to change; the actual DPS/EHP numbers still come from the compute tools.

Browse engine-verified reference / CALIBRATION builds (corpus — offline, deterministic).

A deliberately diverse set of real high-end builds across many ascendancies/skills, kept ONLY to calibrate. They are not templates: never copy, export, or recommend one wholesale when a user asks for a build — build to the USER's stated goal and use these to sanity-check it. Filter by query (class, ascendancy, skill, element, delivery like "spell"/"attack"/"minion", defense like "CI"/"mana", or a lever). Each result returns the build's VERIFIED DPS/EHP, its archetype tags, and the lever it scales on — enough to range-check a number or learn an archetype's dominant scaler, with deliberately nothing to copy (no code, gear, or passive list).

Calibrate the ACTIVE build against the verified reference set (corpus + engine).

Compares this build's computed DPS/EHP to the distribution of real high-end builds of the SAME delivery archetype (spell/attack/minion/…), and reports which levers those references scale on. Answers "is this build's number in a sane endgame range, and what should I scale next?" — it is a calibration check, NOT a license to copy a reference. The user's goal drives the build; if a number is low, find the missing multiplier on THIS build (rank_levers), don't clone a reference.

Parse a Path of Exile 2 item (in-game clipboard or PoB item text) and enrich it.

For each explicit affix, identifies its mod group and the tier it rolled (T1 = best) using the corpus' per-tier ranges, and reports open prefix/suffix slots for craftable rarities. Use it to evaluate a drop or plan a craft ("is this worth using / can I add more?"). Tiers and ranges are looked-up corpus facts — to see how the item changes a build, equip it with equip_item. Affix detection is best-effort; unmatched lines come back under unrecognized.

List Path of Exile 2 ascendancies, optionally filtered by base class.

Search Path of Exile 2 affixes/modifiers by readable text.

item_tag filters by what the mod can roll on (e.g. "ring", "amulet", "body_armour"); mod_type is "prefix" or "suffix". Returns mod text, type, required level, and rolls-on tags.

Find where a stat comes from: matching affixes, gems, and unique items.

Example: reverse_lookup("maximum life") or reverse_lookup("increased fire damage").

Search Path of Exile 2 unique items by name, base, or mod text.

item_type filters by slot family (e.g. "ring", "body", "bow"). Use get_unique for full text.

Return a unique item's full readable text (base, mods) by name.

If the name is a base type rather than a unique (e.g. "Warmonger Bow"), says so and points to get_item, instead of returning a confusing null.

Surface unique items + unique JEWELS that synergize with the ACTIVE build (corpus suggestions).

Matches the active main skill's scaling — its damage type, skill type (spell/attack/projectile/…) and the skill name — against unique mod text, ranked by how many match. Uniques often DEFINE or ENABLE a build (extra projectiles, "+levels to skills", a converted mechanic), and unique JEWELS (Voices, Megalomaniac, …) supply the passive/notable density meta trees lean on — exactly the power a from-scratch, rare-only build misses. These are CANDIDATES, not verified: a unique often enables a mechanic, so read full text with get_unique, then equip_item / equip_jewel and measure the real delta — every number still comes from the engine.

Report the bundled game-data corpus version and entity counts.

Look up live Path of Exile 2 market prices (poe2scout.com).

kind is "currency" or "unique". query filters by name (e.g. "divine", "mageblood"). Defaults to the current challenge league; prices are in the league's base currency.

List Path of Exile 2 leagues available for pricing (with the current one flagged).

Live ascendancy popularity from poe.ninja's ladder snapshot — CONTEXT, not a target.

Returns the most-played ascendancies for a league (default the current challenge league) with each one's share % and a rising/falling/flat trend, plus the sample size. This is popularity among logged ladder characters, not a recommendation — popular is not the same as optimal or right for the player's goal. Use it to inform, not dictate: build to the user's stated goal, and only steer toward the meta when they explicitly ask for the "strongest"/"popular"/"meta" option. Covers ascendancy distribution only (no skill/item meta). Returns {ok: false} if poe.ninja is unreachable.

Fetch a concise mechanic/skill/item explanation LIVE from the PoE2 Wiki (live — network).

The long-tail escape hatch: use this only when explain_mechanic/search_mechanics don't have the topic in the bundled corpus. Returns a short lead extract + source link, attributed (PoE2 Wiki, CC BY-NC-SA 3.0 — cite it). Time-sensitive and may be outdated; the engine remains the source of truth for any number. Returns {available: false} if the wiki is unreachable. Single, user-triggered, read-only — it never sends your build anywhere.

Compare the bundled game-data corpus against upstream and report the current league.

Rebuild the game-data corpus locally from RePoE (power-user / offline path).

Most users don't need this — the server auto-updates from validated releases. Pass rebuild_from_source=true to re-fetch RePoE and rebuild the corpus right now.

Check whether a newer validated release (engine + corpus) is available to install.

Download and install the latest validated release (engine + corpus) now.