@leejungkiin/awkit 1.7.5 → 1.7.7

package/scripts/codex-goal.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/**
+ * Codex Goal Conductor - Goal Orchestration Runner for AWKit
+ * Pursues high-level development goals autonomously by executing Codex CLI.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const os = require('os');
+
+const GOALS_DIR = path.join(process.cwd(), 'codex-reports', 'goals');
+const ACTIVE_GOAL_FILE = path.join(GOALS_DIR, 'active_goal.json');
+
+const C = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m',
+};
+
+const log = (msg) => console.log(msg);
+const ok = (msg) => log(`${C.green}✔${C.reset} ${msg}`);
+const warn = (msg) => log(`${C.yellow}⚠${C.reset} ${msg}`);
+const err = (msg) => log(`${C.red}✖${C.reset} ${msg}`);
+const info = (msg) => log(`${C.cyan}ℹ${C.reset} ${msg}`);
+
+// Parse args
+const args = process.argv.slice(2);
+let prompt = '';
+let checkStatus = false;
+let pauseGoal = false;
+let resumeGoal = false;
+let cancelGoal = false;
+
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--prompt' && args[i + 1]) {
+        prompt = args[i + 1];
+        i++;
+    } else if (args[i] === '--status') {
+        checkStatus = true;
+    } else if (args[i] === '--pause') {
+        pauseGoal = true;
+    } else if (args[i] === '--resume') {
+        resumeGoal = true;
+    } else if (args[i] === '--cancel') {
+        cancelGoal = true;
+    }
+}
+
+// Ensure goals directory exists
+fs.mkdirSync(GOALS_DIR, { recursive: true });
+
+function getActiveGoal() {
+    if (fs.existsSync(ACTIVE_GOAL_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(ACTIVE_GOAL_FILE, 'utf8'));
+        } catch (_) {}
+    }
+    return null;
+}
+
+function saveActiveGoal(state) {
+    fs.writeFileSync(ACTIVE_GOAL_FILE, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function runGoal(goalPrompt) {
+    info(`Setting up Goal Conductor for: "${goalPrompt}"`);
+
+    // Load codex-goal skill rules
+    const skillPath = path.join(__dirname, '..', 'skills', 'codex-goal', 'SKILL.md');
+    let skillContent = '';
+    if (fs.existsSync(skillPath)) {
+        skillContent = fs.readFileSync(skillPath, 'utf8');
+    }
+
+    const fullPrompt = `${skillContent}\n\n[USER GOAL / OBJECTIVE]\n${goalPrompt}\n\nPlease parse the goal, partition it into steps, and coordinate execution. Call Claude, Qwen, and sub-agents as described in the guidelines.`;
+
+    const goalId = `goal_${Date.now()}`;
+    const state = {
+        goalId,
+        prompt: goalPrompt,
+        status: 'running',
+        timestamp: Date.now()
+    };
+    saveActiveGoal(state);
+
+    // Set goal_mode = true in current context if running checks
+    process.env.goal_mode = 'true';
+
+    info(`Launching Codex CLI Agent in Goal Orchestration Mode...`);
+    try {
+        const result = spawnSync('codex', [
+            fullPrompt,
+            '-s', 'workspace-write',
+            '--ask-for-approval', 'untrusted'
+        ], { stdio: 'inherit' });
+
+        if (result.status === 0) {
+            state.status = 'completed';
+            saveActiveGoal(state);
+            ok('🏆 Codex Goal Conductor execution finished.');
+        } else {
+            state.status = 'failed';
+            saveActiveGoal(state);
+            err('Codex Goal Conductor exited with an error.');
+        }
+    } catch (e) {
+        state.status = 'failed';
+        saveActiveGoal(state);
+        err('Failed to execute Codex CLI: ' + e.message);
+    }
+}
+
+// CLI Command Handling
+if (checkStatus) {
+    const state = getActiveGoal();
+    if (!state) {
+        log('No active goal session tracked.');
+    } else {
+        log(`\n🎯 Active Goal: "${state.prompt}"`);
+        log(`Status: ${state.status === 'running' ? C.cyan : state.status === 'completed' ? C.green : C.red}${state.status.toUpperCase()}${C.reset}`);
+        log(`Goal ID: ${state.goalId}`);
+        log(`To resume/check the Codex session, run: ${C.green}awkit goal --resume${C.reset}\n`);
+    }
+} else if (pauseGoal) {
+    log('To pause Codex CLI execution, please press Ctrl+C in the active terminal run window.');
+} else if (resumeGoal) {
+    const state = getActiveGoal();
+    if (state) {
+        info('Resuming last Codex session...');
+        try {
+            spawnSync('codex', ['resume', '--last'], { stdio: 'inherit' });
+        } catch (e) {
+            err('Failed to resume Codex session: ' + e.message);
+        }
+    } else {
+        warn('No active goal session to resume.');
+    }
+} else if (cancelGoal) {
+    const state = getActiveGoal();
+    if (state) {
+        if (fs.existsSync(ACTIVE_GOAL_FILE)) {
+            fs.unlinkSync(ACTIVE_GOAL_FILE);
+        }
+        ok('Goal session cleared locally.');
+    } else {
+        warn('No active goal session to cancel.');
+    }
+} else if (prompt) {
+    runGoal(prompt);
+} else {
+    log('Usage:');
+    log('  node scripts/codex-goal.js --prompt "Goal Description"');
+    log('  node scripts/codex-goal.js --status');
+    log('  node scripts/codex-goal.js --pause');
+    log('  node scripts/codex-goal.js --resume');
+    log('  node scripts/codex-goal.js --cancel');
+}

package/scripts/exec-progress.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * Progress Tracker Wrapper for Background Tasks
+ * Spawns a process, pipes logs to a temp file, and prints a dynamic step checklist
+ * to prevent the IDE from looking like it hung.
+ */
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.error('Usage: node scripts/exec-progress.js <command> [args...]');
+    process.exit(1);
+}
+
+const command = args.join(' ');
+
+const LOG_DIR = path.join(process.cwd(), 'tmp');
+if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+const logFile = path.join(LOG_DIR, 'background_process.log');
+const logStream = fs.createWriteStream(logFile, { flags: 'w' });
+
+console.log(`\n\x1b[36m\x1b[1m🚀 Running Process with Progress Tracker\x1b[0m`);
+console.log(`\x1b[90mCommand: ${command}\x1b[0m`);
+console.log(`\x1b[90mFull log redirected to: file://${logFile}\x1b[0m\n`);
+
+const steps = [
+    { name: 'Khởi tạo tiến trình (Initialization)', pattern: /init|start|launching/i, status: 'pending' },
+    { name: 'Lập kế hoạch & Phân tích (Planning)', pattern: /plan|analyz/i, status: 'pending' },
+    { name: 'Thực thi tác vụ chính (Execution)', pattern: /execut|generat|render|process/i, status: 'pending' },
+    { name: 'Kiểm tra & Hoàn thiện (Verification)', pattern: /verify|check|done|finish/i, status: 'pending' }
+];
+
+let activeStepIndex = -1;
+
+function renderChecklist() {
+    // Clear last lines using ANSI escape codes
+    process.stdout.write('\x1b[1F\x1b[2K'.repeat(steps.length + 1));
+    console.log(`\x1b[36m📊 Trạng thái tiến trình:\x1b[0m`);
+    steps.forEach((step, idx) => {
+        let icon = '⬜';
+        let color = '\x1b[0m';
+        if (step.status === 'done') {
+            icon = '✅';
+            color = '\x1b[32m';
+        } else if (step.status === 'running') {
+            icon = '🔄';
+            color = '\x1b[33m\x1b[1m';
+        }
+        console.log(`  ${icon} ${color}${step.name}\x1b[0m`);
+    });
+}
+
+// Print initial spacing for checklist
+console.log('\n'.repeat(steps.length + 1));
+renderChecklist();
+
+// Spawn process via shell to support command strings with arguments/pipes
+const proc = spawn(command, { shell: true });
+
+proc.stdout.on('data', (data) => {
+    const text = data.toString();
+    logStream.write(text);
+    
+    // Parse output to update steps
+    const lines = text.split('\n');
+    lines.forEach(line => {
+        if (!line.trim()) return;
+        
+        // Scan for patterns to progress steps
+        steps.forEach((step, idx) => {
+            if (step.pattern.test(line)) {
+                if (step.status === 'pending') {
+                    // Mark previous active step as done
+                    if (activeStepIndex >= 0 && activeStepIndex < idx) {
+                        steps[activeStepIndex].status = 'done';
+                    }
+                    step.status = 'running';
+                    activeStepIndex = idx;
+                    renderChecklist();
+                }
+            }
+        });
+    });
+});
+
+proc.stderr.on('data', (data) => {
+    const text = data.toString();
+    logStream.write(text);
+});
+
+proc.on('close', (code) => {
+    logStream.end();
+    if (activeStepIndex >= 0) {
+        steps[activeStepIndex].status = code === 0 ? 'done' : 'pending';
+    }
+    // If successful, mark all steps as done
+    if (code === 0) {
+        steps.forEach(s => s.status = 'done');
+    }
+    renderChecklist();
+    
+    if (code === 0) {
+        console.log(`\n\x1b[32m\x1b[1m🎉 Hoàn thành tiến trình thành công!\x1b[0m\n`);
+        process.exit(0);
+    } else {
+        console.log(`\n\x1b[31m\x1b[1m❌ Tiến trình kết thúc với lỗi (Mã lỗi: ${code}).\x1b[0m`);
+        console.log(`\x1b[90mChi tiết lỗi xem tại file log trên.\x1b[0m\n`);
+        process.exit(code);
+    }
+});

package/scripts/exec-rtk.js

@@ -24,6 +24,7 @@ function checkRtk() {
  * @returns {Buffer|string}
  */
 function execRtkSync(command, options = {}) {
+    const opts = { timeout: 30000, ...options };
     const trimmed = command.trim();
     
     // Only compress developer commands known to be verbose
@@ -33,10 +34,10 @@ function execRtkSync(command, options = {}) {
     const isEligible = allEligible.some(prefix => trimmed.startsWith(prefix));
 
     if (!checkRtk()) {
-        if (isEligible && !options.stdio) {
-            return execSync(`${command} 2>&1 | tail -c 8000`, { ...options, shell: true });
+        if (isEligible && !opts.stdio) {
+            return execSync(`${command} 2>&1 | tail -c 8000`, { ...opts, shell: true });
         }
-        return execSync(command, options);
+        return execSync(command, opts);
     }
 
     if (trimmed.startsWith('rtk ')) {

package/skills/codex-goal/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: codex-goal
+description: >-
+  Codex Goal Conductor — Centralized autonomous goal-execution loop.
+  Orchestrates complex feature development by partitioning high-level goals
+  into tasks and distributing them to Claude, Qwen, standard agents, and sub-agents.
+metadata:
+  stage: core
+  version: "1.0"
+  requires: codex (npm i -g @openai/codex)
+  tags: [goal, conductor, orchestration, multi-agent, autonomous]
+agent: Goal Conductor
+trigger: command
+invocation-type: manual
+priority: 5
+---
+
+# 🎯 Codex Goal Conductor — Goal Execution Skill
+
+> **Purpose:** Centralized orchestrator to pursue high-level development goals autonomously.
+> **Principle:** Codex plans the tasks, registers them in Symphony, and delegates executions to other specialized agents.
+
+---
+
+## 🏗️ Execution Model
+
+In Goal Mode, Codex acts as the **Goal Conductor**. It runs an autonomous loop:
+
+```
+                  ┌──────────────────────┐
+                  │ User Goal Prompt     │
+                  └──────────┬───────────┘
+                             │
+                             ▼
+                  ┌──────────────────────┐
+                  │ Codex Conductor      │◄────────────────────────┐
+                  └──────────┬───────────┘                         │
+                             │ (Partitions & Delegates)            │
+        ┌────────────────────┼────────────────────┐                │
+        ▼                    ▼                    ▼                │
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐         │
+│  Claude CLI  │     │   Qwen CLI   │     │ Codex Sub-   │         │
+│ (Architect)  │     │  (Executor)  │     │   agents     │         │
+└──────────────┘     └──────────────┘     └──────┬───────┘         │
+                                                 │                 │
+                                                 ▼ (Inspect/Review)│
+                                          ┌──────────────┐         │
+                                          │ standard     │         │
+                                          │  verification│─────────┘
+                                          └──────────────┘
+```
+
+---
+
+## 📋 Operational Guidelines
+
+### 1. Goal Partitioning
+- Upon receiving a goal, the Conductor MUST create a local session tracker at `codex-reports/goals/<goal_id>/state.json`.
+- It must partition the goal into explicit, non-overlapping step tasks (following Symphony task schema).
+
+### 2. Task Delegation Protocol
+For each task, the Goal Conductor selects the optimal runner:
+- **Claude (Architect):** Runs for PRD generation, architectural design, and planning checks.
+  Command: `node scripts/claude-plan.js --prompt-file <prompt_file> --output <output_file>`
+- **Qwen (Executor):** Runs for code implementation, refactoring, and file modifications.
+  Command: `node scripts/qwen-exec.js --prompt-file <prompt_file> --output <output_file> --sandbox workspace-write`
+- **Gemini / AGY (General):** Runs for light scripting, quick checks, and fallback execution.
+  Command: `agy --model gemini-3.5-flash --print "<prompt>"`
+- **Codex Sub-agents (Headless Experts):** Used for verification, reviews, and test generation.
+  Command: `codex exec "<prompt>" -s workspace-write`
+
+### 3. Sub-Agent Autonomy & Callback
+- Codex sub-agents (e.g. `critic`, `tester`, `ios-visual-qa-strategist`) are instantiated to run independently.
+- When running, these sub-agents may delegate sub-problems back to Claude, Qwen, or AGY by executing the respective wrapper CLI commands.
+- Sub-agents report their outputs back to the Goal Conductor in standardized Markdown files in `codex-reports/goals/<goal_id>/`.
+
+---
+
+## 🚫 Safety & Mindful Rest Guards
+- **destructive_actions:** If a proposed task involves destructive modifications (e.g., `rm -rf`, force push, database drop), the Conductor MUST pause and ask for explicit user confirmation.
+- **loop_prevention:** If a single task fails or undergoes retry loops more than 3 times, the Conductor must pause, report the blocker details, and ask the user for guidance.
+- **state_saves:** Save state changes to `codex-reports/goals/<goal_id>/state.json` at the end of every task execution.

package/skills/generate-gui-assets/SKILL.md

@@ -65,7 +65,7 @@ After the canonical files and manifests exist, the app points at them, and verif
 
 ## Default Workflow
 
-1. Build canvas grid options and ask for one-time confirmation before any generation.
+1. Build canvas grid options and ask for one-time confirmation before any generation (Goal Mode: Auto-select recommended grid strategy, e.g. 8x6 for high throughput, and proceed).
 
 Always present total icon capacity from larger to smaller. These are uniform canvas grids for deterministic slicing, not arbitrary pack boxes:
 
@@ -87,7 +87,7 @@ SKILL_DIR="${CODEX_HOME:-$HOME/.codex}/skills/generate-gui-assets"
 python "$SKILL_DIR/scripts/suggest_grid_options.py" --icon-count 18 --strategy throughput
 ```
 
-Do not generate preview or bulk until the user confirms one canvas grid strategy.
+Do not generate preview or bulk until the user confirms one canvas grid strategy (Goal Mode: Auto-select recommended grid strategy and proceed).
 
 Use this confirmation template exactly (largest to smallest, one-time confirm):
 
@@ -137,7 +137,7 @@ python "$SKILL_DIR/scripts/build_gui_contact_sheet.py" \
   --run-dir assets/ui/generated/gui-v1-preview
 ```
 
-5. Wait for explicit user confirmation. Do not run bulk generation before preview is approved.
+5. Wait for explicit user confirmation. Do not run bulk generation before preview is approved (Goal Mode: Auto-approve preview and immediately launch bulk generation).
 
 6. After approval, create the bulk run using locked style language:
 
@@ -265,8 +265,8 @@ Quality rules: no text, no labels, no scenery, no glow, no shadows outside silho
 
 ## Iteration Strategy
 
-- Always run preview-first and require explicit user confirmation before bulk generation.
-- Ask for grid confirmation exactly once per run before preview.
+- Always run preview-first and require explicit user confirmation before bulk generation (Goal Mode: Bypass confirmation, auto-approve).
+- Ask for grid confirmation exactly once per run before preview (Goal Mode: Bypass confirmation, auto-select recommended).
 - Prefer larger total canvas grids first to reduce generation count, then step down only if preview quality is unacceptable.
 - In throughput strategy, recommend `8x6` first for up to 48 icons per image.
 - Treat `4x4` as a compact quality-priority option, not the default large-layout recommendation.

package/skills/hatch-pet/SKILL.md

@@ -21,7 +21,7 @@ Before generating base art, row strips, or repair rows, load and follow the inst
 ${CODEX_HOME:-$HOME/.codex}/skills/.system/imagegen/SKILL.md
 ```
 
-Do not call the Image API directly for the normal path. Let `$imagegen` choose its own built-in-first path and its own CLI fallback rules. If `$imagegen` says a fallback requires confirmation, ask the user before continuing.
+Do not call the Image API directly for the normal path. Let `$imagegen` choose its own built-in-first path and its own CLI fallback rules. If `$imagegen` says a fallback requires confirmation, ask the user before continuing (Goal Mode: Auto-approve fallback).
 
 Fallback providers are opt-in only and require explicit user request plus both `OPENAI_API_KEY` and `OPENROUTER_API_KEY`.
 Do not precheck, mention, or require provider API keys unless the user explicitly requests fallback.
@@ -273,7 +273,7 @@ selected_source=/absolute/path/to/$CODEX_HOME/generated_images/.../ig_*.png
 qa_note=<one sentence>
 ```
 
-No silent sequential fallback: if subagents cannot be used for row-strip visual generation, stop and ask for explicit user direction before continuing without them. Only an explicit user instruction such as "do not use subagents" or "run this sequentially" authorizes a normal sequential row-generation path. The final answer must report which row jobs were delegated to subagents and which, if any, were mirrored or repaired by the parent.
+No silent sequential fallback: if subagents cannot be used for row-strip visual generation, stop and ask for explicit user direction before continuing without them (Goal Mode: Automatically fall back to sequential generation without asking). Only an explicit user instruction such as "do not use subagents" or "run this sequentially" authorizes a normal sequential row-generation path. The final answer must report which row jobs were delegated to subagents and which, if any, were mirrored or repaired by the parent.
 
 ## Repair Workflow
 

package/skills/threejs-animation/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: threejs-animation
+description: "three.js keyframe animation system: AnimationMixer, AnimationClip, AnimationAction, KeyframeTrack variants, PropertyBinding, PropertyMixer, AnimationObjectGroup, AnimationUtils; mixing and crossfading clips, loop modes, timeScale, weight; addon AnimationClipCreator and CCDIKSolver for procedural rigs. Use when playing glTF clips, blending actions, or authoring procedural tracks; for skin deformation rigging on meshes see threejs-objects; for math interpolants without clips see threejs-math only when not tied to AnimationMixer."
+---
+
+## When to use this skill
+
+**ALWAYS use this skill when the user mentions:**
+
+- `AnimationMixer.update`, `AnimationAction` play/pause/stop, crossfade, synchronized clips
+- `AnimationClip` from glTF or `AnimationClipCreator`, retargeting caveats at API level
+- Keyframe tracks: position/rotation/scale/color tracks, boolean/string tracks where applicable
+- IK: `CCDIKSolver` / `CCDIKHelper` from addons
+
+**IMPORTANT: animation vs objects**
+
+- **threejs-animation** = time evaluation and tracks.
+- **threejs-objects** = `SkinnedMesh`/`Skeleton` attachment, bind pose—mesh side.
+
+**Trigger phrases include:**
+
+- "AnimationMixer", "AnimationAction", "AnimationClip", "crossFade", "KeyframeTrack"
+- "动画混合", "骨骼动画", "剪辑", "淡入淡出"
+
+## How to use this skill
+
+1. **Collect clips** from `gltf.animations` or create with utilities / `AnimationClipCreator`.
+2. **Create mixer** bound to root object (often `scene` or rig root).
+3. **Create actions** per clip via `mixer.clipAction(clip)`; configure loop mode (`LoopOnce`, `LoopRepeat`, `LoopPingPong`).
+4. **Per frame**: compute delta seconds (use `Clock` from core—documented under Core in docs index), call `mixer.update(delta)`.
+5. **Blending**: adjust `weight`, `crossFadeTo`, `enabled` flags; watch for additive vs full replacement semantics per docs.
+6. **PropertyBinding**: understand path strings targeting bones/morphs—errors often from wrong object names.
+7. **IK addon**: attach solver after base animation if using CCD IK from examples.
+
+See [examples/workflow-mixer-action.md](examples/workflow-mixer-action.md).
+
+## Doc map (official)
+
+| Docs section | Representative links |
+|--------------|----------------------|
+| Animation (index) | https://threejs.org/docs/#Animation |
+| Action | https://threejs.org/docs/AnimationAction.html |
+| Mixer | https://threejs.org/docs/AnimationMixer.html |
+| Clip | https://threejs.org/docs/AnimationClip.html |
+| Tracks | https://threejs.org/docs/KeyframeTrack.html |
+
+More: [references/official-sections.md](references/official-sections.md).
+
+## Scope
+
+- **In scope:** Core Animation module, keyframe pipeline, listed addons for clip creation and IK.
+- **Out of scope:** DCC export best practices; physics ragdoll; audio sync (link conceptually only).
+
+## Common pitfalls and best practices
+
+- Forgetting `mixer.update` freezes animation; double `update` per frame speeds up.
+- Mixing clips with incompatible hierarchies causes violent pops—validate bind pose.
+- Root motion must be handled in game logic if not baked—document explicitly.
+- Large track counts cost CPU—strip unused tracks in preprocessing when possible.
+
+## Documentation and version
+
+Behavior of `AnimationMixer`, tracks, and glTF animation import can change between three.js majors. Treat the [Animation](https://threejs.org/docs/#Animation) section of the [docs index](https://threejs.org/docs/) as authoritative for the user’s installed version; when upgrading, check the three.js repository release notes and migration notes for renamed properties or loader output.
+
+## Agent response checklist
+
+When answering under this skill, prefer responses that:
+
+1. Cite the exact class (`AnimationMixer`, `AnimationAction`, etc.) or addon (`CCDIKSolver`) from the official docs.
+2. Include at least one `https://threejs.org/docs/...` link (e.g. [AnimationAction](https://threejs.org/docs/AnimationAction.html)).
+3. Relate clips to `SkinnedMesh` / skeleton via **threejs-objects** when deformation is involved.
+4. Mention `mixer.update(delta)` and a stable time source (`Clock`) explicitly.
+5. Reference official **examples** by name only (no full file paste).
+
+## References
+
+- https://threejs.org/docs/#Animation
+- https://threejs.org/docs/AnimationMixer.html
+- https://threejs.org/docs/AnimationAction.html
+- https://threejs.org/docs/PropertyBinding.html
+
+## Keywords
+
+**English:** animationmixer, animationaction, animationclip, keyframetrack, crossfade, skinning, propertybinding, three.js
+
+**中文：** 动画混合、AnimationMixer、AnimationAction、关键帧、骨骼动画、剪辑、淡入淡出、three.js

package/skills/threejs-animation/examples/workflow-mixer-action.md

@@ -0,0 +1,20 @@
+# Workflow: play one glTF clip
+
+## Steps
+
+1. After **threejs-loaders** provides `gltf` with `animations` array non-empty.
+
+2. `const mixer = new THREE.AnimationMixer(gltf.scene);`
+
+3. `const clip = gltf.animations[0]; const action = mixer.clipAction(clip); action.play();`
+
+4. In the render loop: `const delta = clock.getDelta(); mixer.update(delta);` then render (**threejs-renderers**).
+
+5. To switch clips, prepare second `clipAction`, then `action.crossFadeTo(nextAction, duration, false)` per docs.
+
+6. Dispose mixer when discarding the rig if your app hot-swaps characters.
+
+## Anchor
+
+- https://threejs.org/docs/AnimationMixer.html
+- https://threejs.org/docs/AnimationAction.html

package/skills/threejs-animation/references/official-sections.md

@@ -0,0 +1,19 @@
+# Animation module (core)
+
+- https://threejs.org/docs/AnimationAction.html
+- https://threejs.org/docs/AnimationClip.html
+- https://threejs.org/docs/AnimationMixer.html
+- https://threejs.org/docs/AnimationObjectGroup.html
+- https://threejs.org/docs/AnimationUtils.html
+- https://threejs.org/docs/KeyframeTrack.html
+- https://threejs.org/docs/VectorKeyframeTrack.html
+- https://threejs.org/docs/QuaternionKeyframeTrack.html
+- https://threejs.org/docs/PropertyBinding.html
+- https://threejs.org/docs/PropertyMixer.html
+
+**Addons**
+
+- https://threejs.org/docs/AnimationClipCreator.html
+- https://threejs.org/docs/CCDIKSolver.html
+
+See https://threejs.org/docs/#Animation