xenodot

Plugin xenodot from marketplace xenodot-forge in arthur0n/xenodot-forge. Commands read from the repo's manifest — 1 month ago.

Skills (50)

• agent-report

  The agent→orchestrator handoff protocol. A backgrounded worker's relayed result string truncates on long, tool-heavy turns, so the handoff is an artifact, not a string — the worker Writes its full report to a file, and the orchestrator reads that file directly. Load this whenever a task asks you to

• autonomous-main-goal

  The hive's Autonomous Mode self-drive loop. When a standing Main Goal is active, evaluate it, break it into ordered slices, then on each `[Autonomous check #N]` cycle assess progress, dispatch the next slice, and record one-line status via mcp__ui__autonomous — until the board satisfies the goal. HI

• caveman

  Ultra-compressed communication mode — always active for this agent. Cuts token usage ~75% by dropping filler, articles, and pleasantries while keeping full technical accuracy. Drop only when interviewing the user via mcp__ui__form (labels/descriptions must be clear prose).

• godot-3d-pixelation

  SubViewport-based low-resolution crisp rendering of a 3D scene in Godot 4.x — the foundation of the "3D pixel art" style. Use for pixelated/retro/PSX/low-res 3D, setting SubViewport render resolution, "crisp pixels", restructuring a scene tree so 3D renders below window resolution, or when a downsca

• godot-animation-libraries

  Import and play skeletal animations on a sourced 3D character in Godot 4.6 — the separate-glTF workflow (one model file + anim-only files), merging anim clips into an AnimationLibrary loaded onto your own AnimationPlayer, and retargeting a foreign animation (e.g. Mixamo) onto your skeleton via Skele

• godot-arena-spatial-design

  OPT-IN spatial-design principles for a combat/arena encounter space in Godot — nine measurable properties (loop topology, interior cover, partitioned sightlines, cover mix, bounded verticality, landmarks, spawn-to-engagement pacing, scale/density, choke-vs-open) that turn a flat blockout into a real

• godot-art-style

  Single source of truth for a 3D-pixel-art game's palette + visual style language in Godot — a shared `tools/art_style.gd` const module of NAMED swatches and style scalars that the procedural generators (`gen_textures.gd`, `gen_models.gd`) `preload()` and read, so textures and models cohere by constr

• godot-code-rules

  Strict typed-GDScript rules (the tsconfig-strict + ESLint equivalent) — full typing, explicit return types, warnings-as-errors, size caps, file headers, @warning_ignore policy, gated by tools/validate.sh. Load BEFORE writing or editing ANY .gd file, when validate.sh / gdlint / gdformat fails, on a t

• godot-composition

  Composition conventions ("SOLID translated to Godot") — component nodes over inheritance, signals up / calls down, scene as the unit of composition, and when (not) to modularize. Load before structuring an entity with more than one behavior, before any refactor/extraction, when a script grows past o

• godot-data-driven-composition

  The GENERIC data-driven composition pattern in Godot 4.x — a typed `.tres` Resource carrier holds an ordered list of typed, composable pieces, so new variants are authored as DATA (a new `.tres`), not code. The shared base for the two flavours — stateless fire-once `Effect` Resources (`godot-effect-

• godot-docs

  The Godot docs MCP (mcp__godot-docs__*) is the SOURCE OF TRUTH for engine API — class names, method/signal/property signatures, enums, and deprecations. Use BEFORE asserting any API: when unsure of a signature, when a `VERIFY-FAIL unknown property` smells like a Godot 3→4 rename, or when choosing be

• godot-effect-composition

  The STATELESS flavour of data-driven composition (Godot 4.x) — a `.tres` ability/cast Resource holds an ordered list of fire-once `Effect` Resources (WHAT) + a `TargetResolver` (WHOM); runtime values ride a `Context` DTO; the apply loop lives in the entity that owns the trigger. New ability = a new

• godot-enemy-ai-headless-smoke

  How to TEST a Godot enemy AI when `--headless` has no RenderingDevice and doesn't sync `Area3D` overlaps — so you CANNOT assert real pathing, vision-cone detection, or hearing headless, and a "does the enemy chase?" headless test can NEVER pass. The one nav fact you CAN assert headless: the runtime

• godot-enemy-ai

  Build a patrolling/chasing enemy in Godot 4.6 from NATIVE nodes only — a baked NavigationRegion3D + NavigationAgent3D for 3D pathfinding/avoidance, a node-based StateMachine component (patrol → chase → attack) composed onto a CharacterBody3D, and a detection-radius + line-of-sight perception seam th

• godot-enemy-archetype

  The STATEFUL flavour of data-driven composition (Godot 4.x) — trait-mixing enemies via an `EnemyArchetype` Resource (`.tres`: stats + an ordered list of behaviour `PackedScene`s) whose pieces are stateful `EnemyBehaviour` child NODES instanced fresh per enemy, NOT stateless Resources. One generic `E

• godot-export-builds

  Export a Godot-family game to a shippable build from the command line — headless `--export-release` to desktop (macOS / Linux / Windows) first, web (HTML5) gated behind a renderer spike, then upload to itch.io with butler. Use when packaging a build for distribution, shipping a POC to itch.io, setti

• godot-first-person-controller

  First-person CharacterBody3D player in Godot 4.6 — yaw the body / pitch a child Head holding a perspective eye-camera, raw mouse-look, camera-relative WASD, gravity from ProjectSettings, jump on is_on_floor, plus flat sprint (hold-to-run speed multiplier), crouch (hold-to-lower eye height + collider

• godot-foliage

  Build animated billboard foliage (grass, vegetation) for a TOP-DOWN / ORTHOGRAPHIC 3D pixel-art Godot 4.x project — dense MultiMeshInstance3D blades that face the orthographic camera via camera-BASIS billboard, optional noise-driven wind sway, and an optional low-framerate "handdrawn" TIME-quantized

• godot-greybox-to-asset

  Migrate a finished greybox blockout to final sourced assets in Godot 4.6 — the REPLACE half of the blockout loop (godot-greybox BUILDS it; this skill RETIRES it). Identify every BoxMesh greybox node in a level `.tscn`, batch-source/verify the `.glb` models and tileable surface textures through the a

• godot-greybox

  Fast HAND-AUTHORED STATIC blockout for prototyping ANY level in Godot — write real, editable nodes (one floor, walls/props, hazards, NavigationRegion3D) DIRECTLY into `levels/<name>.tscn` so every piece is selectable and movable in the editor. Turns a level-designer concept brief into a measurable,

• godot-gridmap-level

  Build a tile-based 3D level from a drawn grid (levels/drawn/current.json) with GridMap + MeshLibrary so geometry is computed and grid-snapped, not hand-authored. Use for any Draw-level brief citing current.json, a level with more than ~10 wall/floor pieces, or when hand-typed Transform3D walls clip,

• godot-hd-material-import

  The HD-PBR import delta for a SOURCED HD texture set in Godot 4.6 Forward+ — layered on the neutral godot-texture-import base (sidecar structure, texture_filter enum, tiling, Make-Unique). This skill sets the HD VALUES and wires a full-PBR StandardMaterial3D / ORMMaterial3D: LINEAR filter + mipmaps

• godot-looping-particle-vfx

  Persistent LOOPING 3D particle VFX for a Godot 4.6 Forward+ game — fire, smoke, torch, aura, magic loops — the opposite-lifecycle sibling of godot-oneshot-vfx. A Node3D-rooted rig groups two GPUParticles3D (`one_shot=false`, `emitting=true`, never emits `finished`, never self-frees) — a billboard fi

• godot-main-scene

  Create the thin main.tscn entry point (set as run/main_scene) that owns the persistent shell — SubViewport pixelation rig, camera rig, UI — and loads/swaps level scenes under a container node. Use when the project needs a main scene, run/main_scene is unset in project.godot, levels need loading/swit

• godot-mesh-import-hd

  The standard-HD surface delta for a sourced .glb prop in Godot 4.6 Forward+ — layered on the neutral godot-mesh-import base, which owns place/import, scale, nested-instance, greybox swap, auto-collision and Make-Unique. This skill adds ONLY the HD look: full PBR (albedo/metallic/roughness/normal/AO,

• godot-mesh-import-pixel-art

  The PIXEL-ART surface delta for a sourced low-poly .glb prop in Godot 4 — layered on the neutral godot-mesh-import base, which owns place/import, scale, nested-instance, greybox swap, auto-collision and Make-Unique. This skill adds ONLY the pixel look: NEAREST texture filter on the model's material

• godot-mesh-import

  The aesthetic-NEUTRAL structural workflow for importing a SOURCED .glb model in Godot 4 as a discrete prop — place/import, glTF Advanced-Import (skip a node, override-vs-extract a material, embedded textures, normal-map invert-Y), near-uniform scale, nested-instance vs inherited vs make-local, 1:1 g

• godot-navmesh-pathing-4-6

  The Godot 4.6 navmesh + NavigationAgent3D INTEGRATION layer beneath `godot-enemy-ai` — the runtime-bake + nav-server-sync + entity-velocity-ordering gotchas that make an agent actually move in 4.6, where the editor "Bake NavigationMesh" silently ships an EMPTY mesh. Covers: baking at RUNTIME in the

• godot-oneshot-vfx

  Fire-and-free 3D combat VFX for a first-person shooter POC in Godot 4.6 — a reusable vfx_base.tscn (Node3D root + GPUParticles3D child) one-shot rig that frees itself on the `finished` signal, plus a thin router COMPONENT (not an autoload) that maps existing gameplay seams (`fired` / `hit` / `died`)

• godot-orthographic-follow-camera

  Orthographic Camera3D at a fixed angle on a pivot that smoothly follows a target — the default camera for top-down / isometric 3D pixel-art games. Use when a top-down/iso game needs its camera, the view looks distorted or "too 3D", an isometric/fixed-angle follow is wanted, or setting up a top-down

• godot-pixel-lighting

  Pixel-readability-first lighting for the 3D pixel-art blockout — one DirectionalLight3D "sun" with hard shadows, Sky/Color ambient fill, Filmic tonemap + fixed exposure on the SubViewport Environment. Use when lighting or re-tuning a level, when a ground shadow or jump landing isn't readable, when t

• godot-playgrade

  The rubric CONTRACT for grading a built Godot game by PLAYING it, not reviewing its code — the deterministic half of the generator-evaluator loop. Use when grading a build against its design Acceptance: run tools/playgrade.sh (it scores runs-clean / renders-healthy / core-loop-functional / data-driv

• godot-playthrough-bot

  The headless INPUT-DRIVEN playthrough bot for a Godot-family game (4.x) WITHOUT GdUnit4 — an `extends SceneTree` tool script (`tools/bot_playthrough.gd` / `tools/play_<slug>.gd`, run via `$GODOT --headless --fixed-fps 60 --script`) that drives the real INPUT layer on a timeline (walk/jump/crouch/aim

• godot-procedural-model

  Generate local placeholder low-poly .glb MODELS procedurally by kitbashing primitives (box/cylinder/cone) and exporting via GLTFDocument, using the reusable headless tool tools/gen_models.gd. Use when the prototype needs discrete props (furniture, items) fast and locally — no web catalogues, no AI,

• godot-procedural-texture

  Generate local placeholder pixel-art SURFACE textures procedurally with the Godot Image API, via the reusable headless tool tools/gen_textures.gd. Use when the prototype needs tileable wall/floor/fabric textures fast and locally (no web generators, no human upload) so a scene reads as a whole. These

• godot-project-baseline

  Establish or verify a Godot 4.x project's game-agnostic baseline — quality gates (warnings-as-errors, gdlint/gdformat), folder layout, naming, physics layers, input map — and record it in CLAUDE.md as the single source of truth. Use FIRST in any new project, on "set up the project" / "start a POC" /

• godot-runtime-arena

  Resource-driven arena assembled at RUNTIME in Godot — author an `ArenaLayout` `.tres` (footprint, cover pieces with class, verticality, lanes, landmarks, spawn markers, fall zones) that ONE builder node instantiates in `_ready()`, plus a headless layout self-audit that REPORTS spatial metrics. OPT-I

• godot-runtime-smoke

  The L2 runtime-smoke layer for a Godot-family game (4.x) WITHOUT GdUnit4 — a headless SceneTree tool script (`tools/smoke_*.gd`, run via `$GODOT --headless --script`) that boots a real scene, drives ONE gameplay seam programmatically (call `weapon.try_fire()`, simulate a hit), and ASSERTS runtime ou

• godot-screen-effects

  Build screen-space post-process effects in a Godot 4.x 3D project — the fullscreen-quad rig plus reading the screen/depth/normal buffers in a spatial shader, the foundation for outlines, edge detection, fog, and depth visualization. Use when adding a custom post-process effect, when a post-process s

• godot-shooter-enemy-combat

  The hit / death / kill-confirm contract for a SHOOTABLE enemy in a shooter game in Godot 4.6 (camera-agnostic — first- or third-person) — projectile or hitscan damage, NOT melee/RTS/other-genre enemy combat. Enemy health + score_value, a `died(enemy)` signal, a duck-typed `on_hit()` shootability sea

• godot-stealth-perception

  The "find player" / aggro-trigger stack for a stealth enemy in Godot 4.6 — a `VisionCone3D` (tattomoosa addon, Area3D, an FOV cone with a LOS test) + a custom `HearingArea` (Area3D radius) + a thin `emit_noise()` seam, all feeding a node-FSM with Patrol → Aggro → Alert → Search states and a recorded

• godot-texture-import-pixel-art

  The PIXEL-ART import delta for a texture in Godot 4 — layered on the neutral godot-texture-import base, which owns the `.import` sidecar structure, the `texture_filter` enum trap, surface tiling and the Make-Unique gotcha. This skill sets ONLY the pixel VALUES: NEAREST filter, no mipmaps, uncompress

• godot-texture-import

  The aesthetic-NEUTRAL mechanics of importing a texture and binding it in Godot 4 — the `.import` sidecar structure (which keys are art-dependent vs fixed), the `texture_filter` enum trap (1 NEAREST / 3 NEAREST_WITH_MIPMAPS / 5 LINEAR_WITH_MIPMAPS), tiling a surface (Texture Repeat + `uv1_scale` size

• godot-travelling-projectile-3d

  Fire a travelling 3D projectile in Godot 4.6 — spawn at a Marker3D muzzle, detach with top_level, move forward along -Z each physics frame, despawn on max range or Area3D hit, gated by a one-shot Timer fire-rate cooldown. A host-agnostic firing component (attaches to any entity). Use when building a

• godot-verify

  Verify Godot scenes/scripts actually load, run, and visibly render — catching silently-dropped invalid properties and "valid but renders nothing" (black-screen, no-error) scenes. Use after ANY .tscn/.gd change and before claiming work done or verified — never assert a scene runs without these checks

• graphify

  Query the game's knowledge graph for codebase / architecture / file-relationship questions — when graphify-out/graph.json exists, treat the question as a graphify query FIRST. Thin wrapper over the installed graphify CLI (query / path / explain / update); the graph lives in the game's graphify-out/.

• level-design-principles

  Level-design interview principles for the level-designer agent (from Langeskov/Lilford theory) — verticality, space contrast, shape variety. Use when starting a level-designer interview — establish the level's concept FIRST (what it is about), then ensure the brief captures variety and avoids flat/b

• library-record-writing

  How a *-researcher writes a durable `library/<kind>/` record — the machine-face frontmatter rule, the index-append step, the one-page limit, and the post-adopt/post-build 4-field Lesson section. Use whenever an addon / cli researcher writes its verdict doc (`library/addons/<slug>.md`, `library/tools

• research-presenting

  How a *-researcher presents a finding/verdict to the human — the 6-bucket framework. Use whenever an addon / cli / skill / transcript researcher is about to present an adopt/reject/keep verdict: never gate on a bare verdict — decompose into the six buckets first, put the verdict ON TOP, and (where t

• tasks-mcp

  Use mcp__ui__tasks as a plan and scratchpad inside any agent run. Add tasks at start, update status as you work, then close them in one call (op complete_open) before you hand off or return. Visible in the UI right rail and persistent across sessions.

Subagents (19)

• addon-researcher

  Addon researcher agent for the game project — the framework's buy-vs-build gate. When a request smells like a solved problem (dialogue, inventory, save/load, state machines, pathfinding, debug overlays, tweening helpers…), this agent searches for FREE Godot addons/plugins that already do it, evaluat

• art-director

  Art direction specialist for the Xenodot framework. Owns the cohesive VISUAL look — palette, value/saturation language, mood — across a game's placeholder art, by setting direction that the procedural generators (via the godot-art-style config) and godot-dev then apply. Use when the look feels incoh

• asset-advisor

  Art-asset specialist for the game project — the art analogue of addon-researcher. Use at two gates of the asset-sourcing loop, for either medium — a texture (PNG) or a 3D prop (a sourced .glb model). BEFORE filing an art request, to classify the asset by medium and kind (texture: sprite / billboard

• bug-triage

  Bug triage agent for the game project — the framework's learning loop. Given a bug that occurred (ideally with how it was found and fixed), a friction report from a small task (improvised pattern, first-try verify failure, scope overrun, ambiguous guidance), OR an evaluator-divergence report (a huma

• cli-researcher

  CLI tooling researcher for the game project — the framework's agent-capability gate. When an agent flags a capability it lacks (do or perceive something at runtime that no skill or file-edit covers — render a frame, capture debug output), this agent decides the transport (CLI by default, MCP only fo

• game-designer

  Game designer agent for the game project. Turns a feature or game idea into a small, buildable design doc in design/. Use BEFORE implementing anything non-trivial — when the user asks for a feature, mechanic, or system whose scope is unclear or too big to build and verify in one step.

• godot-assets

  Godot 4.6 ASSETS builder for the game project — importing and procedurally generating placeholder art. Use to import + wire a sourced .glb model or texture per the game's art style (pixel-art: NEAREST/no-mipmap; HD: LINEAR/mipmaps + PBR; colliders, Make-Unique materials), or to generate placeholder

• godot-dev

  Godot 4.6 CORE/general builder for the game project — project setup, the main scene + level loading, tile-based level geometry (GridMap), export, and general glue code. The default builder for scaffolding and anything not owned by a specialist. Route DOMAIN work to the specialist instead — enemies/A

• godot-docs-evangelist

  Godot documentation source-of-truth agent for the game project. The orchestrator dispatches this agent when a builder needs authoritative API verification beyond a quick inline lookup — confirming a method/signal/property signature, settling a deprecation, mapping a Godot 3 API to its Godot 4.x repl

• godot-enemy

  Godot 4.6 ENEMY builder for the game project — enemy entities, AI, and data-driven archetypes. Use for a shootable enemy (health/death/score via the hit/kill contract), enemy AI (patrol/chase/aggro/line-of-sight via native nav + a node-FSM, NO behaviour trees), or trait-mixing enemies via `EnemyArch

• godot-player

  Godot 4.6 PLAYER builder for the game project — the player entity, cameras, and character animation. Use for a first-person CharacterBody3D controller (mouse-look, camera-relative WASD, sprint/crouch, view-model feel), the orthographic top-down/iso follow camera, or playing/retargeting skeletal anim

• godot-playtester

  The embodied EVALUATOR for the game project — the distinct judge in the generator-evaluator loop. Given a built feature with a design doc, it PLAYS the build (not reviews its code): authors adversarial play_*.gd bots from the design's Acceptance, runs the deterministic grader tools/playgrade.sh, and

• godot-refactor

  Mechanical modularization agent for this Godot project. Extracts existing behavior into component nodes/scenes per the godot-composition skill — no design decisions, no behavior changes, no new features. Use when a script has grown past one job, when a second entity needs behavior that already exist

• godot-vfx

  Godot 4.6 combat-VFX builder for the game project — one-shot and looping particle effects. Use for one-shot bursts (muzzle flash, impact, death burst, shockwave) that react to `fired`/`hit`/`died` signals and free themselves, or persistent looping particle systems (auras, trails, ambient emitters) w

• godot-visuals

  Godot 4.6 VISUALS builder for the game project — the rendered look. Use for the game's render rig (e.g. a SubViewport low-res pixel-art rig when its art style calls for one), lighting (DirectionalLight sun + ambient + tonemap/exposure), screen-space post-process shaders (outlines, edge detection, fo

• godot-weapons-abilities

  Godot 4.6 WEAPONS/ABILITIES builder for the game project — weapons, travelling projectiles, and the data-driven ability/effect layer. Use for a travelling projectile weapon with fire-rate, the fire→hit contract, or a data-driven ability/effect system (damage/heal/knockback/slow authored as `.tres`,

• level-designer

  Level designer agent for the game project. Turns a hand-drawn blockout grid (from the UI "Draw level" tool, saved to levels/drawn/current.json) into a level-design brief that game-designer turns into the build. It reads the drawing, interviews the user concept-first — what the level is ABOUT before

• skill-researcher

  Skill researcher agent for the game project — the framework's self-improvement loop. When a task has NO matching godot-* skill (godot-dev reported a gap, or the orchestrator sees none applies before dispatching), this agent searches the external skill library, evaluates candidates against project co

• transcript-researcher

  Transcript researcher agent for the game project — the framework's source-driven harvester. When we are ABOUT TO BUILD something in a domain a saved video transcript covers (lighting, shaders, a mechanic…), this agent reads the raw transcript dropped in the project's `transcripts/` folder, distills

Hooks (12)

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/rtk-rewrite.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/deny-orchestrator-git.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/block-destructive-git.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/block-destructive-shell.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/rtk-usage-log.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/read-dedup.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/grep-usage-log.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/allow-game-edits.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/deny-orchestrator-game-edits.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/allow-subagent-ui-control.sh"

• PreToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/caveman-reminder.sh"

• PostToolUse

  bash "${CLAUDE_PLUGIN_ROOT}/hooks/graphify-update.sh"

Similar plugins