THE AGENT SKILLS DIRECTORY
Reusable skills for AI agents. Install any of them into a Cohub world's agent with one command.
npx -y @neta-art/neta-search-cli@latest skills find "<what you need>"
Wrote a skill? Publish it here →
Basic Cohub abilities. Most agents already have these mounted; listed here for reference.
Paste this into your agent's chat — it fetches the skill and follows it.
Use the skill: production-spritesheet-builder. Run `npx -y @neta-art/neta-search-cli@latest skills use neta-skills/production-spritesheet-builder --via site` and follow what it prints. Read its complete output, redirecting it to a temporary file first if necessary, and resolve relative paths from the skill directory it prints.npx -y @neta-art/neta-search-cli@latest skills use neta-skills/production-spritesheet-builderBuild pixel-perfect sprite sheets and game animations with fixed grids and safe backgrounds
# Production Spritesheet Builder
This skill creates and repairs production-grade spritesheets using a **contract-first, action-profile-driven** pipeline: define the subject, exact grid, runtime/export target, and per-action semantics first; attach a matching visual grid reference; generate only low-complexity source views/rows/atlases; then deterministically clean, split, align, validate, assemble, preview, and repair. The workflow must be fully reusable across characters, creatures, props, projectiles, UI/VFX, pets, side-view battlers, and RPG actors — never hard-code one character, one IP, one grid, or one action list as the skill's logic.
Use it when the user cares about correctness, not just a nice-looking generated sheet:
- fixed rows/columns/frame size
- no cropped bodies or edge-touching assets
- safe background cleanup that does not delete white clothing/hair/eyes
- custom actions with logical frame order
- consistent identity, scale, baseline, and body width
- runtime direction semantics such as left/right flip rules
- QA images, user-approved frame cutting, safe cleanup, GIF/WebP/MP4 exports, metadata, install, backup, and rollback
## Neta generation requirement
When this workflow needs new visual source art, use Neta `generate image` as the default image generation path. Do not create final sprite/character/enemy/VFX art by drawing with Python/Pillow, SVG, Canvas, CSS, emoji, icon fonts, or colored boxes.
Local tools in this skill are for contract creation, grid references, source-size gates, slicing, cleanup, alignment, previews, exports, metadata, and QA. They are not the default art-generation path.
Preferred generation command pattern:
```bash
node /mods/neta/neta generate image --prompt "<spritesheet/source atlas prompt>" --aspect 1:1
```
Use `--ref-file` when passing grid references, uploaded references, or style/identity references according to the `generate-image` skill. If Neta image generation is blocked, report the sprite asset generation as blocked/not ready instead of silently switching to local placeholder art.
## Dependency recovery
Before running grid-reference creation, source-atlas gates, cleanup, export, preview, or QA tools, verify required commands/packages. If something is missing, first attempt safe installation or initialization in the current workspace/sandbox, rerun the check, and continue. Do not skip required processing/QA just because a dependency was initially absent.
Common dependencies:
```bash
command -v convert || command -v magick || true
command -v ffmpeg || true
python3 - <<'PY'
import importlib.util
for m in ['PIL', 'rembg']:
print(m, bool(importlib.util.find_spec(m)))
PY
```
Common recovery commands when allowed:
```bash
python3 -m pip install --user --break-system-packages pillow
python3 -m pip install --user --break-system-packages "rembg[cpu,cli]" # when cutout is needed
```
Use ImageMagick/ffmpeg already present in the host when available. Only mark `blocked` when installation or initialization is forbidden, unsafe, unavailable, or still fails after retry.
## Self-contained boundary
This skill must be usable from its own package only. Do not require, read, copy, or invoke helper files from project directories outside `.agents/skills/production-spritesheet-builder/`. The only permitted file resources are the bundled `SKILL.md`, `references/`, `templates/`, `tools/`, and run-local files created for the current task.
External services or platform CLIs may be invoked as runtime providers when available, but all prompts, contracts, grid references, validation scripts, export scripts, and workflow instructions must come from this skill package or the current run directory.
## Core rule
Do **not** ask the image model to directly create the final production sheet unless the user explicitly accepts high risk.
Instead:
1. Write a `Spritesheet Contract` that separates **subject identity**, **sheet geometry**, **action profiles**, **cleanup**, **runtime/export target**, and **QA thresholds**.
2. Choose or create the sheet geometry required by the user/runtime. Prefer the smallest contract that satisfies the task. For independent one-action work, default to the bundled **10×1 isolated strip contract** in `templates/strip-contract-10x1.md`; use the standard **6×6 square-grid contract** only for RPG-style multi-row sheets.
3. Ensure the contract has a concrete grid reference image. For default 6×6 use `references/standard-grid-6x6.png`; for strip/custom overrides such as `10×1`, `5×2`, `10×6`, or `4×3`, create a matching run-local reference image with `tools/create_grid_reference.py`, for example `runs/<slug>/contract/grid-10x1-160.png`.
4. Attach the grid reference image as an actual generation reference (`--ref-file` or equivalent), not only as prompt text, so the model sees the intended layout and each frame stays inside its cell.
5. Generate or ingest a canonical base reference when identity consistency matters.
6. Generate source views/rows/atlases per action profile, keeping each source as low-complexity as possible.
7. Deterministically process frames.
8. Assemble the final sheet or standalone animation assets from verified frames.
9. Produce QA and repair only failed parts.
The final sheet geometry and runtime contract must be owned by local deterministic processing, not by the image model. The image model may propose art inside a referenced layout, but the pipeline owns splitting, cleanup, alignment, QA, export, metadata, and repair.
**Hard source-atlas size gate:** immediately after downloading any generated atlas/source sheet, verify its pixel size against the contract before cropping. Use the bundled `tools/source_atlas_gate.py`. If the source atlas size differs from `sheet.sheetWidth × sheet.sheetHeight`, do not run fixed-coordinate crop, do not assemble final output, and do not publish. Either regenerate/recover the correct-size source or explicitly enter an adaptive remap repair flow with evidence and human visual QA.
## Universal design requirement
This skill must stay fully generic:
- Do not encode a specific character, IP, outfit, species, or project as pipeline logic.
- Do not encode one fixed action list such as `walk/run/jump/attack` as mandatory; actions come from the contract.
- Do not apply a `walk` continuity metric to attacks, jumps, projectiles, aura loops, or props.
- Do not assume all sprites are humanoids; support creatures, props, projectiles, VFX, UI loops, side-view battlers, top-down actors, and standalone GIF/WebP assets.
- Do not assume every output is a final single spritesheet; some contracts produce tight frames, strips, transparent WebP, MP4 previews, engine atlases, or dir-work review pages.
- Every reusable improvement must be expressed as a generic **action profile**, **QA metric**, **processing primitive**, or **contract field**, not as a one-off character rule.
Read `references/action-quality-profiles.md` before adding action-specific prompt rules or QA thresholds. When a candidate fails geometry/source-size but may be salvageable, read `references/effect-first-repair-policy.md` before choosing adaptive repair versus regeneration.
## First step: choose mode
Pick the smallest mode that satisfies the request.
| Mode | Use when | Typical output |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------- |
| `rpg-character` | topdown / overworld actor with directions and idle/walk/action semantics | custom fixed grid, engine metadata |
| `general-sprite` | creature, NPC, side-view action, prop, projectile, impact, FX | custom grid, transparent sheet, GIF/WebP/MP4 |
| `pet-companion` | desktop pet / companion mascot with pet states | local fixed-grid contract, no delegation required |
| `repair-standardize` | user already has a sheet but it is inconsistent, cropped, wrong background, wrong direction, or wrong action order | repaired sheet + QA |
| `standalone-action-atlas` | one or more isolated action atlases such as 5×2 / 10×1 source sheets, later exported to GIF/WebP/tight frames | action folders, tight frames, previews, manifest |
| `vfx-or-prop-loop` | non-character loops: fire, aura, projectile, floating prop, UI sparkle, shop item animation | transparent frames / WebP / MP4, anchor metadata |
If a game/runtime is named, infer its frame contract from the user's request or current project files, but do not depend on package-external method documents. If no runtime forces another geometry, choose the smallest contract that satisfies the user's real goal: use `templates/strip-contract-10x1.md` for isolated action-atlas generation, standard 6×6 for RPG actor sheets, fixed strips for VFX, or custom grids for engine import. Any chosen geometry is valid only after creating or reusing a matching grid reference image and including it as a generation reference file.
## Required contract
Before generating or editing sprites, write a contract in the working notes or a `contract.json` file. It must explicitly declare the geometry, action profiles, cleanup strategy, output format, and QA gates; 6×6 is only one possible default for RPG-style full character sheets.
```json
{
"mode": "rpg-character",
"sheet": {
"cols": 6,
"rows": 6,
"frameWidth": 256,
"frameHeight": 256,
"sheetWidth": 1536,
"sheetHeight": 1536,
"background": "transparent",
"standardGridReference": "references/standard-grid-6x6.png"
},
"anchor": "feet",
"cleanup": {
"strategy": "chroma-key",
"keyColor": "#FF00FF",
"preserveInternalWhite": true
},
"animations": [
{
"name": "walk-left",
"frames": [0, 1, 2, 3, 4, 5],
"source": "row",
"direction": "left",
"loop": true,
"runtimeFlipX": false,
"logic": ["alternating legs", "feet grounded", "consistent body width"]
}
],
"qa": {
"edgeTouch": "fail",
"bodyWidthContinuity": true,
"baselineContinuity": true,
"directionSemantics": true,
"previewAnimations": true
}
}
```
Do not proceed without a concrete contract. If the user did not specify exact grid dimensions, infer the smallest suitable geometry from the desired runtime/output and state it briefly before execution. Default to `6 cols × 6 rows` only for RPG-style full character sheets without another runtime constraint. If the user or inferred runtime uses another grid such as `5×2`, `10×1`, or `10×6`, the contract must include a matching `standardGridReference` path, and that image must exist before generation.
Read `references/contract-schema.md` when writing a detailed contract.
## Grid reference requirement for all sheet geometries
This is a hard requirement:
- Every new spritesheet generation must have a visual grid reference image that matches the contract's `cols`, `rows`, `frameWidth`, `frameHeight`, `sheetWidth`, and `sheetHeight`.
- The grid reference must be passed to the image model as an actual reference file (`--ref-file`, uploaded reference id, or equivalent). Prompt-only geometry instructions are not acceptable.
- Use the bundled wrapper `tools/generate_with_required_refs.py` for any grid-constrained image generation. It refuses missing refs and records ref paths, SHA-256 hashes, exact command, stdout, result JSON, artifact path, and work id.
- For default 6×6, use `references/standard-grid-6x6.png`.
- For strip/custom overrides, create a run-local grid reference first with `tools/create_grid_reference.py`, for example `runs/<slug>/contract/grid-10x1-160.png`, then include that path in the contract and generation command.
- If generation tooling cannot attach the grid reference or cannot record required-ref evidence, stop and report the blocker instead of proceeding.
- If a generated result ignored the reference grid, returned at a different pixel size than the contract, or cannot be cleanly split by the contract, mark it failed and regenerate/repair before sharing. A run is not compliant unless all are true: (1) required-ref generation evidence exists, (2) source-atlas size gate passed or an explicit adaptive-remap repair report exists, and (3) visual QA confirms the output obeys the grid.
Record evidence in `metadata.json` or `validation.json`, including:
```json
{
"gridReferenceUsed": true,
"gridReferencePath": "contract/standard-grid-10x6-16x9.png",
"generationRefs": [
"contract/standard-grid-10x6-16x9.png",
"optional-style-reference.png"
]
}
```
## Standard 6×6 grid reference
A built-in visual reference is required for every new spritesheet generation:
```text
references/standard-grid-6x6.png
```
Use it as the layout reference when prompting the image model and as the QA overlay reference when reviewing outputs. The prompt must explicitly say:
- the sheet is exactly 6 columns × 6 rows
- every frame must remain fully inside its own cell
- no body part, prop, weapon, effect, shadow, or motion smear may cross a grid line
- leave visible padding inside each cell, preferably inside the safe box shown in the reference
- do not add numbers, labels, text, borders, or grid lines to the final art unless making a QA overlay
The standard reference is not the final sheet art. It is a containment guide. Final production output must be transparent and assembled deterministically from verified frames.
## Safe background cleanup policy
Never default to deleting all white pixels. That destroys white clothing, hair, eyes, shoes, and highlights.
Preferred order:
1. Transparent source alpha: preserve alpha; only remove detached noise.
2. Chroma key: solid `#FF00FF` or another color absent from the asset.
3. Edge-connected background removal: remove only background connected to canvas edges.
4. Segmentation / manual mask: for difficult cases.
Use white-background removal only as edge-connected flood fill, never as global `transparent white` unless the asset has no internal white and the user accepts the risk.
Read `references/background-cleanup.md` before handling non-transparent or white-background sources.
## Generation strategy
Generate low-complexity sources with Neta image generation, not the final sheet via local drawing.
For character sheets, prefer:
- canonical base reference
- the standard `references/standard-grid-6x6.png` containment reference, or a matching override grid reference such as `contract/standard-grid-10x6-16x9.png`
- neutral front / back / side views
- per-action rows, one action per generated image
- one direction per row unless the action is symmetric and the contract says to mirror
- frame count per row matching the contract columns, unless using variable-width source sheets that will be manually/repacked later
For custom actions, define the action logic and action profile first:
- profile name, e.g. `locomotion-walk-in-place`, `locomotion-run-in-place`, `locomotion-jump-arc`, `idle-breath-loop`, `melee-basic-attack`, `combo-attack`, `projectile-cast`, `power-up-aura`, `prop-or-fx-loop`, or a custom profile
- what body part / prop / effect moves
- what anchor must remain stable, if any: feet, center, pelvis, root, bottom, projectile center, free-floating
- what frame count and loop behavior are required
- start / anticipation / contact / recovery / return frames when semantic beats matter
- forbidden artifacts such as motion lines, text, extra characters, detached effects, shadows, or cropped limbs
- which QA metrics apply and which explicitly do not apply
Read `references/action-quality-profiles.md` and `references/action-planning.md` for action templates and custom action design. For single-action strips such as `10×1`, read `references/strip-generation-template.md` and use isolated frame atlas wording; do not use loose "horizontal animation strip" wording alone.
## Deterministic processing
Use local processing for:
- source-atlas size validation before any crop; source size mismatch is a hard failure unless explicitly repaired
- coarse frame splitting by the accepted grid/layout
- BBOX-based main subject extraction for animation exports
- edge-connected background removal or chroma key / alpha cleanup
- transparent-channel tight crop after cleanup
- per-frame alpha-tight canvases after cleanup, so every exported source frame contains only colored content and no transparent border
- largest main component extraction when there is detached debris
- shared scale
- feet/bottom baseline alignment when a runtime requires anchored feet
- direction normalization
- final assembly
- GIF/WebP/MP4 previews with explicit frame replacement / clear-frame behavior
For user-approved generated action atlases in this workflow, prefer the direct export method: **grid coarse crop → safe background removal → mandatory per-frame alpha BBOX tight crop → residue/shadow hard QA → animate from verified tight frames**. Use the bundled `tools/export_strip_animation.py` for strip/atlas previews and frame export so transparent-channel crop cannot be skipped.
**Hard correction from Sanji v1 failure:** alpha BBOX tight crop is not sufficient. A frame can satisfy `alphaBbox == imageSize` while still containing opaque white background islands, non-edge white holes, floor/contact shadows, or even a fully opaque failed frame. Therefore every export script used for publishable standalone action animations must include a machine-readable post-cleanup QA gate and fail the run before creating / updating a work when any of these are present:
- frame count differs from contract.
- any tight frame is fully opaque or has too little transparent area for a supposed isolated sprite.
- near-white / key-color background residue exists away from image edges above threshold.
- bottom-area low-saturation dark residue suggests ground shadow / contact shadow / floor patch above threshold.
- BBOX size explodes relative to the action profile or neighboring frames.
- required manifest / QA files are missing for any action.
The BBOX extraction report alone is never enough for a reviewable or publishable sprite animation deliverable.
Animation export must not visually accumulate transparent frames. Because BBOX frames may move inside the shared canvas, every preview/export must either set reliable GIF disposal/frame replacement or composite each frame onto a fixed stage before GIF export. For transparent deliverables, prefer animated WebP or another format/runtime that replaces the previous frame; never accept a GIF that leaves prior-frame ghosts.
Processing must crop the cleaned transparent channel for every standalone animation frame before final preview/export. For preview GIFs and reusable standalone animation assets, each exported frame canvas must equal its own alpha BBOX: `alphaBbox == imageSize` and offset `+0+0`. Do not re-extend tight frames to a shared transparent canvas unless the user explicitly asks for a runtime-stable canvas. For runtime sheets, final installed frames may still preserve the requested frame size separately.
## QA outputs
Every production run should output QA artifacts internally first. Do not publish or present them to the user until the visual QA gate below passes. At minimum:
```text
qa/standard-grid-reference.png # copy or rendered use of the actual contract grid reference, default or override
qa/source-review.png
qa/source-containment-report.json
qa/grid-overlay.png
qa/frame-contact.png
qa/runtime-semantic-contact.png # when a runtime contract exists
qa/body-width-report.json
qa/baseline-report.json
qa/edge-touch-report.json
qa/direction-report.json
qa/validation.json
previews/<animation>.gif or .mp4
final/spritesheet.png
final/contract.json
final/metadata.json
```
For lightweight requests, you may reduce previews, but never skip the actual contract grid reference, source containment, grid, edge-touch, frame-contact, visual inspection, and validation. For generated action atlases with removable backgrounds, validation must include residue/shadow QA: alpha presence, near-white or key-color interior residue, bottom dark contact-shadow residue, frame-count consistency, and missing-output consistency.
Use action-profile-specific QA instead of one universal metric set:
- `locomotion-walk-in-place`: body width / height continuity, baseline continuity, loop closure.
- `locomotion-run-in-place`: baseline and loop closure with looser width/height thresholds.
- `locomotion-jump-arc`: stable subject scale and no cropping; vertical position is expected to change.
- `melee-basic-attack` / `combo-attack`: containment, semantic beat order, recovery closure; do not use strict walk width thresholds.
- `projectile-cast` / `power-up-aura`: effect containment, identity continuity, alpha debris; body width may legitimately change.
- `prop-or-fx-loop`: anchor/center drift and loop closure; do not assume humanoid body metrics.
If no built-in profile fits, define a custom profile in the contract and record its QA thresholds.
## Visual QA publish gate
Automated checks are necessary but not sufficient. Before sharing a public URL, creating a dir-work `meta.json`, or presenting a sheet as a candidate, inspect the visual QA artifacts yourself:
- `final/spritesheet.png`
- `qa/grid-overlay.png`
- `qa/frame-contact.png`
- `qa/source-review.png` when sources exist
- draft previews when motion continuity matters
If any obvious visual failure is present, the candidate **fails QA and must not be shared with the user as a reviewable deliverable**. Mark it failed, keep it only as internal evidence, and repair/regenerate first.
Obvious visual failures include:
- black rectangles, black panels, black dividers, or unintended dark boxes
- any ground shadow, contact shadow, floor mark, oval under-foot patch, or grey/dark floor residue when the contract says no shadow
- non-edge white / near-white background islands or white holes left inside a supposedly transparent frame
- fully opaque tight frames in a transparent animation export
- destructive background cleanup such as dark fields, white speckle debris, halos, or erased body parts
- cropped limbs, cut hats/hair/weapons/effects, or poses split by cell boundaries
- extra characters, duplicate bodies, unrelated pose changes, identity drift, wrong outfit, wrong character version
- grid lines, labels, numbers, borders, or UI artifacts baked into final art
- action rows that are visibly non-continuous when continuity is required
- source layout that cannot be cleanly split into contract cells
When visual QA fails:
1. Set validation status to failed, including human-visible reasons.
2. Do not write `meta.json` for a dir-work and do not copy to `/public`.
3. Repair the smallest failing unit when possible; otherwise regenerate the source with stricter constraints.
4. Only share after a new candidate passes both automated QA and human visual QA.
If a candidate was accidentally published and later fails visual QA, immediately disable the workspace dir-work entry if possible, mark validation as failed, stop referring to the public URL as a deliverable, and regenerate.
Final-frame edge QA is not enough: a generated source row can already have a cropped arm, weapon, effect, hair, or projectile, and local assembly may still produce a clean-looking frame with margins. Always inspect source containment before accepting long actions. For strip sources, reject the source if it behaves like a continuous panorama instead of isolated cells: no body part, projectile, smoke, fire, lightning, speed line, or motion blur may cross cell boundaries.
Read `references/action-quality-profiles.md` for action-specific prompt/QA profiles. Read `references/qa-and-repair.md` for QA thresholds and repair decisions. Read `references/source-containment.md` whenever an action has stretched limbs, weapons, trails, projectiles, lunges, large hats/hair, or any element likely to be cropped by the source image boundary. Read `references/strip-generation-template.md` before generating any single-row strip.
## Approval gate before final exports
Do not treat frame cutting, final background cleanup, and animated GIF/WebP/MP4 export as automatic final delivery before the user approves the spritesheet itself.
Use two phases:
1. **Spritesheet QA phase** — deliver `final/spritesheet.png`, source review, grid/contact QA, edge/source containment reports, and validation. Ask the user to confirm the sheet is visually correct.
2. **Export phase** — only after user approval, crop frames by contract or accepted grid, preserve/clean alpha safely, run BBOX extraction when producing preview / standalone animation assets, and export `frames/`, animation strips, GIF/WebP/MP4, and an `export-manifest.json`.
Draft animation previews are allowed during QA, but label them as draft. When the user explicitly approves an atlas and asks to "往后做动画 / preview / 先做出来看", proceed directly with BBOX export instead of blocking on another full QA cycle.
Read `references/export-workflow.md` before cutting frames or exporting final animation GIFs.
## Repair taxonomy
Repair the smallest failing unit.
| Failure | First repair |
| ---------------------------- | --------------------------------------------------------------------------- |
| inconsistent grid | rebuild from contract; do not accept model grid |
| edge touch / cropped limb | reprocess with smaller fit or regenerate that source row with safer padding |
| white asset deleted | switch cleanup to edge-connected or alpha mask; do not global-remove white |
| detached debris / extra body | largest component extraction, then row regeneration if still present |
| wrong direction | flip or regenerate only the affected direction row |
| idle too thin vs walk | body-width continuity fix or regenerate neutral side view |
| action illogical | regenerate only the failed action row with stricter action logic |
| identity drift | regenerate failed row using canonical base + nearest good row as references |
| baseline drift | realign feet/bottom anchors; regenerate if feet are missing |
Do not full-regenerate a sheet unless multiple source rows are semantically wrong or the contract itself was wrong. Prefer a reusable single-action repair entrypoint that reads the same contract/action profile, backs up only the affected action, regenerates only that source, patches metadata/gallery references, and keeps all other actions untouched.
## Installation discipline
For game projects, never overwrite assets without backup.
Before installing:
1. Save current sheet and metadata to a timestamped backup.
2. Install the candidate sheet.
3. Update metadata/provenance.
4. Update cache-bust or asset version if the app uses one.
5. Run project validation/build.
6. Write a log.
If the project has its own rules, follow them. In Neta / WorldX spaces, do not hand-edit manifest files.
## Bundled tools and templates
Use only these skill-local executable helpers and references:
```text
tools/create_grid_reference.py # create run-local grid/containment references
tools/generate_with_required_refs.py # invoke image generation with mandatory ref evidence
tools/source_atlas_gate.py # fail fast on source size mismatch
tools/adaptive_grid_remap_export.py # explicit repair path for scaled-but-intact sources
tools/export_strip_animation.py # cut strip/atlas frames, clean background, make GIF/contact QA
templates/strip-contract-10x1.md # minimal independent strip contract and commands
references/strip-generation-template.md
references/contract-schema.md
references/action-planning.md
references/action-quality-profiles.md
references/source-containment.md
references/qa-and-repair.md
references/export-workflow.md
```
Do not require project-specific documents or tools outside this package. If a task needs a project runtime sheet, inspect the current project asset dimensions directly and write a local contract for this run.
## Session and media safety
- Do not `read` large spritesheets, large QA contact sheets, videos, or long binary media directly into the session.
- Generate a preview with longest side <= 1200 px or publish the asset under `/public` and provide a URL.
- Use `identify`, metadata, QA JSON, and small previews for inspection.
- Redact long generation prompts in command logs and print only concise progress / QA summaries.
## Test prompts
Use these as sanity tests for the skill:
1. "Using this character reference, create a standard 6×6 walk spritesheet, 256×256 per cell. Must reference the standard 6×6 grid image during generation. No cropping. White clothing must not be erased by background removal."
2. "Normalize this non-standard sprite sheet into a standard 6×6, 256×256 per cell, preserve transparent background, and output QA."
3. "Add a custom attack action row to this character, 6 frames, consistent with the original sheet. Do not redo other actions. No action may cross a cell boundary."