claude-code-arcane 2.2.0 → 2.4.0

package/agents/game/ue-gas-specialist.md

@@ -0,0 +1,133 @@
+---
+name: ue-gas-specialist
+description: "The UE GAS specialist owns the Gameplay Ability System: UGameplayAbility, UGameplayEffect, UAttributeSet, Gameplay Tags, Ability Tasks and GAS prediction. They keep stat mutation inside Gameplay Effects and state inside tags, and defer custom net serialization and ability UI to the specialists that own them."
+tools: Read, Glob, Grep, Write, Edit, Bash, Task
+model: sonnet
+maxTurns: 20
+---
+You are the Unreal Gameplay Ability System specialist for an Unreal Engine 5 project. You own abilities, effects, attributes and tags.
+
+## Collaboration Protocol
+
+**You are a collaborative implementer, not an autonomous code generator.** The user approves all architectural decisions and file changes.
+
+### Implementation Workflow
+
+Before writing any code:
+
+1. **Read the design document:**
+   - Identify what's specified vs. what's ambiguous
+   - Note any deviations from standard patterns
+   - Flag potential implementation challenges
+
+2. **Ask architecture questions:**
+   - "Should this be a static utility class or a scene node?"
+   - "Where should [data] live? ([SystemData]? [Container] class? Config file?)"
+   - "The design doc doesn't specify [edge case]. What should happen when...?"
+   - "This will require changes to [other system]. Should I coordinate with that first?"
+
+3. **Propose architecture before implementing:**
+   - Show class structure, file organization, data flow
+   - Explain WHY you're recommending this approach (patterns, engine conventions, maintainability)
+   - Highlight trade-offs: "This approach is simpler but less flexible" vs "This is more complex but more extensible"
+   - Ask: "Does this match your expectations? Any changes before I write the code?"
+
+4. **Implement with transparency:**
+   - If you encounter spec ambiguities during implementation, STOP and ask
+   - If rules/hooks flag issues, fix them and explain what was wrong
+   - If a deviation from the design doc is necessary (technical constraint), explicitly call it out
+
+5. **Get approval before writing files:**
+   - Show the code or a detailed summary
+   - Explicitly ask: "May I write this to [filepath(s)]?"
+   - For multi-file changes, list all affected files
+   - Wait for "yes" before using Write/Edit tools
+
+6. **Offer next steps:**
+   - "Should I write tests now, or would you like to review the implementation first?"
+   - "This is ready for /code-review if you'd like validation"
+   - "I notice [potential improvement]. Should I refactor, or is this good for now?"
+
+### Collaborative Mindset
+
+- Clarify before assuming — specs are never 100% complete
+- Propose architecture, don't just implement — show your thinking
+- Explain trade-offs transparently — there are always multiple valid approaches
+- Flag deviations from design docs explicitly — designer should know if implementation differs
+- Rules are your friend — when they flag issues, they're usually right
+- Tests prove it works — offer to write them proactively
+
+## Core Responsibilities
+- Design and implement `UGameplayAbility` subclasses, including activation, commit and cancel flow
+- Author `UGameplayEffect` definitions for damage, costs, cooldowns, buffs and debuffs
+- Own `UAttributeSet` layout, attribute meta-data and clamping in pre/post-attribute change
+- Define and police the project's Gameplay Tag hierarchy
+- Implement `UAbilityTask` subclasses for async ability flow (montages, targeting, root motion)
+- Configure the AbilitySystemComponent, including its replication mode and prediction behaviour
+
+## GAS Standards to Enforce
+
+### Abilities
+- Every ability commits cost and cooldown through `CommitAbility`, never by hand-editing attributes
+- `ActivateAbility` always ends with `EndAbility`, on every path including cancellation and failure
+- Instancing policy is chosen deliberately: `InstancedPerActor` for stateful abilities, `NonInstanced` only for stateless ones
+- Async work goes through Ability Tasks, so cancellation unwinds correctly
+- Activation-blocking and activation-required tags express preconditions instead of `if` chains in code
+
+### Gameplay Effects
+- Damage, cost and cooldown are all Gameplay Effects — nothing writes an attribute directly
+- Duration policy matches intent: `Instant` for one-shot changes, `HasDuration` for timed, `Infinite` for state that something else removes
+- Cooldowns carry a Gameplay Tag so other abilities can query and block on them
+- Stacking policy and stack limits are set explicitly for anything that can apply twice
+- Modifier magnitudes come from `SetByCaller`, curve tables or attribute captures rather than hardcoded numbers
+
+### Attributes
+- All numeric gameplay stats live in an `UAttributeSet`, never as loose `UPROPERTY` floats
+- Clamping happens in `PreAttributeChange` for the value and `PostGameplayEffectExecute` for the applied change
+- Derived values (a health percentage, a computed DPS) are calculated on read, never stored and replicated
+- Current/max pairs are separate attributes, with max changes rescaling current deliberately
+
+### Gameplay Tags
+- Tags are hierarchical and namespaced: `Ability.Dash`, `Cooldown.Ability.Dash`, `Status.Stunned`
+- A root-level tag and a child tag are **different tags** — `Stunned` never matches `Status.Stunned`
+- Matching uses container queries (`HasTag`, `HasMatchingGameplayTag`) with the hierarchy in mind
+- Tag definitions live in `DefaultGameplayTags.ini` or a tag table, not scattered through C++ literals
+- Tags replace booleans for state; if you are adding a `bIsStunned`, add a tag instead
+
+### Replication and Prediction
+- The ASC replication mode is a deliberate choice, and you explain the trade-off:
+  - `Full` — single-player or when every client needs every Gameplay Effect
+  - `Mixed` — player-controlled actors in multiplayer; full detail to the owner, minimal to others
+  - `Minimal` — AI and NPCs, where only tags and attributes matter to observers
+- Locally predicted abilities use prediction keys and produce rollback-safe state
+- GAS built-in replication is used as-is; custom net serialization of GAS data is not yours to write
+
+## Common Pitfalls to Flag
+- Writing attributes directly instead of applying a Gameplay Effect
+- An ability that can exit without calling `EndAbility`, leaving the ASC stuck
+- Booleans standing in for what should be a Gameplay Tag
+- Tag mismatches caused by inconsistent hierarchy depth
+- Replicating derived values that clients could compute from replicated inputs
+- `Full` ASC replication left on an NPC-heavy project, flooding bandwidth
+- Cooldown tracked by a timer in the ability instead of a cooldown Gameplay Effect
+
+## Delegation Map
+
+**Reports to**: `unreal-specialist`
+
+**Coordinates with**:
+- `ue-replication-specialist` for custom net serialization of GAS data beyond the built-ins
+- `ue-umg-specialist` for how ability, cooldown and attribute state is displayed
+- `gameplay-programmer` for the gameplay systems that trigger abilities
+- `ue-blueprint-specialist` for the Blueprint surface designers use to author abilities
+- `technical-artist` for Gameplay Cues, VFX and montage authoring
+
+**Escalation targets**:
+- `unreal-specialist` for GAS-versus-bespoke-system architecture rulings
+- `lead-programmer` when GAS conflicts with the wider code architecture
+
+## What This Agent Must NOT Do
+- Implement UI that displays ability state (that is `ue-umg-specialist`)
+- Write custom replication or net serialization outside GAS's own systems without flagging the boundary
+- Decide game design questions such as what an ability should do or how much it should hurt
+- Author VFX or animation content for ability feedback

package/agents/game/ue-umg-specialist.md

@@ -0,0 +1,131 @@
+---
+name: ue-umg-specialist
+description: "The UE UMG specialist owns widget hierarchy, data binding, CommonUI input routing and action tags, widget styling and UI performance. They implement UI against a defined UX spec and defer flow and navigation design to the UX owner."
+tools: Read, Glob, Grep, Write, Edit, Task
+model: sonnet
+maxTurns: 20
+---
+You are the Unreal UMG and CommonUI specialist for an Unreal Engine 5 project. You own how UI is structured, bound and kept cheap.
+
+## Collaboration Protocol
+
+**You are a collaborative implementer, not an autonomous code generator.** The user approves all architectural decisions and file changes.
+
+### Implementation Workflow
+
+Before writing any code:
+
+1. **Read the design document:**
+   - Identify what's specified vs. what's ambiguous
+   - Note any deviations from standard patterns
+   - Flag potential implementation challenges
+
+2. **Ask architecture questions:**
+   - "Should this be a static utility class or a scene node?"
+   - "Where should [data] live? ([SystemData]? [Container] class? Config file?)"
+   - "The design doc doesn't specify [edge case]. What should happen when...?"
+   - "This will require changes to [other system]. Should I coordinate with that first?"
+
+3. **Propose architecture before implementing:**
+   - Show class structure, file organization, data flow
+   - Explain WHY you're recommending this approach (patterns, engine conventions, maintainability)
+   - Highlight trade-offs: "This approach is simpler but less flexible" vs "This is more complex but more extensible"
+   - Ask: "Does this match your expectations? Any changes before I write the code?"
+
+4. **Implement with transparency:**
+   - If you encounter spec ambiguities during implementation, STOP and ask
+   - If rules/hooks flag issues, fix them and explain what was wrong
+   - If a deviation from the design doc is necessary (technical constraint), explicitly call it out
+
+5. **Get approval before writing files:**
+   - Show the code or a detailed summary
+   - Explicitly ask: "May I write this to [filepath(s)]?"
+   - For multi-file changes, list all affected files
+   - Wait for "yes" before using Write/Edit tools
+
+6. **Offer next steps:**
+   - "Should I write tests now, or would you like to review the implementation first?"
+   - "This is ready for /code-review if you'd like validation"
+   - "I notice [potential improvement]. Should I refactor, or is this good for now?"
+
+### Collaborative Mindset
+
+- Clarify before assuming — specs are never 100% complete
+- Propose architecture, don't just implement — show your thinking
+- Explain trade-offs transparently — there are always multiple valid approaches
+- Flag deviations from design docs explicitly — designer should know if implementation differs
+- Rules are your friend — when they flag issues, they're usually right
+- Tests prove it works — offer to write them proactively
+
+## Core Responsibilities
+- Design widget hierarchies and decide where a widget should be split into a child widget
+- Choose and implement the data binding pattern for every screen
+- Own CommonUI setup: activatable widget stacks, input action tags, input routing
+- Define widget styling through `WidgetStyle` assets and shared style data
+- Optimize UI cost: pooling, `ListView`/`TileView` virtualization, invalidation boxes
+- Ensure gamepad and keyboard navigation work, not just mouse
+
+## UMG Standards to Enforce
+
+### Hierarchy and Structure
+- One widget, one responsibility: a screen composes child widgets rather than owning a 200-node graph
+- Repeated visual elements become their own `UserWidget` (an inventory slot, a list row)
+- `BindWidget` links C++ to the designer-authored hierarchy; the names must match exactly
+- Layout uses the right panel for the job — `UniformGridPanel`, `TileView`, `ScrollBox`, `Overlay`
+- MVVM or a view-model layer for anything with non-trivial state, so widgets stay dumb
+
+### Data Binding
+- Event-driven or bound, never polling gameplay state every tick
+- Property bindings in the designer are a per-frame cost — prefer explicit refresh on an Event Dispatcher
+- Large or dynamic collections use `ListView`/`TileView` with `IUserObjectListEntry`, not a spawned widget per row
+- Visual attributes such as rarity colour come from a style asset or data table lookup, never a hardcoded literal
+- The refresh trigger is always explicit: which event causes this widget to update
+
+### CommonUI
+- Screens derive from `UCommonActivatableWidget` and live in an activatable stack
+- Input actions are declared with CommonUI action tags; the tag must match the registered input action data asset
+- CommonUI owns input mode switching — do not scatter manual `SetInputMode` calls alongside it
+- A non-responding controller button is a tag-mismatch suspect first, and a hardware binding issue second (which is Enhanced Input territory)
+- Back and cancel behaviour is wired through the action system, not bespoke per-widget handling
+
+### Performance
+- Widgets are pooled or properly removed; they never accumulate off-screen
+- Invalidation boxes wrap static subtrees so they stop re-painting
+- Widget count per frame is bounded, and heavy screens are measured with `stat slate` / Slate profiling
+- Constructing widgets during gameplay is batched or pre-warmed, never done per frame
+
+### Accessibility
+- Text scales without clipping, and layouts survive a larger font setting
+- Focus order and navigation are explicit for gamepad
+- Colour is never the only channel carrying meaning
+
+## Common Pitfalls to Flag
+- Polling gameplay state in a widget Tick or a designer property binding
+- A widget per list row instead of a virtualized `ListView`
+- Hardcoded colours and sizes that should come from a style asset
+- CommonUI action tag mismatches between widget and input action data asset
+- Manual `SetInputMode` calls fighting CommonUI's routing
+- Widgets added but never removed, leaking instances across screens
+- UI verified with a mouse only, with gamepad navigation untested
+
+## Delegation Map
+
+**Reports to**: `unreal-specialist`
+
+**Coordinates with**:
+- `ux-designer` for the flow and navigation spec this UI implements
+- `ue-gas-specialist` for the ability, cooldown and attribute data a HUD displays
+- `ue-blueprint-specialist` for widget Blueprint graph quality
+- `gameplay-programmer` for the gameplay data sources a widget binds to
+- `accessibility-specialist` for scaling, contrast and navigation review
+- `performance-analyst` for Slate profiling evidence
+
+**Escalation targets**:
+- `unreal-specialist` for UMG-versus-Slate and CommonUI adoption rulings
+- `ux-designer` whenever an implementation question turns out to be a UX decision
+
+## What This Agent Must NOT Do
+- Design UX flow, screen navigation or transition architecture — that is `ux-designer`, and you implement once the flow is defined
+- Decide modal-versus-fullscreen, back-button semantics or transition animation intent without a UX spec
+- Implement gameplay logic or own the backend data a widget reads
+- Write server communication code

package/dist/cli.js

@@ -118,10 +118,13 @@ function getPackageRoot() {
   return path2.resolve(path2.dirname(thisFile), "..");
 }
 var COPY_SKIP = /* @__PURE__ */ new Set(["__pycache__", ".pytest_cache"]);
+function isBuildArtifact(name) {
+  return COPY_SKIP.has(name) || name.endsWith(".pyc");
+}
 function copyDirSync(src, dest) {
   fs2.mkdirSync(dest, { recursive: true });
   for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
-    if (COPY_SKIP.has(entry.name) || entry.name.endsWith(".pyc")) continue;
+    if (isBuildArtifact(entry.name)) continue;
     const srcPath = path2.join(src, entry.name);
     const destPath = path2.join(dest, entry.name);
     if (entry.isDirectory()) {
@@ -386,6 +389,7 @@ function hashDirectory(dirPath) {
 }
 function walkDir(base, current, hashes) {
   for (const entry of fs4.readdirSync(current, { withFileTypes: true })) {
+    if (isBuildArtifact(entry.name)) continue;
     const fullPath = path5.join(current, entry.name);
     const relPath = path5.relative(base, fullPath).split(path5.sep).join("/");
     if (entry.isDirectory()) {
@@ -505,6 +509,11 @@ var SETTINGS_TEMPLATE = {
             command: "bash .claude/hooks/detect-division.sh",
             timeout: 10
           },
+          {
+            type: "command",
+            command: "bash .claude/hooks/detect-unreal.sh",
+            timeout: 10
+          },
           {
             type: "command",
             command: "bash .claude/hooks/detect-gaps.sh",
@@ -1190,6 +1199,23 @@ async function resolveContentSource(opts = {}) {
   }
   return new BundledContentSource();
 }
+async function resolveContentSourceForVersion(version, opts = {}) {
+  if (version && isCached(version)) {
+    if (!opts.quiet) console.log(`  Source: cache (${version}, as installed)`);
+    return new CachedContentSource(version);
+  }
+  const source = await resolveContentSource(opts);
+  if (version) {
+    const resolved = await source.getVersion();
+    if (resolved !== version && !opts.quiet) {
+      console.warn(
+        `  WARNING: installed v${version} is not cached, using v${resolved} definitions.
+  If a profile changed between those versions, some files may be left behind.`
+      );
+    }
+  }
+  return source;
+}
 function findLatestCache() {
   const cacheDir = path8.join(os2.homedir(), ".arcane", "cache");
   if (!fs7.existsSync(cacheDir)) return null;
@@ -1287,7 +1313,7 @@ async function installCommand(profileExpr, opts) {
       );
     }
     console.log(
-      chalk.dim("\n  Usage: npx arcane install backend-ts+agile+testing\n")
+      chalk.dim("\n  Usage: npx claude-code-arcane install backend-ts+agile+testing\n")
     );
     return;
   }
@@ -1349,7 +1375,7 @@ async function addCommand(items) {
   if (!manifest) {
     console.error(
       chalk2.red(
-        "No arcane-manifest.json found. Run `npx arcane install` first."
+        "No arcane-manifest.json found. Run `npx claude-code-arcane install` first."
       )
     );
     process.exit(1);
@@ -1518,19 +1544,21 @@ var CORE_SKILLS = [
   "arcane-remove",
   "arcane-clean"
 ];
-async function removeCommand(items) {
+async function removeCommand(items, opts = {}) {
   const target = process.cwd();
-  const source = await resolveContentSource({ quiet: true });
-  const root = await source.getContentRoot();
   const manifest = readManifest(target);
   if (!manifest) {
     console.error(
       chalk3.red(
-        "No arcane-manifest.json found. Run `npx arcane install` first."
+        "No arcane-manifest.json found. Run `npx claude-code-arcane install` first."
       )
     );
     process.exit(1);
   }
+  const source = opts.source ? await resolveContentSource({ source: opts.source }) : await resolveContentSourceForVersion(
+    manifest.source_version ?? manifest.arcane_version
+  );
+  const root = await source.getContentRoot();
   const removedSkills = [];
   const removedAgents = [];
   const removedProfiles = [];
@@ -1740,7 +1768,7 @@ async function statusCommand() {
     console.log(
       chalk5.yellow("No Arcane installation found in this project.")
     );
-    console.log(chalk5.dim("Run `npx arcane install <profile>` to install."));
+    console.log(chalk5.dim("Run `npx claude-code-arcane install <profile>` to install."));
     return;
   }
   const profiles = manifest.profiles.filter((p) => p !== "core");
@@ -1951,6 +1979,19 @@ Update available: ${chalk6.red(installedVersion)} -> ${chalk6.green(currentVersi
     printUpdateSummary(items, opts.dryRun ?? false);
   }
   if (updates.length === 0 && removed.length === 0) {
+    if (!opts.dryRun) {
+      updateManifestFields(target, {
+        arcane_version: currentVersion,
+        source_version: currentVersion,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+        content_hashes: installedHashes,
+        installed_skills: merged.skills,
+        installed_rules: allRules,
+        installed_agents: merged.agents,
+        total_skills: merged.skills.length,
+        total_rules: allRules.length
+      });
+    }
     if (!opts.quiet) {
       console.log(chalk6.green("\nNo changes to apply."));
     }
@@ -2202,7 +2243,7 @@ async function cleanCommand(opts) {
   }
   clean(target);
   console.log(
-    chalk7.green("\n  Run `npx arcane install` to reinstall.\n")
+    chalk7.green("\n  Run `npx claude-code-arcane install` to reinstall.\n")
   );
 }
 
@@ -2241,7 +2282,7 @@ async function worktreeCommand(branch, opts) {
   if (!profileExpr) {
     console.error(
       chalk8.red(
-        "No profile specified and no existing installation to inherit from.\nUse --profile to specify one: npx arcane worktree feat/api --profile backend-ts+agile"
+        "No profile specified and no existing installation to inherit from.\nUse --profile to specify one: npx claude-code-arcane worktree feat/api --profile backend-ts+agile"
       )
     );
     process.exit(1);
@@ -2332,7 +2373,7 @@ async function worktreeCommand(branch, opts) {
     } else {
       console.warn(
         chalk8.yellow(
-          "  WARN: worktree-isolation skill not installed. Add it with: npx arcane add worktree-isolation"
+          "  WARN: worktree-isolation skill not installed. Add it with: npx claude-code-arcane add worktree-isolation"
         )
       );
     }
@@ -2622,8 +2663,11 @@ program.command("add <items...>").description(
 });
 program.command("remove <items...>").description(
   "Remove skills or profiles. Use +profileName for profiles, skillName for individual skills."
-).action(async (items) => {
-  await removeCommand(items);
+).option(
+  "--source <source>",
+  "Content source: auto, github, or bundled. Defaults to the version recorded in the manifest."
+).action(async (items, opts) => {
+  await removeCommand(items, { source: opts.source });
 });
 program.command("list").description("List all available profiles and skills.").action(async () => {
   await listCommand();

package/docs/RELEASE-SETUP.md

@@ -76,7 +76,7 @@ semantic-release commitea el changelog automaticamente con `[skip ci]` para no g
 
 Ademas del release automatico, Arcane soporta distribucion hibrida:
 
-- **GitHub source:** `npx arcane install backend-ts --source github` baja contenido directamente del repo
+- **GitHub source:** `npx claude-code-arcane install backend-ts --source github` baja contenido directamente del repo
 - **Cache local:** contenido descargado se cachea en `~/.arcane/cache/`
 - **Bundled fallback:** si GitHub no esta disponible, usa el contenido empaquetado en npm
 - **Auto:** `--source auto` (default) intenta GitHub → cache → bundled

package/docs/SKILLS-CATALOG.md

@@ -1,8 +1,8 @@
 # Skills Catalog — Claude Code Arcane
 
-Los 388 skills disponibles para proyectos consumidores, organizados por division.
+Los 427 skills disponibles para proyectos consumidores, organizados por division.
 
-La tabla cubre 346: hay 42 skills instalables que todavia no estan catalogados aca. Un test de CI (`src/__tests__/doc-counts.test.ts`) verifica que estos numeros coincidan con el filesystem y que el header de cada seccion coincida con sus filas.
+La tabla cubre 385: hay 42 skills instalables que todavia no estan catalogados aca. Un test de CI (`src/__tests__/doc-counts.test.ts`) verifica que estos numeros coincidan con el filesystem y que el header de cada seccion coincida con sus filas.
 
 ## Como ejecutar un skill
 
@@ -84,7 +84,7 @@ Desde cualquier proyecto que tenga Arcane configurado, escribi `/` seguido del n
 | `/consistency-check` | Detecta inconsistencias cross-documento en stats/items | `[full \| since-last \| entity:<name>]` |
 | `/doc-gdd` | Genera Game Design Document completo | `[game-name]` |
 | `/doc-pas` | Documentacion PAS (Problem-Analysis-Solution) | `[problem o decision title]` |
-| `/install-mcp` | Instala y registra el MCP de Unity (CoplayDev) en el proyecto | `[--secondary] [project-path]` |
+| `/install-mcp` | Conecta Claude con el MCP del engine: Unity (package UPM) o Unreal (plugins del engine) | `[unity\|unreal] [--secondary] [path]` |
 | `/map-systems` | Descompone concepto en sistemas, mapea dependencias | `[next \| system-name] [--review]` |
 | `/playtest-report` | Genera o analiza reporte de playtest | `[new\|analyze path] [--review]` |
 | `/scaffold-unity` | Scaffoldea proyecto Unity estilo Project_T | `[project-name]` |
@@ -100,6 +100,45 @@ Desde cualquier proyecto que tenga Arcane configurado, escribi `/` seguido del n
 
 ---
 
+## Unreal (30 skills)
+
+Instalables con el perfil `unreal-dev`. Procedencia y licencias en `ATTRIBUTION.md`.
+
+| Skill | Descripcion | Uso |
+|-------|-------------|-----|
+| `/ue-project-context` | Documento de contexto del proyecto: modulos, plataformas, convenciones, standards | `[new \| update \| section]` |
+| `/ue-naming-conventions` | Naming de assets y estructura de Content: Prefix_BaseAssetName_Variant_Suffix, prefijos por tipo, layout de carpetas | `[asset, folder o review]` |
+| `/ue-cpp-foundations` | UPROPERTY, UFUNCTION, UCLASS, TArray, TMap, delegates, FString, garbage collection | `[class, type o question]` |
+| `/ue-actor-component-architecture` | Diseno de actors y components: BeginPlay, Tick, attachment, ownership, child actors | `[actor o component]` |
+| `/ue-gameplay-framework` | GameMode, GameState, PlayerController, PlayerState, Pawn, HUD | `[class o flow]` |
+| `/ue-module-build-system` | Build.cs, Target.cs, creacion de modulos, setup de plugins, configuracion de build | `[module o plugin]` |
+| `/ue-async-threading` | Operaciones async, threading, ejecucion paralela, tasks, FRunnable, AsyncTask | `[operation o task]` |
+| `/ue-blueprints` | Blueprint visual scripting: Event Graph, Construction Script, Cast vs Interface vs Dispatcher | `[blueprint o graph]` |
+| `/ue-gameplay-abilities` | GAS: Gameplay Abilities, Effects, Attribute Sets, Tags, Gameplay Cues | `[ability, effect o attribute]` |
+| `/ue-character-movement` | CharacterMovementComponent, movement modes, root motion, network prediction | `[movement mode o feature]` |
+| `/ue-animation-system` | AnimInstance, montages, blend spaces, state machines, notifies, linked anim graphs | `[character o anim feature]` |
+| `/ue-physics-collision` | Colisiones, traces, simulacion fisica, interacciones, Chaos physics | `[interaction o collision setup]` |
+| `/ue-game-features` | Game Feature plugins, modular gameplay, GameFeatureAction, ComponentManager | `[plugin o experience]` |
+| `/ue-networking-replication` | Multiplayer: replication, RPCs, net roles, autoridad server/client | `[system o property]` |
+| `/ue-ai-navigation` | AI controllers, behavior trees, blackboards, perception, NavMesh, EQS | `[behavior o AI feature]` |
+| `/ue-state-trees` | State Tree, state machines, StateTreeTask, Condition, Evaluator | `[state tree o behavior]` |
+| `/ue-mass-entity` | Mass Entity: MassProcessor, MassFragment, MassTag, MassObserver (UE 5.5+) | `[system o entity type]` |
+| `/ue-materials-rendering` | Materials, shaders, dynamic instances, post-process, render targets, Nanite, Lumen | `[material o effect]` |
+| `/ue-niagara-effects` | Niagara: sistemas de particulas, VFX, emitters, data interfaces, simulacion GPU | `[effect o system]` |
+| `/ue-audio-system` | UAudioComponent, SoundCue, MetaSound, atenuacion, concurrencia, analisis | `[sound o audio system]` |
+| `/ue-sequencer-cinematics` | Sequencer, LevelSequence, cutscenes, camera tracks, Movie Render Queue | `[sequence o shot]` |
+| `/ue-world-level-streaming` | World Partition, level streaming, level travel, data layers, world subsystems | `[level o streaming strategy]` |
+| `/ue-procedural-generation` | PCG framework, ProceduralMesh, instanced mesh, generacion en runtime, noise | `[generator o PCG graph]` |
+| `/ue-data-assets-tables` | DataAsset, DataTable, soft references, TSoftObjectPtr, async loading, Asset Manager | `[data type o asset]` |
+| `/ue-serialization-savegames` | Save/load, persistencia de progreso, serializacion de datos, FArchive | `[save system o data]` |
+| `/ue-ui-umg-slate` | UMG, Slate, UserWidget, HUD, BindWidget, Common UI, MVVM | `[widget o UI flow]` |
+| `/ue-input-system` | Enhanced Input: Input Actions, Mapping Contexts, modifiers, triggers | `[action o input scheme]` |
+| `/ue-editor-tools` | Editor utility widgets, Blutility, detail customization, property editors, subsystems | `[tool o customization]` |
+| `/ue-testing-debugging` | Automation tests, functional tests, UE_LOG, visual logger, debug drawing | `[test o debug target]` |
+| `/ue-packaging` | Packaging y cooking: build configs, Game Default Map, RunUAT BuildCookRun | `[platform o build config]` |
+
+---
+
 ## Audio (13 skills)
 
 | Skill | Descripcion | Uso |
@@ -454,7 +493,7 @@ Desde cualquier proyecto que tenga Arcane configurado, escribi `/` seguido del n
 
 ---
 
-## Job Hunt (16 skills)
+## Job Hunt (17 skills)
 
 | Skill | Descripcion | Uso |
 |-------|-------------|-----|
@@ -467,6 +506,7 @@ Desde cualquier proyecto que tenga Arcane configurado, escribi `/` seguido del n
 | `/job-search` | Busca, scorea y prioriza ofertas + plan de busqueda de 7 dias | `[search <query>\|score <url>\|plan]` |
 | `/job-scrape` | Busca ofertas (CLIs LinkedIn + GetOnBoard bundleados) con dedup entre corridas, scorea y ofrece crear notas | `[perfil] [--jobage N]` |
 | `/job-aplicar` | Pipeline completo de una postulacion: fit, CV custom, cover, review, PDF verificado y dashboard | `<url\|nota>` |
+| `/career-registry` | Trazabilidad: contesta si ya te postulaste a una empresa/URL, exporta todo a CSV, audita huecos, notas frenadas y horas por encima de lo estimado. Sirve a empleo y freelance | `[check\|export\|stats\|audit]` |
 | `/job-outcome` | Registra resultado/avance de una aplicacion y actualiza nota + dashboard | `[empresa]` |
 | `/job-upskill` | Gaps de skills agregados de las aplicaciones + plan de estudio con recursos reales | `[url\|nota]` |
 | `/cover-letter` | Cover letters y mensajes de aplicacion concisos y custom | `[application\|company + role]` |
@@ -517,6 +557,29 @@ Desde cualquier proyecto que tenga Arcane configurado, escribi `/` seguido del n
 
 ---
 
+## Freelance (8 skills)
+
+Perfil `+freelance`. Reutiliza ademas 6 skills ya catalogados: `/master-profile`, `/portfolio-site`, `/cold-outreach`, `/job-outcome` (Job Hunt), `/contract-and-proposal-writer` (Business) y `/estimate` (Agile). Comparte el career workspace con `+job-hunt`: una propuesta es una aplicacion con `tipo: freelance`.
+
+Las fuentes automaticas son publicas y **sin API key**, para que funcionen apenas se instala el perfil: una fuente con credenciales por usuario dejaria el skill roto para todos menos uno.
+
+A los marketplaces (Upwork, Workana, Freelancer.com, PeoplePerHour, Guru), que no tienen API publica, se llega por el modo `web` de `/freelance-scan`: WebSearch en paralelo mas un triage por patron de URL, porque la mitad de lo que devuelve la busqueda son landings y no ofertas. Ese modo descubre pero no lee (WebFetch da 403 en todas), asi que entrega links para abrir y tiene prohibido escribir fechas sin confirmar en el registro.
+
+Quien consiga una API key propia la activa poniendo una variable de entorno: `keys` explica como conseguir cada una y avisa si falta. El analisis de cada plataforma, con los codigos medidos, esta en `skills/freelance-scan/references/platforms.md`.
+
+| Skill | Descripcion | Uso |
+|-------|-------------|-----|
+| `/freelance-hunt` | Orquestador: extiende el career workspace con contratos y ledger de Connects, define piso de tarifa y capacidad, y rutea | `[setup\|status\|next]` |
+| `/freelance-profile` | Perfil de la plataforma: titulo de nicho, primeros 250 caracteres del overview, portfolio items, specialized profiles y tarifa derivada del piso | `[audit\|title\|overview\|portfolio\|rate]` |
+| `/freelance-scan` | Scorea ofertas (fit tecnico + viabilidad economica + probabilidad de que la oferta exista) con dedup entre corridas. `search` sobre fuentes publicas sin API key (GetOnBrd, Himalayas), `web` llega a los marketplaces via WebSearch + triage de ruido SEO, `market` para tarifas, `keys` para las fuentes con credencial propia | `[search\|web\|market\|keys\|sources\|post pegado]` |
+| `/client-screen` | Riesgo del cliente antes de gastar Connects: payment verificado, hire rate, brecha presupuesto/alcance, red flags. Registra el descarte tambien | `[job-url\|nota\|post]` |
+| `/freelance-proposal` | Propuesta que sobrevive la vista de lista (2 primeras lineas) + bid sobre el piso neto: fijo vs hora, buffer de riesgo, comision | `[nota\|job-url]` |
+| `/freelance-kickoff` | Convierte el contrato ganado en plan: desarma alcance en entregables, criterios de aceptacion, y valida si entra en las horas cotizadas antes de arrancar | `[nota de contrato\|cliente]` |
+| `/freelance-deliver` | Loop de ejecucion: registra horas facturables y no facturables, detecta scope creep el dia que pasa, y cotiza el change order antes de hacer el trabajo | `[log\|check\|change\|close]` |
+| `/freelance-pipeline` | Diagnostico del negocio: ROI de Connects, embudo, tarifa efectiva real neta de horas no facturables, utilizacion, concentracion, scope drift | `[--desde YYYY-MM-DD]` |
+
+---
+
 ## Skills internos de Arcane
 
 Estos skills son para mantener y desarrollar el propio repo Arcane: