nccgs 1.0.0

package/.claude/skills/sprite-editor/scripts/README.md

@@ -0,0 +1,134 @@
+# Sprite Editor Utility Examples
+
+Reference implementations demonstrating sprite editing operations. Each file contains a single method for token efficiency.
+
+## Basic Operations
+
+### GetTextureSourceImageSize.cs
+Gets the original source image dimensions (before import).
+
+**Use when:** You need to know the true image dimensions, not the imported texture size.
+
+**Key APIs:** ITextureDataProvider.GetTextureActualWidthAndHeight()
+
+### SpriteToPng.cs
+Exports a sprite to PNG byte array by rendering its mesh geometry.
+
+**Use when:** Extracting individual sprites from sprite sheets.
+
+**Key concepts:** Renders sprite vertices, UVs, and triangles. Handles tight packing and custom meshes.
+
+### SetPivotExample.cs
+Demonstrates setting sprite pivots using both predefined alignments and custom pivot positions.
+
+**Use when:** Changing sprite pivot points.
+
+**Key methods:**
+- `SpriteEditorUtility.SetCustomPivot()` - Sets custom pivot position. Must set `alignment = SpriteAlignment.Custom` and `pivot = Vector2`
+- `SpriteEditorUtility.SetPivot()` - Sets predefined alignment (Center, BottomLeft, TopRight, etc.)
+
+**Important:** Always set `alignment` field when changing pivots. Custom pivots require `SpriteAlignment.Custom`.
+
+## Slicing Operations
+
+### GetTextureToSlice.cs
+Prepares a readable texture for slicing, upscaling to original dimensions if needed.
+
+**Use when:** Before any slicing operation to ensure correct coordinates.
+
+**Key concept:** See [../references/background.md](../references/background.md#critical-for-slicing-operations) for why this is necessary.
+
+### AutomaticSliceTexture.cs
+Automatically detects sprite regions using Unity's built-in detection algorithm.
+
+**Use when:** Slicing sprite sheets where sprites have transparent borders.
+
+**Key APIs:**
+- UnityEditorInternal.InternalSpriteUtility.GenerateAutomaticSpriteRectangles()
+- GenerateNewSpriteRects() for sprite management
+
+### GridSliceTexture.cs
+Slices textures into regular grid patterns.
+
+**Use when:** Sprite sheet has evenly-spaced sprites (e.g., animation frames, tile sets).
+
+**Parameters:** offset, size, padding, keepEmptyRects
+
+**Key APIs:** UnityEditorInternal.InternalSpriteUtility.GenerateGridSpriteRectangles()
+
+### IsometricSliceTexture.cs
+Slices textures into isometric diamond-pattern tiles.
+
+**Use when:** Working with isometric tile sets (e.g., isometric RPG tiles).
+
+**Key features:**
+- Diamond-shaped outline generation
+- Empty tile detection based on alpha pixels
+- Alternating row offset support
+
+**Key APIs:** ISpriteOutlineDataProvider for diamond outlines
+
+### GenerateNewSpriteRects.cs
+Core utility for managing sprite rectangles during slicing operations.
+
+**Three modes:**
+- **DeleteAll**: Replace all existing sprites with new ones
+- **Smart**: Update overlapping sprites, add non-overlapping ones
+- **Safe**: Only add sprites that don't overlap with existing sprites
+
+**Key features:**
+- Automatic sprite naming with conflict resolution
+- Overlap detection (with tolerance and best-fit options)
+- Preserves existing sprites in Safe/Smart modes
+
+**Use when:** Implementing custom slicing logic or managing sprite updates.
+
+## Usage Pattern
+
+All slicing utilities follow this pattern:
+
+```csharp
+// 1. Get texture at original size
+var texture = GetTextureToSlice(textureProvider);
+
+// 2. Generate rectangles
+var rects = [algorithm to generate Rect collection];
+
+// 3. Convert to SpriteRects with management logic
+var newRects = GenerateNewSpriteRects(
+    spriteDataProvider,
+    rects,
+    addNewSpriteMethod,
+    nameGenerator
+);
+
+// 4. Apply to data provider
+spriteDataProvider.SetSpriteRects(newRects.ToArray());
+```
+
+## Name Generator Examples
+
+The `nameGenerator` parameter is a function that takes an integer index and returns a sprite name string.
+
+### Using Asset Filename from Data Provider
+```csharp
+string assetPath = AssetDatabase.GetAssetPath(spriteDataProvider.targetObject);
+string filename = !string.IsNullOrEmpty(assetPath)
+    ? System.IO.Path.GetFileNameWithoutExtension(assetPath)
+    : "sprite";
+Func<int, string> nameGenerator = (index) => $"{filename}_{index}";
+// Produces: character_sheet_0, character_sheet_1, etc. (or sprite_0, sprite_1 if no path)
+```
+
+### Simple Numbered Names
+```csharp
+Func<int, string> nameGenerator = (index) => $"sprite_{index}";
+// Produces: sprite_0, sprite_1, sprite_2, etc.
+```
+
+## Important Notes
+
+- All coordinates are in **original image space** (see [../references/background.md](../references/background.md#original-vs-imported-image-sizes))
+- Use GetTextureToSlice before any slicing operation
+- GenerateNewSpriteRects handles name conflicts and overlap detection
+- For Unity 2021.2+ requirements, see [../references/background.md](../references/background.md#version-specific-requirements)

package/.claude/skills/sprite-editor/scripts/SetPivotExample.cs

@@ -0,0 +1,58 @@
+using UnityEditor;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Sets a custom pivot point for a specific sprite within a sprite editor data provider.
+        /// The pivot is specified as a normalized Vector2 where (0,0) is bottom-left and (1,1) is top-right.
+        /// </summary>
+        /// <param name="dataProvider">The sprite editor data provider containing the sprite data.</param>
+        /// <param name="sprite">The GUID of the sprite to modify.</param>
+        /// <param name="pivot">The normalized pivot position (0-1 range for both x and y).</param>
+        /// <returns>True if the sprite was found and the pivot was set successfully; otherwise, false.</returns>
+        public static bool SetCustomPivot(ISpriteEditorDataProvider dataProvider, GUID sprite, Vector2 pivot)
+        {
+            var rects = dataProvider.GetSpriteRects();
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                if (rects[i].spriteID == sprite)
+                {
+                    rects[i].pivot = pivot;
+                    rects[i].alignment = SpriteAlignment.Custom;
+                    dataProvider.SetSpriteRects(rects);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Sets a predefined pivot alignment for a specific sprite within a sprite editor data provider.
+        /// Uses Unity's built-in alignment options (e.g., Center, TopLeft, BottomRight).
+        /// </summary>
+        /// <param name="dataProvider">The sprite editor data provider containing the sprite data.</param>
+        /// <param name="sprite">The GUID of the sprite to modify.</param>
+        /// <param name="alignment">The predefined sprite alignment to apply.</param>
+        /// <returns>True if the sprite was found and the alignment was set successfully; otherwise, false.</returns>
+        public static bool SetPivot(ISpriteEditorDataProvider dataProvider, GUID sprite, SpriteAlignment alignment)
+        {
+            var rects = dataProvider.GetSpriteRects();
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                if (rects[i].spriteID == sprite)
+                {
+                    rects[i].alignment = alignment;
+                    dataProvider.SetSpriteRects(rects);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

package/.claude/skills/sprite-editor/scripts/SpriteToPng.cs

@@ -0,0 +1,88 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        static public byte[] SpriteToPng(Sprite sprite)
+        {
+            Texture2D texture = sprite.texture;
+            Rect rect = sprite.textureRect;
+
+            // Create a temporary RenderTexture
+            RenderTexture renderTexture = RenderTexture.GetTemporary(
+                (int)rect.width,
+                (int)rect.height,
+                0,
+                RenderTextureFormat.ARGB32,
+                RenderTextureReadWrite.Default);
+
+            // Save the current active RenderTexture
+            RenderTexture previousActive = RenderTexture.active;
+            RenderTexture.active = renderTexture;
+
+            GL.Clear(true, true, Color.clear);
+
+            // Get sprite vertices and UVs
+            Vector2[] vertices = sprite.vertices;
+            Vector2[] uvs = sprite.uv;
+            ushort[] triangles = sprite.triangles;
+
+            // Calculate bounds for centering
+            Vector2 min = new Vector2(float.MaxValue, float.MaxValue);
+            Vector2 max = new Vector2(float.MinValue, float.MinValue);
+            foreach (var v in vertices)
+            {
+                min = Vector2.Min(min, v);
+                max = Vector2.Max(max, v);
+            }
+
+            Vector2 size = max - min;
+            Vector2 offset = -min;
+
+            // Create material for rendering the sprite with proper alpha
+            Material mat = new Material(Shader.Find("UI/Default"));
+            mat.mainTexture = texture;
+
+            // Render the sprite mesh
+            GL.PushMatrix();
+            GL.LoadPixelMatrix(0, rect.width, 0, rect.height);
+
+            mat.SetPass(0);
+            GL.Begin(GL.TRIANGLES);
+
+            for (int i = 0; i < triangles.Length; i += 3)
+            {
+                for (int j = 0; j < 3; j++)
+                {
+                    int idx = triangles[i + j];
+                    Vector2 vertex = vertices[idx];
+                    Vector2 uv = uvs[idx];
+
+                    // Transform vertex to render texture space
+                    float x = (vertex.x + offset.x) * rect.width / size.x;
+                    float y = (vertex.y + offset.y) * rect.height / size.y;
+
+                    GL.TexCoord2(uv.x, uv.y);
+                    GL.Vertex3(x, y, 0);
+                }
+            }
+
+            GL.End();
+            GL.PopMatrix();
+
+            // Read pixels from RenderTexture into a new Texture2D
+            Texture2D croppedTexture = new Texture2D((int)rect.width, (int)rect.height, TextureFormat.ARGB32, false);
+            croppedTexture.ReadPixels(new Rect(0, 0, rect.width, rect.height), 0, 0);
+            croppedTexture.Apply();
+
+            // Restore the previous RenderTexture and clean up
+            RenderTexture.active = previousActive;
+            RenderTexture.ReleaseTemporary(renderTexture);
+            Object.DestroyImmediate(mat);
+
+            return croppedTexture.EncodeToPNG();
+        }
+    }
+}

package/.claude/skills/status/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: status
+description: Reports read-only NCCGS project status including active work, risk, selected roles/models, context freshness, evidence, blockers, closure artifacts, repository state, and the next concrete action.
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# Status
+
+Remain read-only. Read project policy, state, active context packet, feature contract, evidence and closure records, plus repository status. Do not run broad tests solely for status.
+
+Report current objective and risk, accountable role and active specialists, configured model profile and any fallback, implementation/automated/runtime/regression/docs/PO-gate states, closure mode and artifacts, blockers, stale records, and next concrete action.
+
+For `brief`, omit evidence detail. For `full`, add requirement mapping, source revision freshness, role/model routing, hook health, linked artifact completion, working-tree summary, and recent decisions. For a feature ID, scope the report to that feature.
+
+Use IMPLEMENTED, VERIFIED, VALIDATED, DONE, or BLOCKED exactly. Never show DONE while a configured artifact, strict checklist, objective check, or manual gate is incomplete without a valid item-specific waiver.
+

package/.claude/skills/story-readiness/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: story-readiness
+description: Checks whether a feature or story is safe and specific enough to implement, including requirements, decisions, dependencies, ownership, tests, and Product Owner gates.
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# Story Readiness
+
+Read `.nccgs/project.yaml`, `.nccgs/state.md`, and the active context packet when present. Preserve Product Owner authority and unrelated work.
+
+Remain read-only. Check approved objective, stable requirements, acceptance criteria, governing decisions, dependencies, ownership, protected paths, compatibility, testability, and unresolved semantics. Verify the context packet source revisions. Return READY, READY WITH RISKS, or BLOCKED with exact missing inputs and the smallest next action. Do not demand documents that add no implementation value.
+
+Return outcome, evidence, affected records, blockers or decisions, residual risk, and the exact next workflow. Do not claim DONE unless this is the `closure` skill and every configured gate passes.
+

package/.claude/skills/test/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: test
+description: Plans or executes requirement-based Unity verification using automated tests, Unity CLI/Pipeline, runtime, build, regression, profiling, and explicit Product Owner gates. Use to prove behavior or reproduce failures without changing intended semantics.
+allowed-tools: Read, Glob, Grep, Write, Edit, Bash, Task, AskUserQuestion
+---
+
+# Test
+
+Read policy, context packet, requirements, decisions, implementation, existing tests, and baseline. Classify each target as objective verification, regression, or subjective validation.
+
+Use `/qa-plan` when coverage is not obvious. Choose the strongest proportional evidence described in the [evidence protocol](../../nccgs/protocols/evidence.md). Use official Unity Skills and `unity-cli` for Unity operations.
+
+Run existing relevant checks first. Add deterministic tests only when the surrounding request authorizes implementation; remain read-only for a standalone audit. Capture environment, commands/actions, counts, skips, baseline comparison, runtime/build state, console errors, and regressions.
+
+Use an independent verification role for STANDARD/CONTROLLED work. Verdicts are PASS, FAIL, NOT PROVEN, PO GATE, or N/A with reason. Do not mark the feature DONE; hand evidence to `/evidence-review` and `/closure`.
+

package/.claude/skills/ui/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: ui
+description: Unity UI expert for menus, HUDs, screens, panels, buttons, labels, and all visual interface elements. Handles questions about UI in scenes or prefabs (how many elements, what exists, structure analysis), styling changes (colors, borders, backgrounds, fonts, spacing, rounded corners), layout adjustments, and UI generation. Routes to UI Toolkit, uGUI, or IMGUI based on project context.
+---
+
+Determine the appropriate UI system for the project and route to the correct specialized skill.
+
+## When to Route vs Answer Directly
+
+**Route to a specialized skill when:**
+- User wants to understand, edit, or generate specific UI elements
+- User references specific files or UI objects
+- User asks for UI changes or creation
+
+**Answer directly (without routing) when:**
+- User asks comparative/educational questions ("What's the difference between UI Toolkit and uGUI?")
+- User asks about UI system capabilities or recommendations ("Should I use UITK or uGUI for mobile?")
+- User needs conceptual explanation of Unity UI architecture
+
+## Routing Logic
+
+**Step 1: Check for explicit file references or keywords:**
+
+| User mentions | Route to |
+|---------------|----------|
+| `.uxml` or `.uss` files (including in `/Editor/`) | `ui-uitk` |
+| "UI Toolkit", "UITK", "UIElements", "CreateGUI" | `ui-uitk` |
+| Canvas prefabs/objects, `.prefab` with UI | `ui-ugui` |
+| "uGUI", "Canvas", "RectTransform", "legacy UI" | `ui-ugui` |
+| "IMGUI", "OnGUI", "OnInspectorGUI", "immediate mode" | `ui-imgui` |
+| Figma URL (`figma.com/design/...`), "Figma", "import from Figma" | Not available — see below |
+
+**For editor-related requests (EditorWindow, custom inspector, PropertyDrawer):**
+- If no explicit UI system mentioned → **Go to Step 2** to detect project's editor UI system
+- If no existing pattern is detected, default to `ui-uitk` for new editor UI
+- Only use `ui-imgui` if project exclusively uses IMGUI or user explicitly requests it
+
+If explicit file or keywords found, activate the corresponding skill immediately.
+
+**Step 2: If ambiguous, detect from project:**
+
+Search the project to determine which UI system is in use:
+
+| Look for | Indicates |
+|----------|-----------|
+| `.uxml` or `.uss` files (including in `/Editor/`) | UI Toolkit (runtime or editor) |
+| `UIDocument` components in scenes | UI Toolkit (runtime) |
+| Editor scripts with `CreateGUI()` method | UI Toolkit (editor) |
+| `Canvas` in scenes/prefabs | uGUI |
+| `RectTransform` heavy usage | uGUI |
+| Editor scripts with `OnGUI()` or `OnInspectorGUI()` | IMGUI (legacy editor) |
+
+**Step 3: If still unclear, ask or default:**
+
+- For existing projects: detect and follow whichever framework is already in use (Step 2)
+- For new projects with no UI yet: ask the user which framework they prefer (UI Toolkit vs uGUI), briefly explaining that UI Toolkit is modern/CSS-like while uGUI is Canvas-based/mature
+- For new runtime/game UI where the user has no preference: default to uGUI (`ui-ugui`)
+- When the user mentions mobile/performance constraints or older Unity versions (pre-6.0): bias toward uGUI (`ui-ugui`)
+
+## Request Types
+
+Specialized skills handle three types of requests:
+
+| Type | Examples |
+|------|----------|
+| **Understanding** | "What does this button do?", "How is this laid out?", "Explain this UI" |
+| **Editing** | "Change this color", "Add a label here", "Fix this layout" |
+| **Generation** | "Create a menu", "Make an inventory screen", "Build a settings panel" |
+
+Route all types to the appropriate specialized skill based on the UI system.
+
+## Available Sub-Skills
+
+### UI Toolkit — `ui-uitk`
+- For Unity 6.0+ projects using UI Toolkit (runtime game UI and editor tools)
+- **Understands**, **edits**, and **generates** `.uxml` and `.uss` files
+- Modern, CSS-like styling approach
+- Preferred for new editor windows (CreateGUI) and existing UI Toolkit projects
+
+### uGUI — `ui-ugui`
+- For projects using Unity's Canvas-based UI system
+- **Understands**, **edits**, and **generates** Canvas hierarchies
+- Uses Layout Groups for responsive design
+- Default for new runtime/game UI when the user has no framework preference
+
+### IMGUI — `ui-imgui`
+- For legacy editor tools using OnGUI/immediate mode
+- Only use when project has existing IMGUI editor code or user explicitly requests IMGUI
+- **Understands**, **edits**, and **generates** EditorWindow, inspectors, PropertyDrawers built with OnGUI
+- Not for runtime game UI — for new editor tools, use UI Toolkit unless the project already uses IMGUI exclusively
+
+### Figma design import — not available here
+
+Importing a Figma design requires Unity's Figma integration service, which only exists
+inside Unity AI Assistant. There is no client-side equivalent, so do not promise it.
+
+If the user brings a Figma URL, say the automated import is not available here and offer
+the alternative: ask them to describe or screenshot the screen, then build it with the
+appropriate framework skill above.
+
+## Common Guidelines (All UI Systems)
+
+### Scope Discipline
+
+**Do only what is requested:**
+- Question → answer without making changes
+- Targeted edit → modify only what's specified
+- Generation → create only requested files
+- Don't proactively add scripts unless explicitly asked
+
+**These do NOT imply scripts:**
+- "proper buttons" → well-styled buttons
+- "working UI" → valid UI that renders
+- "menu screen" → visual layout only
+
+### Conventions
+
+**Follow project patterns first.** Search existing files before applying defaults.
+
+| Type | Convention |
+|------|------------|
+| Element names | Follow project patterns, or camelCase |
+| File organization | Match existing project structure |
+
+### Workflow
+
+1. **Determine UI system** — Use routing logic above
+   - For Figma requests, tell the user the automated import is not available here, then
+     work from their description or screenshot and continue with framework detection
+2. **Activate specialized skill** — Route to `ui-uitk`, `ui-ugui`, or `ui-imgui`
+3. **Skill handles request** — Understanding, editing, or generation as appropriate
+
+## Handling Mixed Projects
+
+Many Unity projects use multiple UI systems simultaneously (e.g., UI Toolkit for runtime game UI plus editor tools). When you detect multiple systems:
+
+- **For runtime UI requests** (menus, HUDs, game screens) → Route to whichever runtime system (UITK or uGUI) is already in use
+- **For editor tool requests** (custom inspectors, editor windows):
+  - **Prefer UI Toolkit** (CreateGUI) for new editor UI — it's the modern approach
+  - Only use IMGUI if the project's existing editor tools use IMGUI exclusively, or user explicitly requests IMGUI
+  - Check for existing editor `.uxml` files to confirm UITK usage
+- **If creating new runtime UI in a mixed project** → Match the pattern used by similar existing UI; if there is no similar existing UI and the user has no preference, use uGUI

package/.claude/skills/ui-imgui/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: ui-imgui
+description: Unity IMGUI (Immediate Mode GUI) expert for legacy editor tools using OnGUI/immediate mode. Generates and modifies IMGUI EditorWindows, custom Inspectors, PropertyDrawers, and scripts with IMGUI code (OnGUI, OnInspectorGUI). Use when maintaining existing IMGUI editor code or when user explicitly requests IMGUI/OnGUI.
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+---
+
+**Before proceeding:** If the user is asking about creating a **new** editor window, custom inspector, or PropertyDrawer without explicitly mentioning IMGUI/OnGUI, recommend using UI Toolkit (CreateGUI) instead, as it's the modern approach. Only proceed with IMGUI if:
+- User is modifying existing IMGUI code
+- User explicitly requests IMGUI/immediate mode
+- The project exclusively uses IMGUI for editor tools
+
+When activated, read the reference files:
+- [references/templates.md](references/templates.md) — EditorWindow, Inspector, PropertyDrawer templates
+- [references/gui-elements.md](references/gui-elements.md) — GUI elements, layout groups, styling
+
+## When to Use This Skill
+
+**IMPORTANT:** This skill is for **legacy IMGUI code only**. Use this skill when:
+
+- User is maintaining/updating **existing** IMGUI editor code (files with `OnGUI()`, `OnInspectorGUI()`)
+- User **explicitly requests** IMGUI/immediate mode GUI
+- Project exclusively uses IMGUI for all editor tools
+
+**Do NOT use this skill for:**
+- New editor windows (use UI Toolkit with `CreateGUI()` instead)
+- New custom inspectors (use UI Toolkit instead)
+- Requests that don't explicitly mention IMGUI or OnGUI
+
+**Legacy IMGUI is used for:**
+- **Editor windows** — `EditorWindow` classes with `OnGUI()`
+- **Custom inspectors** — `Editor`, `PropertyDrawer` classes with `OnInspectorGUI()`
+- **Debug overlays** — `OnGUI()` in MonoBehaviour (runtime)
+
+IMGUI is **not** for runtime game UI — use UI Toolkit or uGUI instead.
+
+## Scope
+
+**Generate only what is requested (for legacy IMGUI code):**
+
+| Request | Output | Note |
+|---------|--------|------|
+| Editor window (IMGUI/OnGUI) | `EditorWindow` with `OnGUI()` | Only if explicitly IMGUI |
+| Custom inspector (IMGUI) | `Editor` with `OnInspectorGUI()` | Only if explicitly IMGUI |
+| Property drawer (IMGUI) | `PropertyDrawer` with `OnGUI()` | Only if explicitly IMGUI |
+| Debug overlay | `MonoBehaviour` with `OnGUI()` | Runtime debugging |
+| Update existing IMGUI script | Modify existing OnGUI code | Always appropriate |
+
+**Clarify if ambiguous:**
+- "inspector" → Custom Editor for a specific type, or PropertyDrawer? **Also ask:** Should this use UI Toolkit (modern) or IMGUI (legacy)?
+- "editor window" → **First ask:** Should this use UI Toolkit (modern/CreateGUI) or IMGUI (legacy/OnGUI)?
+- "tool window" → EditorWindow with what functionality? Which UI system?
+
+## Conventions
+
+**Follow project patterns first.** Search existing editor scripts before applying defaults.
+
+| Type | Convention | Good | Bad |
+|------|------------|------|-----|
+| Script names | PascalCase | `MyToolWindow.cs` | `my-tool-window.cs` |
+| EditorWindow | `[Name]Window.cs` | `LevelEditorWindow.cs` | `LevelEditor.cs` |
+| Custom Editor | `[Type]Editor.cs` | `EnemyEditor.cs` | `EnemyInspector.cs` |
+| PropertyDrawer | `[Type]Drawer.cs` | `RangeDrawer.cs` | `RangePropertyDrawer.cs` |
+| Location | `Editor` folder | `Assets/Editor/` | `Assets/Scripts/` |
+
+**Editor folder is required** — Scripts using `UnityEditor` namespace must be in an `Editor` folder or they will fail to build.
+
+## Workflow
+
+1. **Analyze** — Determine script type needed (EditorWindow, Editor, PropertyDrawer, etc.)
+2. **Search** — Find existing editor scripts to match patterns
+3. **Follow project patterns** — Match folder structure and naming
+4. **Create script** — Use appropriate base class and attributes
+5. **Implement OnGUI** — Build the interface with layout groups
+
+## Script Structure
+
+### EditorWindow
+```
+[MenuItem attribute] → adds to menu
+ShowWindow() static method → opens window
+OnGUI() → draws interface
+OnEnable/OnDisable → initialization/cleanup
+```
+
+### Custom Editor
+```
+[CustomEditor attribute] → targets component type
+OnInspectorGUI() → draws inspector
+OnEnable() → cache SerializedProperties
+serializedObject.Update/ApplyModifiedProperties → undo support
+```
+
+### PropertyDrawer
+```
+[CustomPropertyDrawer attribute] → targets type or attribute
+OnGUI(Rect, SerializedProperty, GUIContent) → draws property
+GetPropertyHeight() → custom height if needed
+```
+
+## Key Rules
+
+- **Cache GUIStyle objects** — never create new GUIStyle in OnGUI (causes memory allocation every frame)
+- **Use SerializedProperty** — for proper undo/redo support in inspectors
+- **Call ApplyModifiedProperties()** — after any serialized object changes
+- **Use EditorGUILayout** — for editor scripts (auto-layout)
+- **Use GUILayout** — for runtime OnGUI
+- **Begin/End pairs** — always match BeginHorizontal with EndHorizontal, etc.
+- **Editor folder required** — scripts fail to build if not in Editor folder
+
+## Layout Basics
+
+**Horizontal grouping:**
+```csharp
+EditorGUILayout.BeginHorizontal();
+// elements appear side by side
+EditorGUILayout.EndHorizontal();
+```
+
+**Vertical grouping:**
+```csharp
+EditorGUILayout.BeginVertical("box");
+// elements appear stacked, with box style
+EditorGUILayout.EndVertical();
+```
+
+**Scroll view:**
+```csharp
+scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
+// scrollable content
+EditorGUILayout.EndScrollView();
+```
+
+**Foldout section:**
+```csharp
+showSection = EditorGUILayout.Foldout(showSection, "Section Name");
+if (showSection)
+{
+    EditorGUI.indentLevel++;
+    // section content
+    EditorGUI.indentLevel--;
+}
+```
+
+## Common Patterns
+
+**Button with action:**
+```csharp
+if (GUILayout.Button("Do Something"))
+{
+    // action here
+}
+```
+
+**Property field with label:**
+```csharp
+EditorGUILayout.PropertyField(myProperty, new GUIContent("Label"));
+```
+
+**Object reference field:**
+```csharp
+myObject = (MyType)EditorGUILayout.ObjectField("Label", myObject, typeof(MyType), true);
+```
+
+**Disabled group:**
+```csharp
+EditorGUI.BeginDisabledGroup(condition);
+// disabled elements
+EditorGUI.EndDisabledGroup();
+```
+
+## Best Practices
+
+- Use `SerializedObject` and `SerializedProperty` for undo support
+- Cache property references in `OnEnable()`
+- Use `EditorUtility.SetDirty()` only for non-serialized changes
+- Use `Undo.RecordObject()` before modifying objects directly
+- Use `EditorStyles` for consistent appearance
+- Use `GUILayout.FlexibleSpace()` to push elements apart
+
+See `references/templates.md` for complete script templates.
+See `references/gui-elements.md` for full element reference.