@musashishao/agent-kit 1.9.0 → 1.9.1

package/.agent/skills/game-development/testing-qa/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: testing-qa
+description: Comprehensive QA and testing patterns for games. Playtesting, alpha/beta phases, bug triage, performance testing, and automated testing for Unity.
+---
+
+# Game Testing & QA Skill
+
+> **Purpose**: Systematic quality assurance for game development.
+
+## When to Use
+- Preparing for alpha/beta release
+- Setting up automated test suites
+- Organizing playtesting sessions
+- Debugging production issues
+
+---
+
+## 1. Testing Phases
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    TESTING LIFECYCLE                        │
+├─────────────────────────────────────────────────────────────┤
+│  DEV TEST → ALPHA → CLOSED BETA → OPEN BETA → RELEASE      │
+│     ↓         ↓          ↓            ↓           ↓        │
+│  Internal   Friends    Invited     Public     Everyone      │
+│  Team only   & Family   Testers    Testers                  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Phase Goals
+| Phase | Focus | Testers |
+|-------|-------|---------|
+| **Dev Test** | Core mechanics work | Team only |
+| **Alpha** | Feature complete, major bugs | 10-50 |
+| **Closed Beta** | Balance, UX, edge cases | 100-1000 |
+| **Open Beta** | Scale, server load, final polish | Unlimited |
+
+---
+
+## 2. Playtesting Sessions
+
+### Session Structure
+```markdown
+## Playtest Session Plan
+
+**Duration**: 30-60 minutes
+**Testers**: [X] people
+**Build**: v[X.X.X]
+
+### Pre-Session (5 min)
+- Explain purpose (not testing player, testing game)
+- No hints during play
+- Think-aloud protocol
+
+### Observation (20-40 min)
+- Silent observation
+- Note confusion points
+- Track completion times
+
+### Post-Session (10-15 min)
+- Open questions first
+- Then specific questions
+- Collect written feedback
+```
+
+### Observation Checklist
+- [ ] Where did player get stuck?
+- [ ] What did player try that didn't work?
+- [ ] What did player miss?
+- [ ] What caused frustration?
+- [ ] What caused joy?
+
+---
+
+## 3. Bug Triage System
+
+### Severity Classification
+| Severity | Definition | Response Time |
+|----------|------------|---------------|
+| **S1 - Critical** | Game unplayable, data loss, crash | Immediate |
+| **S2 - Major** | Feature broken, blocking progression | 24 hours |
+| **S3 - Minor** | Annoying but workaround exists | Next sprint |
+| **S4 - Trivial** | Cosmetic, typo, minor polish | Backlog |
+
+### Bug Report Template
+```markdown
+## Bug: [Short Description]
+
+**Severity**: S[1-4]
+**Platform**: [iOS/Android/PC]
+**Build**: v[X.X.X]
+
+### Steps to Reproduce
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+### Expected Behavior
+[What should happen]
+
+### Actual Behavior
+[What actually happens]
+
+### Evidence
+[Screenshot/Video/Logs]
+
+### Additional Context
+[Device, OS version, etc.]
+```
+
+---
+
+## 4. Performance Testing
+
+### Target Metrics
+| Metric | Mobile Target | PC Target |
+|--------|---------------|-----------|
+| **FPS** | 30-60 stable | 60+ stable |
+| **Frame Time** | <33ms | <16ms |
+| **Memory** | <500MB | <2GB |
+| **Load Time** | <5s | <3s |
+| **Battery Drain** | <10%/hour | N/A |
+
+### Performance Test Checklist
+- [ ] Profile on lowest target device
+- [ ] Test full session (30+ min)
+- [ ] Monitor thermal throttling
+- [ ] Check memory leaks
+- [ ] Measure after 100 entity spawns
+
+### Unity Profiler Commands
+```csharp
+// Frame timing
+Profiler.BeginSample("MySystem");
+// ... code ...
+Profiler.EndSample();
+
+// Memory snapshot
+UnityEngine.Profiling.Memory.Experimental.MemoryProfiler.TakeSnapshot();
+```
+
+---
+
+## 5. Automated Testing (Unity)
+
+### Test Types
+
+| Type | Purpose | Location |
+|------|---------|----------|
+| **Edit Mode** | Logic, utilities, pure C# | `Tests/Editor/` |
+| **Play Mode** | Runtime, MonoBehaviour | `Tests/Runtime/` |
+| **Integration** | Full systems together | `Tests/Integration/` |
+
+### Edit Mode Test Example
+```csharp
+// Tests/Editor/CombatTests.cs
+using NUnit.Framework;
+
+[TestFixture]
+public class CombatTests
+{
+    [Test]
+    public void Damage_ReducesHealth()
+    {
+        var health = new HealthComponent(100);
+        health.TakeDamage(25);
+        Assert.AreEqual(75, health.CurrentHealth);
+    }
+    
+    [Test]
+    public void Damage_CannotGoBelowZero()
+    {
+        var health = new HealthComponent(50);
+        health.TakeDamage(100);
+        Assert.AreEqual(0, health.CurrentHealth);
+    }
+}
+```
+
+### Play Mode Test Example
+```csharp
+// Tests/Runtime/PlayerMovementTests.cs
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+public class PlayerMovementTests
+{
+    private GameObject _player;
+    
+    [SetUp]
+    public void Setup()
+    {
+        _player = new GameObject("Player");
+        _player.AddComponent<PlayerController>();
+    }
+    
+    [TearDown]
+    public void Teardown()
+    {
+        Object.Destroy(_player);
+    }
+    
+    [UnityTest]
+    public IEnumerator Player_MovesRight_WhenInputPositive()
+    {
+        var controller = _player.GetComponent<PlayerController>();
+        var startPos = _player.transform.position;
+        
+        controller.SimulateInput(Vector2.right);
+        yield return new WaitForSeconds(0.5f);
+        
+        Assert.Greater(_player.transform.position.x, startPos.x);
+    }
+}
+```
+
+---
+
+## 6. Regression Testing
+
+### When to Run
+- Before every release
+- After major feature merge
+- After engine update
+- After platform SDK update
+
+### Regression Checklist
+- [ ] All save files load correctly
+- [ ] Tutorial completes without errors
+- [ ] IAP flow works (sandbox)
+- [ ] Ads display and reward correctly
+- [ ] Analytics events fire
+- [ ] All levels completable
+- [ ] No new crashes in crash reporter
+
+---
+
+## 7. Test Coverage Guidelines
+
+| System | Required Coverage |
+|--------|-------------------|
+| **Save/Load** | 90%+ (critical) |
+| **Economy** | 80%+ (balance-sensitive) |
+| **Combat** | 70%+ (core mechanic) |
+| **UI Navigation** | 50%+ (regression) |
+| **Visual Polish** | Manual only |
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Test only happy path | Test edge cases |
+| Skip low-end device testing | Test on min spec |
+| Rely only on team testing | Use external testers |
+| Fix all bugs at once | Prioritize by severity |
+| Ship without regression | Run full suite before release |
+
+---
+
+## Related Skills
+- `game-development/game-analytics-integrator`
+- `game-development/unity-integration`
+
+## Related Workflows
+- `/game-launch` - Includes pre-launch audit

package/.agent/skills/game-development/unity-mobile-optimization/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: unity-mobile-optimization
+description: Mobile-specific optimization for Unity games. Battery, thermal, memory management, build size, and platform-specific optimizations for iOS and Android.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# Unity Mobile Optimization Skill
+
+> Expert-level mobile optimization patterns for Unity 6 targeting iOS and Android.
+
+---
+
+## When to Use
+
+- Optimizing Unity games for mobile devices
+- Debugging performance issues on phones/tablets
+- Reducing battery drain and heat
+- Minimizing build size for app stores
+- Platform-specific tuning (iOS Metal, Android Vulkan)
+
+---
+
+## Performance Targets
+
+| Metric | iOS Target | Android Target | Tool |
+|--------|------------|----------------|------|
+| **FPS** | 60 stable | 30-60 stable | Profiler |
+| **Frame Time** | < 16.67ms | < 33ms | Profiler |
+| **Draw Calls** | < 100 | < 80 | Frame Debugger |
+| **SetPass Calls** | < 50 | < 40 | Frame Debugger |
+| **Memory** | < 500MB | < 400MB | Memory Profiler |
+| **Battery** | < 5%/hour | < 8%/hour | Device monitor |
+| **Build Size** | < 200MB | < 150MB AAB | Build Report |
+
+---
+
+## Battery Optimization
+
+### Frame Rate Management
+```csharp
+public class BatteryManager : MonoBehaviour
+{
+    [SerializeField] private int _gameplayFPS = 60;
+    [SerializeField] private int _menuFPS = 30;
+    [SerializeField] private int _backgroundFPS = 5;
+    
+    public void SetGameState(GameState state)
+    {
+        Application.targetFrameRate = state switch
+        {
+            GameState.Playing => _gameplayFPS,
+            GameState.Menu => _menuFPS,
+            GameState.Paused => _backgroundFPS,
+            _ => _gameplayFPS
+        };
+    }
+    
+    void OnApplicationPause(bool paused)
+    {
+        Application.targetFrameRate = paused ? 1 : _gameplayFPS;
+    }
+}
+```
+
+### GPU Throttling Detection
+```csharp
+public class ThermalManager : MonoBehaviour
+{
+    private float _lastFrameTime;
+    private int _consecutiveSlowFrames;
+    
+    void Update()
+    {
+        float frameTime = Time.deltaTime;
+        
+        // Detect thermal throttling
+        if (frameTime > 0.02f) // >20ms
+        {
+            _consecutiveSlowFrames++;
+            if (_consecutiveSlowFrames > 60) // 1 second of slow frames
+            {
+                ReduceQuality();
+                _consecutiveSlowFrames = 0;
+            }
+        }
+        else
+        {
+            _consecutiveSlowFrames = 0;
+        }
+    }
+    
+    void ReduceQuality()
+    {
+        QualitySettings.DecreaseLevel();
+        Application.targetFrameRate = 30;
+    }
+}
+```
+
+---
+
+## Memory Management
+
+### Addressables Best Practices
+```csharp
+public class AssetLoader : MonoBehaviour
+{
+    private Dictionary<string, AsyncOperationHandle> _loadedAssets = new();
+    
+    public async UniTask<T> LoadAsset<T>(string key) where T : Object
+    {
+        if (_loadedAssets.TryGetValue(key, out var handle))
+            return (T)handle.Result;
+        
+        var newHandle = Addressables.LoadAssetAsync<T>(key);
+        await newHandle.ToUniTask();
+        
+        _loadedAssets[key] = newHandle;
+        return newHandle.Result as T;
+    }
+    
+    public void UnloadAsset(string key)
+    {
+        if (_loadedAssets.TryGetValue(key, out var handle))
+        {
+            Addressables.Release(handle);
+            _loadedAssets.Remove(key);
+        }
+    }
+    
+    public void UnloadAll()
+    {
+        foreach (var handle in _loadedAssets.Values)
+            Addressables.Release(handle);
+        _loadedAssets.Clear();
+        
+        Resources.UnloadUnusedAssets();
+        GC.Collect();
+    }
+}
+```
+
+### Texture Compression Guide
+| Platform | Format | Quality | Use Case |
+|----------|--------|---------|----------|
+| iOS | ASTC 6x6 | High | Characters, UI |
+| iOS | ASTC 8x8 | Medium | Backgrounds |
+| Android | ETC2 | Good | Universal |
+| Android | ASTC | Best | High-end only |
+
+---
+
+## Build Size Optimization
+
+### Code Stripping
+```csharp
+// link.xml - Prevent stripping needed assemblies
+<linker>
+    <assembly fullname="UnityEngine">
+        <type fullname="UnityEngine.Networking.*" preserve="all"/>
+    </assembly>
+</linker>
+```
+
+### Build Settings
+```
+Player Settings:
+- Scripting Backend: IL2CPP
+- Managed Stripping Level: High
+- Engine Code Stripping: Enabled
+- Compress Meshes: Enabled
+- Vertex Compression: Everything
+
+Android:
+- Build App Bundle (AAB)
+- Split Application Binary
+- Target Architectures: ARM64 only
+
+iOS:
+- App Thinning: Automatic
+- Strip Engine Code: Enabled
+```
+
+---
+
+## Platform-Specific
+
+### iOS Metal
+```csharp
+// Check Metal support
+if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
+{
+    // Metal-specific optimizations
+    QualitySettings.antiAliasing = 0; // Use FXAA instead
+}
+```
+
+### Android Vulkan
+```csharp
+// Prefer Vulkan, fallback to GLES
+// Set in Player Settings: Auto Graphics API
+
+#if UNITY_ANDROID
+void Start()
+{
+    bool isVulkan = SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan;
+    Debug.Log($"Graphics API: {(isVulkan ? "Vulkan" : "OpenGL ES")}");
+}
+#endif
+```
+
+---
+
+## Profiling Workflow
+
+### Step 1: Profile on Device
+```
+1. Build Development Build with Autoconnect Profiler
+2. Connect device via USB/WiFi
+3. Run game and capture frames
+4. Focus on:
+   - GC.Alloc column
+   - Rendering time
+   - Scripts time
+```
+
+### Step 2: Identify Hotspots
+```csharp
+// Use profiler markers
+using (new ProfilerMarker("MyExpensiveFunction").Auto())
+{
+    // Code to profile
+}
+```
+
+### Step 3: Fix Priority
+1. GC Allocations (causes stutters)
+2. Draw calls (GPU bound)
+3. Physics (CPU heavy)
+4. Scripts (logic overhead)
+
+---
+
+## Quick Wins Checklist
+
+- [ ] `Application.targetFrameRate` set explicitly
+- [ ] All `GetComponent` calls cached
+- [ ] Object pooling for bullets/effects
+- [ ] Static batching enabled
+- [ ] Texture compression correct per platform
+- [ ] No `Resources.Load` in gameplay
+- [ ] `CompareTag` instead of `tag ==`
+- [ ] `NonAlloc` physics methods used
+- [ ] StringBuilder for string operations
+- [ ] No LINQ in Update loops
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Max quality everywhere | Adjust by device tier |
+| Ignore battery/heat | Monitor and adapt |
+| 4K textures on mobile | Max 2K, usually 1K |
+| Full mesh colliders | Simple primitives |
+| Sync asset loading | Async with loading screen |
+
+---
+
+> **Remember:** Profile first, optimize second. Don't guess.

package/.agent/skills/intent-capture/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: intent-capture
+description: "High-resolution intent extraction for Vibe Coding. Extracts explicit requests, implicit needs, unknown needs, and anti-goals."
+version: "1.0.0"
+---
+
+# 🎯 Intent Capture
+
+> **"Capture the vibe, not just the command"**
+
+This skill ensures that as an AI agent, you understand not just what the user said, but what they actually need to succeed in the 2026 Vibe Coding era.
+
+---
+
+## The Intent Matrix
+
+When a user makes a request, analyze it across these 4 dimensions:
+
+| Dimension | Question | Example |
+|-----------|----------|---------|
+| **Explicit** | What did they literally ask for? | "Create a login page" |
+| **Implicit** | What is required based on context? | "Must be mobile-responsive, use Tailwind" |
+| **Unknown** | What haven't they considered yet? | "Need CSRF protection, rate limiting" |
+| **Anti-Goals** | What do they specifically NOT want? | "No social logins, no third-party cookies" |
+
+---
+
+## 📋 Pre-Flight Intent Checklist
+
+Before moving to the B (Bifurcation) stage of VIBES, verify:
+
+- [ ] **Problem Understanding**: Why is the user asking for this?
+- [ ] **Success Criteria**: What does "done" look like to them? (Outcome vs Process)
+- [ ] **Hidden Constraints**: Any tech stack or performance limits?
+- [ ] **Risk Level**: Is this a prototype or production-critical?
+
+---
+
+## 🎼 CONDUCTOR Integration
+
+As a CONDUCTOR, your role in Intent Capture is:
+
+1. **Context Provision**: Feed the agent related files and past decisions.
+2. **Socratic Probing**: Ask ONE high-leverage question at a time to fill gaps.
+3. **Synthesis**: Summarize the intent back to the user to confirm alignment.
+
+---
+
+## Usage Patterns
+
+### For New Features
+Run intent extraction before any architecture planning.
+
+### For Bug Fixes
+Identify the *intended behavior* versus the *actual behavior* before proposing a solution.
+
+### For Refactors
+Identify the *underlying goal* (performance? maintainability?) to avoid circular refactoring.
+
+---
+
+## Related Skills
+- `brainstorming` - The communication engine for intent capture
+- `bifurcation-analysis` - The next step in VIBES
+- `vibe-coding-guard` - The overall framework