spriteforge 0.1.1__py3-none-any.whl

spriteforge/memory/okf/search.py

@@ -0,0 +1,53 @@
+"""In-memory BM25: no embeddings, model calls, or persistent search database."""
+
+import math
+import re
+from collections import Counter
+
+from .models import Entry
+
+
+def terms(text: str) -> list[str]:
+    return re.findall(r"\w+", text.casefold())
+
+
+def rank(query: str, entries: list[Entry]) -> list[tuple[Entry, float]]:
+    documents = [
+        Counter(terms(" ".join([e.title] * 3 + e.metadata.tags * 2 + [e.body]))) for e in entries
+    ]
+    lengths = [sum(d.values()) for d in documents]
+    average = sum(lengths) / max(len(entries), 1) or 1
+    scores = [0.0] * len(entries)
+    for term in set(terms(query)):
+        df = sum(term in document for document in documents)
+        idf = math.log(1 + (len(entries) - df + 0.5) / (df + 0.5))
+        for i, document in enumerate(documents):
+            freq = document[term]
+            scores[i] += idf * freq * 2.5 / (freq + 1.5 * (0.25 + 0.75 * lengths[i] / average))
+    return sorted(
+        [(entry, score) for entry, score in zip(entries, scores, strict=True) if score > 0],
+        key=lambda row: (-row[1], row[0].id),
+    )
+
+
+def token_cost(text: str) -> int:
+    # Conservative tokenizer-independent ceiling: at most one token per UTF-8 byte.
+    # Budgets are strict for this accounting, rather than pretending to know a model tokenizer.
+    return len(text.encode("utf-8"))
+
+
+def sentence_excerpt(text: str, allowance: int) -> str:
+    """Keep complete sentences; reserve an explicit marker when anything is omitted."""
+    if token_cost(text) <= allowance:
+        return text
+    marker = "..."
+    if allowance < token_cost(marker):
+        return ""
+    parts = re.split(r"(?<=[.!?])\s+", text.strip())
+    kept = []
+    for part in parts:
+        candidate = "\n".join([*kept, part, marker])
+        if token_cost(candidate) > allowance:
+            break
+        kept.append(part)
+    return "\n".join([*kept, marker])

spriteforge/memory/okf/seed.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+
+import yaml
+
+from .models import Entry, GenreSeed, Metadata
+from .store import KnowledgeStore
+
+BOOTSTRAP_SOURCE = {
+    "resource": "Project owner Milestone 3 bootstrap instructions, 2026-10-28",
+    "title": "Owner-authorized seed library and trust designation",
+    "author": "human:project-owner",
+}
+
+
+def seed_entries() -> list[Entry]:
+    directory = Path(__file__).with_name("seeds")
+    entries = []
+    for values in yaml.safe_load((directory / "genres.yaml").read_text(encoding="utf-8")):
+        genre = GenreSeed.model_validate(values)
+        body = (
+            f"# Perspective and camera\n{genre.perspective}\n\n# Controls\n{genre.controls}\n\n"
+            f"# Core mechanics template\n{genre.mechanics}\n\n# Typical entities\n"
+            + ", ".join(genre.entities)
+            + "\n\n# Recommended sizes\n"
+            "16x16 tiles; 48x48 character canvases; subjects fit within about 40x40 logical pixels.\n\n"
+            f"# Palette suggestions\n{genre.palette}\n\n# Asset checklist\n\n| Asset | Count |\n|---|---:|\n"
+            + "".join(f"| {asset} | {count} |\n" for asset, count in genre.assets.items())
+            + f"\n# Animation needs\n{genre.animations}\n\n# Common pitfalls\n"
+            + "".join(f"* {pitfall}\n" for pitfall in genre.pitfalls)
+            + "\n# Adaptive questions\n"
+            + "".join(f"{i}. {question}\n" for i, question in enumerate(genre.questions, 1))
+        )
+        entries.append(
+            Entry(
+                id="genres/" + genre.id,
+                metadata=Metadata(
+                    type="Genre Template",
+                    title=genre.title,
+                    description=genre.mechanics,
+                    tags=[genre.id, "genre", "game-design"],
+                    sources=[BOOTSTRAP_SOURCE],
+                ),
+                body=body,
+            )
+        )
+    for values in yaml.safe_load((directory / "other.yaml").read_text(encoding="utf-8")):
+        values["metadata"].setdefault("sources", []).append(BOOTSTRAP_SOURCE)
+        entries.append(Entry.model_validate(values))
+    for entry in entries:
+        entry.metadata.model_extra["x-spriteforge-review"] = "unreviewed"
+    return entries
+
+
+def seed(store: KnowledgeStore) -> int:
+    present, _ = store.scan()
+    existing = {entry.id for entry in present}
+    missing = [entry for entry in seed_entries() if entry.id not in existing]
+    legacy = [
+        entry
+        for entry in present
+        if entry.id in {e.id for e in seed_entries()}
+        and BOOTSTRAP_SOURCE in [s.model_dump(exclude_none=True) for s in entry.metadata.sources]
+        and "x-spriteforge-review" not in entry.metadata.model_extra
+    ]
+    for entry in legacy:
+        entry.metadata.model_extra["x-spriteforge-review"] = "unreviewed"
+    if legacy:
+        store.write_batch(
+            legacy,
+            "Clarify bootstrap review designation",
+            verified_by="human:project-owner",
+            preserve_generation=True,
+        )
+    if missing:
+        store.write_batch(
+            missing,
+            f"Seed {sum(e.id.startswith('genres/') for e in seed_entries())} genres, "
+            "4 art styles, 4 Phaser patterns and Muse prompt pattern",
+            verified_by="human:project-owner",
+        )
+    return len(missing)

spriteforge/memory/okf/seeds/genres.yaml

@@ -0,0 +1,121 @@
+- id: top-down-dungeon-crawler
+  title: Top-down dungeon crawler
+  perspective: Three-quarter top-down, room camera with restrained follow and visible exits.
+  controls: WASD or arrows to move; Space to attack; E to interact; Escape to pause.
+  mechanics: Enter a room, read enemy telegraphs, fight, collect a key or reward, unlock the exit, and defeat a compact boss.
+  entities: [hero, melee slime, ranged enemy, boss, key, chest, door, breakable pot]
+  palette: Dungeon neutrals with green enemies and amber rewards; reserve red for danger.
+  assets: {hero: 1, enemies: 3, boss: 1, floor-tiles: 4, wall-tiles: 6, props: 4, items: 4, ui: 6}
+  animations: Hero idle/walk/attack/hurt/death; enemy idle/move/attack/hurt; door open and item pickup.
+  pitfalls: [Occluded exits, Inconsistent collision feet, Unreadable attacks, Keys behind their own locked door]
+  questions: ["If combat is central, melee or ranged?", "If exploration matters, fixed rooms or a connected maze?", "Should failure restart the room or the whole run?", "If loot is included, what changes the player's choices?", "How long should one dungeon take?", "Which input devices must work?"]
+- id: side-scrolling-platformer
+  title: Side-scrolling platformer
+  perspective: Side-on orthographic camera with forward lookahead and a stable vertical dead zone.
+  controls: Left/right or A/D to move; Space to jump; optional Shift to dash; Escape to pause.
+  mechanics: Traverse platforms, learn one movement ability, avoid hazards, collect optional rewards, reach a clear exit.
+  entities: [runner, patrolling enemy, moving platform, spikes, checkpoint, collectible, exit]
+  palette: Separate foreground collision surfaces from a lower-contrast background; warm collectibles.
+  assets: {hero: 1, enemies: 2, terrain-tiles: 10, platforms: 3, hazards: 3, props: 4, items: 3, ui: 5}
+  animations: Idle/run/jump/fall/land/hurt; enemy walk; checkpoint activate; collectible loop.
+  pitfalls: [Hidden landing zones, Slippery movement, Camera-induced jumps, Missing coyote time, Unclear one-way platforms]
+  questions: ["If jumping is the focus, precision or forgiving movement?", "Should held jump change height?", "If a dash exists, where is it first taught safely?", "Do checkpoints reset enemies?", "If secrets matter, how are they signposted?", "Should the camera scroll vertically too?"]
+- id: shmup
+  title: Scrolling shmup
+  perspective: Vertical top-down scrolling with fixed player bounds and telegraphed incoming waves.
+  controls: WASD or arrows to fly; hold Space to shoot; optional slow-focus and bomb buttons.
+  mechanics: Dodge readable projectile patterns, clear waves, collect upgrades, survive a short boss phase.
+  entities: [player ship, scout, turret ship, boss, player bullet, enemy bullet, powerup, explosion]
+  palette: Dark low-detail field; distinct player shots, enemy shots, and pickups with strong luminance contrast.
+  assets: {player: 1, enemies: 3, boss: 1, backgrounds: 3, projectiles: 5, pickups: 3, effects: 4, ui: 6}
+  animations: Ship thrust; enemy damage flash; explosion frames; boss phase transitions; pickup pulse.
+  pitfalls: [Bullets hidden by effects, Ambiguous hitbox, Unbounded projectile growth, Spawn-on-player attacks]
+  questions: ["If bullet density is high, should a focus key slow movement?", "Vertical or horizontal scrolling?", "If upgrades are lost on death, how can the player recover?", "How many lives or continues?", "Should shooting be automatic?", "If a boss is present, what pattern teaches its rules?"]
+- id: roguelike
+  title: Turn-based roguelike
+  perspective: Top-down grid camera with visible explored tiles and explicit turn state.
+  controls: Arrows or WASD move one cell; Space waits; E interacts; number keys choose items.
+  mechanics: Move or act once per turn, reveal rooms, manage resources, choose upgrades, and reach a deeper-floor exit.
+  entities: [adventurer, melee monster, ranged monster, stairs, potion, trap, chest, locked door]
+  palette: Muted stone with strong actor contrast; distinguish explored, unseen, and visible areas.
+  assets: {hero: 1, enemies: 4, terrain-tiles: 8, props: 4, items: 6, effects: 2, ui: 6}
+  animations: Short idle/move/attack/hit frames; turn indicator; reveal and death effects; no timing-based input required.
+  pitfalls: [Inconsistent turn costs, Unavoidable damage, Unexplained procedural failures, Item overload]
+  questions: ["Is each action strictly turn-based?", "If maps are random, which reachability guarantees must hold?", "Does death erase the run or retain progress?", "If hunger exists, what decision does it improve?", "How much information about enemies is visible?", "Should generated floors be reproducible independently of image generation?"]
+- id: farming-life-sim
+  title: Farming and life sim
+  perspective: Three-quarter top-down camera over a small homestead with readable interaction tiles.
+  controls: WASD or arrows to move; E to interact; number keys select tools; optional mouse targeting.
+  mechanics: Prepare soil, plant, water, advance a day, harvest, sell, and choose a modest farm upgrade.
+  entities: [farmer, shopkeeper, crop, soil plot, water source, shipping box, fence, bed]
+  palette: Earthy browns and greens with distinct crop stages; daylight changes must preserve UI contrast.
+  assets: {farmer: 1, npc: 2, soil-tiles: 4, crop-stages: 8, tools: 4, props: 6, ui: 6}
+  animations: Farmer idle/walk/tool use; crop growth stages; watering effect; NPC idle/walk; day transition.
+  pitfalls: [Chores without choices, Invisible tool range, Unclear day rollover, Excessive waiting]
+  questions: ["If time advances, real-time or sleeping to the next day?", "Is the focus crops, relationships, or decorating?", "If energy is limited, what makes spending it interesting?", "How many crop types fit the first build?", "Should missed watering destroy a crop or delay it?", "If NPC schedules exist, must they be simulated or scripted?"]
+- id: world-building
+  title: World building and sandbox
+  perspective: Three-quarter top-down camera over an open map where the player gathers resources and places structures on a readable grid.
+  controls: WASD or arrows to move; Space uses the tool on the tile in front; X places the selected structure.
+  mechanics: Gather wood and stone from the world, place huts, fences and paths on free tiles, grow a small settlement, and meet a building goal.
+  entities: [builder, tree, rock, resource pile, hut, fence, path, villager, animal]
+  palette: Natural greens and earth tones; placed structures must contrast with terrain and show where they can go.
+  assets: {builder: 1, villager: 2, terrain-tiles: 6, resources: 4, structures: 6, props: 6, ui: 6}
+  animations: Builder idle/walk/tool swing; tree and rock hit shake; structure placement pop; villager idle/walk.
+  pitfalls: [Placement without feedback, Resource grind without goals, Unreadable occupied tiles, Too many structure types at once]
+  questions: ["What does the player build first, and what does it unlock?", "Which resources exist, and where do they come from?", "Is there a goal (population, buildings, coins) or is it pure sandbox?", "Can structures be removed or moved once placed?", "Are there villagers or animals living in the world?", "How large should the first map be?"]
+- id: puzzle
+  title: Grid puzzle
+  perspective: Fixed top-down board with all relevant state visible and no camera movement.
+  controls: Arrows or WASD select/move; Space confirms; Z undoes; R restarts.
+  mechanics: Teach one rule, combine it in a small board, provide reversible experimentation, and detect a clear solved state.
+  entities: [cursor or avatar, movable block, goal, wall, switch, gate]
+  palette: Few high-contrast role colors; duplicate color meaning with shapes for accessibility.
+  assets: {avatar: 1, blocks: 4, board-tiles: 6, goals: 3, switches: 3, gates: 3, effects: 2, ui: 6}
+  animations: Move/slide; switch on/off; gate open; success feedback; animations never determine puzzle correctness.
+  pitfalls: [Unrecoverable softlocks, Hidden rules, Color-only clues, Undo losing state]
+  questions: ["What single rule should the first puzzle teach?", "If blocks can be pushed, can they also be pulled?", "Must every move be undoable?", "If there are multiple solutions, does move count matter?", "How are locked or invalid moves communicated?", "Should puzzles be authored or generated and solver-checked?"]
+- id: metroidvania
+  title: Metroidvania exploration map
+  perspective: Side-scrolling room camera with a persistent connected map and marked room transitions.
+  controls: A/D or arrows move; Space jumps; attack button; E interacts; M opens the map.
+  mechanics: Explore a connected map, discover an ability gate, gain the matching traversal power, backtrack through a shortcut, and unlock a new region.
+  entities: [explorer, patrol enemy, flying enemy, ability pickup, locked gate, save station, map marker, boss]
+  palette: Region-specific hue accents within one global palette; ability gates need consistent visual coding.
+  assets: {hero: 1, enemies: 3, terrain-tiles: 10, gates: 3, map-icons: 4, pickups: 3, props: 3, ui: 5}
+  animations: Idle/run/jump/fall/attack/hurt; ability-specific dash or climb; gate activation; save station.
+  pitfalls: [Ability-gate softlocks, Backtracking without shortcuts, Unreadable map connections, Required paths mistaken for secrets]
+  questions: ["If the map branches, which branch is initially reachable?", "What first traversal ability changes the map?", "If backtracking is required, which shortcut rewards it?", "Should the map reveal rooms, exits, or item hints?", "Can any gate be crossed in an unintended order?", "If bosses lock progression, where is the nearby save point?", "How many interconnected rooms fit this build?"]
+- id: tower-defense
+  title: Tower defense
+  perspective: Fixed top-down map with a clear enemy path, buildable cells, and visible ranges.
+  controls: Mouse selects and places towers; keyboard shortcuts choose tower type; Space starts a wave.
+  mechanics: Inspect a path, place a small tower roster, start a wave, earn currency, upgrade, and protect a base.
+  entities: [basic tower, splash tower, slow tower, runner, armored enemy, base, projectile]
+  palette: Neutral build terrain, clear path edges, distinct enemy silhouettes and projectile roles.
+  assets: {towers: 3, enemies: 4, terrain-tiles: 8, projectiles: 4, base: 1, effects: 4, ui: 7}
+  animations: Tower fire/reload; enemy walk/hit/death; range preview; placement valid/invalid; base damage.
+  pitfalls: [Blocking all paths, Invisible tower range, Economy snowball, Too many simultaneous effects]
+  questions: ["Is the path fixed or shaped by placement?", "If towers can block paths, how will path validity be enforced?", "What makes each tower useful?", "Can towers be sold between waves?", "If waves are timed, can the user pause planning?", "How many waves form a complete short game?"]
+- id: beat-em-up
+  title: Side-scrolling beat-em-up
+  perspective: Side-facing art on a shallow top-down movement plane; camera advances after each arena clears.
+  controls: Left/right and up/down move on the ground plane; attack, jump, and optional special buttons.
+  mechanics: Enter an arena, manage spacing, read enemy windups, use a short combo, collect recovery, and clear the arena gate.
+  entities: [fighter, grunt, ranged foe, heavy foe, boss, pickup, crate, exit barrier]
+  palette: Strong character/background separation; consistent shadows anchor feet to the ground plane.
+  assets: {fighter: 1, enemies: 3, boss: 1, ground-tiles: 5, backdrop-tiles: 4, props: 5, items: 3, ui: 6}
+  animations: Idle/walk/jab/combo finisher/hurt/knockdown; enemy windup; impact effects; boss attack states.
+  pitfalls: [Wrong depth sorting, Unclear attack lane, Stunlock loops, Attacks without readable anticipation]
+  questions: ["If there is lane movement, how wide is an attack's depth range?", "One attack button or separate light/heavy attacks?", "Can the player escape repeated hits?", "If jumping exists, is it movement or attack timing?", "How many enemies should attack at once?", "Should the first build support local co-op or stay single-player?"]
+- id: top-down-racer
+  title: Top-down racer
+  perspective: Top-down follow camera with lookahead along velocity and visible upcoming turns.
+  controls: Arrows or WASD steer, accelerate, and brake; optional handbrake; R resets to track.
+  mechanics: Learn steering, follow checkpoints in order, complete a lap, compare time, and restart quickly.
+  entities: [player car, rival car, track, checkpoint, barrier, boost pickup, finish line]
+  palette: Asphalt and grass separate from cars; checkpoints and hazards remain readable at speed.
+  assets: {cars: 3, track-tiles: 12, barriers: 4, props: 4, pickups: 2, effects: 3, ui: 5}
+  animations: Car directions or rotation policy; tire smoke; boost and skid effects; countdown; finish feedback.
+  pitfalls: [Skipping checkpoints, Invisible collision edges, Camera lag at turns, Drift without recovery]
+  questions: ["Arcade steering or momentum-heavy drifting?", "If pixel cars rotate, are rotations discrete or continuous?", "Time trial or opponents?", "Should going off-track slow the car or reset it?", "How many checkpoints prevent shortcut exploits?", "If tracks are generated, how is a driveable loop guaranteed?"]

spriteforge/memory/okf/seeds/other.yaml

@@ -0,0 +1,150 @@
+- id: art-styles/dungeon-muted
+  metadata:
+    type: Art Style
+    title: Muted dungeon pixel art
+    description: Restrained stone colors with readable green actors and amber loot.
+    tags: [pixel-art, dungeon, palette, contrast]
+  body: |
+    # Rules
+    Use one 16-color palette: near-black outline, four stone shades, greens for monsters,
+    amber for items, red for damage, and one cool magical accent. Keep lighting at top-left.
+    Use 16x16 tiles and 48x48 character canvases; silhouettes should fit within about
+    40x40 logical pixels. Use 3/4 top-down perspective and nearest-neighbor previews.
+    No anti-aliasing, gradients, text, watermark, or background texture in raw sprite prompts.
+    # Validation
+    Palette compliance and binary alpha are hard checks. Dark silhouette boundaries
+    should not receive a doubled outline. Preserve native source-grid proportions.
+- id: art-styles/bright-adventure
+  metadata:
+    type: Art Style
+    title: Bright adventure pixel art
+    description: Cheerful colors with separate terrain, actor, reward, and danger roles.
+    tags: [pixel-art, adventure, platformer, farming]
+  body: |
+    # Rules
+    Start with 16 colors: navy outline, three warm earth shades, three leaf greens,
+    sky blues, cream highlights, orange rewards, and a reserved red danger accent.
+    Flat shading should use two or three value steps per material. Avoid color-only
+    puzzle clues. Use 16x16 tiles and 48x48 characters containing at most about 40x40 art.
+    # Validation
+    Check silhouettes at native resolution, uniform top-left light, no gradients,
+    and a stable background-free palette across every animation state.
+- id: art-styles/limited-monochrome
+  metadata:
+    type: Art Style
+    title: Limited monochrome pixel art
+    description: Four distinct luminance steps with shape-led gameplay readability.
+    tags: [pixel-art, monochrome, readability, puzzle]
+  body: |
+    # Rules
+    Use #101820, #486858, #90A880, and #E0E8B0 as a four-color starting palette.
+    Assign the darkest color to outline and collision edges. Prefer solid clusters
+    over dithering so small animations remain stable. Tiles are 16x16; character
+    canvases are 48x48 with about 40x40 logical artwork.
+    # Validation
+    Require at most four visible colors and binary alpha. Convey hazards with
+    silhouette, motion, and placement as well as value. Reject one-pixel clutter.
+- id: art-styles/night-neon
+  metadata:
+    type: Art Style
+    title: Night neon pixel art
+    description: Dark readable geometry with sparse cyan and amber gameplay accents.
+    tags: [pixel-art, neon, shmup, racer]
+  body: |
+    # Rules
+    Use a 16-color palette with dark blue-gray surfaces, cyan player accents, amber
+    pickups, and red threats. Keep luminous effects as discrete palette bands;
+    never request blurred glows on sprites. Default to 16x16 tiles and 48x48 actor
+    canvases with logical subjects bounded near 40x40.
+    # Validation
+    Keep backgrounds lower contrast than projectiles. Review dark-color tint warnings
+    before accepting a palette: a deliberate blue outline is different from key spill.
+- id: engine-patterns/phaser-scenes
+  metadata:
+    type: Engine Pattern
+    title: Phaser boot, play, and UI scenes
+    description: Separate asset loading, gameplay state, and HUD lifetime in a small fixed scaffold.
+    tags: [phaser, scenes, lifecycle, input]
+    sources:
+      - resource: https://docs.phaser.io/phaser/concepts/scenes
+        title: Phaser scene lifecycle
+  body: |
+    # Pattern
+    Load the atlas in a boot scene, create game state and actors in a play scene,
+    and keep HUD rendering in a lightweight UI scene. Register scene-specific
+    input and event listeners once, and remove them on shutdown or restart.
+    # Checks
+    Restart twice and check for duplicate listeners, timers, and actors. Avoid
+    sharing mutable level state across scene restarts unless explicitly intended.
+    Phaser scaffolding stays fixed; future code generation fills game-logic hooks.
+- id: engine-patterns/phaser-actor-collisions
+  metadata:
+    type: Engine Pattern
+    title: Phaser actor collision feet and depth
+    description: Use small ground-footprint colliders independently of tall visual sprites.
+    tags: [phaser, collisions, top-down, depth, hitbox]
+  body: |
+    # Pattern
+    Represent each top-down actor with a small collision footprint at its feet,
+    independently of its 48x48 image canvas. Sort visible actors by ground Y.
+    Use 16x16 wall tiles as collision geometry. Keep damage hitboxes separate from
+    movement collision and disable repeated damage during a short invulnerability state.
+    # Checks
+    Test walking past a chest, behind a tall prop, and through a doorway. A sprite
+    outline or transparent image margin must not expand its physical footprint.
+- id: engine-patterns/phaser-atlas-animations
+  metadata:
+    type: Engine Pattern
+    title: Phaser atlas animation frame keys
+    description: Build animation sequences from actual packed atlas keys rather than guessed filenames.
+    tags: [phaser, atlas, animation, frames]
+    sources:
+      - resource: https://docs.phaser.io/phaser/concepts/animations
+        title: Phaser animation frame sequences
+  body: |
+    # Pattern
+    Keep frame keys such as hero/idle/0 and hero/walk/1 unchanged in atlas.json.
+    Read sequence order from the packer's meta.animations map and create animation
+    definitions in scene logic using those actual keys. Metadata alone does not
+    start a Phaser animation. Use the same canvas and palette across frames.
+    # Checks
+    Validate every referenced frame key before starting the scene. Exercise idle,
+    movement, attack, and restart; fail headless tests on missing textures.
+- id: engine-patterns/phaser-room-map
+  metadata:
+    type: Engine Pattern
+    title: Phaser room map and ability gates
+    description: Model interconnected rooms as a graph and keep traversal gates deterministic.
+    tags: [phaser, map, metroidvania, gates, reachability]
+  body: |
+    # Pattern
+    Store room IDs and exits as data, and track visited rooms and acquired abilities
+    separately from rendered tile layers. Before generating a connected exploration
+    map, verify that the starting room reaches an ability pickup without that same
+    ability. Unlock a gate by updating state, not by modifying collision in several places.
+    # Checks
+    Test reachability before and after each ability, reciprocal room transitions,
+    map marker persistence, and a route back to a checkpoint after an upgrade.
+- id: prompt-patterns/muse-pixel-sprite
+  metadata:
+    type: Prompt Pattern
+    title: Pixel sprite prompting for Muse Image
+    description: Constrain one centered subject and a flat key background before deterministic processing.
+    tags: [muse-image, prompt, sprite, pixel-art, magenta]
+    x-spriteforge-scores:
+      status: unmeasured
+      style_match: null
+      readability: null
+      note: No scored asset-production run has occurred; connectivity success is not an art score.
+  body: |
+    # Template
+    One single centered full-body SUBJECT. Chunky pixel art on a flat solid magenta
+    background. The subject fits within approximately 40x40 logical pixels on a
+    48x48 character canvas. Consistent top-left light and one dark silhouette outline.
+    Match the approved palette and anchor. No text, watermark, border, extra subjects,
+    detached decoration, anti-aliasing, gradients, or background texture.
+    # Evidence and limits
+    The 2026-10-28 live smoke check confirmed generation and editing connectivity;
+    its vision result named the edited slime a jellyfish. This prompt remains a
+    bootstrap pattern, not a claim of proven semantic consistency. Store measured
+    critic scores in x-spriteforge-scores after asset production, not fabricated scores.