GripForge

Concept art for a whole game, reused before generated. Use it when a user asks for a game like a title they name: call stage=plan with the game as they wrote it. When the user describes specific items (heroes, weapons, props…), pass them in wishes: they are drawn exactly as asked. The plan lists concepts that already exist for that game (GripForge community catalog or the workspace) and theme assets already in the library: reuse them first. It then prices the missing concepts: one style bible, heroes and bosses one image each (MOBA and hero games: each hero with its ability kit and ability icons, see hero_kits), enemies, NPCs, weapons, vehicles, buildings, props and VFX in sheets of 6 cut automatically, textures in sheets of 2 turned into seamless 1024 px textures. Maps (counts.maps) are environment paintings, one image each: the level is then built and dressed to match them. Show the plan and price to the user; only call stage=build with a budget after they agree. Concepts are private review images; nothing is sent to 3D. The plan also returns ambient_kits: the kits of the theme's atmosphere (weather, lighting, snow tracks) with their config; install them in the game project next to the blueprint's gameplay kits.

Journey — the content of the game. Once written, gripforge_game_audit says what a finished game of the genre still lacks (a quest, a way to win and to lose, dialogues…). Read and write the content of a Game Kit project (gkp_…) — what game.engine builds the game from, no engine code needed. kind: archetype (an entity template: kind prop|npc|…, asset { item: lib_… } bound to content:<id> | { slot }, components claimed by kits — see gripforge_game_engine blocks — and gives { quest, offer, progress?, thanks? } for "this NPC gives this quest"), scene (world { kit, config?, doc? }, entries, instances [{ id, archetype, at, yaw?, place?, set? }], zones, layers, ui), script (gripforge.script/1: { id, on: <instance> | archetype:<id> | scene:<id>, rules: [{ when, if?, then, else?, once? }] } with sugars { "interact": "self" }, { "enter": zone }, { "state": { open: false } }, { "quest": id, "is": "completed" }, { "talked": npc }, engine verbs set_state, play_clip, set_solid, show, hide, enable_script, disable_script, load_scene, end_game, call, set_talk and kit verbs as shorthand { "give_item": "key" }), mission (alias quest), dialogue, npc, item, translations, code_module (what game code registers: verbs, components, services, entity kinds), zone, trigger. action=list (kind optional: counts), get (kind, id), put (kind, doc or docs: upsert, validated against the declaring kit schema), remove (kind, id), validate (dry run of a put: the report it would give), place (scene, archetype or asset lib_…, at, yaw?, id?, place ground|none: the placement on the ground is baked once on the server, the same on every engine), bake (re-bake the placements of a scene after its world changed). Writes return the content report after the change; the report never refuses a write — only a document invalid for its schema is. 0 credits.

The website and CLI share this saved 3D game creation workflow. Ask which engine (Unity, Godot, Unreal, Three.js) if unspecified; do not choose silently. create saves a brief without spending. quote(operation=plan) estimates AI preparation, accept(quote_token) starts its durable job ONLY after user approval of the shown price. get returns a persistent operation log, slots, studio_url and the same project to resume. Planning can select an appropriate preset OR compose real engine-compatible modules. A missing preset never means the genre needs a native engine. composition.modules pins all module versions; composition.tasks lists the custom logic still to implement. New plans return design from a separate game-designer agent: named content lists and their counts, animation clips per actor, user-request versus agent-proposal attribution, assumptions and a machine-readable completion contract. Show this saved scope before assembly; refine changes it. get also returns production_sources. quote(operation=produce, production_source=one source ID) estimates a bounded production batch for any contract content, animation, capability or journey obligation; omit production_source to choose the next unprepared source. After price approval, accept runs decomposition, compatible Library matching, authored source documents and at most one concept board for missing visual assets, cropped into individually traceable review drafts. Audio, animation and executable VFX never become complete through a picture. An unavailable matcher with candidates requires review rather than speculative replacement. production.batches persists tasks, dependencies, acceptance checks, candidates, concepts, text, deferred work and diagnostics. asset_matched is not acquisition or integration. draft_ready is not gameplay verification. Changed design fingerprints retain old batches as stale. Use existing concept review/manufacturing and content tools for integration; Develop can read production batches using creation_production. Never report prepared-source coverage as game completeness. Assembly persists that contract on the project before auditing. A design is not implementation or passing evidence. The quoted planning budget includes this bounded stage; old accepted jobs retain their original behavior. New plans also return world: structure (open_world, semi_open, linear, arena, interior or circuit), deterministic seed, validated kit configurations, level documents and remaining work. Assembly applies this saved layout atomically. Reuse it when continuing in the CLI; a visual-theme change does not imply changing geography. A seed change alone is not a designed level. Show world.remaining, including unbuilt architecture or transitions, before calling the game complete. Assembly is a foundation, not a completed custom game: For contract-backed web games, quote build includes a persistent queue derived from every named source and capability, with isolated authoring sessions and independent final verification; there is no twelve-turn limit for the entire game. Review the quoted maximum before acceptance. Unattempted credit-funded tasks are not charged. development.work records reported_unverified and blocked tasks, retained authoring IDs and pending IDs; these are not release evidence. delivery.status=ready requires the build-specific contract and final checks. For an assembled project, quote operation=develop with an optional message to continue the saved queue under a new approved budget, preserving the same project and completed authoring work. The development result distinguishes agent-declared changes, actual checks, remaining work and unsupported runtime capabilities. Each additional pass needs its own estimate; no paid asset generation is included. Native/custom-code development still uses the CLI. After a build, get also returns creatures (the models bound so that no unit is a capsule) and audit { verdict: complete | playable_with_defects | incomplete, headline, fixed (the free fixes applied: models, standard clips, control scheme), defects [{ severity, message, fix { tool, args, credits? } }], next }: show the user the verdict and what is left, work through next (gripforge_game_audit reads it again), and never present a verdict other than complete as a finished game. quote refine with message updates the same plan after approval, preserves selected assets and reviewed work, and persists the conversation. use_reference with slot_id and an owned image asset_id supplies an uploaded concept for visual review. assets searches workspace/community items by actual role before invented generation details. Generic nature packs may cross world themes while keeping the rendering look. New plans consider available styles before inventing one; selection_reason explains planner choices. other_styles=true reveals alternatives with explicit mismatch/unknown compatibility for manual review; never bind a known look mismatch automatically. Prefer reuse before generation; select chooses one or sets mode=generate with a prompt. For generation: quote concept, obtain approval, accept, poll get, show the concept, approve_concept only after visual user review; quote generate, obtain approval, accept, poll and show the model in its studio. A quote with auto_select_character=true selects the missing main character by default when ready; it remains inspectable and replaceable. Other models, replacement generations and older approved jobs remain drafts: approve_asset only after visual review. Never infer visual approval from technical success. quote build then accept acquires the selected community assets and binds them to a Game Kit prototype, without generating extra assets. The main playable character is presented first. If no usable matching rigged/animated model is found, prepare its generation. A missing main character blocks assembly until an existing or generated model is selected. With explicit allow_incomplete=true on the build quote, missing secondary slots may use module defaults where available or remain empty, but a generated model awaiting review blocks assembly until explicitly approved or another asset is selected. Show missing_assets before approval; never imply that an incomplete prototype is finished. Native engine projects still need CLI delivery/import; a web project has a play_url. Revision required for edits. Cancel/retry preserve completed steps. 2D unsupported. No automatic spending, invented asset IDs, or unrelated template substitutions.

Journey — the build order of the content; its last step is gripforge_game_audit, not "it loads". Read game.engine of a Game Kit project (gkp_…) — a direction, never a gate. action=start (default): the start pack { version, active, structure { engine, kits, content counts, code }, scene, blocks digest, order (scene → playable → assets → archetypes → story → scripts → ui → validate → deliver → code), next [{ step, tool, args, why }], code (where game code goes per engine), rules } and the full content report. action=blocks: the brick catalogue computed from the manifests — entity kinds, archetype components (kit, schema, example), script verbs (conditions / actions with arguments and shorthand), script sugars (interact, enter, leave, scene, talked, quest, state, gives), quest step types, NPC behaviours, worlds, layers, events, variables; scope=catalog adds the bricks of kits not installed (install <kit>). action=points (game.engine 1.3): what can be plugged into the kits without recoding them — without kit, the compact view of every installed kit (hooks with their mutable fields and whether they cancel, events emitted and listened to, registries, collections and config keys with what is moddable or live, settings, verbs, components, services, completeness counters); with kit, the full extension points of that kit with schemas. Look here before writing anything new: the kit or tool that already does it is the proven way, above all for what makes a game complete (input, camera, combat, saving, HUD, menus, sound). The kits are built to be adapted, nothing in them is fixed: adapt one as deep as the game needs through its extension points — its config (gripforge_gamekit_configure), its documents and registries (gripforge_game_content, gripforge_game_project data), taps on its hooks (documents of the hooks collection), scripts whose rules react to its events and change data — in the project, or packaged as a mod (gripforge_game_mods); write something new only when no kit does it, and then as a kit following the extension contract; a local copy of a kit last, saying why. action=report: { ok, errors, warnings, stats } — an error means that piece is left out of the game (the rest plays), a warning that it loads with something missing; each issue may carry a fix { tool, args }. action=next: the next steps only. A game with everything in code is valid: content first, kits second, code for the rest. 0 credits.

Journey — while building or after: a packaged way to apply the same extension mechanisms (config, documents, hooks, reactions) as one separable unit — a variant to switch on, content added over the game, a game opened to its players' mods (an option of the developer). gripforge_game_audit then plays the modded game. The mods of a Game Kit project (gkp_…), docs/mods-engine.md: a mod (gripforge.mod/1) is data applied over the project before the kits mount — config keys and collection documents the kits declare moddable (configPatch by dotted path, data.<collection> { remove, patch, add, order }, hooks documents that tap decisions, scripts whose rules react to events) — whole or not at all, never code. The kits are built to be adapted without recoding them — interceptable (hooks), registrable (registries), modifiable (config, documents, patches) and reactive (rules on events that change data): that is the normal, recommended way to build a game, written in the project (see gripforge_game_engine points) or packaged as a mod. A mod packages those changes as one separable unit: a variant to switch on or off (a hard mode, a season event) without copying the project, content added over the game, and — an option of the developer — a game opened to its players' mods. action=list (default): the game policy (config.mods of game.engine: enabled, disabled, order, deny), every mod with its status (applied | disabled | refused) and issues ({ level, code, path, message }), the documents each added, the fingerprint the network handshake compares. action=validate { mod }: a dry run — the project with this mod added (or replacing the one with its id), applied as the host would: its status and issues, nothing written. action=install { mod }: writes it to the mods collection (validated against the mod schema). action=remove { id }. action=enable / disable { id }: the policy list mods.disabled. action=order { ids }: these mods first, in this order (a mod always comes after those it depends on). 0 credits.

Journey — to look at the running game. Share it as finished only when gripforge_game_audit says complete and gripforge_validate_release says ready; otherwise say what is left. Get the browser play URL of a Game Kit project so a human (or a screenshot step) can run its current revision in the web runtime. Reads the project bundle and returns { url, absolute }; absolute is built on the GripForge origin of this key. Call it AFTER gripforge_gamekit_install or gripforge_game_project bind to check the result live. 0 credits.

Journey — create, then bind a model to every creature slot (get carries the creatures report) and set the controls: action=controls applies the control scheme of the gameplay, a proposal to adapt. Before telling the user the game is done: gripforge_game_audit. Manage Game Kit projects (gkp_…): the container holding installed kits, their lockfile, asset bindings and data collections. action=list lists the workspace projects; create needs name and takes a preset (see gripforge_gamekit_search; adventure is the reference game of game.engine) or an explicit kits map — every new project gets game.engine first (the engine of the game: scenes, archetypes, scripts, life cycle; its answer carries the engine start pack { structure, scene, blocks, order, next, rules } and added, the kits installed for dependencies), then the default kits ui.menu (title / pause / options / load and save screen), input.remap (key remapping), settings.graphics (graphics options), ui.prompts (on-screen key prompts that follow remapping and the gamepad), ui.endscreen (end screen and credits), save.persistence (save slots, quick save, autosave), audio.core (game audio: mixer, music, effects, event → sound table), i18n.text (game texts in the player’s language: translation tables in the translations collection, ICU plurals) ui.theme (the design of every interface as kit config: colours, font, shapes, key glyphs; unset = built-in look) and input.virtualpad (the on-screen gamepad of touch screens, mode auto: shown on a touch screen without a gamepad, Touch controls tab) and display.fullscreen (the game in fullscreen: F11, the Options entry, start in fullscreen with atStart, the player’s choice saved), asset.preload (the files of the game loaded in phases — first playable frame, background, next scene ahead — each file once, checked; progress as state and events shown by ui.menu, ui.endscreen and hud.action) and asset.cache (the files kept on the device between visits: IndexedDB, then Cache Storage with a service worker, then the HTTP cache; quota and eviction) and, on web, ai.navigation (the paths of the game over its real collision geometry: route and steer for NPCs, enemies and click-to-move), addedBy default: keep and configure them (never recode a pathfinding: ask ai.navigation and adapt its config, the hook navigation.plan and the event navigation.blocked; never recode an asset loader, a download queue or a cache: adapt their rules, asset_preload documents, scenes ahead and cache quota instead), leave one out ({ "ui.menu": false }) or remove it only if the user asks. They hold for EVERY game, a compiled module with its own page or a custom page included: that page mounts the menu, Options › Controls and Video, fullscreen and the prompts from the bindings through the kits’ web views (gripforge-ui.mjs, GET /api/v1/hud) or their adapter, never its own copy; get returns the full ProjectDetail (installed kits, bindings, capabilities, missing, playUrl); bind maps asset slots to Library items (lib_…, null to clear); data reads a collection or upserts / removes documents validated against the kits’ schemas (replace=true swaps the whole collection); controls reads or sets the controls: without scheme it returns the control schemes of the catalogue (fps, third_person, moba_click, top_down, platformer, fighting, vehicle, rts, point_click: movement by keys or by click, what the mouse is for, expected actions and keys, touch layout), the project scheme, the one its kits suggest, every action with its effective key and the keys two actions share in one mode (warnings with a proposed reassignment, never a refusal — also in get → report.controls); with scheme and dry_run=true it returns the diff of keys the scheme would write; with scheme alone it applies it (input.actions overrides marked source: scheme, the touch layout of input.virtualpad, the help bar of ui.prompts). Choose the scheme from the kind of game, never from a kit default: Kits offer capabilities that can be switched off and tuned; the game makes one high-level gameplay choice and enables only the coherent set that choice needs: what is not chosen is off and invisible, and no kit default is imposed on the game. The generic modules propose choices, the request picks one: name the kind of game, take its control scheme from the table below (usually the only one allowed), and embed only what that scheme uses on each device — its input sources, its on-screen controls on a touch screen, its settings (remapping, sensitivity, inversion, capture, dead zone only where the scheme uses them). Every option is a choice of the request too: the network input frame is embedded only for a multiplayer game, each other option only when asked. Write the choice into the project: gripforge_game_project create with controls=<scheme>, or action=controls scheme=<scheme> on an existing game (dry_run first, reset=true to drop old key overrides). A dungeon crawler is played with the mouse, not on W A S D. In play, input.scheme (a default kit) implements that choice: it follows the device in hand (keyboard and mouse, gamepad, touch) with the variant of the scheme for it, takes the vehicle scheme while the player drives, gives the input to the interface while a menu, a dialogue or a text field is open, and the Options show per device only the controls the scheme uses; tune it within the choice (input.scheme allowed: the closed list the player may switch between, usually one; variants; composites for held / double / charged / chorded / combo actions), never by enabling every option. Gameplay choices (kind → control scheme, per device): - MOBA → `moba_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: tap_world, settings: touch_layout). A hero is ordered with the mouse (right click to move / attack, abilities toward the cursor); a gamepad moves it with the stick. Interaction feedback: interaction.feedback style bold, on: highlight, cursor, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Real-time strategy → `rts` (mouse+keys: click to move, right click = context, settings: remap; gamepad: click to move, settings: remap, deadzone; touch: tap to move, on screen: stick + buttons + tap_world, settings: touch_layout). Units are selected and ordered with the cursor; nothing is moved with W A S D. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound, moveMarker, orderMarker; interaction.system pointerTarget: true. - Dungeon crawler / action RPG seen from above → `arpg_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Played with the mouse: click to walk, click an enemy to attack, right click for the special; the left stick on a gamepad, a tap on a touch screen. W A S D is not the default for this genre. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, holdGauge, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Top-down shooter / twin-stick roguelike → `top_down` (mouse+keys: WASD, right click = aim, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Constant dodging needs direct movement (W A S D / left stick) with the cursor or right stick to aim. The game may also allow: arpg_click. Interaction feedback: interaction.feedback style default, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Point-and-click adventure → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). A free cursor: click where to go and what to use. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, confirm, fail, sound, moveMarker; interaction.system pointerTarget: true. - First-person shooter / survival → `fps` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D and the captured mouse to look (right stick on a gamepad). Interaction feedback: interaction.feedback style subtle, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Third-person action / open world → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D relative to the camera and the captured mouse (right stick) to turn it. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, holdGauge, confirm, fail, sound. - Platformer → `platformer` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Direct movement and jump, no pointer. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail, sound. - Fighting → `fighting` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: buttons, settings: touch_layout). One key per blow, no pointer. No interaction.feed…

Journey — after each change: it also checks what the game chose (its scheme's gestures, fullscreen, right button, pointer capture, texts against the bindings). A playtest that passes is not a finished game: gripforge_game_audit (playtest="run" runs this test) gives the verdict and everything the tester cannot see. Play the project headless and report what works and what is broken. Run it after building or changing a game, before telling the user it is done. An automatic player spawns, walks, follows the mission waypoints, uses what offers a prompt, picks things up and attacks enemies. Probes check each capability the game provides (character control, combat, XP and levels, inventory, interactions, missions, needs, gathering, crafting, building, machines, world counters). Detectors flag a stuck player, unreachable goals, kit exceptions, NaN positions, a player under the ground, enemies that never reach the player, and step time. Then it checks the game on what it CHOSE, on a fresh run (lines game.*): the gestures its control scheme promises (a click game: click to walk, held to follow the cursor, click an enemy to strike, held to keep striking), fullscreen when the game offers it, the right button when the game gives it a role (no browser menu), the pointer captured exactly when the scheme looks with the mouse, and its texts (title, help, tutorial, dialogue) against the real bindings — never a fixed W A S D in a click game; nothing is imposed on a game that did not choose it. The frame rate is · not verified here: only a real page measures it (the play page reports it to the audit). Returns { summary, text, report, next }: text has one line per result, ✓ pass, ⚠ warning, ✕ failure, · not checked, each with its time, position, entity or kit; "provoked" means the tester set the condition up through the kit service. Fix the ✕ lines first, then run it again. report.notCovered lists the capabilities no probe looks at. report.replay replays the same inputs; pass it back as replay to check a fix against the same run. Deterministic: same project, seed and budget, same report. Runs in the compute service, about 5–20 s. 0 credits.

Generic concept → theme pipeline for a Game Kit project: the saved art direction (gripforge_game_art_direction: look, theme, palette, notes, device) becomes ONE interface concept image (title, main menu, HUD with health, a weapon card, key prompts), a vision pass reads its design tokens (colour roles, radius, border width, button shape, padding, letter case, weight, the closest open-licence font, glyph style, closest preset) and they are written as the ui.theme config (contrast repaired). The concept is kept in the Library (kind concept, category ui). action=quote prices it: 1 credit per run (quote it and ask the user before run). Without regenerate the latest concept of the project is reused with the tokens already read from it (0 credits), so a run after a dry run applies exactly what the dry run showed; reread=true reads the concept again (1 credit). dry_run=true writes nothing. run returns a generation job: poll it with gripforge_generation_read; its result carries config, tokens, fixes, previous_config and revision_before for a rollback (gripforge_gamekit_configure ui.theme with previous_config).

Journey — last. Run gripforge_game_audit then gripforge_validate_release first: export a game whose verdict is complete and whose release is ready, or tell the user what is left. Prepare a download manifest for an existing web Game Kit project in the current workspace. Reuses the same player and HUD as hosted play, compiles only installed enabled kit runtimes, and lists the game configuration, static resources and Library assets to download. Does not publish the project or change its visibility. The hosted MCP cannot write local files: use gripforge game-export <project_id> <folder> locally, then npm run dev. The CLI verifies downloads and preserves local edits on updates (--check previews conflicts; --force backs up and replaces edits only when authorized). The delivered versions remain fixed until an explicit export update. Legacy kits and unpublished source overlays cannot be exported. net.* kits still need their online services. 0 credits.

Read source-linked plans (get), author one (plan), construct actual kit content atomically (build, with plan_id, options and expected_revision; dry_run previews; activate explicitly sets the entry scene), save an input journey (journey), inspect without a run (inspect), or queue a real Bevy input/capture test (test). get section:builder with kit returns the provider options; section:journey returns its schema. Builders belong to kits, never genres. 0 credits. test returns a durable job; AI visual review uses a separately quoted Develop and test pass. Generated content remains unverified. Preserve requirements and existing authored content.

Read every spatial obligation in the saved game contract (get), or save region/location classifications, hierarchy, entries and intended connections (put). No genre counts. Old contracts need explicit classifications; declared spatial roles cannot be weakened. Regions require real child locations. Construction and verification remain separate. 0 credits; scope writes use project revision checking. Continue with gripforge_game_world build/journey/test.

The API reference of one Game Kit, as compact Markdown: what it does and when to use it, every config key (type, default, unit, limits; mod = a mod may set it, live = read again while the game runs, scene = a scene may override it), hooks (payload, mutable fields, cancellable), events emitted and listened to (when, payload), web views and HUD vars, services and their methods, script verbs, asset slots, data collections, input actions, mod points, its Bevy presentation module (needs, ABI families, web UI), target parity, changelog, and an example config and an example mod (gripforge.mod/1). Read it BEFORE gripforge_gamekit_configure, before writing a mod (gripforge_game_mods) or hooks / scripts for the kit, and before writing its presentation module. sections narrows the answer (e.g. ["config","hooks"]); full=true adds nested keys, examples of every hook and verb, and the README. 0 credits.

Journey — while composing, and to fix what gripforge_game_audit reports (its defects carry the exact config to write). Tune an installed kit: merge config values validated against the kit configSchema (read it with gripforge_gamekit_get), or patch the config as a document (patch: set a nested key, add / change / remove one element of a list without rewriting it), or toggle enabled to switch the kit off without uninstalling it. Configure installed kits freely rather than recoding what they do (game.engine: startScene, startEntry, flow.title, story flags). The interface look of a game is ui.theme: set preset (scifi-lowpoly, military, fantasy-medieval, cyberpunk-neon, cartoon-bright, horror-dark, minimal-clean, retro-pixel) for a complete look, and only the colours, typography, shapes or glyphs that must differ (they win over the preset); gripforge_game_theme_from_concept fills it from the art direction. Switching game.engine off follows the confirmation of a removal: the first call answers 409 confirm_required with details.confirm; send it back with enabled=false after the user agreed — never on your own. Returns { kit, project } with the new project revision. Call this AFTER gripforge_gamekit_install. 0 credits.

Journey — right after creating or binding: no unit stays a capsule, every model gets its movement and action clips. gripforge_game_audit folds this report with the rest and applies the free steps with fix=true. The living units of a Game Kit project (gkp_…) — player, heroes, enemies, bosses, minions, monsters, NPCs: the creature slots its kits declare. Two rules: NO creature ships as a capsule, and a model ships WITH its animations (movement AND action). action=report (default): every creature slot with its status (bound | fallback = a capsule in game), the model bound, the clips the slot plays (locomotion, action), the ones the model lacks, and its chain (steps: clone | rig | animate | more_clips, each done / running / proposed with its tool, free or its credits). action=propose: ranked Library models for each unbound slot — the workspace first, then the Community — with the reasons of the rank (source, slot and role words, game theme, size, rigged, animated, triangle budget). YOU judge: read the reasons, pick the model that fits the game (any monster beats a capsule), bind it with gripforge_game_project { action: "bind" }; nothing is final, rebind any time. A slot with no proposal at all carries defect creature_no_model: generate a model (paid — quote and ask first), never leave the capsule. action=animate: run the free steps of the chain now for the bound models (a free Community model is copied into the workspace and bound in place of the original; the standard clip pack is retargeted, 0 credits; wait=true waits for the result, else it runs in the background — read report again). action=fill: bind the best free proposal to every unbound creature slot, then animate (what the hosted creation does). Nothing here spends credits: the automatic rig, a priced Community asset and generated motions always come back as proposed steps for you to quote and ask about. Binding a model through gripforge_game_project already starts its chain. 0 credits.

Journey — last. Run gripforge_game_audit then gripforge_validate_release first: deliver a game whose verdict is complete and whose release is ready, or tell the user what is left. Turn catalogue kits, or the enabled kits of a Game Kit project, into engine files: Godot gets GDScript, scenes and config under gripforge/kits/<kit>/, Unity gets an embedded UPM package plus C# files and Unreal a Blueprint-first plugin for every kit with an engine delivery (gameplay and net.* kits; recipes otherwise), web needs nothing. Kits always deliver at their latest version; a kit the project copied locally is delivered from its copy. Call with dry_run=true FIRST: it returns the plan (files to add / keep / modify / delete, conflicts, dependencies, post-install steps) and never charges. Pass project_state (the current gripforge/gamekits.lock.json, path → sha256 of the files under gripforge/, engineVersion) so updates keep your edits and detect conflicts. Then call without dry_run to get the bundle. The hosted endpoint cannot write into your project: write bundle.files following plan.actions in order (backup, write, writeBin from bundle.binaries, delete with .uid / .import siblings, writeLock with bundle.lock), or use the npm client with project_dir (gripforge_gamekit_deliver_local), or the editor bridge. A blocked plan answers 409 with the plan: a file edited in the engine project is reported (modified_file), never overwritten silently; force backs it up then overwrites it. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major, dry runs and the web target are free.

Dependency graph of a Game Kit project: nodes (installed kits with version, provides, requires), edges labelled by capability, same-scene overlaps (conflicts: several enabled providers of one exclusive capability) and unresolved requirements. Pass project_id for the installed graph; pass a kit id instead to read the declared requires / provides tree of a catalogue kit before installing it. Call this BEFORE gripforge_gamekit_remove with force. 0 credits.

Read one Game Kit: its manifest (provides / requires capabilities, asset slots, data collections, events), README docs, config JSON schema with defaults, version and changelog (information only: projects always run the latest version), and summary { tagline, tags, targets, status, cover, coverUrl } with the featured image URL. Pass with_usage=true to also list the workspace projects that have it installed. Call this BEFORE gripforge_gamekit_configure to know which config keys exist. 0 credits.

Journey — while composing. A kit installed and left empty is not done (audio.core without a sound, ui.endscreen without an end condition): gripforge_game_audit names them. Add a gameplay kit (a brick) to a Game Kit project (gkp_…); installing marks that the game uses it. Decide it yourself, no confirmation needed. Always the latest version; dependencies are added automatically and listed in added [{ kit, version, requiredBy, capability }] (e.g. game.engine for a kit that requires it). A kit that looks with the mouse (first person, third person, shooters, vehicles, mounts) also brings its companion input.pointer_lock (mouse capture) the first time it is added — listed in added with reason "companion of …"; keep it unless the user wants the cursor visible (remove it alone with gripforge_gamekit_remove), and never code requestPointerLock by hand. Kits are bricks that go together: two kits handling the same thing (e.g. two lightings) are a same-scene overlap, never a game-level conflict — only one is active in a scene. Returns { plan, applied, added, project }; dry_run=true previews without writing. Check gripforge_gamekit_installed first, then gripforge_gamekit_search; tune with gripforge_gamekit_configure. To adapt a kit to the game, go through its extension points first — its configuration, its overridable collections, rules and scripts on its events, hooks documents on the hooks it declares (engine.hooks) — and recode or copy a kit only as a last resort, saying why: a copy is no longer updated. Legacy genre kits (legacy.*) use gripforge_kit. 0 credits.

Journey — first on an existing project; gripforge_game_audit then says what stands between it and a finished game. Start here for an existing project. Lists the kits installed in a Game Kit project (gkp_…), first and marked priority: id, name, enabled, addedBy (user / agent / auto / preset / default — the interface kits every new game gets), provides, requires and config, plus the rule that goes with them. Versions are for your information (projects always follow the latest): each kit also has version (in the project), latest, delivered { godot | unity | unreal } (the version the last engine delivery carries — a delivered game can run an older one) and pendingMigrations (manual migrations left to you). Installed kits are choices already made for this game: build on them for what they cover and configure them as needed; search the catalogue only for what they do not cover. 0 credits.

Uninstall a kit from a Game Kit project (gkp_…). Remove a kit the user installed (addedBy user in gripforge_gamekit_installed) only when the user asks. game.engine (the engine of the game) and the default kits (ui.menu, input.remap, settings.graphics, ui.prompts, ui.endscreen, save.persistence, audio.core, i18n.text, ui.theme, input.virtualpad, display.fullscreen, asset.preload, asset.cache, ai.navigation on web, addedBy default) are removed only when the user explicitly asks — never to "clean up". A kit other kits depend on, and game.engine always, is not removed by a first call: it answers 409 (kit_in_use, or confirm_required) with details { dependents, confirm } — nothing applied; show the user the dependents, then call again with with_dependents=true and confirm=<token> to remove the kit and its dependents together (the token is bound to the project revision). dry_run=true returns the plan, the dependents and the token without writing. force=true (legacy) removes it and disables its dependents instead; prune=true also drops the dependencies nothing else needs (never game.engine nor a default kit). Returns { applied, removed[], dependents, project }. 0 credits.

Journey — first: find the preset of the genre. Its `done` says what a finished game of that genre has beyond the request: write it into the contract (gripforge_define_game) as required, and gripforge_game_audit checks it at the end. Start here. Search the modular Game Kit catalogue (vehicle.driveable, mission.objectives, npc.wanted, …) by free text, capability, tag or engine target. Pass project_id to score kits against that project: each hit then carries state { installed, enabled, fills, reason } and kits that fill one of its missing capabilities rank first. Kits are bricks that go together: a kit handling the same thing as an installed one is a same-scene overlap (only one active in a scene), never a reason to skip it. Returns { kits, presets }; each kit carries its presentation: name, tagline (one-line hook), tags, targets and status per engine (web / godot / unity / unreal), and cover / coverUrl, the featured landscape image (WebP) to show the user when proposing kits. legacy.* kits play through their existing client. Kart Racing is native: compose world.racetrack + vehicle.driveable + race.kart; edit race_tracks through project data. world.lighting adds shared sun/fill, point lights and spots, presets, bounded light budgets and bloom; edit world_lights through project data. world.fluids adds interactive mud / blood surfaces, displaced 3D wheel ruts and footprints; edit fluid_surfaces through project data (web renderer). world.terrain adds a seeded large landscape (terrain_edits data), movement.traversal climbing / swimming / gliding with stamina, world.elements data-driven fire, water, ice, electricity and poison (element_rules, element_materials, element_climates data). Also returns packs: content packs (ready-made game content — documents and kit configs, e.g. a realistic atmosphere, a tree of life, a star system) that gripforge_gamekit_install { pack } installs into a project. Call this BEFORE gripforge_gamekit_install. 0 credits.

Projects always follow the latest version of their kits: the studio updates them automatically when a project is opened. Use this to do it now. Dry-run by default: returns the plan (from / to version, migrations). Pass apply=true to apply it. A migration with auto=false is never applied by itself: it is your task — apply its note (config, data) then call again. Omit id to check every installed kit. 0 credits.

CREATE any mesh asset and save it to Library — the canonical generation door. kind decides the pipeline: character/enemy/boss are auto-rigged (pass concept_item or file_url for image-to-3D; otherwise text-to-3D), weapon and prop are direct text-to-model (no rig, no concept step). The workspace Style DNA is applied to the prompt. If the look may already exist, call gripforge_style_kit FIRST. Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read for progress and the Library/Studio result. Closing this call does not cancel it.

Reusable plan → artistic concept → isolated reference views → review → Meshy or explicitly selected Tripo build workflow. Generate 1–4 images through OpenAI or Imagine; alternate views reference one master but must be checked for actually different viewpoints. If edits repeat the front, use one good concept instead of a false multiview set. Separate explicit budgets for concepts and 3D. Accepts text, owned concept views or a static GLB. Optional delivery preserves the source master and prepares reusable LOD GLBs with PBR and a common metric fit. Durable jobs return workspace links; poll generation_read, cancel/retry preserves finished steps. Review the actual render before publishing. No guaranteed interiors, collisions or runtime LOD switching; no automatic game replacement.

CREATE a Mixamo T-pose auto-rigged character, enemy or boss and save it to Library. NEVER describe a handheld weapon, staff or shield in the prompt: characters and enemies are forged empty-handed (the forge enforces it); make the weapon apart with gripforge_generate (kind=weapon) and put it in the hand with gripforge_attach. polycount is honoured (default 8000; keep it at or under 10000 for a mobile game).To sculpt from a picture (image-to-3D): pass concept_item (lib_… from gripforge_concept_correct / character_concepts) or file_url. Without an image this is text-to-3D. If the look may already be in the locker, call gripforge_style_kit FIRST. For knives/guns use gripforge_generate_weapon. Alias of gripforge_generate (the canonical door). Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read. Closing this call does not cancel it.

Generic animal/alien creature factory, one to eight original creatures per batch. stage=plan quotes concept + Meshy 3D + anatomy vision without paid calls. stage=build requires explicit budget and stable idempotency_key, then generates private meshes and inspectable skeleton overlays. Poll gripforge_generation_read; inspect each preview/profile before stage=rig with generation_job, creature_id, reviewed_anatomy=true and optional corrected profile. Reuses the anatomy-aware Blender rig, never humanoid autorig. Exports GLB, Blender source and diagnostics. Procedural starting clips are drafts; missing fly/swim/action clips are reported. No automatic game-ready approval. Existing owned immutable source/concept revisions can be reused. Use generation_cancel/retry for durable work.

Plan then build a straight-street district from 1–8 distinct Meshy/Tripo buildings, each manufactured once and reused as separate editable instances. Includes road, pavements, spawn, daylight and camera in the shared Map SceneDocument. Optional owned PBR road/pavement maps; otherwise simple solid surfaces. Plan returns layout, provider-credit count and account quote without spending. Build requires a budget and returns a persistent job, then Map Studio link. Private work version requiring visual review; no automatic Community publication or game replacement.

Persistent concept → isolated handle/segment references → Meshy PBR components → FlexibleChain XPBD → Blender assembly/rig → actual GripForge renderer review. Read flexible_weapon_schema first. recipe stage=concept returns an image before 3D; build can reuse that concept and owned pinned components. Up to 12 existing source clips or sampled motions; character choreography is not generated by this tool. Returns job_id immediately; poll generation_read for weapon GLB, Blender source, physics reports, separate character/weapon review scene and Studio links. Max 23 credits when all art is new; reused components are free. Cancel/retry retains successful provider and fabrication steps. Always private work: no automatic replacement, promotion or Community publication.

Manufacture a NEW fps-arms work asset using the native FPS template: curved hand surface refinement, fitted skinned long sleeves/cuff, optional tactical glove reinforcement and embedded PBR. recipe={version:1,name,quality:high|standard,gloves:tactical|light,sleeves:long|none,colors?:{fabric:#RRGGBB,sleeve:#RRGGBB,trim:#RRGGBB},source?:{assetId,revisionId,fileRole?}}. No source gives standalone hands with native finger rig, hand_item_r/l sockets and existing starting clips. Optional owned immutable native paired source keeps weapon, camera and animation tracks; source must contain FPS_Hands or FPS_Arms_Mesh, all ten native fingers, embedded GLB <=32 MiB. This is template geometry/garment manufacture, not prompt-to-new-anatomy or arbitrary rigging. Returns job_id; poll generation_read. Inspect fingers, seams and weapon/garment contact in the actual renderer before binding. No external provider charge; never auto-promotes or overwrites.

CREATE a game-ready prop GLB (kart, crate, barrel, banana…) and save it to Library as kind=prop. Default Meshy, no T-pose, no biped rig. polycount defaults to 4000. Quoted against the shared subscription, or 10 GripForge credits if it cannot cover the complete operation. Returns a persistent job_id immediately; poll gripforge_generation_read, then download and import the completed model.

Read vehicle_schema first. Recommended recipe.workflow=body_wheels follows concept → references (five wheel-less body views + wheel) → geometry (stop/review) → topology (stop/review) → build (PBR + wheel + rig). Each geometry review uses scene_review with the returned assetRef and must be approved before the next paid step. Rigging preserves UVs and corner normals, GLB/FBX/Blend and measured Chaos setup. Top view is review-only. parts.body.geometry accepts unfinished Hunyuan/Blender GLB; parts.body.topology pins the reviewed reduced GLB; parts.<role>.source reuses finished meshes. Legacy modular_doors remains available for articulated doors. stage=plan quotes each stage without spending; paid stages require its budget. Durable job; poll generation_read. Work draft, real-render review and target-engine driving test required; no automatic publication/replacement.

CREATE a game-ready weapon GLB (knife, gun, sword…) and save it to Library as kind=weapon. Default provider Meshy, no T-pose, no biped rig. polycount defaults to 4000. style=melee|gun is written to meta.style for gripforge_attach. 10 credits. Returns a persistent job_id; poll gripforge_generation_read. Do NOT write one-off Meshy scripts.

Plan then manufacture 1–64 original static weapon models using the existing Meshy PBR pipeline. plan is free and returns an exact aggregate quote and plan_hash. build requires that hash, an explicit budget covering the quote and a stable idempotency_key. One durable job, two bounded fabrication lanes, per-weapon checkpoints and billing; cancellation/retry preserves finished work and provider task IDs. Results remain private work assets. Inspect geometry, textures and actual renderer output before publishing. Does not create attack/reload animations, grip bindings, or flexible-chain physics. Poll gripforge_generation_read; result.items contains Library IDs and Studio links.

Request worker cancellation while retaining completed steps and artifacts. Closing a page alone does not cancel a job.

List workspace jobs. Jobs and completed steps survive closing the studio or restarting the web server and worker.

Free quote for a model, concept, texture, rig or animation. Reports the account funding mode, available balance and estimated operation cost. A subscription combines AI and paid asset generation in one monthly limit without also charging generation credits. Quote every missing role, propose the plan, and obtain a generation budget before submitting paid jobs. Estimates cover one operation, not the full concept/rig/review pipeline.

Poll a job returned by a generation tool. Includes durable steps, progress, failure/retry state and the resulting work revision with a Studio link. include_preview returns saved HUD/map/building concept images (at most 4). Set preview_view to return one chosen view. Concepts are generated illustrations, not verified 3D renders. Success does not mean visual approval or promotion.

Retry a failed or cancelled job, reusing completed steps. An unconfirmed interrupted provider call may be executed again when explicitly retried.

Journey — while building: what the contract still misses, leaves unverified, fails or blocks. The genre defects come from gripforge_game_audit. Read the contract, requirements, implementation status, build-specific evidence, blockers and remediation. Without a contract returns the schema and a proposal. 0 credits.

Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

Body capsules (head/torso/limbs) plus weapons[] — one reach capsule per gf_prop_ wrapper on a loadout/armed bind. Pass id of a loadout GLB (or character_id / attach_id). 0 credits. Use weapons[] not the single weapon field for dual-wield.

Required completion gate: action=workflow stays ready=false until a current runtime capture passes all artistic criteria. After screen_assets/assembly, submit screen_item (or design/project), renderer_version, capture_item, capture and the authorized review_budget; workflow schedules the reviewer automatically. Poll workflow; correct and recapture if changes_requested. No paid retry loop. Genre-independent workflow: pass design (from plan, edited) WITHOUT project to get/quote/concept/review_quote/review. get returns the normalized design hash; quote then concept returns reference_item. For review supply design, reference_item, renderer_version (fingerprint of actual presenter/build including styles/assets/dependencies), capture_item and capture. Forward exact quote.next and poll the generation job. This reviews an immutable snapshot; compare returned identity with current files before reusing the result. No installed kit or per-genre adapter is needed for concept/review. Project mode remains available: Artistic QA: get returns renderer_version and the latest review with current/approved flags. Upload a fresh viewport screenshot to the private Library, then review_quote with capture_item + capture context; submit its exact next payload with review, poll the generation job and read get again. Corrections, stale evidence, missing criteria or unavailable vision never count as approval. Review applies only to the submitted state; preview evidence cannot approve map contrast. v2: action=templates lists reusable compositions and independent themes; plan derives a per-game design from the project art direction and actual capabilities; get reads it; apply writes the same editable document to hud.tactical and ui.theme with expected_revision; quote then concept queues an optional paid visual board. Poll the returned generation job. Studio edits the same document. Current live adapter: FPS Bevy web; other templates are Studio/export documents. Never flatten the UI into the concept image or invent gameplay widgets. Omit action for the legacy survivor export. Generate a ready-to-drop survivor HUD: hud.json (layout/anchors, no pixels), original GripForge cartoon PNGs (hearts full/half/empty, portrait frame, currency chips, empty hex slot), a Godot 4 .tscn (Control with named nodes Health/XP/Portrait/Currencies/Minimap), and Three.js / Unity / Unreal snippets. 1 credit per successful generate. CONSUMER RECIPE — (1) call gripforge_hud; (2) write the PNGs (download the asset URLs) + hud.json (+ hud.tscn) into the game repo, same folder; (3) Godot: instance the tscn, add_child, then get_node("Health").set_health(current, max) and set XP.value; (4) Unreal: the GripForgeHUD plugin must already be in the project (unreal_plugin_url) — point UGFHudWidget::CreateFromFolder at the folder and call BindHealth on your health component. DO NOT redraw the hearts. DO NOT open a UI editor. This hosted endpoint returns file CONTENTS + URLs; pass out_dir only with the npm MCP package, which writes the files for you.

Forge an ORIGINAL themed health-bar style: an image model draws the ornate empty frame (transparent background), the inner trough is located pixel-precisely, and a thematic gradient fill is composed to match — returns an aligned frame+fill PNG pair, same contract as the built-in gripforge_hud bar styles. Describe a THEME (e.g. "gothic demon-hunter, baroque metal, horn ornaments"), never a specific game — styles of a genre, not copies. 2 credits. RECIPE: download frame_url + fill_url next to your hud.json ; Godot: TextureProgressBar (texture_under=frame, texture_progress=fill, custom_minimum_size=size) ; Three/Unity: frame behind, fill cropped horizontally to the health percent. Generation has model variance — if the trough is not found, retry with a clearer theme.

Not the survivor generator (that is gripforge_hud): this one READS an existing HUD. action=import {text, filename?, name?} → reads the HUD of the project and saves it as a HUD document of the workspace; Pass screenshot (a capture of the screen while the game runs) so My HUDs shows the real thing; action shot attaches one to a HUD imported earlier.returns the studio URL to open it. `text` is the engine file as-is: a Godot .tscn scene, a Unity .uxml (UI Toolkit) or a .unity / .prefab (RectTransforms), the Unreal UMG designer clipboard (select the widgets, Ctrl+C — .uasset files are binary), or a GripForge hud.json / hud.v2.json. Read the file yourself and pass its content; `filename` helps detect the format. Controls are recognised by name (health, mana, minimap, ammo, quest…) and type, placed on nine anchors; the report lists what was created and skipped. action=list → HUDs of the workspace. action=get {id} → one HUD document (hud_… id).

Godot InputMap for an FPS: move_forward/back/left/right bound to WASD AND arrow keys, plus jump/crouch/fire/reload/buy. Write res://gripforge/input.json and autoload GfInput (snippet_godot). Player still uses Input.is_action_pressed("move_*"). Optional third_person=true adds portable character-facing JavaScript and a Three.js adapter: movement-facing, independent camera, aim/fire/build facing. Orientation only, not a physics controller. 0 credits.

THE FEEDBACK LOOP: call this after every generate/attach/rig to SEE and VERIFY what you made, before building on top of it. Deterministic, free, repeatable. Returns (1) a structured report — kind guess, triangles/vertices, materials+textures, skeleton (bones, finger bones per hand, cape grid), animations, size in metres — and (2) QA checks with ok/warn/fail + why: plausible scale, poly budget, normals/UVs, rig skinned, strict T-pose arms, five-finger bones, feet on ground. Also returns a multi-angle render sheet (front/right/back/left by default) so you can look at the asset. Fix warns/fails (regenerate, rest_pose, retarget…) then inspect again.

Generate input.joystick source files and installation instructions: touch + mouse, independent dual sticks, radial deadzone, continuous holding and release/focus reset. Unreal runtime Pawn component, Godot CanvasLayer scene, Unity UI component, Three.js DOM controls + GripForge input.actions bridge. Feeds the existing movement controller rather than replacing physics, collision or networking. Returns files with relative path/content; the agent writes them into the target project and compiles/tests there. Does not install automatically, modify project settings or claim runtime validation. 0 credits.

A game kit IS an engine: its manifest carries asset slots AND GameRules — the genre as a document (movement, camera, world, objective, entities, pickups, ai, hud, audio). action=list → kits of the workspace. action=get {id} → manifest + rules (lib_… id). action=create {style?, name?, rules?, slots?} → new kit, rules default to the style then merge yours. action=patch {id, rules?, slots?, prompts?, name?} → partial update; rules merge section by section, a section set to null resets it. Slot refs inside rules must point at slot ids of the kit (unknown refs are dropped, the renderer falls back to procedural). Compose a NEW genre by writing rules: e.g. movement vehicle-boost + world arena-ring + objective knockout = sumo cars, no code.

Plan a playable level from a prompt (0 credits): rooms placed in metres (entrance, combat rooms, key/lock, boss room, treasure, secret), connections, critical path, shortcuts, and gameplay spawns (player/packs/boss/rewards). Same seed → same level. Pair with gripforge_scene_kit for dressing props.