fix: address code review feedback

- Fix release-plugin.yml condition to handle workflow_dispatch events
- Correct JObjectPool constructor signature (maxSize, not createFunc)
- Fix JAction state parameter docs (value types work without boxing)
- Update README AI feature wording for better clarity

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

Author: JasonXuDeveloper

.github/workflows/release-plugin.yml

@@ -21,8 +21,8 @@ on:
 jobs:
   release-plugin:
     runs-on: ubuntu-latest
-    # Skip if this is an automated version bump commit
-    if: "!contains(github.event.head_commit.message, 'chore(plugin): bump version')"
+    # Skip if this is an automated version bump commit (only applies to push events)
+    if: github.event_name == 'workflow_dispatch' || !contains(github.event.head_commit.message || '', 'chore(plugin): bump version')
     steps:
       - uses: actions/checkout@v4
         with:

README.md

@@ -18,7 +18,7 @@
 - **Zero/Minimal GC** - UniTask (GC-free async) + Nino (high-performance serialization)
 - **All Platforms** - iOS, Android, Windows, macOS, WebGL, WeChat, Douyin, Alipay, TapTap
 - **Secure Updates** - Obfuscate hot update DLL + encrypt resources (assets & DLL/PDB) with XOR/AES/ChaCha20
-- **AI-Ready** - AI coding assistants [automatically discover and apply](claude-plugin/) JEngine APIs as you code
+- **AI-Accelerated** - Intelligent AI [seamlessly integrated](claude-plugin/), deeply understands JEngine to boost productivity
 - **Commercial Ready** - Production-proven by individuals and enterprise teams
 
 ## Overview

README_zh_cn.md

@@ -18,7 +18,7 @@
 - **零/极低GC** - UniTask（无GC异步）+ Nino（高性能序列化）
 - **全平台支持** - iOS、Android、Windows、macOS、WebGL、微信、抖音、支付宝、TapTap
 - **安全更新** - 热更DLL混淆 + 资源（资产和DLL/PDB）支持XOR/AES/ChaCha20加密
-- **AI就绪** - AI编码助手[自动发现并运用](claude-plugin/)JEngine的API和模式
+- **AI赋能** - AI[深度理解JEngine](claude-plugin/)，无缝融入开发流程，效率倍增
 - **商用验证** - 经个人和企业团队生产环境验证
 
 ## 概述

claude-plugin/skills/jaction/SKILL.md

@@ -73,16 +73,19 @@ await JAction.Create()
     .ExecuteAsync();
 ```
 
-### State Parameter for Zero-Allocation (Reference Types Only)
+### State Parameter for Zero-Allocation
 ```csharp
-// CORRECT - no closure allocation
+// CORRECT - no closure allocation (works with both reference and value types)
 var data = new MyData();
 JAction.Create()
     .Do(static (MyData d) => d.Process(), data)
     .Execute();
 
-// NOTE: State overloads ONLY work with reference types (classes, arrays)
-// Value types get boxed, defeating allocation avoidance
+// Also works with value types without boxing
+int count = 5;
+JAction.Create()
+    .Do(static (int c) => Debug.Log($"Count: {c}"), count)
+    .Execute();
 ```
 
 ### Set Timeouts for Production
@@ -106,6 +109,5 @@ action.Cancel();
 ## Common Mistakes
 - NOT using `using var` after ExecuteAsync (memory leak, never returns to pool)
 - Using Execute() in production (blocks main thread, causes frame drops)
-- Using state overloads with value types (causes boxing)
 - Forgetting to call Execute() or ExecuteAsync() (nothing happens)
 - Code in .Do() runs atomically and cannot be interrupted - keep callbacks lightweight

claude-plugin/skills/jobjectpool/SKILL.md

@@ -18,53 +18,49 @@ Thread-safe, lock-free generic object pooling for Unity using CAS operations. Wo
 ### Constructor
 ```csharp
 new JObjectPool<T>(
-    Func<T> createFunc = null,    // Factory (defaults to Activator.CreateInstance<T>())
-    Action<T> onRent = null,       // Called when renting
-    Action<T> onReturn = null      // Called when returning
+    int maxSize = 64,           // Maximum pooled objects (excess discarded)
+    Action<T> onRent = null,    // Called when renting (for initialization)
+    Action<T> onReturn = null   // Called when returning (for cleanup)
 )
 ```
+Note: `T` must be a reference type with a parameterless constructor (`where T : class, new()`).
 
 ### Methods
 - `.Rent()` - Get object from pool or create new
-- `.Return(T obj)` - Return object to pool
+- `.Return(T obj)` - Return object to pool (null values ignored)
 - `.Clear()` - Remove all pooled objects
-- `.Prewarm(int count)` - Pre-allocate objects
-- `.Count` - Current available count
+- `.Prewarm(int count)` - Pre-allocate objects (won't exceed maxSize)
+- `.Count` - Current available count (approximate, thread-safe)
 
 ### Static Access
-- `JObjectPool.Shared<T>()` - Global shared pool per type (simple objects only)
+- `JObjectPool.Shared<T>()` - Global shared pool per type (default config: maxSize=64)
 
 ## Patterns
 
 ### Basic Pool
 ```csharp
-var pool = new JObjectPool<Bullet>();
+var pool = new JObjectPool<Bullet>(maxSize: 100);
 var bullet = pool.Rent();
 // ... use bullet ...
 pool.Return(bullet);
 ```
 
-### With Custom Factory
+### With Initialization on Rent
 ```csharp
 var pool = new JObjectPool<Enemy>(
-    createFunc: () => new Enemy(defaultHealth: 100)
+    maxSize: 50,
+    onRent: static enemy => enemy.Reset()
 );
 ```
 
 ### Reset State on Return (RECOMMENDED)
 ```csharp
 var pool = new JObjectPool<List<int>>(
+    maxSize: 32,
     onReturn: static list => list.Clear()
 );
 ```
 
-### Initialize on Rent
-```csharp
-var pool = new JObjectPool<Projectile>(
-    onRent: static p => p.Reset()
-);
-```
-
 ### Prewarm During Loading
 ```csharp
 var pool = new JObjectPool<Effect>();
@@ -73,21 +69,23 @@ pool.Prewarm(50);  // Pre-create during loading screen
 
 ### Shared Pool (Simple Objects)
 ```csharp
-// Good for simple reusable objects without custom initialization
+// Good for simple reusable objects without custom callbacks
 var sb = JObjectPool.Shared<StringBuilder>().Rent();
 sb.Append("Hello");
+sb.Clear();  // Clean up before returning
 JObjectPool.Shared<StringBuilder>().Return(sb);
 ```
 
 ## Best Practices
 1. **Pre-allocate during loading** to prevent in-game allocation spikes
 2. **Reset state on return** to prevent data leaks between reuses
-3. **Use custom pools** for complex objects requiring specific initialization
-4. **Use shared pools only** for simple value objects with default construction
+3. **Set appropriate maxSize** based on expected concurrent usage
+4. **Use shared pools** for simple objects without custom callbacks
 5. **Monitor pool Count** to optimize sizing
 
 ## Common Mistakes
 - Returning null to pool (ignored, but wasteful)
 - Not clearing object state on return (causes bugs from stale data)
 - Forgetting to return objects (pool becomes ineffective)
-- Using shared pool for complex objects needing initialization
+- Setting maxSize too low (causes frequent allocations)
+- Setting maxSize too high (wastes memory)