nccgs 1.0.0

package/.claude/skills/localization/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: localization
+description: "Sets up and configures Unity Localization, including locales, String/Asset Tables, CJK font support, and Addressables workflows. Use when the user wants to add languages to a project, translate UI text, support Asian (CJK) languages with TMP fonts, or mentions i18n, l10n, multilingual support, or making a game support multiple languages."
+---
+
+This guide covers setting up and configuring Unity Localization, including locales, String and Asset Tables, Addressables integration, and CJK font support via Asset Tables.
+
+## 0. Package Installation Check
+Before doing anything else, verify that the Localization packages is installed. Many APIs in this skill will fail silently or throw confusing errors if the package isn't present.
+1. **Check:** Use `UnityEditor.PackageManager.Client.List(true)` to check for `com.unity.localization`.
+2. **Install:** If missing, use `Client.Add("com.unity.localization")`.
+3. **Wait:** Do not proceed until `Client.List` confirms installation.
+
+## 1. Localization Settings & Locales
+If `LocalizationEditorSettings.ActiveLocalizationSettings` is null, you must find or create it:
+1. **Find:** Use `AssetDatabase.FindAssets("t:LocalizationSettings")`. If found, load the first one and assign it to `LocalizationEditorSettings.ActiveLocalizationSettings`.
+2. **Create:** If not found, create a new instance and save it to `Assets/Localization/LocalizationSettings.asset`. Use `ScriptableObject.CreateInstance<LocalizationSettings>()` followed by `AssetDatabase.CreateAsset()`.
+3. **Activate:** Set `LocalizationEditorSettings.ActiveLocalizationSettings = settings`.
+4. **Locales:** Ensure locales (en, fr, de, etc.) exist. Create them if missing and add them to settings using `LocalizationEditorSettings.AddLocale(locale)`.
+
+## 2. Modifying Localization Tables
+Programmatic changes to String or Asset tables require notification to the Editor.
+Always create the required asset tables, unless there is already an existing one in the project.
+
+### **Safe Population Pattern**
+When populating tables from a dataset, match by `Locale.Identifier.Code` explicitly. The order of `GetLocales()` is not guaranteed to match your input data array — assuming it does will cause silent data mismatches that are very hard to debug.
+For **Asset Tables**, use the GUID of the asset: `table.GetEntry(sharedId) ?? table.AddEntry(sharedId, guid);`.
+
+### **Refresh & Notification**
+After any modification (adding keys, updating values), notify the Editor so it can refresh its internal state. Skipping this will leave the Editor showing stale data until the next reimport.
+1. Call `EditorUtility.SetDirty(collection)`, `EditorUtility.SetDirty(collection.SharedData)`, on each modified `Table`.
+2. **Unity 6+ Notification:** `LocalizationEditorSettings.EditorEvents.RaiseCollectionModified(sender, collection);`
+3. Always call `AssetDatabase.SaveAssets()` at the end.
+
+## 3. UI Localization and Layout
+### **Namespacing & Conflicts**
+- **Always qualify names:** Use `UnityEngine.UI.Image`, `UnityEngine.UI.VerticalLayoutGroup`, `UnityEngine.UI.ScrollRect`, `UnityEngine.UI.Mask`, `UnityEngine.UI.CanvasScaler`, `UnityEngine.UI.GraphicRaycaster`, `UnityEngine.UI.ContentSizeFitter`, `UnityEngine.UI.LayoutRebuilder`, etc. 
+- `UnityEngine.UI` is both a namespace and a class container, so unqualified names produce `CS0118` (namespace used like a type). Full qualification avoids this entirely.
+- **Single Instance:** Always check `GameObject.Find("YourCanvasName")` and destroy the old one before creating a new one.
+- **No Debug Dropdown:** NEVER create a manual UI dropdown or debug menu to change the locale. The Localization package has a built-in way to do this properly (e.g., via the "Localization Scene Controls" window for previews).
+
+### **Localized String Events (Robust Binding)**
+- **Check Component Type:** Identify if the target is `TextMeshPro` or legacy `UnityEngine.UI.Text`.
+- **Bind Correctly:** add the public `UnityEngine.Localization.Components.LocalizeStringEvent`
+  component and wire it yourself — set `StringReference` to the table entry, then add an
+  `OnUpdateString` listener that assigns the value to the text component (`TMP_Text.text` for
+  TextMeshPro, `UnityEngine.UI.Text.text` for legacy Text).
+
+  Do **not** reflect into `UnityEditor.Localization.Plugins.TMPro.LocalizeComponent_TMPro` or its
+  UGUI counterpart. Those are `internal` (measured on Localization 1.5.12), so reaching them means
+  routing around access control to reach an API Unity makes no stability commitment about — it can
+  change or disappear in any package release. `LocalizeStringEvent` is public and does the same job
+  with the wiring made explicit.
+- **Layout Rebuild:** After setting localized text or populating a list, call `UnityEngine.UI.LayoutRebuilder.ForceRebuildLayoutImmediate(parentTransform)` to ensure dimensions update.
+
+## 4. Asian Language Font Support (CJK)
+Avoid TMP Fallback Fonts for CJK locales. Use **Asset Table Font Swapping** for each specific locale instead — fallbacks are unreliable and hard to debug when glyphs are missing.
+
+1. **Use locale-specific fonts:** Western fonts like Arial or Liberation Sans don't contain CJK glyphs, which results in "tofu" (square blocks). Always use a font designed for the target language:
+   - For **Simplified Chinese (zh-Hans)**: Use `msyh.ttc` (Microsoft YaHei) or equivalent.
+   - For **Japanese (ja)**: Use `msgothic.ttc` (MS Gothic) or equivalent.
+   - For **Korean (ko)**: Use `malgun.ttf` (Malgun Gothic) or equivalent.
+   - If system font copying fails, stop and report it. Do not substitute with a Western font.
+2. **Robust Font Creation:** Create dynamic `TMP_FontAsset` from imported fonts.
+3. **Multi-Atlas & Dynamic:** CJK character sets are too large for static atlases; a single atlas will run out of space immediately.
+   - `fontAsset.atlasPopulationMode = AtlasPopulationMode.Dynamic;`
+   - `fontAsset.isMultiAtlasTexturesEnabled = true;`
+4. **Sub-Assets:** Save atlas and material as sub-assets, or they'll be lost on reimport: `AssetDatabase.AddObjectToAsset(fontAsset.atlasTexture, fontAsset);`. 
+    - Explicitly link the material's texture: `fontAsset.material.mainTexture = fontAsset.atlasTexture;` and set both as dirty before saving.
+5. **Addressables:** Every asset referenced in an Asset Table must be marked as Addressable. 
+    - Do not reference assets inside a `Resources/` folder in an Asset Table. This causes `OperationException: Failed to load sub-asset` errors. If an asset is in `Resources/`, copy it to `Assets/Fonts/` or similar before making it Addressable.
+    - If a font asset is deleted and recreated, the new GUID must be manually updated in the Asset Table and re-added to Addressables.
+6. **Specialized Types:** For TextMesh Pro font swapping, prefer `LocalizedTmpFont` over `LocalizedAsset<TMP_FontAsset>` to avoid implicit conversion errors.
+7. **Build Requirement:** After updating Asset Tables or Addressable groups, trigger a build: `AddressableAssetSettings.BuildPlayerContent();`.
+
+### **Verification Step**
+Before concluding any CJK localization task:
+1. **The Tofu Check:** Switch the editor locale to `zh-Hans`, `ja`, and `ko`. Inspect the UI. If any characters appear as squares (tofu), the font setup has FAILED.
+2. **Asset Table Check:** Verify that the `AssetTable` for the CJK locale points to the correct CJK `TMP_FontAsset`, NOT a default Western font.
+3. **Multi-Atlas Check:** Confirm `isMultiAtlasTexturesEnabled` is `true` on the CJK font assets.
+
+## 5. Automatic Layout (UGUI)
+- **Parent:** `VerticalLayoutGroup` with `Child Control Height: True`, `Child Force Expand Height: False`.
+- **Labels:** Each label must have a `ContentSizeFitter` set to `Vertical Fit: Preferred Size`.
+- **TMP:** Set `Enable Word Wrapping: True` and `Overflow: Overflow`.
+
+### Notes when translating an existing project
+- **Minimal Code Changes**: Never modify code unrelated to localization. Use a static helper class (e.g., `L10n`) to wrap `LocalizationSettings.StringDatabase.GetLocalizedString` for easy injection into existing scripts.
+- **Robust Mapping Strategy**: When mapping existing UI text to keys, sort keys by string length (descending) and match longest strings first. This prevents short strings (like "NO") from matching parts of longer sentences. Use case-insensitive matching where appropriate.
+- **Component Event Listeners**: When setting up `LocalizeStringEvent` via script, avoid `UnityEventTools.AddPersistentListener` as it often fails to set the dynamic mode (Mode 0) correctly. 
+Instead, use the **SerializedObject Pattern** described in Section 3 to explicitly set `m_MethodName` to `set_text` and `m_Mode` to `0`. Persistent listeners **MUST** point to a method on a `UnityEngine.Object`; lambdas will fail.
+- **Initialization & Refresh**: 
+    - `LocalizationEditorSettings.CreateStringTableCollection` expects a **directory path** (e.g., `Assets/Localization`), not a full asset path.
+    - Always call `lEvent.RefreshString()` after assigning a `LocalizedString` reference programmatically to update the UI immediately.
+    - Ensure keys are added to **all** tables in a collection (en, de, ja, etc.) to avoid "No translation found" errors.
+- **Namespaces & Linq**: Always include `using System.Linq;` when searching collections and `using UnityEngine.Localization;` when working with locales or tables.
+- **Verification**: After modifying tables or addressables, run `AddressableAssetSettings.BuildPlayerContent()` and switch the Editor locale to verify changes. Check `LocalizationSettings.Instance` status after activation.
+- **Smart Strings**: Set up smart strings where needed. Inspect the context of each string by taking the entire UI it is on, and any scripts that affect it, into account. Set the context on the string table to ensure translations make sense.
+
+## 6. Recommended Translation Strategy
+To efficiently translate an existing project, follow this multi-step workflow:
+
+1. **Extraction & Component Setup:**
+   - **Find all occurrences:** Scan all scenes and prefabs for strings in code and UI components (Legacy `UnityEngine.UI.Text`, `TextMeshPro`, buttons, etc.).
+   - **Shared Table:** Create a central String Table (e.g., `UIStrings`) with the base language and a "Context" column for each key to guide translators.
+   - **Attach Components:** For every UI element found, attach a `LocalizeStringEvent` (for text) and a `LocalizedFont` helper (for font swapping).
+   - **Validation:** Ensure these components are set up with persistent listeners (`EditorAndRuntime`) so they update in the Editor immediately when the locale changes.
+
+2. **Context-Aware Translation:**
+   - **Translate:** Once the table is populated, provide translations for each locale.
+   - **Context is King:** Always refer to the "Context" column or inspect the UI layout to ensure the translation fits the intended meaning and space.
+   - **Grammar & Tone:** Ensure the tone matches the game's style. For example, use imperative verbs for buttons (e.g., German: "Lauf!" instead of "Laufen") and correct pluralization for labels (e.g., "Punkte" instead of "Punkt").
+
+3. **Quality Assurance (QA):**
+   - **Scene Controls:** Use `Window > Asset Management > Localization Scene Controls` or script: `LocalizationSettings.SelectedLocale = LocalizationSettings.AvailableLocales.GetLocale("de");`.
+   - **Visual Inspection:** Methodically inspect every prefab and scene in the base language and all target languages.
+   - **Layout Fit:** Check for text overflows or "tofu" (missing glyphs). Adjust font sizes or use `ContentSizeFitter` if strings are too long.
+
+
+## API Reference
+For detailed API usage, common namespace conflicts, Addressables patterns, and font repair steps, see [references/api-notes.md](references/api-notes.md).
+
+## 7. Accelerated Localization Workflow
+To localize an entire project efficiently, use a batch processing script that handles all scenes in one pass.
+
+**Ask before acting:** Before running any batch operation, confirm with the user:
+> "This will open every scene in the project, attach `LocalizeStringEvent` components, and save all modified scenes. This cannot be undone automatically. Shall I proceed?"
+
+Only proceed once the user has confirmed. The batch processor template is in [resources/L10nBatchProcessor.cs](resources/L10nBatchProcessor.cs).
+
+### **Technical Tips for Speed**
+- **Table References:** Use `TableReference` names (strings) instead of GUIDs — they are easier to read and maintain.
+- **Batch Refresh:** Use `LocalizationSettings.Instance.ForceRefresh()` after modifications to force the UI to update in the editor.
+- **Font Swap Automation:** Create the `GameAssets` table once and use a script to re-assign `LocalizeFontEvent` to all labels in one pass.
+- **LocalizedFontAsset component:** The template is in [resources/LocalizedFontAsset.cs](resources/LocalizedFontAsset.cs).

package/.claude/skills/localization/references/api-notes.md

@@ -0,0 +1,76 @@
+# Localization API Reference
+
+## LocalizationEditorSettings
+The primary entry point for Editor-time localization settings.
+- `GetStringTableCollections()` / `GetAssetTableCollections()`: Retrieves collections.
+- `CreateStringTableCollection(name, path)`: Factory methods. Expects a **directory path** (e.g., `Assets/Localization`), not a full asset path.
+- `EditorEvents.RaiseCollectionModified`: Must be called after any modification to refresh the editor.
+
+```csharp
+LocalizationEditorSettings.EditorEvents.RaiseCollectionModified(sender, collection);
+```
+
+## Asset Table Entries
+When adding entries to an Asset Table (fonts, textures, etc.), always use the asset's GUID:
+
+```csharp
+string guid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(myAsset));
+var entry = table.GetEntry(sharedEntryId) ?? table.AddEntry(sharedEntryId, guid);
+entry.Guid = guid;
+EditorUtility.SetDirty(table);
+```
+
+## Common Namespace Conflicts (CS0118)
+`UnityEngine.UI` is both a namespace and a class container — always fully qualify these types:
+- `UnityEngine.UI.Image`
+- `UnityEngine.UI.ScrollRect`
+- `UnityEngine.UI.Mask`
+- `UnityEngine.UI.CanvasScaler`
+- `UnityEngine.UI.GraphicRaycaster`
+- `UnityEngine.UI.VerticalLayoutGroup`
+- `UnityEngine.UI.ContentSizeFitter`
+
+## Addressables Requirement
+Any asset referenced in an Asset Table must be marked as Addressable:
+
+```csharp
+var guid = AssetDatabase.AssetPathToGUID(assetPath);
+var settings = UnityEditor.AddressableAssets.AddressableAssetSettingsDefaultObject.Settings;
+settings.CreateOrMoveEntry(guid, settings.DefaultGroup);
+```
+
+## Avoiding the Resources Folder
+Do not reference assets inside a `Resources/` folder in Asset Tables — the Addressables system
+cannot load sub-assets from Resources, causing `OperationException: Failed to load sub-asset`.
+Copy the asset out first:
+
+```csharp
+string source = "Assets/TextMesh Pro/Resources/Fonts & Materials/LiberationSans SDF.asset";
+string target = "Assets/Fonts/LiberationSans SDF Localized.asset";
+if (!File.Exists(target)) {
+    AssetDatabase.CopyAsset(source, target);
+    AssetDatabase.ImportAsset(target);
+}
+// Use target path for Addressables and Asset Tables
+```
+
+## Triggering an Addressables Build
+After modifying Addressable entries or Asset Tables:
+
+```csharp
+using UnityEditor.AddressableAssets.Settings;
+AddressableAssetSettings.BuildPlayerContent();
+```
+
+## UI Layout Refresh
+Programmatic text changes require a layout rebuild to update dimensions:
+
+```csharp
+UnityEngine.UI.LayoutRebuilder.ForceRebuildLayoutImmediate(parentRectTransform);
+```
+
+## Robust TMP_FontAsset Repair
+If fonts appear as "tofu" or throw `UnassignedReferenceException`:
+- Check that the Material and Atlas Texture are nested under the Font Asset in the Project window.
+- Re-assign `fontAsset.material.mainTexture = fontAsset.atlasTexture;` and re-save.
+- If the font was deleted and recreated, update the GUID in both the Asset Table and the Addressables Group.

package/.claude/skills/localization/resources/L10nBatchProcessor.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine.UI;
+using UnityEditor.Events;
+using UnityEngine.Events;
+using UnityEngine.Localization.Components;
+using System.Collections.Generic;
+
+/// <summary>
+/// Batch-processes all scenes in the project, attaching LocalizeStringEvent components
+/// to every Text element whose content matches a key in the provided mapping.
+///
+/// Only call LocalizeAll() after confirming with the user — it modifies and saves every scene.
+/// </summary>
+public static class L10nBatchProcessor
+{
+    public static void LocalizeAll(Dictionary<string, string> mapping, string table)
+    {
+        string[] scenes = AssetDatabase.FindAssets("t:Scene");
+        foreach (var guid in scenes)
+        {
+            var path = AssetDatabase.GUIDToAssetPath(guid);
+            var scene = EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
+            LocalizeHierarchy(mapping, table);
+            EditorSceneManager.MarkSceneDirty(scene);
+            EditorSceneManager.SaveScene(scene);
+        }
+    }
+
+    static void LocalizeHierarchy(Dictionary<string, string> mapping, string table)
+    {
+        var allText = Object.FindObjectsByType<Text>(FindObjectsInactive.Include, FindObjectsSortMode.None);
+        foreach (var text in allText)
+        {
+            foreach (var kvp in mapping)
+            {
+                if (!text.text.Contains(kvp.Key)) continue;
+
+                var lse = text.gameObject.GetComponent<LocalizeStringEvent>()
+                    ?? text.gameObject.AddComponent<LocalizeStringEvent>();
+                lse.StringReference = new UnityEngine.Localization.LocalizedString(table, kvp.Value);
+
+                // Wire the listener through the public UnityEventTools API. The persistent-call
+                // fields could be written directly through SerializedObject instead, but those
+                // are private serialized names with no compatibility guarantee — and it isn't
+                // necessary. A delegate to Text's public `text` setter, handed to
+                // AddPersistentListener, serializes to exactly the same thing: target = the Text
+                // component, method = set_text, mode = EventDefined (dynamic), call state =
+                // EditorAndRuntime. Measured on Unity 6000.5.7f1.
+                //
+                // The setter has no C# method-group name, so the delegate is built by name.
+                // That is reflection over a *public* member, which is fine; reaching for the
+                // private m_* fields would not be.
+                var setText = (UnityAction<string>)System.Delegate.CreateDelegate(
+                    typeof(UnityAction<string>), text, "set_text");
+
+                for (int i = lse.OnUpdateString.GetPersistentEventCount() - 1; i >= 0; i--)
+                {
+                    UnityEventTools.RemovePersistentListener(lse.OnUpdateString, i);
+                }
+                UnityEventTools.AddPersistentListener(lse.OnUpdateString, setText);
+
+                EditorUtility.SetDirty(lse);
+                break;
+            }
+        }
+    }
+}

package/.claude/skills/localization/resources/LocalizedFontAsset.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+using TMPro;
+using UnityEngine.Localization;
+using UnityEngine.Localization.Components;
+
+/// <summary>
+/// Swaps a TMP_Text font based on the active locale using an Asset Table.
+/// Add to any GameObject with a TMP_Text that needs locale-specific fonts (e.g., CJK).
+/// </summary>
+[AddComponentMenu("Localization/Asset/Localized Font Asset")]
+public class LocalizedFontAsset : LocalizedAssetBehaviour<TMP_FontAsset, LocalizedTmpFont>
+{
+    protected override void UpdateAsset(TMP_FontAsset font)
+    {
+        var tmp = GetComponent<TMP_Text>();
+        if (tmp != null) tmp.font = font;
+    }
+}

package/.claude/skills/localize-game/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: localize-game
+description: Plans, implements, or reviews internationalization and localization across strings, fonts, layout, input, assets, culture, and LQA using the project's supported locales.
+allowed-tools: Read, Glob, Grep, Write, Edit, Bash, Task, AskUserQuestion, WebSearch, WebFetch
+---
+
+# Localize Game
+
+Read `.nccgs/project.yaml`, `.nccgs/state.md`, and the active context packet when present. Preserve Product Owner authority and unrelated work.
+
+Read locale scope, canonical terminology, UI/content sources, existing localization architecture, and platform constraints. Route writing, UI, accessibility, content, and Unity specialists as needed. Preserve stable string IDs, context, placeholders, plurals, fallback, font coverage, layout expansion, and extraction determinism. Use the official `localization` Unity Skill for Unity operation mechanics. Do not invent locale scope or approve translations without review evidence.
+
+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/migrate-project/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: migrate-project
+description: Reviews, plans, applies, and verifies adoption or upgrade of NCCGS in an existing Unity project. Preserves canonical truth, ownership, closure safeguards, model policy, local settings, and rollback while replacing obsolete workflow machinery.
+allowed-tools: Read, Glob, Grep, Write, Edit, Bash, Task, AskUserQuestion
+---
+
+# Migrate project
+
+Treat brownfield adoption and NCCGS upgrades as CONTROLLED work. Read the complete [migration procedure](references/procedure.md). Default to `review` when no mode is given.
+
+## Modes
+
+- `review`: read-only inventory and KEEP/ADAPT/MIGRATE/DEPRECATE/REMOVE/MISSING classification.
+- `plan`: write a dated reversible plan and proposed schema-2 policy without overwriting project truth.
+- `apply`: execute an approved plan in validated batches with backups.
+- `verify`: prove policy, routing, hooks, Unity integration, evidence, closure, and a representative work path.
+
+Migration decisions must cover canonical sources, ownership/protected paths, architecture, Unity tooling, model profile/fallback, enabled departments, context packets, verification baselines, closure safeguards, Git tracking, local settings, obsolete global skills, and rollback.
+
+Never remove reports, registers, checklists, user settings, source assets, or legacy instructions until their live purpose is mapped and the Product Owner approves the replacement. Do not infer canon from code. Return batches, commits, preserved evidence, unresolved decisions, rollback, and final migration state.
+

package/.claude/skills/migrate-project/references/procedure.md

@@ -0,0 +1,63 @@
+# Brownfield migration procedure
+
+## Review
+
+1. Inspect repository status and project root without modifying it.
+2. Inventory Unity version, packages, scenes/assets, code assemblies, tests, build
+   targets, CLI/Pipeline setup, and installed Unity Skills.
+3. Locate current project instructions, canonical design/architecture/planning,
+   requirement/story registries, QA evidence, session state, hooks, agents, skills,
+   closure/completion artifacts, safety checklists, and release machinery.
+4. Identify conflicts in authority, duplicated Unity instructions, unsafe ownership,
+   token-heavy context loading, redundant reports, stale global routing signals,
+   machine-local settings, and legacy engine support.
+5. Classify each relevant artifact KEEP/ADAPT/MIGRATE/DEPRECATE/REMOVE/MISSING.
+6. Determine whether closure should be `lean`, `linked`, or `strict`. Preserve the
+   strongest active safeguard until the PO explicitly accepts a weaker model.
+7. Determine the project model profile, enabled departments, permitted fallback,
+   orchestration depth/parallelism, context-packet locations, and hook compatibility.
+
+## Plan
+
+Create `.nccgs/migrations/<date>-migration-plan.md` with:
+
+- current-state summary and canonical-source map;
+- proposed `.nccgs/project.yaml` values;
+- proposed model/department/orchestration/context policy and any compatibility
+  fallback needed for the user's Claude Code subscription or context mode;
+- proposed closure mode, canonical record, linked artifacts, completion rules, and
+  any legacy safeguard that must block DONE;
+- ordered reversible batches and dependencies;
+- exact broad/irreversible decisions requiring PO authority;
+- backup/rollback method;
+- validation for each batch and final end-to-end proof.
+
+Prioritize authority and policy conflicts, then model/routing conflicts, Unity
+integration, canon mapping, ownership, context isolation, closure safeguards,
+traceability/evidence, lifecycle hooks, workflow replacement, and cleanup.
+
+## Apply
+
+- Start from a known repository status and preserve unrelated changes.
+- Apply one coherent batch, inspect diff, run its validation, and update migration
+  status before continuing.
+- Never rewrite project canon from implementation inference without PO acceptance.
+- Do not delete or collapse legacy completion reports/registers/checklists until the
+  configured closure model preserves their safety purpose and the PO approves it.
+- Back up removals and conflicting framework files. Do not remove project assets or
+  source merely because their folder layout differs from NCCGS examples.
+- Preserve `.claude/settings.local.json` and other machine-specific files. Merge the
+  managed hook fragment into shared settings without erasing unrelated permissions,
+  hooks, or local paths.
+- Do not leave two active agents/skills advertising mutually exclusive Unity
+  execution bridges. Disable obsolete global routing signals outside the repository
+  through an explicit user action.
+
+## Verify
+
+Check installation integrity, schema-2 project policy, model profile/fallback,
+role/workflow catalogs, bounded delegation, hook health, context packet freshness,
+canonical map, requirements/state, Unity Skills integrity, CLI/Pipeline operation,
+relevant tests, runtime evidence, and subjective-gate routing. Verify that required
+linked artifacts block DONE in `linked` or `strict` mode. Use a small representative
+task or dry run when product changes are not authorized.

package/.claude/skills/milestone-review/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: milestone-review
+description: Evaluates milestone progress, scope, quality, risk, evidence, and release trajectory against approved goals without disguising incomplete work as percentage completion.
+allowed-tools: Read, Glob, Grep, Bash, Task
+---
+
+# Milestone Review
+
+Read `.nccgs/project.yaml`, `.nccgs/state.md`, and the active context packet when present. Preserve Product Owner authority and unrelated work.
+
+Remain read-only unless asked to update records. Compare approved milestone outcomes with feature closures, evidence, defects, dependencies, PO gates, and repository/build state. Report achieved outcomes, incomplete gates, scope movement, forecast assumptions, top risks, and decision options. Use evidence-based confidence rather than arbitrary completion percentages.
+
+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/new-unity-project/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: new-unity-project
+description: Use when starting a brand-new Unity game or project from scratch — "make/start/create a new game", "bootstrap a Unity project", "I want to build a <genre> game", "scaffold/prototype a game", game jam, greenfield, blank project, project setup. A guided flow that gathers the concept, target platforms, and monetization, installs the Editor in the background while it asks, then creates the project and source control and installs packages — delegating the mechanics to the unity-cli and unity-package-management skills and handing off monetization to the dedicated skills. Does not scaffold gameplay code.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - AskUserQuestion
+---
+
+# New Unity Project
+
+A guided flow from an idea to a running, version-controlled Unity project. This skill owns the
+**flow** — the questions, their ordering, running slow installs in the background while you ask,
+and the handoffs. It deliberately does **not** re-document commands; it delegates the mechanics
+to other skills.
+
+**Delegates to (read these for the actual commands — don't reinvent them):**
+- **`unity-cli`** — CLI install, auth/license, Editor install, project creation, source control,
+  opening the project. Its "Bootstrap a new project from scratch" workflow is the backbone here.
+- **`unity-package-management`** — installing packages via the C# PackageManager Client API, and
+  choosing packages by genre / platform / monetization.
+- **`implement-in-app-purchases`**, **`levelplay-unity-integration`**, **`build-live-game`** —
+  monetization / backend *integration* (invoked at the end).
+
+**Work one step at a time.** Ask only the current step's questions and wait for the user before
+moving on — platform and monetization answers change what you install, so don't gather everything
+up front or scaffold before they're settled.
+
+## The flow — and where the parallelism is
+
+1. **Concept** — what they're building.
+2. **Platforms & monetization** — then, as soon as platforms are known, **kick off the Editor
+   install in the background** (it takes minutes) and keep talking.
+3. **(joins)** Editor + platform modules finish installing.
+4. **Project + source control** — create from a matching template; init git.
+5. **Packages** — install via the C# Client API.
+6. **Save & first commit.**
+7. **Hand off** monetization / backend.
+
+The whole point of a guided flow over a raw recipe: the multi-minute Editor install overlaps the
+minutes the user spends answering concept questions, so setup feels instant.
+
+## Step 1 — Concept
+
+Use `AskUserQuestion` so the user can pick fast, but let them answer freely too. Cover:
+
+- **Genre / core loop** — platformer, top-down shooter, puzzle, idle, RPG, racing, card, tower
+  defense, sim, hyper-casual, first-person, etc.
+- **Dimension & look** — 2D or 3D; art style (pixel, low-poly, stylized, realistic, UI-only).
+- **Gameplay** — the one-sentence "what the player does moment to moment."
+- **Scope** — single-screen prototype vs. multi-scene game; single-player or multiplayer.
+
+Also settle on a **project name**. Write a 2–4 line **project brief**, read it back to confirm.
+The brief drives template choice (Step 4) and packages (Step 5).
+
+## Step 2 — Platforms & monetization, then start installing
+
+Two decisions, because both change what you install:
+
+- **Target platforms** (multi-select): Desktop (Win/macOS/Linux), Mobile (iOS/Android), WebGL,
+  Console. These map to Editor **modules** (Step 3) and argue for leaner packages on mobile/WebGL.
+- **Monetization**: none / premium / in-app purchases / ads / mix. This only decides which
+  handoff skill you invoke in Step 7 — don't integrate it now.
+
+Confirm the Editor version to use (**default: latest LTS** — see `unity-cli` for the LTS vs. Tech
+vs. beta trade-off). Ask this *now*, before kicking off the install, so you don't install the
+wrong one.
+
+Then confirm prerequisites and **launch the Editor install as a background task** so it runs while
+you continue. See the `unity-cli` skill for exact syntax, module names per platform, and auth /
+license setup:
+
+```bash
+unity --version
+unity auth status --format json      # if signed out:  unity auth login
+unity license status --format json   # if none active: unity license activate
+
+# Start in the BACKGROUND, then go straight back to the conversation. Module names per platform
+# (android / ios / webgl / …) are in the unity-cli skill.
+unity install lts --module <platform-modules> --yes --accept-eula
+```
+
+Run that install as a **background task** (don't block on it). If you have nothing left to ask,
+it's fine to just wait — the parallelism only helps when there's a conversation to overlap.
+
+## Step 3 — Join: Editor ready
+
+Before creating the project, confirm the background install finished:
+
+```bash
+unity editors --installed --format json
+```
+
+If it failed, surface the error (see `unity-cli` troubleshooting) and stop — nothing downstream
+works without an Editor.
+
+## Step 4 — Create the project + source control
+
+Follow the **`unity-cli`** "Bootstrap a new project from scratch" workflow verbatim:
+
+- List the **real** template ids the Editor offers (`unity templates list`) and pick one matching
+  2D/3D and render pipeline from the brief — don't guess ids.
+- Create with `unity projects create "<Name>" --path <dir> --editor-version <v> --template <id>`.
+- Set up source control — **ask the user which they want**, don't assume: Git (GitHub / GitLab;
+  add `--git-lfs` for asset-heavy games) or **Unity Version Control** (`--vcs uvcs`, which handles
+  large binary assets natively — no LFS), or a purely local `git init` + Unity `.gitignore`.
+  Publish in one step with `unity projects create --vcs … --git-token-stdin --no-initial-commit`
+  (tokens on stdin). Pass **`--no-initial-commit`** so the CLI doesn't commit the bare project
+  before packages and `.meta` files exist — you make the real first commit/check-in in Step 6.
+  See the `unity-cli` workflow for exact flags.
+
+## Step 5 — Packages
+
+Map the brief to a concrete package list and install it via the **`unity-package-management`**
+skill (C# PackageManager Client API — **never** hand-edit `manifest.json`). Read that skill for
+the genre/platform/monetization → package mapping, the installer script, and the `-quit` gotcha.
+Read the final list back to the user before installing; verify `manifest.json` afterward.
+
+## Step 6 — Save & first commit
+
+Open the project once so Unity imports the assets and generates every `.meta` file, then make
+the first commit **with whichever VCS you set up in Step 4**:
+
+```bash
+unity open "<project-path>"     # imports + generates .meta; for headless/CI use the
+                                # "Import & save headlessly" method in unity-package-management
+```
+
+- **Git (GitHub / GitLab / local):**
+  ```bash
+  cd "<project-path>"
+  git add -A
+  git status                    # Library/ Temp/ obj/ Build/ must NOT be staged
+  git commit -m "Initial Unity project: <Name>"
+  ```
+  Every `.cs`/asset must be committed together with its `.meta`.
+- **Unity Version Control (UVCS):** check in through your UVCS client/workspace (created during
+  Step 4) — there's no `git` step. Generated folders are still excluded by the ignore rules.
+
+If you published via `--vcs` in Step 4 **without** `--no-initial-commit`, the CLI already made an
+initial commit of the bare project — add a follow-up commit here rather than double-committing.
+
+## Step 7 — Hand off
+
+Based on Step 2 monetization, invoke the matching skill for the actual integration:
+- IAP → **implement-in-app-purchases**
+- Ads → **levelplay-unity-integration**
+- Accounts / cloud save / economy / remote config / leaderboards → **build-live-game**
+
+Report the project path, Editor version, installed packages, and next steps.
+
+## Scope — what this skill does NOT do
+
+- **No gameplay scaffolding.** It gets you to a running, empty-but-wired project; building the
+  actual game (scenes, controllers, art) is the next conversation — iterate there with the Editor
+  via the `unity-cli` MCP server and the Package Manager. Generic genre skeletons tend to produce
+  throwaway mocked primitives, so this skill intentionally stops at a clean starting point.
+- **No command reference.** Syntax lives in `unity-cli` / `unity-package-management`.
+
+## Checklist
+
+- [ ] Concept brief captured and confirmed (genre, look, gameplay, scope, name)
+- [ ] Platforms + monetization recorded; Editor version chosen
+- [ ] Editor + platform modules installed (started in the background during Step 2)
+- [ ] Project created from a matching template; git initialized with a Unity `.gitignore`
+- [ ] Packages installed via the C# Client API; `manifest.json` verified
+- [ ] Project opened/saved so `.meta` files exist; first commit made; `Library/` excluded
+- [ ] Handed off to the monetization/backend skill if applicable
+
+## Common mistakes
+
+- **Blocking on the Editor install** instead of backgrounding it while you ask questions.
+- **Installing the wrong Editor** because the version wasn't confirmed before the background install.
+- **Gathering all questions up front** — platform/monetization answers change the modules and packages.
+- **Hand-editing `manifest.json`** instead of using the Client API (see `unity-package-management`).
+- **Committing `Library/`/`Temp/`/`obj/`/`Build/`**, or scripts without their `.meta` files.
+- **Missing Editor modules** — a mobile target needs `android`/`ios`; WebGL needs `webgl`.