Retrieve D&D 5e character information optimized for minimal token usage. Returns: full stats (abilities, skills, saves, AC, HP, 2024 weapon-mastery kinds), action names, active effects/conditions (name only), and ALL items with minimal metadata (name, type, equipped status, attunement, weapon mastery property) without descriptions. Perfect for checking equipment or identifying what to investigate further. Use get-actor-entity to fetch full details for specific items, spells, or effects.

Write ONE actor to a LOCAL file as a full-fidelity native Foundry JSON export — the complete document source (system, every embedded item with its uses/charges and flags, effects, prototype token, ownership), stamped with the exportSource envelope so the file round-trips through the sheet's Import Data button. THE character backup/restore path (get-actor is a lossy summary view). Accepts a placed token id to capture an unlinked token instance. Refuses to overwrite an existing file unless overwrite:true.

List all available characters with basic information

Retrieve full details for a specific entity from a character. Works for items (feats, equipment, spells), actions (strikes, special abilities), or effects/conditions. Returns complete description, all system data, and (for items) module flags — the read path for flag forensics like item-piles transfer residue. Use this after get-actor when you need detailed information about a specific entity.

Search within a character's items, spells, actions, and effects. More token-efficient than get-actor when you need specific items. Supports text search (name/description) and type filtering. Returns matching items with full details including targeting info for spells. Use this to find specific spells, equipment, feats, or abilities without loading the entire character.

Create world-level Item document(s) in the Items sidebar — reusable library items (weapons, equipment, consumables, feats, spells). For dnd5e prefer the 2024 data model; pass system-specific data via the "system" field. GM-only. To put items on an actor instead, copy from a compendium with import-item, author one with add-item, or attach raw item data with add-feature (mode "items").

List world-level Item documents, optionally filtered by type, name substring, or folder.

Retrieve a single world-level Item document with its full system data, embedded effects, flags, and flattened description. Resolves by id (most reliable), exact name, or case-insensitive name. Use list-items first to find ids. For an UNIDENTIFIED dnd5e item (system.identified=false) name is the mystery mask; the real source name is returned as trueName.

Update existing world-level Item(s) by id — change name, img, system data, or folder. GM-only. Renaming an UNIDENTIFIED dnd5e item works on the true source name; the echo shows the mystery-mask name plus trueName so the rename is visible.

Permanently delete one or more world-level Item documents (Items sidebar) by exact id or exact name. STRICT resolution — no fuzzy/substring matching, so it never deletes the wrong item. GM-only. To remove an item embedded on an actor instead, use remove-from-actor.

Delete items already on an actor, identified by itemIds and/or itemNames (optionally constrained by type). GM-only. Use get-actor to find item ids.

Broad NAME search across the premium book compendium packs (any document type). The SRD (dnd5e.*) packs are NOT searched and never appear in results — the authoring library is the premium books only (design.md §2.3). Matches entity NAMES only (all whitespace-separated terms must appear); descriptions and traits are NOT searchable. Premium-first ranked, exact-name first. For faceted discovery by real system data (CR/type/size, spell level/school, item rarity/type), use the type-specific tools instead: search-compendium-creatures, search-compendium-spells, search-compendium-items. Use this for a quick name lookup, then inspect with get-compendium-entry.

Retrieve a specific compendium entry (monster, item, spell, etc.) by pack id + entry id. Returns the full stat block — items, spells, abilities, effects, system data — needed for actor/item creation. Set compact=true for a condensed stat block when full detail is not needed. An SRD (dnd5e.*) pack id is refused — author only from the premium books (design.md §2.3).

D&D 5e CREATURE DISCOVERY: find creatures matching faceted criteria (Challenge Rating, type, size, spellcasting, legendary actions) across the premium book Actor packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so CR/type/size check real system data (not name heuristics); hasSpells/hasLegendaryActions are approximate index flags. Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates by name, then pull full stat blocks with get-compendium-entry. High result limits for complete encounter-building surveys.

D&D 5e SPELL DISCOVERY: find spells matching faceted criteria (level, school, damage type, name) across the premium book packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so filters check real spell data (not name heuristics). Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates here, then pull full detail with get-compendium-entry. damageType is a two-stage refine (loads candidate spells to inspect their activities).

D&D 5e ITEM/GEAR DISCOVERY: find equipment, weapons, armor, consumables, and treasure matching faceted criteria (rarity, subtype, properties, magical, name) across the premium book packs only — the SRD (dnd5e.*) packs are excluded and never appear in results (design.md §2.3). Backed by the system Compendium Browser, so filters check real item data (not name heuristics). Returns minimal hits ({id,name,type,uuid,pack,packLabel,img,facets}) premium-first ranked — identify candidates here, then pull full detail with get-compendium-entry. Use documentType to narrow the item family (gear=all, or weapon/armor/consumable).

List the available compendium packs. SRD (dnd5e.*) packs are excluded — only the premium book packs (and any other non-SRD packs) are listed (design.md §2.3).

Get information about the currently active scene, including tokens and layout

Get basic information about the Foundry world and system, including the world description (HTML) and join-page background path. READ-ONLY: world metadata has no write tool (the /setup editWorld route needs a role-4 GAMEMASTER session; the bridge user is deliberately an ASSISTANT) — hand edits go through the in-app "Edit World" dialog.

Copy one or more actors from a premium-book compendium pack — the DEFAULT, preferred path for official content (e.g. pull the Owlbear from the Monster Manual). Find the entry with search-compendium / get-compendium-entry, then pass its packId + itemId plus names[] for the new actors. PREFAB-AS-BASE (the §6 step-2 bridge): to make a CUSTOM creature, copy the closest Monster Manual match and pass modifications (update-actor-shaped stat edits — cr/hp/ac/abilities/skills/defenses/biography/currency) to layer onto the world copy in the SAME call; the edits land on the copy only, never the source entry. Pass folder (id or exact name, created if absent) to file the copies directly — no move-documents follow-up. For a fully hand-authored NPC with no compendium base, use author-npc (last resort).

Author a custom NPC (type:npc) from a hand-written stat block — the LAST-RESORT path in the §6 ladder, used ONLY when nothing in the premium MM/PHB/DMG books is a workable base. Prefer create-actor-from-compendium (copy a real Monster Manual creature, optionally with prefab-as-base modifications); if the books are missing what you need, tell the user and ask before authoring rather than inventing content. Prefer the 2024 ruleset (sourceRules:'2024'). Required: name, creatureType (humanoid/undead/beast/dragon/fiend/…), size (tiny…gargantuan), cr (number or fraction string like '1/4'), abilities {str,dex,con,int,wis,cha}, hpAverage, hpFormula (e.g. '5d8+10'), acMode ('default'|'flat'; acValue required if 'flat'). Optional: alignment, savingThrows[], skills[{skill,proficiency}], walk/fly/swim/climb/burrowSpeed, darkvision/blindsight/tremorsense/truesight, damage immunities/resistances/vulnerabilities[], conditionImmunities[], languages[], biography, sourceBook/sourcePage/sourceRules, disposition ('hostile' default | 'friendly' for allies/townsfolk | 'neutral' | 'secret'). Add features, attacks, and spells afterward with add-feature; copy gear from a compendium with import-item.

Build a player character (type:character) headlessly from premium class + species + background by NAME, running real dnd5e advancement so @scale.* (rage damage, sneak attack, breath weapon, …) resolves natively — unlike an NPC. Compendium-first, premium books only, never the SRD (design.md §2.3); a missing class/species/background is an error, not invented. The SKILL owns the math: pass FINAL ability scores (point-buy/array/ASI already applied) and the player CHOICES (skills, fighting style, ancestry…) in choices (level → advancement-id → {chosen|selected|uuid}). Call with no/partial choices first to get a needsChoices[] dry-run (legal options per choice — incl. the available subclasses at level 3 — NOTHING is created); fill the map and re-call. Levels 1-20: HP/features/subclass/spell-slots scale with level (subclass at L3 via a choices uuid; HP per level hpMode avg|max). Multiclass in ONE call via multiclass:[{className,levels}] (className/level is the primary; each multiclass class gets the 2024 proficiency subset; total ≤ 20). Caster spell slots auto-derive from the class; pass spells.cantrips/spells.prepared (names) to add chosen spells. ASI ability-increases ride in the FINAL scores (not applied separately); a feat taken at an ASI tier is added by the skill via add-feature/import-item, like equipment — this tool adds no gear or ASI-feats. If a required advancement (a forced grant / supplied pick / subclass embed) FAILS to apply, the PC is NOT persisted (no junk actor) and success:false is returned with errors[]. Returns {success, actor, applied[], needsChoices[], unresolvedScale[], errors[], warnings[]}.

Read-only: report the player CHOICE points a premium class exposes up to a level — each advancement's id, type (Trait/ItemChoice/Subclass), how many to pick, and the legal options — so the skill can ask the DM and fill create-pc's choices map without inventing anything. Resolve by className OR classUuid (exactly one); premium books only, never the SRD. Touches no actor.

Add ONE level to an existing PC (type:character) and apply that level's advancement IN PLACE. Same className as a class the PC already has → a single-class level-up; a class it does NOT have → a MULTICLASS add (the PC gets the 2024 multiclass proficiency SUBSET, not the full first-level kit). HP/features/subclass(@ the class's level 3)/spell-slots scale; @scale stays native. Like create-pc: call with no/partial choices to get a needsChoices[] dry-run (e.g. the subclass options at level 3 — the actor is NOT touched); fill choices (level → advancement-id → {chosen|selected|uuid}) and re-call. ASI ability bumps are NOT applied here — raise the final scores with update-actor; a feat taken at an ASI tier is added with add-feature. If a required advancement FAILS to apply, the PC is rolled back to its prior level and success:false is returned with errors[]. Required: actorIdentifier, className. Returns {success, actor (incl. classLevel + classes[]), applied[], needsChoices[], unresolvedScale[], errors[], warnings[]}.

Create a player character by COPYING a premium-book PREGEN (a complete type:character template — e.g. the PHB class pregens Barbarian…Wizard in dnd-players-handbook.actors, each a ready level-1 build with gear/feats/art) and layering your changes, INSTEAD of building via advancement. The PC family's prefab-as-base path — the §6/§7 analog of create-actor-from-compendium for NPCs, but PC-correct (files under the PC folder, never the NPC one). Resolve the source by prefab NAME (e.g. "Fighter") OR explicit packId+actorId; premium books only, never the SRD (design.md §2.3). Override the pregen's ability array via abilities (final scores) and/or any update-actor-shaped modifications — applied to the COPY only, the source is never touched. @scale resolves natively (it is a real character, no advancement run). Assign the player as owner afterward with set-actor-ownership. Returns {success, from, actor, modificationsApplied, unresolvedScale, warnings}.

Clone one or more existing WORLD actors as full copies — the whole sheet travels (system data, embedded items, spells, effects, prototype token), so every copy stays fully rollable. THE sandbox path: clone PCs as "(Sim)" copies (suffix: " (Sim)") so a player can re-run a battle without touching the real sheets. Resolution is STRICT (exact id or exact name — look up with list-actors first); a missing source is reported per-actor, never fatal to the batch. Name the copies with newNames[] (index-aligned) or a suffix on every source name (default " (Copy)"). Pass folder (id or exact name, created if absent) to file the copies together — omit to file each beside its source. Pass owner (user id or exact/partial name; + ownershipLevel, default OWNER) to set each copy's ownership to exactly {default: NONE, that user: level} — omit to copy the source's ownership unchanged. GM-only.

Permanently delete one or more world actors (NPCs/characters) by exact name or ID. IRREVERSIBLE — Foundry has no undo for document deletion; the actor is removed from the world directory. GM-only. Resolution is STRICT (exact id or exact name — no fuzzy matching), so look up the precise name/ID with list-actors first. If the deletion empties a folder the bridge itself created (e.g. "Foundry MCP Creatures"), that folder is auto-removed unless removeEmptyFolder is false.

Permanently delete a folder by exact name or ID. GM-only, IRREVERSIBLE. By default refuses to delete a folder that still contains documents or subfolders (safe for cleaning up empty leftover folders). Pass deleteContents:true to delete the folder AND everything inside it. Defaults to Actor folders; set type for other document folders.

[D&D 5e only] Edit an EXISTING actor's own stat-block fields. Supply only the groups you want to change: • identity + prototype token — name, tokenName (prototype nameplate ≠ actor name), img, disposition (friend/foe), tokenAutoRotate (face movement / lockRotation), tokenRing (dynamic ring), tokenScale (art size), tokenRotation (facing), tokenDisplayName / tokenDisplayBars (nameplate / HP-bar visibility) — the PROTOTYPE-token editor. (elevation / hidden / x / y are placement-only: edit those on a dropped token with update-token) • details — size, cr*, creatureType*, creatureSubtype*, swarmSize*, alignment, biography, source • abilities — abilities.{str..cha}, savingThrows (replace), skills (merge; proficiency none/proficient/expert) • weaponMasteries [PC] — {mode: replace|add|remove, values: ["greatsword", ...]} — 2024 Weapon Mastery weapon KINDS (base weapon ids, not mastery names) • vitals — hp, ac, initiative • movement, senses • defenses — damageImmunities / damageResistances / damageVulnerabilities / conditionImmunities / languages (each {mode: replace|add|remove, values, custom?}), telepathy • resources* — legendaryActions, legendaryResistances, lair • spellcasting* — {level, ability}: caster level (the sheet's "Spellcasting Level", which DERIVES the slot pools) + casting ability (which drives save DC / attack bonus) • 2024* — habitat, treasure • currency — coins {mode: set|add, pp, gp, ep, sp, cp} (carried money)

Fields marked * are NPC-only (skipped with a warning on player characters). This authors the stat block; it does NOT edit embedded items (use update-actor-item / add-feature / manage-activity) or run combat. Use list-actors or get-actor to find the actorIdentifier.

[D&D 5e] Edit an item embedded on an actor (weapon / feature / spell / equipment). Apply a dot-path patch (values applied as-is; arrays/Sets replace whole) and/or deletePaths (remove keys, e.g. an activity by id), and/or change name/img. This is the low-level item editor — to add/edit/remove activities (attacks, saves, heals, etc.) prefer manage-activity, which knows the shapes. Use get-actor or get-actor-entity to find the item and the exact paths/ids to change.

[D&D 5e only] Add / edit / remove / list Activities on an item — the rollable things (attack, damage, save, heal, check, utility, cast). Target an item on an actor (set actorIdentifier) or a world item (omit it). This authors actions like a Multiattack (action="add", type="utility", name="Multiattack"), a heal, an ability-check, a saving-throw activity, OR a spell-casting item (action="add", type="cast", spellUuid=…, charges=…, saveDC/attackBonus=… to pin a fixed challenge) — the cast LINKS a real compendium spell so its measured template + save/attack fire for free. appliesEffects puts real ActiveEffects on the targets (dnd5e 6.0) — e.g. [{ref:"Poisoned", onSave:false}] on a save activity; they inherit the activity duration/expiry. Use action="list" (or get-actor-entity) to find activityIds, then edit/remove by id. EDIT changes only name, duration, template, affects, behaviors and appliesEffects — every other field goes through patch (dot-paths relative to the activity, e.g. {"attack.bonus":"3"}) or a remove + add. Authoring only — it does not run combat.

[D&D 5e] Grant "cast without a spell slot, N per rest" the native 2024 way — Magic Initiate, Favored Enemy, lineage grants. TWO sheet entries result: the spell stays in the repertoire as a normal ALWAYS-PREPARED spell (castable with slots; imported from the compendium if missing), and a cast activity ON the granting feature projects a " - " entry into the sheet's native "Additional Spells" spellbook section with its own tracked pool (default 1/long rest) — no slot, no use-dialog. Also MIGRATES the old shape (on-spell use pool + forward activity) off the spell, and dedupes dnd5e's cached spellbook copies. Idempotent. NEVER track a free cast as a separate tracker feat or as a forward on the spell.

[D&D 5e] Create / edit / delete / list ActiveEffects on an actor or an item. Effects carry changes ({key, value, type}) that modify the target — e.g. +1 AC ({key:"system.attributes.ac.bonus", value:"1", type:"add"}) or resist fire — or, with a dnd5e 6.0 RULES type, modify a ROLL: type "dnd5e.advantage" | "dnd5e.bonus" | "dnd5e.minimum" | "dnd5e.maximum" on key "attack" | "check" | "d20" | "save" (damage / healing: bonus only), e.g. +1d4 on History checks = {key:"check", value:"1d4", type:"dnd5e.bonus", conditions:{k:"roll.skill", v:"his"}}, disadvantage on STR d20 tests = {key:"d20", value:"-1", type:"dnd5e.advantage", conditions:{k:"roll.ability", v:"str"}}. 6.0 conditions (a Filter) gate the whole effect ("while Bloodied") or one change; duration.expiry takes the combat / rest / source-target turn events. Target the actor (actorIdentifier), an embedded item (actorIdentifier + itemIdentifier), or a world item (itemIdentifier alone). Use action="list" to find effectIds (it reads conditions + rules back). Item effects transfer to the owning actor by default. Authoring only — it sets effect data, it does not run combat.

[D&D 5e] Read or set the dnd5e 6.0 AUTOMATION settings — falling damage, token size ↔ creature size, senses ↔ token vision, exhaustion, initiative grouping, auto-apply Unconscious/Dead at 0 HP, encounter placement, the player damage / effects trays, the bastion system, and the calendar (enabled, daily recovery mode, which calendar). Call with NO arguments to read every switch; pass any of them to change it — each change echoes previous → new, re-applying the current value is a clean no-op, and the switches that need a client reload are named. Allow-listed: nothing else in the settings menu is reachable. GM-only.

[D&D 5e] The in-world date and time (dnd5e 6.0 calendar on Foundry v14 game.time). action "read" (default) reports the calendar in use, whether it is enabled, and the current date / time (year as displayed, month name + number, day, weekday, hour, minute, plus the system's own formatted / approximate strings). "advance" moves time by rounds / minutes / hours / days / seconds (negative rewinds) — this is what triggers dawn / dusk / day recovery and bastion turns when the calendar is enabled. "set" jumps to a date (year / month by number or name / day) and/or a time of day (hour / minute); omitted parts keep their value. Writes report before → after. Enable the calendar / pick one with configure-dnd5e-settings. GM-only writes.

[D&D 5e only] Apply or remove one or more conditions on an actor (blinded, frightened, grappled, poisoned, prone, restrained, stunned, unconscious, exhaustion, ...). Set active=false to remove. Exhaustion is leveled — pass exhaustionLevel (1-6; 0 removes). This authors condition state on a creature; it is NOT a combat-automation loop (no duration countdown / save-ends handling). Use list-actors or get-actor to find the actorIdentifier.

[D&D 5e only] Create a structured physical item (loot/gear) on an actor or in the world Items sidebar. Pick itemType, then supply only the fields you need — sensible defaults fill the rest:

• weapon — to-hit weapon. damage (base die), weaponClass, attackType, reach/range, magicalBonus, properties. Builds a rollable attack activity by default (withAttack). • armor / shield — armorValue, dex, strength; magicalBonus = +N AC. Pass wireAc (BODY ARMOR only) to make the actor derive AC from the worn armor; a shield needs no wireAc (its +2 applies under any AC calc). • wondrous — rings/cloaks/etc. (equipmentType); use magical:true + attunement (a wondrous item has no numeric +N field — model a bonus with manage-effect). • consumable — potion/scroll/ammo/wand. consumableType, uses {max, recovery, autoDestroy}. Ammo can carry damage + ammoReplace + magicalBonus. • tool — toolType, ability, proficient, toolBonus. • loot — gems/art/trade goods (lootType, price). NOT equippable/attunable. • container — bag/chest with capacity and an inner currency pile. Place items inside any container with the container param (id or name).

Cross-cutting: price, weight, quantity, rarity, identified, equipped, attunement (""/required/optional) + attuned, magicalBonus (the +N), properties (incl. "mgc"). Setting magicalBonus/magical adds the mgc flag; the numeric +N is stored for weapons, body armor, and magic ammo (wondrous/potion have no +N field). Unlike add-feature, add-item does NOT reject a duplicate name — intentional, so you can author stacks/copies; de-dupe yourself if you need uniqueness.

Target: actorIdentifier embeds on that actor; omit it to create a reusable world Item (optionally in folder). This authors documents — it does NOT roll, equip-in-combat, or spend charges. For features/attacks-as-abilities use add-feature; for free-form system data use create-item / add-feature. To COPY a real item from a compendium (keeps art + stats), prefer import-item.

[D&D 5e only] COPY an existing item from a compendium pack onto an actor (or into the world Items sidebar), keeping its artwork, full system data, and activities. PREFER THIS over add-item for any real piece of gear — a plain greatsword, a Potion of Healing, a +1 shield, a magic weapon: copying brings the correct PHB/DMG 2024 stats AND the graphic, where authoring from scratch does not.

WORKFLOW: 1) find the item with search-compendium (prefer the 2024 packs: "dnd-players-handbook.equipment", "dnd-dungeon-masters-guide.equipment" — premium books ONLY, never the dnd5e.* SRD); 2) import-item with its packId + itemId; 3) for a CUSTOM item, copy the closest base then refine it with update-actor-item / manage-activity / manage-effect and rename via name.

Optional on-copy tweaks: name (rename), quantity, equipped, identified, container (nest in a bag/chest), folder (world target only). Target an actor with actorIdentifier, or omit it to build a reusable world Item. Use add-item only for genuine homebrew with no compendium base.

[D&D 5e only] Finishing check for authored content — scan documents for the five strict authoring-quality rules and report violations to fix (read-only; never mutates): • rule 8 — placeholder icons (icons/svg/...) on an actor, item, or authored feature. • rule 7 — GM-fudge / pretend-reskin language in a description or biography ("treat its X as Y", "reflavor", "deals necrotic in place of bludgeoning", "pretend", "is really "). • rule 9 — a magic item on an NPC with no matching world-Item loot twin. • rule 12 — a GM-note / spoiler leaked into a PLAYER-VISIBLE item description ("GM:" asides, "the DM", "fill in the …", "ready-made hook", "to suit your table"). Item descriptions only — an NPC biography is GM-facing, so it is not scanned for this.

RUN THIS before declaring a build done. Target what you built: actorIdentifiers (NPCs, with their gear/features), itemFolders (your loot folder), and/or worldItemIds. With NO target it runs a full sweep of every NPC + every world Item. Fix each finding (set a real icon via update-actor-item/update-item/set-actor-art; replace fudge with real mechanics; mint the missing loot copy; rewrite the item description to innocuous in-world flavor and move the GM note to a GM-only journal) then re-run until clean.

Create a dnd5e GROUP actor (type:group) — the shared party stash / travel group. Enrolls world actors as members, can grant every player default ownership (defaultOwnership:'owner' = the classic shared stash), seed shared coin, and optionally crown it the world's PRIMARY PARTY. Member resolution is fail-closed: one bad name and nothing is created. Stock the inventory afterwards with add-item / import-item against the group.

Add and/or remove members on an existing dnd5e group actor. Uses the system addMember/removeMember API; every requested actor gets a reported outcome (added / removed / skipped with reason) and the final roster is echoed back.

Read a dnd5e group actor the group-shaped way: member roster (with dangling ids flagged), shared currency, shared inventory, ownership (default + per-user), and whether it is the primary party. Use this instead of get-actor for type:group.

Read or change the world's dnd5e PRIMARY PARTY (the group shown in the players sidebar; XP awards and party overviews target it). No arguments → report the current primary party. groupIdentifier → point it at that group. clear:true → unset.

Add a feature/spell/ability to an existing actor (NPC or PC). Set mode: • 'compendium-features' — import named class/monster features from an official compendium (PREFERRED for official content, e.g. Pack Tactics, Multiattack, Spellcasting). Params under compendiumFeatures. • 'feature' — author a feature/attack/spellcasting setup/spells from scratch (use only when not available in a compendium). Params under feature (select feature.featureType). • 'items' — attach world items by raw data. For real GEAR prefer import-item (copy from a compendium, keeps art+stats) or add-item (author); use this mode only for free-form item data. Params under items[]. actorIdentifier (exact name or ID) is always required — find it with list-actors / get-actor.

Create a multi-page journal (quest log, handout, lore, GM notes) from STRUCTURED typed blocks — a STRUCTURING tool, it never writes the words. You pass pages of blocks (heading / lead / paragraph / readaloud / gmnote / list / grid / html); the tool renders them in the house style and sets per-page visibility (playerVisible -> players can observe a handout; omit -> GM-only). Compose the prose yourself (that's the journal-builder skill's job). For plain raw-HTML pages use create-journal instead.

Append a link from a quest journal to a REAL world NPC: resolves the actor, inserts a Foundry @UUID[Actor.id]{Name} enricher link (clickable on render) in a GM note, labelled with the relationship. Refuses an unknown NPC (no dead links) — create the actor first.

Append a new styled section to a quest/journal page from typed blocks (e.g. a heading "Session 3" + paragraphs of what happened) — the §8 session-log/progress path. You supply the words as blocks; the tool styles + appends them. By default appends to the first text page; use pageId to target a page, or newPageName to start a new page. Structuring only.

List all journal entries, or read a specific journal/page. Without parameters: lists all journals with their pages (id, name, type). With journalId: reads the journal's first text page content and shows all available pages. With journalId + pageId: reads a specific page's full content.

Search through all pages of all journal entries for specific content or keywords. Returns which specific page matched, so you can read it with list-journals using journalId + pageId.

Create a generic multi-page JournalEntry from caller-supplied pages. Each page is either a TEXT page ({name, content} — HTML, Foundry v13 ProseMirror) or an IMAGE page ({name, kind:"image", src, caption?} — a picture page, e.g. a map legend key), so an image-only journal builds in one call. Unlike create-quest-journal (styled blocks, auto-folders), this takes explicit pages and only folders when folderName is given. Per-page playerVisible exposes a handout; otherwise GM-only.

Generic JournalEntry update: rename the entry (name) and/or set page content. Content replaces the target page — pass pageId to target a specific page, newPageName to add a new page, or neither to update the first text page. For quest-style append updates use update-quest-journal instead. GM-only.

Flip one journal PAGE between player-visible (a handout players can OBSERVE) and GM-only, WITHOUT rewriting its content. Sets the page ownership default. Use this to reveal/hide an existing page — e.g. a page that came up GM-only from an append — instead of rebuilding the whole journal. GM-only.

Delete ONE page from a JournalEntry by page id (from list-journals), leaving the rest of the entry intact. Use to remove a stray/mistaken page instead of deleting and rebuilding the whole journal. GM-only.

Permanently delete one or more JournalEntry documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Set ownership permissions for actors. Use permissionLevel OWNER/OBSERVER/LIMITED to grant access, NONE to explicitly deny it (a stored level-0 entry that OVERRIDES the actor's default ownership), or INHERIT to remove the player's entry so the actor's default applies again. On an actor whose default is permissive (e.g. a shared party stash defaulting to OWNER), NONE revokes access the player would otherwise inherit and INHERIT is what restores it. Supports individual assignments like "Make John the owner of Aragorn" and bulk operations like "Give the party observer access to all friendly NPCs".

List current ownership permissions for actors, showing which players have what access levels. Each row reports the EFFECTIVE level plus its source: 'explicit' (the actor's ownership map holds an entry for that player) or 'inherited' (the actor's default, also reported per actor as defaultPermission). Use it to tell an explicit NONE — a stored deny that overrides a permissive default — from a player who simply has no entry.

Plane B (file channel, read-only). List the immediate contents of a directory under the Foundry Data/ root over WebDAV (folders + files, with size / type / public URL). Use to browse uploaded assets, e.g. worlds/your-world/assets/audio. Empty/omitted path lists the Data/ root.

Plane B (file channel, read-only). Report whether a single path under the Foundry Data/ root exists, and (for files) its size, content-type, last-modified, and public HTTPS URL. A cheap existence/metadata check before uploading or linking.

Plane B (file channel, read-only). Download a file from under the Foundry Data/ root (over WebDAV) to a local path on this machine. For grabbing an existing asset to inspect or re-process.

Plane B (file channel, write). Upload an ASSET (map/token/audio/handout image) from a local file to the Foundry data area over WebDAV and return its public HTTPS URL, so large media bypass the bridge entirely. Missing parent folders are created automatically. ASSETS ONLY — never world-DB files (LevelDB writes while the server runs corrupt it; such paths are refused). PRIVACY: anything under Data/ is served publicly with no auth — do not upload anything sensitive. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Recursively upload a LOCAL directory tree of ASSETS to the Foundry data area over WebDAV, preserving the subtree layout (each file → remoteRoot/), creating parent folders as needed. Use for BULK imports — a scene pack's images, a tiles folder — instead of one upload-asset per file. Skips files that already exist unless overwrite:true; optional includeExt filter (e.g. ["webp"]). ASSETS ONLY — refuses live world-DB paths. Reports uploaded/skipped/error counts. PRIVACY: anything under Data/ is served publicly with no auth. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Create a folder (and any missing parents) under the Foundry Data/ root over WebDAV. Idempotent — succeeds if the folder already exists. Refuses paths inside a live world DB. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Delete a file under the Foundry Data/ root over WebDAV. REFERENCE-AWARE: consults find-asset-references first and REFUSES if any scene/actor/journal/playlist still points at it (pass force:true to override). Deleting a directory requires recursive:true. Refuses live world-DB paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Move/rename a file under the Foundry Data/ root over WebDAV; missing destination parent folders are created automatically. REFERENCE-AWARE: by default REFUSES with a report if anything references the source (moving would break those pointers). Pass relink:true to move AND rewrite all references (old→new), or force:true to move without relinking. Refuses live world-DB paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel, write). Copy a file under the Foundry Data/ root over WebDAV; missing destination parent folders are created automatically. (Copying does not affect existing references, so no reference check is needed.) Refuses live world-DB destination paths. Requires MOLTEN_WEBDAV_PASSWORD.

Plane B (file channel). Return the public HTTPS URL for a file under the Foundry Data/ root. Pure mapping (no network): everything under Data/ is served at the server root (DESIGN §6), e.g. Data/worlds/w/maps/x.jpg → /worlds/w/maps/x.jpg. Useful for turning an uploaded/known asset path into a link Foundry or a player can load.

Reference integrity. Find every world document (scenes, actors, items, journals, playlists, macros, roll tables) that references a given asset path under Data/. Use this BEFORE deleting or moving a file to see what would break. Read-only.

Reference integrity. Rewrite every reference from one asset path to another (e.g. after moving/renaming a file) so nothing breaks. Pass dryRun:true to preview the documents that would change without writing. GM-only.

Composition. Set an actor's portrait image, and by default its prototype token art too, from a Data-relative path. The portrait (actor.img) must be a STILL image; pass tokenImagePath to give the prototype TOKEN an animated video (.webm/.mp4) while keeping a still portrait (the JB2A-effect pattern). GM-only.

Composition. Append an image page to a journal entry from a Data-relative image path, with an optional caption. GM-only by default; set playerVisible to expose it as a handout.

Read a Tom-Cartos-style Foundry SCENE-PACK MODULE off disk (a module.json + LevelDB/NeDB compendium packs — Scene/JournalEntry packs AND modern type:"Adventure" packs whose single Adventure doc embeds every scene/journal) and return its era-normalized documents for import. OFF-LINE and Node-only: it reads files, never the live world. Detects the pack's Foundry era from field shape (older v10/NeDB vs newer v13/LevelDB), extracts each Scene (dimensions, grid, background, thumbnail, walls, lights, regions/teleporters) and JournalEntry (pages), strips cli pack artifacts, and — when given the destination root the skill chose — emits per-asset path REWRITE HINTS (the module-relative %-encoded src → a clean Data-relative path). Also discovers any standalone TILE images the pack ships (building/prop pieces with a Tile_<W>x<H> grid footprint in the name, not referenced by any scene) so the skill can make them available for the GM to drop onto scenes. The heavy per-scene walls/lights/regions are written to PAYLOAD FILES and referenced by placeablesPath (NOT inline — the response cap truncates them at scene scale); pass that path to create-scene, which reads it server-side. The skill then uploads the assets, recreates the scenes/journals, and (modern packs) remaps the cross-scene teleporters. Handles all eras: modern v13/LevelDB (via the @foundryvtt/foundryvtt-cli child process) AND legacy v10/NeDB .db (parsed directly — no cli needed). The full manifest is PAGED to fit the response cap: returns totalScenes + a page of scenes + nextOffset (call again with offset until null). Pass index:true first for a tiny names-only survey of the whole pack (variant planning + dedup) before paging the heavy import.

Create a Foundry Scene from a Data-relative background image path (e.g. an uploaded map). Width/height auto-detect from the image when omitted. Places it in a folder (created if absent) and sets navigation (false = a DM-only scene off the player nav bar) in the same call. AUTO-GENERATES the navigation thumbnail from the background (Foundry-native) when no explicit thumb is given — no more thumbnail-less scenes. Optionally set grid size/type/distance/units/color/alpha, token vision, fog mode, lighting (darkness, global light, or a whole environment{}/fog{} mood object + saved camera for pack imports), weather, a linked playlist/journal, a nav thumbnail, padding, provenance flags, and activate it. Can also IMPORT walls + ambient lights from a map sidecar JSON (the walls/lights arrays many battlemaps ship alongside the image): pass them and they are placed on the new scene (legacy or v14 shapes both accepted, normalized to v14). GM-only.

List Scene documents with id, name, active flag, dimensions, grid size, and background path. Optionally filter by name substring or show only the active scene.

Update an existing Scene document — rename, swap its background image (Data-relative path), toggle navigation, set the navigation label, change dimensions/grid (size/type/distance/units)/padding, token vision, fog mode, lighting (darkness, global light), weather, a nav thumbnail, or the linked playlist/journal ("" clears a link). Also (parity with create-scene) deep-merges a full environment{}/fog{} mood object, re-points the saved camera (initial{x,y,scale}), or re-stamps document flags on an existing scene. Scene-document only: never touches placeables (walls/lights/tokens) and never activates the scene. GM-only.

ACTIVATE a scene — make it the one active scene, which is where connected clients land and where users log in. Foundry allows exactly ONE active scene world-wide, so this deactivates whatever was active; the previous scene is reported back so you can put it back. Activating an already-active scene is a no-op and says so (alreadyActive) rather than pretending it did something. Kept separate from update-scene (which is scene-DOCUMENT-only and never activates) because this changes every connected player's screen. To move only SOME players, leave the active scene alone and use pull-users-to-scene instead. GM-only.

Pull specific users' VIEW to a scene WITHOUT changing which scene is active — the party-split path (one player off in a side scene while everyone else stays put). This is what a cross-scene teleporter does as a side effect of moving a token; here it is the whole operation, so no token has to move. Viewing needs NO scene ownership — Scene#view() has no permission gate, which is why players already move between scenes they do not own. ⚠️ Only CONNECTED users can be pulled: core silently skips offline ones, so this reports pulled vs offline vs notFound per user instead of a blanket success. ⚠️ It also cannot pull the BRIDGE user itself — pullUsers rides a socket emit, which is never echoed back to the sending client (reported as selfSkipped). Look up names with list-users. GM-only.

Assign where a user LOGS IN — a per-user landing scene that persists, so a party split survives a refresh. Core Foundry has no such thing: every user lands on the one ACTIVE scene, and the User document has no scene field to change that (verified on v14.364). This writes a durable User FLAG that the house module fvtt-mod-openserver reads on ready and acts on with Scene#view() — so the module must be installed and enabled for it to do anything, and this tool WARNS when it is not, instead of reporting a working assignment. Unlike pull-users-to-scene, this works on OFFLINE users — that is the whole point. Sticky until cleared: pass sceneIdentifier "none" to put users back on the active scene. Reports who is assigned and who still follows the active scene. Needs NO scene ownership. GM-only.

Permanently delete one or more Scene documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Read a scene's live PADDED-CANVAS geometry (by id or exact name): total width/height, the background rect within the padding (sceneX/sceneY/sceneWidth/sceneHeight), grid size/distance, and rows/columns. A scene insets its background by a padding border, so a placeable's canvas pixel is NOT just gridCell×size — use sceneX/sceneY to offset. Feeds the legend→pins cell→px math. Works on any scene (no need to activate it).

Render a scene in the headless bridge and capture a PNG to a local file — visual QA for imports/maps. Views the scene, waits for the WebGL canvas to draw, fits the whole map into the viewport (or keeps the saved camera with fit:false), and optionally draws numbered markers over each map-note pin (mark:true) to check legend-pin placement (a view-only overlay, no document changes). Returns the file path + scene metadata; open/read that file to view the image. GM-only.

Place one or more TILES (props, roof/overhead pieces, decals, video overlays) on a scene from Data-relative image paths. A tile's on-map SIZE is width/height in canvas pixels; x/y are the absolute-canvas-pixel TOP-LEFT (see get-scene-dimensions for padding-aware cell→px math; the tool converts to v14's center-anchored doc coords — never pre-add width/2 yourself). Optionally set rotation, alpha, elevation, sort, texture tint/fit/scale, roof occlusion (occlusionMode: 1 fade / 4 radial so it fades when a token walks under), light/weather restrictions, video loop/autoplay/volume, hidden, locked. Per-tile error isolation; a 404 texture keeps the path but warns. Returns created ids. GM-only.

List every Tile on a scene — id, position (x/y = the TOP-LEFT in canvas pixels, converted from v14's center-anchored doc coords), size (width/height), rotation, elevation, sort, texture src, image scale, hidden/locked. Read-only; the inspect step before update-tiles / delete-tiles (you need the ids + current values to edit).

Edit one or more placed TILES by id (from list-tiles). RESIZE via width/height (the tile's on-map size — this is "tile scale"; the top-left corner stays put unless x/y is also given); MOVE via x/y (the new TOP-LEFT in canvas pixels — center-anchor conversion is handled for you); also rotation, alpha, elevation, sort, texture src/tint/fit/scaleX/scaleY (image zoom within the frame), occlusion, light/weather restrictions, video, hidden, locked. Patches only the fields you pass; unresolved ids are reported, not fatal. GM-only.

Delete one or more Tiles from a scene by id (from list-tiles). Missing ids are reported, never fatal. GM-only.

Place one or more AMBIENT LIGHTS (torches, braziers, magical glows) on a scene. x/y are the light CENTER in absolute canvas pixels; dim/bright are radii in grid-distance units (feet), NOT pixels. Set color, alpha (tint intensity), angle (cone), luminosity, attenuation (edge softness), an animation (animationType "torch"/"flame"/"pulse" + speed/intensity for flicker), and a darkness activation range (darknessMin ~0.1 so a torch only lights once the scene dims). walls confines it, vision lets it grant sight. Per-light error isolation. Returns created ids. GM-only.

List every AmbientLight on a scene — id, center (x/y), rotation, dim/bright radii, color, cone angle, animation type, hidden, walls/vision. Read-only; the inspect step before update-lights / delete-lights.

Edit one or more placed AMBIENT LIGHTS by id (from list-lights): MOVE via x/y, change dim/bright radii, color, alpha, angle, luminosity, attenuation, the animation (animationType/Speed/Intensity — e.g. add torch flicker), the darkness activation range, walls/vision, hidden. Emission fields nest under config internally — patches only the fields you pass, so a partial change never wipes the rest. Unresolved ids reported. GM-only.

Delete one or more AmbientLights from a scene by id (from list-lights). Missing ids are reported, never fatal. GM-only.

Place one or more positional AMBIENT SOUNDS on a scene (a crackling hearth, a waterfall, dripping cave water) from Data-relative audio paths. x/y are the emitter CENTER in absolute canvas pixels; radius is in grid-DISTANCE units (feet), NOT pixels. Optionally set volume, repeat (loop), walls (muffle through walls), easing (fade by distance), a darkness activation range (night-only sounds), and listener effects (baseEffect/muffledEffect, e.g. "lowpass"). A 404 audio path keeps the path but warns. Distinct from a scene playlist: this is a point emitter players walk into. Returns created ids. GM-only.

List every AmbientSound on a scene — id, name, center (x/y), radius, audio path, volume, repeat/walls/easing flags, darkness range, base effect. Read-only; the inspect step before update-sounds / delete-sounds.

Edit one or more placed AMBIENT SOUNDS by id (from list-sounds): MOVE via x/y, resize the audible radius, swap the track (path), change volume/repeat/walls/easing, the darkness activation range, or the listener effects. Patches only the fields you pass. Unresolved ids reported, never fatal. GM-only.

Delete one or more AmbientSounds from a scene by id (from list-sounds). Missing ids are reported, never fatal. GM-only.

Place one or more DRAWINGS (GM annotation shapes: secret-area boxes, trap outlines, zone labels) on a scene. x/y are the TOP-LEFT origin in absolute canvas pixels; pick a shapeType — rectangle/ellipse (width+height), circle (radius), or polygon (flat relative points list). Style with stroke (width/color/alpha), fill (fillType 1 solid / 2 pattern + fillTexture), and an optional centered text label (fontSize/textColor). hidden:true keeps it GM-only; interface:true floats it above fog. The default stroke makes a bare shape visible as an outline. Per-drawing error isolation. Returns created ids. GM-only.

List every Drawing on a scene — id, origin (x/y), shape type + dimensions (width/height/radius/pointCount), rotation, label text, fill type, stroke color, hidden/locked/interface. Read-only; the inspect step before update-drawings / delete-drawings.

Edit one or more placed DRAWINGS by id (from list-drawings): MOVE via x/y, RESIZE via width/height/radius or replace polygon points, restyle stroke/fill, change or clear the text label (text:""), toggle hidden/locked/interface. The shape KIND cannot change — delete and recreate for that. Patches only the fields you pass. GM-only.

Delete one or more Drawings from a scene by id (from list-drawings). Missing ids are reported, never fatal. GM-only.

Create one or more WALL segments on a scene — surgical additions (block a corridor, add a door/secret door) to walls normally drawn in the app or shipped by a map pack. Each wall is a segment x0,y0→x1,y1 (or c:[4]) in absolute canvas pixels. Channels: move (0/20), light/sight/sound (0 none / 10 limited / 20 normal / 30 proximity / 40 distance — omitted channels default to 20 blocking), dir (one-way), door (1 door / 2 secret) + ds (state) + doorSound, and proximity thresholds. Per-wall error isolation. Returns created ids. GM-only.

List walls on a scene — id, segment c:[x0,y0,x1,y1], move/sight/light/sound channels, one-way dir, door kind + state + sound. A populated scene carries HUNDREDS of walls: pass doorsOnly:true to get just the doors (the usual edit loop). Read-only; the inspect step before update-walls / delete-walls.

Edit one or more WALLS by id (from list-walls): flip a door to secret (door:2), open/close/LOCK it (ds: 0/1/2), change what it blocks (move/light/sight/sound: 0 none / 10 limited / 20 normal / 30 proximity / 40 distance), set one-way dir, doorSound, or proximity thresholds; MOVE by giving the full segment (all of x0,y0,x1,y1 or c:[4] — a wall never half-moves). Patches only the fields you pass; an off-enum value skips that patch with a warning. GM-only.

Delete one or more Walls from a scene by id (from list-walls) — e.g. open up a sealed passage. Missing ids are reported, never fatal. GM-only.

List every PLACED TOKEN on a scene (by id or exact name — any scene, not just the active one) — id, name, position (x/y), size, rotation, elevation, hidden, disposition, actorId, art src + scale, lockRotation. Read-only; the inspect step that feeds update-token / delete-tokens. The token ids also work as the actorIdentifier of the actor tools (get-actor, update-actor, update-actor-item, remove-from-actor, add-item/add-feature, import-item, manage-activity/-effect, apply-condition) — targeting a token id edits THAT instance's own delta, the way to re-gear/wound ONE placed copy of an unlinked NPC (base-actor edits never reach tokens already on a scene).

Place one or more actors' tokens on a scene (batch encounter prep — e.g. drop the whole hobgoblin band on the bridge). Each entry names an actor (id or EXACT name) + an absolute canvas-pixel x/y; the token is built from the actor's PROTOTYPE (so the house token defaults — auto-rotate, ring, disposition — carry over), with optional per-copy hidden/elevation/rotation/name/disposition overrides. Repeat an actor for several copies. The GM can always drag tokens in the app instead — this is for scripted/batch placement. GM-only.

Edit one or more PLACED tokens on a scene — a token INSTANCE already dropped on the map, NOT the actor's prototype token (that's update-actor). Resolve the scene by id/exact name (default: the ACTIVE scene), then target tokens by tokenIds and/or actorIds (an actor id OR exact name — updates EVERY placed copy of that actor, e.g. all "Dead Guard" corpses). Patch any of: rotation (or randomizeRotation for an independent per-token angle), scale (token art size — sets texture.scaleX/scaleY together), imagePath (RESKIN the placed instance — new token art, still image or animated video, existence-checked so a 404 never breaks working art; no more delete+re-place), elevation, hidden, lockRotation, x/y, name, displayName (nameplate visibility), displayBars (resource-bar visibility), bar1/bar2 (which resource each bar tracks — the health bar is bar1 = attributes.hp), ring (dynamic token ring on/off), and hp (this token's CURRENT hit points, per-token on its own delta — so two copies of one actor can be wounded differently, which update-actor cannot do) — all matched tokens update in one batch. GOTCHA handled for you: a token whose actor had auto-rotate OFF carries lockRotation:true, which HIDES a set rotation — so when you rotate a locked token the tool auto-unlocks it and warns. Reports matched/updated counts + any unresolved ids. GM-only.

Remove one or more PLACED tokens from a scene by token id (from list-tokens) — clears the map instance only; the sidebar actor survives (delete-actor removes that). Missing ids are reported, never fatal. GM-only.

Place map-note PINS on a scene, each linked to a JournalEntry (and optionally a specific page) — the deterministic half of the legend→GM-room-pins feature. Pass absolute canvas pixel x/y (see get-scene-dimensions for the padding-aware math), an optional label/icon/size, and the journal id|name. Per-note error isolation: a pin whose journal does not resolve is reported and skipped, not fatal. GM-only secrecy is the linked journal's ownership, not the pin; global only controls fog occlusion. Returns each created note id (for update-note/delete-note). GM-only.

List every MAP-NOTE PIN on a scene — id, position (x/y), label text, linked journal entryId/pageId, icon src + size, fog global, font. Read-only; the inspect step that feeds update-note / delete-note (create-scene-notes places them).

Nudge ONE existing map-note pin by id (the legend→pins review loop): move it (x/y), relabel it, resize/restyle its icon, toggle fog global, or re-point it to a different journal/page. Patches only the fields you pass; at least one is required. Strict scene + note-id resolution. GM-only.

Remove one or more map-note pins from a scene by note id (from create-scene-notes). Missing ids are reported, never fatal. GM-only.

Create one or more Regions on an EXISTING scene (the general primitive behind create-teleporter). Each region carries its v14 shapes whole (rectangle/ellipse/polygon in canvas px) plus optional color/visibility/behaviors. Behaviors pass through verbatim: a teleportToken here must already have system.destinations = ["Scene..Region."] (use create-teleporter for the two-new-region convenience, or add-region-behavior to wire one onto an EXISTING region). Returns the created region ids. GM-only.

List every Region on a scene — id, name, each shape's bounds, and any teleporter destinations. Read-only; use it to find region ids for update-region / delete-region.

Update ONE region by id: rename, recolor, change visibility, replace its shapes whole, or reshape to a single grid rectangle via the rect convenience (center px + cells + snap — the move/resize you'd do reviewing a teleporter). Patches only what you pass; behaviors are left untouched. GM-only.

Delete one or more Regions from a scene by id. Missing ids are reported, never fatal — and if a surviving teleporter elsewhere still points at a deleted region, that orphan is warned. GM-only.

Create a two-way (or one-way) region TELEPORTER between two points on existing scenes — the thing create-scene can only do at import time. Give a CENTER point (canvas px) on each scene (from/to, may be the same scene); a rectangle trigger is placed at each (sized in whole grid cells, grid-snapped by default) and a teleportToken behavior on each points at the OTHER — so a token that walks onto one is sent to the other. Both regions are created before either link is wired (the destination-UUID chicken-and-egg). twoWay:false makes it one-directional. By default the player is ASKED before moving (confirmation dialog — the house pattern for map transitions); confirm:false makes it fire silently (traps/plot teleports only). Regions default to GM/Regions-layer visibility (no player-visible overlay). GM-only.

Add ONE behavior to an EXISTING region — the write create-region only offers at creation time and update-region deliberately never touches. Creates a real RegionBehavior embedded document (validated against the registered behavior types). For teleporters, pass teleportTo {sceneIdentifier, regionIdentifier} and the destination UUID is resolved for you; the landing region's geometry is then sanity-checked and you are WARNED when it contains no grid-snapped token position (the silent teleport no-op: off-grid pads). GM-only.

Second pass of a scene-pack import: rewrite cross-scene teleporter destinations after the scenes + regions have been created. A pack teleporter points at Scene..Region., but the import mints FRESH ids, so every destination is stale until remapped. Pass the import sourceModule; this reconstructs the old→new scene/region id maps from the provenance flags the scenes + regions carry and rewrites every teleportToken destination. Idempotent (safe to re-run), and reports destinations that point outside the import (e.g. a variant you skipped) rather than dropping them silently. Call it ONCE after all chosen scenes are imported. GM-only.

Create a Foundry Playlist from a list of Data-relative sound paths (e.g. ones just returned by upload-asset). Modes: sequential, shuffle, simultaneous, soundboard. GM-only.

List Playlist documents with id, name, mode, track count, and whether each is currently playing.

Update a Playlist's document fields: rename, change playback mode, or set the crossfade duration. Does not add/remove tracks. GM-only.

Permanently delete one or more Playlist documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Author a scene's atmospheric SOUND SETS — the house module fvtt-mod-soundscape (#6), which does what core Foundry cannot: a POOL of small audio files played at randomized intervals with silence between (a crow, quiet, a distant dog), or overlapped into a seamless crossfaded bed. AmbientSound placeables are positional single-file loops and Playlists have no silence-with-variation, so neither covers this. A scene carries any number of sets, stacked and independent. Actions: "list" (what the scene has, plus what would be playing right now and why a set is idle), "library" (browse the prebaked template catalog by section/category/name), "add" (copy a template by name, or author one from explicit files), "update" (patch one set — named fields only; files replaces the whole pool), "remove" (one set, or "all"). Defaults to the ACTIVE scene when no sceneIdentifier is given. Out-of-range numbers are CLAMPED to the module's limits and the clamp is reported, not applied silently. Audio paths are HEAD-checked: a 404 is kept and warned about (a track has no sensible substitute). Sets are inert data without the module, so this WARNS when it is missing or disabled instead of reporting a working soundscape. GM-only.

Create a RollTable from a list of results. Each result is literal text and/or a uuid referencing a REAL premium-book item (rendered as a clickable @UUID link — the way the published loot tables are built; SRD refs are refused). Ranges are auto-assigned from weights (and the formula defaults to 1d) unless you provide explicit ranges/formula. Use for random encounter/loot/rumour/treasure tables. GM-only.

Copy a whole RollTable from a compendium pack into the world (e.g. a DMG treasure / magic-item table). Roll tables are world-only at roll time, so a published table must be imported before roll-on-table can use it; the embedded results — including their @UUID item links — come along intact. Premium-book packs only (SRD refused). GM-only.

List RollTable documents with id, name, formula, result count, and description.

Update a RollTable's fields (name, description, formula, replacement, displayRoll) and/or its entries, two ways: editResults = TARGETED per-entry edits — name an entry by its roll face (e.g. 7 on a d12) or resultId (from get-rolltable) and patch just its text, linked uuid, weight, and/or range; every OTHER entry (ranges, weights, @UUID item links) stays byte-identical — the right way to fix a typo on one entry of a tuned table. text/uuid REPLACE that entry's content (copy the raw text from get-rolltable and change only what you need). results = DESTRUCTIVE whole-set replace (all entries deleted and recreated with auto-assigned ranges). Bad edits are isolated + reported; an introduced range overlap/gap is warned. GM-only.

Roll on a world RollTable and return the drawn result(s). Evaluates without marking results drawn or posting to chat. Any @UUID item links in a drawn result are surfaced as importable (uuid + label) so loot can be pulled into the world. (World tables only — copy a compendium/DMG table in first with import-rolltable.)

Read a RollTable's FULL contents — every entry with its roll range, weight, drawn flag, the result text (HTML/@UUID enrichers intact), and any linked items surfaced as uuid + label — sorted low-to-high so a d table reads 1..N. The deterministic way to inspect or audit a table's entries without brute-force rolling (list-rolltables gives only a per-table summary; roll-on-table draws one random entry). Resolves by id or exact name.

Permanently delete one or more RollTable documents by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Create a Cards stack (deck, hand, or pile) with optional initial cards. Each card has a name and optional face text (HTML shown on the card — e.g. a Deck of Many Things outcome) and/or img (a Data-relative path), plus a card-level description (GM/meta note). Use for custom themed decks (Deck of Many Things, tarokka, encounter decks). GM-only.

Instantiate a core Foundry PRESET deck into the world (e.g. "pokerDark"/"pokerLight" — a standard 52-card deck). Cards have no premium-book compendium, so this is the ready-made deck path; build themed D&D decks with create-cards. GM-only.

List Cards stacks with id, name, type (deck/hand/pile), and card count.

Permanently delete one or more Cards stacks by exact id or exact name. STRICT resolution — no fuzzy/substring matching. GM-only.

Post a message to the Foundry chat log as the GM bridge user. Content is HTML. Choose a visibility mode (public / gm whisper / blind / self) and optionally speak AS a character (speakerActor). Embed images via the images param (local files upload over WebDAV; Data-relative paths and https URLs link directly — uploaded files are PUBLIC). GM-only.

List recent chat messages (id, author, time, whisper/blind, content preview). Use to find ids for delete, verify a post, or preview before export. contentMode:"none" keeps it cheap on a huge log.

Delete chat messages: by exact id(s) (a single id is an array of one), or all messages older than a timestamp (beforeTimestamp + confirm:true — handy for the known Molten big-log perf drag), or the entire log (clearAll + confirm:true). Both bulk modes need confirm:true. IRREVERSIBLE. GM-only.

Export the chat transcript to a LOCAL absolute file AND/OR a WebDAV Data/ path (returns its public URL). Formats: markdown | html | json | plaintext. Refuses to overwrite an existing file at either destination unless overwrite:true. WebDAV needs MOLTEN_WEBDAV_PASSWORD.

Post a rich dnd5e card for an actor's item/feature/spell with WORKING buttons (Attack/Damage/Apply-Effects), or roll an attack/damage to chat. Drives the dnd5e Activity system — the only way to get interactive buttons without a module. Items with no activity return a clear reason (use send-chat-message for a plain card). GM-only.

Post a click-to-roll request card (saving throw / ability check / skill) that players click to roll their OWN check — the table-facing "everyone make a DEX save (DC 15)" prompt. Uses the dnd5e inline roll enricher. GM-only.

List every user account in the world: id, name, role (player/trusted/assistant/gamemaster), whether they are currently connected, player color, pronouns, avatar, their assigned character, and their LANDING SCENE if one is set (where they come up at login — shown only when assigned, since an unassigned user just follows the active scene). The read to run before update-user and set-landing-scene.

Update a Foundry user account: permission role (e.g. demote a trusted player to player), login name, player color, pronouns, or assigned character. GM admin — guarded so the bridge user's own role and the world's last gamemaster cannot be demoted.

Set a Foundry user's avatar — the portrait shown next to that user's chat messages. Defaults to the bridge user (MCP-Claude), so this is how you give the MCP's own chat posts a portrait instead of the default mystery-man. Pass a Data-relative path or https URL (upload local files with upload-asset first). GM-only.

Create a world Macro — a hotbar button. type "script" (default) runs JavaScript as the clicking user (e.g. dnd5e.documents.macro.rollItem("Graze") rolls that item on their assigned character); type "chat" posts its text to chat. Optionally grant a player OWNER access and pin the button to their hotbar (hotbarUser + optional hotbarSlot, default first free slot) in the same call — the way to hand a player a one-click ability. GM-only.

List every macro in the world: id, name, type (script/chat), author, icon, a command preview, and every user hotbar slot it is pinned to. The read to run before delete-macro.

Delete world macros by id or exact name, scrubbing any user hotbar slots that pointed at them so no dead buttons are left behind. GM-only.

Read or configure the combat tracker (the world's core.combatTrackerConfig setting): the custom TURN MARKER shown under the active combatant (enabled / animation / image src / disposition tint), the tracked resource, and skip-defeated. Call with NO arguments to read the current config and the valid animation ids. Changed fields echo previous → new; re-applying the current value is a clean no-op. GM-only.

Fold Battle Flow's stat-stamped chat messages into per-combat analytics: damage dealt/taken (with per-round rate), healing + overheal, verdict-flip credits, spend economy (resource pools AND spell slots), buff-die (Bless) margin flips, and session flavor (nat 20s/1s, advantage economy, death saves). Read-only scan; reverted applications are subtracted; unlinked monsters aggregate by archetype. GM-facing — filter at call time via sections/actor/combat/since. includeLedger:true appends the folded JSON for charts.

Log the DM Assistant bridge user out of the live Foundry world: closes the persistent headless browser session so the user goes inactive (drops off the active-player list). The world itself keeps running and the MCP server stays up — the NEXT tool call transparently reconnects (wake → join → ready), so nothing needs to be restarted. Use at the end of a work session ("log out please"); safe to call any time — already disconnected is a clean no-op.

Read the sidebar folder TREE — every world folder (or one document type) in tree order with its id, nesting depth + "/"-joined path, hex color, raw sort value, parent, direct document count, and subfolder count. Siblings are listed ALPHABETICALLY — which matches how the v14 sidebar actually renders FOLDERS (it ignores sort for them), so this listing order IS the sidebar order. The inspect step the folder tools were missing: find the ids/names for update-folder (rename/recolor/reparent), delete-folder, move-documents, and the folder params on the create tools — without guessing what exists. Read-only.

Create a sidebar Folder for any world document type, optionally nested under a parent folder of the same type. Use to organize generated content. GM-only.

Update a sidebar Folder in place — rename it, recolor it, set its raw sort, and/or reparent it (nest under another folder of the same type, or pass parentFolder:"" to move it to the root). Resolves the folder by exact id or exact name+type. Use this to RENAME a folder without the move-documents + delete-folder dance. To reposition a folder, RENAME it — sort does not drive folder order in the v14 sidebar. GM-only.

Move one or more world documents of a single type into a target folder (resolved by id or name; created at root if absent). Pass an empty targetFolder to move them to the root. GM-only.

Permanently delete many world documents of a single type by exact id or exact name. STRICT resolution — no fuzzy/substring matching. IRREVERSIBLE — pass dryRun:true first to preview exactly what would be deleted. For folders use delete-folder. GM-only.