claude-code-arcane 2.2.0 → 2.4.0

package/profiles/unreal-dev.yaml

@@ -0,0 +1,97 @@
+name: unreal-dev
+description: "Programador Unreal Engine 5 — C++, Blueprints, GAS, replication, rendering, naming conventions, build y editor MCP"
+type: base
+
+skills:
+  # Foundation — read this first, every other ue-* skill depends on it
+  - ue-project-context
+  - ue-naming-conventions
+  # C++ & architecture
+  - ue-cpp-foundations
+  - ue-actor-component-architecture
+  - ue-gameplay-framework
+  - ue-module-build-system
+  - ue-async-threading
+  # Blueprints
+  - ue-blueprints
+  # Gameplay systems
+  - ue-gameplay-abilities
+  - ue-character-movement
+  - ue-animation-system
+  - ue-physics-collision
+  - ue-game-features
+  - ue-networking-replication
+  # AI & behaviour
+  - ue-ai-navigation
+  - ue-state-trees
+  - ue-mass-entity
+  # Rendering & VFX
+  - ue-materials-rendering
+  - ue-niagara-effects
+  # Audio & cinematics
+  - ue-audio-system
+  - ue-sequencer-cinematics
+  # World & data
+  - ue-world-level-streaming
+  - ue-procedural-generation
+  - ue-data-assets-tables
+  - ue-serialization-savegames
+  # UI & input
+  - ue-ui-umg-slate
+  - ue-input-system
+  # Tooling, build & QA
+  - ue-editor-tools
+  - ue-testing-debugging
+  - ue-packaging
+  # Cross-engine, reused from the shared library
+  # Unreal ships its own MCP as engine plugins; install-mcp only enables and connects it.
+  - install-mcp
+  - test-setup
+  - perf-profile
+  - optimize
+  - deps-audit
+  - env-sync
+  - security-audit
+  - release-checklist
+  - patch-notes
+  - onboard
+  - map-systems
+  - game-audit
+  - audit-game
+  - asset-audit
+  - accessibility
+  - balance-check
+  - consistency-check
+  - doc-gdd
+  - playtest-report
+
+rules:
+  universal:
+    []
+  gamedev:
+    - unreal-code
+    - gameplay-code
+    - engine-code
+    - shader-code
+    - network-code
+    - ui-code
+    - ai-code
+
+agents:
+  - game
+
+permissions:
+  allow:
+    - "Bash(*RunUAT*)"
+    - "Bash(*UnrealBuildTool*)"
+    - "Bash(*UnrealEditor-Cmd*)"
+    - "Bash(*GenerateProjectFiles*)"
+    - "Glob(Source/**)"
+    - "Glob(Plugins/**)"
+    - "Grep(Source/**)"
+  deny:
+    - "Write(Content/**)"
+    - "Edit(Content/**)"
+    - "Write(Binaries/**)"
+    - "Write(Intermediate/**)"
+    - "Write(DerivedDataCache/**)"

package/rules/drafter-reviewer.md

@@ -9,14 +9,19 @@ Las rutas son relativas al career workspace (`./career-workspace/` o env `CAREER
 - Al terminar el borrador de un CV custom (flujo cv-tailor) o de una cover / mensaje de aplicación (flujo cover-letter) destinado a una postulación concreta.
 - NO aplica a ediciones menores de un CV ya revisado (typos, cambiar una fecha) ni a los CVs base de `02-CVs/` fuera de una postulación.
 
+Quién la ejecuta: `/job-aplicar` (paso 7, obligatorio), y `/cv-tailor` y `/cover-letter` cuando se corren sueltos. Los tres declaran `Task` en `allowed-tools` justamente para poder cumplirla - un skill sin `Task` no puede aplicar esta regla, y ahí la regla sería solo una intención.
+
 ## El paso reviewer
 
-Lanzar UN agente `general-purpose` de contexto fresco vía el Agent tool, con este contenido inline en el prompt (para que no dependa de leer archivos de la conversación):
+Lanzar UN agente **`cv-reviewer`** de contexto fresco vía el Agent tool. El agente ya trae la persona, el límite de lectura y el contrato de salida; el prompt solo tiene que aportar lo que el agente no puede saber:
 
 1. El texto completo de la job description.
 2. El borrador del CV y/o cover, verbatim.
-3. Instrucción de lectura acotada: solo puede leer `01-Perfiles/<perfil usado>.md` del workspace. NO debe leer los templates ni el resto del workspace - critica contenido, no estructura.
-4. Instrucción de research: búsqueda web breve sobre la empresa (misión, producto, noticias recientes, cultura) para detectar ángulos no aprovechados.
+3. Cuál es el perfil usado, para que sepa qué archivo de `01-Perfiles/` puede leer.
+
+Va inline en el prompt para que no dependa de leer archivos de la conversación.
+
+Si el agente `cv-reviewer` no está instalado (perfil `+job-hunt` sin su directorio de agentes), usar un `general-purpose` y pasarle en el prompt las cuatro restricciones: lectura acotada a `01-Perfiles/<perfil usado>.md`, prohibido leer templates y el resto del workspace, research web breve de la empresa, y el contrato de salida de abajo.
 
 El reviewer devuelve dos partes:
 
@@ -27,6 +32,14 @@ El reviewer devuelve dos partes:
   - Bullets que se pueden reformular como logro medible
   - Tono / estilo (registro, longitud, muletillas)
 
+## Segunda lente (opcional): `hiring-manager`
+
+`cv-reviewer` contesta "¿pasa el filtro?". Un CV puede pasar con match del 85% y morir igual en el escritorio de quien contrata, por una razón distinta: **no hay evidencia de que la persona ya hizo el trabajo**.
+
+Cuándo vale el segundo agente: postulación que importa, rol senior, o racha de rechazos post-CV. Se lanza **en paralelo** con `cv-reviewer` (no en cadena: son lentes independientes y encadenarlos solo suma latencia). Devuelve veredicto, evidencia faltante y las 3 preguntas que haría, que además son material de `/interview-prep`.
+
+No es obligatorio. Para una aplicación de rutina, `cv-reviewer` solo alcanza.
+
 ## Reglas de aplicación del feedback
 
 - **Una sola ronda.** El drafter aplica la Parte A, incorpora de la Parte B lo que corresponda, y sigue. Sin ida y vuelta iterativo.

package/rules/freelance-guardrails.md

@@ -0,0 +1,53 @@
+# Freelance Guardrails (marketplaces y clientes directos)
+
+Buscar empleo es gratis: aplicás a 40 puestos y solo perdés tiempo. Freelancear no. Cada propuesta cuesta algo, cada contrato malo toca tu reputación, y cada "¿me agregás esto rapidito?" sin cobrar sale de tu bolsillo.
+
+Estas cuatro reglas existen porque los tres recursos que se gastan (plata, reputación, tiempo no facturado) no se recuperan.
+
+**El costo de postularse tiene nombre distinto en cada plataforma** y las reglas valen igual: Connects en Upwork, bids en Freelancer.com, y en outreach directo son las horas que ponés en escribir la propuesta. Donde abajo diga Connects, leé "lo que te cuesta postularte".
+
+Las rutas son relativas al career workspace (`./career-workspace/` o env `CAREER_WORKSPACE`).
+
+## 1. Postularse cuesta plata: no se gasta sin screen
+
+Nunca redactar una propuesta para una oferta cuyo cliente no pasó `/client-screen`, ni para una que quedó bajo el umbral de score.
+
+Si el usuario quiere postularse igual a una que falló el screen, se puede - **pero se le dice qué falló y se registra en la nota**. Un pago sin verificar que nadie nombró es una postulación tirada, y peor: es la propuesta que sí te contestan y termina en disputa.
+
+## 2. La reputación se protege rechazando
+
+Ganar un contrato no siempre es bueno. Casi toda plataforma calcula un puntaje sobre contratos cerrados (en Upwork es el Job Success Score) donde un cliente insatisfecho pesa más que dos contentos, y con clientes directos el equivalente son las referencias que no vas a poder pedir. Un contrato con alcance difuso, presupuesto irrealista o cliente sin historial es **riesgo de reputación**, no una oportunidad.
+
+Cuando el screen marca riesgo alto, la recomendación por defecto es no postularse. Decir "no" es una acción del pipeline, no una ausencia de acción.
+
+## 3. Nada se cotiza abajo del piso
+
+Todo bid pasa por el piso declarado en `01-Perfiles/` (tarifa mínima aceptable). El piso es **neto**, después de la comisión de la plataforma: si se queda un 10%, un piso de 40 USD/h exige bidear 45. Con cliente directo la comisión es cero, pero el piso sigue siendo neto de impuestos y de las horas no facturables.
+
+Si el usuario todavía no fijó un piso, `/freelance-scan market` da la mediana de lo que cobran otros con su perfil. Es un punto de partida, no el piso: el piso lo define su costo de vida, no el mercado.
+
+Alcance nuevo, precio nuevo. Ninguna propuesta ni contrato se amplía sin cotizarlo: si el trabajo extra no entra en un change order con número, no entra.
+
+## 4. El envío siempre lo hace el usuario
+
+Ninguna skill de este perfil envía una propuesta, acepta un contrato ni gasta el presupuesto de postulaciones. Se redacta, se revisa, se muestra, y el usuario copia y manda.
+
+Esto no es prudencia nuestra: **la API de Upwork no tiene mutation para postularse ni para gastar Connects**, justamente para frenar bots de auto-bidding, y las demás plataformas prohíben el envío automatizado en sus términos. Ninguna skill debe pretender lo contrario, y una que lo intentara estaría violando los ToS además de esta regla.
+
+El corolario para las **fuentes**: ninguna skill del perfil puede depender de credenciales que cada usuario tenga que conseguir por su cuenta. Este perfil lo instala cualquiera, y una fuente con API key aprobada a mano funciona para uno y está rota para el resto. Las fuentes automáticas son públicas y sin key (ver `skills/freelance-scan/references/platforms.md`); lo demás se pega a mano.
+
+## La estructura no la sostiene este archivo
+
+Una regla sin columna derecha es una intención.
+
+| Regla | Qué la hace cumplir |
+|---|---|
+| Screen antes de gastar en postularse | `/freelance-proposal` exige la nota de screen; sin ella, pregunta y no redacta |
+| Rechazar por riesgo de reputación | `/client-screen` emite veredicto explícito; el agente `client-screener` es adversarial por diseño |
+| Piso de tarifa | `/freelance-proposal` lee el piso del perfil y falla ruidoso si el bid queda abajo; `/freelance-scan market` da la referencia de mercado |
+| Alcance nuevo, precio nuevo | `/freelance-pipeline` detecta drift de alcance en contratos activos y pide change order |
+| Envío manual | Ningún script del perfil escribe a una plataforma: `freelance_search.py` solo lee, y no hay otro |
+
+## Registro
+
+Toda decisión de no postularse se registra igual que una postulación: nota en `03-Aplicaciones/` con `estado: descartado` y el motivo en `## Notas`. Los descartes son la mitad de los datos que `/freelance-pipeline` necesita para decirte si tu criterio de selección funciona.

package/rules/gamedev/unreal-code.md

@@ -0,0 +1,125 @@
+---
+paths:
+  - "Source/**"
+  - "Plugins/**/Source/**"
+---
+
+# Unreal Engine C++ Rules
+
+- Every UObject reference held by another UObject must be a `TObjectPtr<>` marked `UPROPERTY()` — an unmarked pointer is invisible to the GC and becomes a dangling pointer
+- Never `new`/`delete` a UObject — use `NewObject<>()` or `CreateDefaultSubobject<>()`; use `TSharedPtr`/`TUniquePtr`/`TWeakPtr` only for non-UObject types
+- Follow engine naming: `U` for UObject, `A` for AActor, `F` for structs, `E` for enums, `I` for interfaces, `T` for templates
+- Restrict every identifier to `[A-Za-z0-9_]` — no whitespace, no symbols, no Unicode. This applies to type names, asset references and paths alike; non-ASCII identifiers break cooking, batch tools and source control in ways that surface far from the cause
+- Use `FName` for identifiers and lookups, `FText` for anything shown to a player, `FString` only for manipulation — never build display strings by concatenating `FString` for localized UI
+- Use `TArray`/`TMap`/`TSet`, not STL containers, in any reflected or engine-facing code
+- `Tick` is opt-in, not default: disable it (`PrimaryActorTick.bCanEverTick = false`) and use timers, delegates or events instead. Ticking work multiplied across instances is a measured cost, not an assumption
+- ZERO allocations in hot paths (tick, animation, physics, rendering) — pre-allocate, pool and reuse
+- Always call `Super::` in overridden engine functions (`BeginPlay`, `EndPlay`, `Tick`, `GetLifetimeReplicatedProps`, `PostInitializeComponents`)
+- Every replicated `UPROPERTY(Replicated)` must appear in `GetLifetimeReplicatedProps` with a `DOREPLIFETIME` entry, and every Server RPC must validate its input — never trust the client
+- Use soft references (`TSoftObjectPtr`, `TSoftClassPtr`) plus the Asset Manager for assets that are not always needed; a hard reference pulls the whole asset tree into memory
+- No synchronous load of large assets on the game thread during gameplay — use `StreamableManager` / async loading
+- UObject access happens on the game thread only; async completion paths must handle their owner being destroyed mid-flight
+- Editor-only code lives in an editor module or behind `WITH_EDITOR`, and never ships in a runtime target
+- Profile with Unreal Insights and `stat` commands before AND after every optimization — document the measured numbers
+- Blueprint Nativization was removed in UE5; never propose it as an optimization
+
+## Examples
+
+**Correct** (GC-visible reference, no tick, validated RPC):
+
+```cpp
+UCLASS()
+class AGate : public AActor
+{
+    GENERATED_BODY()
+
+public:
+    AGate()
+    {
+        PrimaryActorTick.bCanEverTick = false;  // event-driven, nothing to tick
+    }
+
+protected:
+    virtual void BeginPlay() override
+    {
+        Super::BeginPlay();  // never skip Super
+        OnActorBeginOverlap.AddDynamic(this, &AGate::HandleOverlap);
+    }
+
+    UFUNCTION(Server, Reliable, WithValidation)
+    void ServerRequestOpen();
+
+private:
+    // TObjectPtr + UPROPERTY: the GC can see and keep this alive.
+    UPROPERTY(VisibleAnywhere)
+    TObjectPtr<UStaticMeshComponent> Frame;
+
+    // Soft reference: the VFX only loads when the gate actually opens.
+    UPROPERTY(EditDefaultsOnly)
+    TSoftObjectPtr<UNiagaraSystem> OpenEffect;
+};
+
+bool AGate::ServerRequestOpen_Validate()
+{
+    return true;
+}
+
+void AGate::ServerRequestOpen_Implementation()
+{
+    // Server re-checks authority and state; the client's word is not enough.
+    if (!HasAuthority() || bIsLocked)
+    {
+        return;
+    }
+    OpenInternal();
+}
+```
+
+**Incorrect** (invisible to GC, needless tick, trusted client, hot-path allocation):
+
+```cpp
+UCLASS()
+class AGate : public AActor
+{
+    GENERATED_BODY()
+
+    // VIOLATION: raw pointer with no UPROPERTY — GC cannot see it, this will dangle
+    UStaticMeshComponent* Frame;
+
+    // VIOLATION: hard reference, loads the VFX and its dependencies with this actor
+    UPROPERTY()
+    UNiagaraSystem* OpenEffect;
+
+    virtual void BeginPlay() override
+    {
+        // VIOLATION: missing Super::BeginPlay()
+        Frame = new UStaticMeshComponent();  // VIOLATION: never new a UObject
+    }
+
+    virtual void Tick(float DeltaTime) override
+    {
+        // VIOLATION: allocates every frame
+        TArray<AActor*> Nearby;
+        UGameplayStatics::GetAllActorsOfClass(GetWorld(), APawn::StaticClass(), Nearby);
+
+        // VIOLATION: string comparison in a hot path — use FName or a tag
+        for (AActor* A : Nearby)
+        {
+            if (A->GetName() == TEXT("BP_Player_C_0"))
+            {
+                OpenInternal();
+            }
+        }
+    }
+
+    UFUNCTION(Server, Unreliable)
+    void ServerRequestOpen(bool bClientSaysUnlocked)
+    {
+        // VIOLATION: trusts a client-supplied authority decision
+        if (bClientSaysUnlocked)
+        {
+            OpenInternal();
+        }
+    }
+};
+```

package/skills/career-registry/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: career-registry
+description: "Traceability across the whole career workspace: check whether you already applied somewhere before spending another application, export everything to CSV, and audit the registry for gaps and drift. Covers job applications, freelance proposals and contracts. Triggers: ya me postule a, ya aplique aca, exportar postulaciones a csv, registro de aplicaciones, trazabilidad, historial de postulaciones, cuantas mande, planilla de postulaciones, auditar el registro."
+argument-hint: "[check <empresa|url> | export | stats | audit]"
+category: "career"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+
+# Career Registry - Trazabilidad y registro
+
+Contestás la pregunta que grepear a mano contesta mal: **¿ya me postulé acá?** Y das el registro completo en CSV para mirarlo en una planilla.
+
+Sirve a los dos perfiles: `+job-hunt` (empleo) y `+freelance` (proyectos). Rutas relativas al career workspace (`--workspace`, env `CAREER_WORKSPACE`, o `./career-workspace/`).
+
+Modo: `$ARGUMENTS`
+
+## La regla que sostiene todo esto
+
+**Las notas son la fuente de verdad. El CSV se deriva de ellas, siempre.**
+
+No hay una segunda base que mantener sincronizada, y no la va a haber: una segunda base diverge en dos semanas y después nadie sabe cuál miente. Es el mismo flujo unidireccional que el dedup de `/job-scrape` (`seen_jobs` → nota → vista, nunca de vuelta).
+
+Consecuencia práctica: si el CSV está mal, se arregla la nota, no el CSV. Y si el usuario pide "guardame el CSV para editarlo a mano", avisale que en la próxima corrida se pisa.
+
+## Los cuatro modos
+
+```bash
+python .claude/skills/career-registry/scripts/career_registry.py check "Acme"
+python .claude/skills/career-registry/scripts/career_registry.py check "https://www.linkedin.com/jobs/view/123"
+python .claude/skills/career-registry/scripts/career_registry.py export --csv registro.csv
+python .claude/skills/career-registry/scripts/career_registry.py stats
+python .claude/skills/career-registry/scripts/career_registry.py audit
+```
+
+### `check` - antes de gastar otra postulación
+
+Busca por **tres claves** porque el usuario pega cualquiera de las tres: nombre de la contraparte, URL de la oferta, o título de la nota.
+
+Es tolerante donde importa: `acme` encuentra a "Acme Inc" (ignora sufijos legales), `tecnologia latam` encuentra a "Tecnología Latam SA" (ignora acentos), y una URL con `?utm_source=...` distinto encuentra la misma oferta (canoniza el link, igual que el dedup).
+
+Devuelve un veredicto de tres valores, y la diferencia entre los dos primeros importa:
+
+| Veredicto | Qué significa |
+|---|---|
+| `YA TE POSTULASTE` | Hay una nota en estado enviado. No repitas |
+| `YA LO VISTE, NO TE POSTULASTE` | Hay nota o entrada de dedup, pero nunca se envió. Vale revisarla antes de descartarla de nuevo |
+| `SIN REGISTRO` | Nunca apareció |
+
+Cuándo correrlo: **antes de `/client-screen` o `/job-aplicar`**, cuando el nombre suena conocido. Un screen sobre algo que ya descartaste hace tres meses es trabajo repetido, y peor, te hace repetir el descarte sin recordar por qué.
+
+### `export` - el CSV
+
+Una fila por nota, con `tipo` discriminando empleo / freelance / contrato. Columnas: contraparte, título, estado, si está abierta, plataforma, `match_score`, riesgo del cliente, perfil usado, bid o monto, costo de postularse, fechas, **días sin movimiento**, link y la ruta de la nota.
+
+Sin `--csv` va a stdout; con `--csv <archivo>` lo escribe en UTF-8 con BOM para que Excel no rompa los acentos. `--tipo` filtra a un solo tipo.
+
+`dias_sin_movimiento` es la columna más útil de la planilla: ordenando por ahí aparece lo que quedó colgado.
+
+### `stats` - conteos
+
+Total y abiertas por tipo, desglose por estado, cuántas se enviaron y el costo de postulaciones registrado.
+
+Trae `muestra_suficiente_para_tasas`: **con menos de 10 enviadas es `false`, y ahí no hay que calcular tasas de conversión**. Diez rechazos no son un patrón, y tratarlos como tal manda al usuario a arreglar lo que no estaba roto.
+
+### `audit` - las divergencias
+
+Lo que hace que la trazabilidad sea real y no una intención:
+
+- Notas sin `estado` o sin contraparte
+- Enviadas sin fecha de envío (rompe cualquier cálculo de tiempos)
+- **Abiertas frenadas hace 21+ días** - candidatas a follow-up con `/cold-outreach` o a cerrar como `sin_respuesta`
+- Posibles duplicados: misma contraparte, mismo título, dos notas
+- **Contratos con horas reales arriba de lo estimado**, con el exceso en horas y en porcentaje. Cada uno es trabajo regalado si no hubo change order
+- Punteros del dedup que apuntan a notas que ya no existen
+
+## Proceso
+
+1. Correr el modo pedido. Si el workspace no existe, el script lo dice y sugiere `/freelance-hunt setup` o `/job-hunt setup`.
+2. **Mostrar el resultado en el chat, no solo el JSON crudo.** Para `check`, el veredicto y una línea por coincidencia con su estado. Para `audit`, agrupado por severidad: primero lo que cuesta plata (horas de más, enviadas sin fecha), después lo cosmético.
+3. Para cada hallazgo de `audit`, ofrecer la acción concreta: follow-up, cerrar como `sin_respuesta`, change order, o completar el campo que falta.
+4. Los arreglos se hacen **en la nota** con approval del usuario, una por una. Nunca en masa.
+
+## Reglas
+
+- **Nunca editar el CSV como si fuera la fuente de verdad.** Se regenera; los cambios van a la nota.
+- **No editar notas en masa.** Cada arreglo se muestra y se aprueba.
+- Nunca inventar un dato que falta: si una nota no tiene fecha de envío, se pregunta o se deja el hueco reportado.
+- No cambiar `estado`: eso lo hace `/job-outcome`, que es el único que mueve el pipeline.
+- El CSV puede tener nombres de clientes y montos: **no commitearlo a un remoto sin confirmación explícita**.
+- Sin guiones largos en el texto agregado a las notas.
+
+## Handoff
+
+Pedí aprobación (approval) antes de escribir el CSV o tocar una nota. Registro COMPLETE cuando el modo corrió y el usuario sabe qué hacer con cada hallazgo. Según el caso, el siguiente paso es `/cold-outreach` (follow-up de lo frenado), `/job-outcome` (cerrar lo que no va a responder), `/contract-and-proposal-writer` (change order de las horas de más) o `/freelance-pipeline` (si hay 10+ resueltas y querés el diagnóstico del embudo).