claude-code-arcane 1.2.0 → 1.3.0

package/skills/dotnet-best-practices/references/performance.md

@@ -0,0 +1,63 @@
+# 6. Performance (HIGH)
+
+## 6.1 Output Caching & HybridCache — HIGH
+
+Cachear respuestas caras evita recomputar en cada request. `HybridCache` combina cache en memoria (L1) y distribuida (L2) con stampede protection.
+
+**Incorrecto:**
+```csharp
+app.MapGet("/stats", async (StatsService s) => await s.ComputeAsync()); // recomputa siempre
+```
+**Correcto:**
+```csharp
+builder.Services.AddHybridCache();
+
+app.MapGet("/stats", async (HybridCache cache, StatsService s, CancellationToken ct) =>
+    await cache.GetOrCreateAsync("stats", async token => await s.ComputeAsync(token), cancellationToken: ct));
+```
+
+## 6.2 Response Compression — HIGH
+
+Comprimir respuestas reduce el ancho de banda y la latencia percibida en payloads JSON grandes.
+
+**Correcto:**
+```csharp
+builder.Services.AddResponseCompression(o => o.EnableForHttps = true);
+var app = builder.Build();
+app.UseResponseCompression();
+```
+
+## 6.3 Never Block on Async (sync-over-async) — HIGH
+
+`.Result` o `.Wait()` bloquean un hilo del thread pool y pueden causar deadlocks y thread starvation bajo carga.
+
+**Incorrecto:**
+```csharp
+var user = _repo.GetUserAsync(id).Result; // bloquea el hilo
+```
+**Correcto:**
+```csharp
+var user = await _repo.GetUserAsync(id);
+```
+
+## 6.4 DbContext Pooling — MEDIUM-HIGH
+
+Reusar instancias de `DbContext` desde un pool reduce las allocations y el costo de setup por request.
+
+**Correcto:**
+```csharp
+builder.Services.AddDbContextPool<AppDbContext>(o =>
+    o.UseNpgsql(builder.Configuration.GetConnectionString("Default")));
+```
+
+## 6.5 Stream Large Results with IAsyncEnumerable — MEDIUM
+
+Devolver `IAsyncEnumerable<T>` transmite filas a medida que llegan en vez de materializar toda la colección en memoria.
+
+**Correcto:**
+```csharp
+app.MapGet("/orders", (AppDbContext db) =>
+    db.Orders.AsNoTracking().AsAsyncEnumerable()); // streaming, server GC ayuda en cargas altas
+```
+
+_Ref: https://learn.microsoft.com/en-us/aspnet/core/performance/caching/hybrid · https://learn.microsoft.com/en-us/aspnet/core/performance/response-compression · https://learn.microsoft.com/en-us/ef/core/performance/advanced-performance-topics_

package/skills/dotnet-best-practices/references/security.md

@@ -0,0 +1,73 @@
+# 5. Security (HIGH)
+
+## 5.1 Short-Lived JWT + Refresh Tokens — CRITICAL
+
+Access tokens cortos (5-15 min) limitan la ventana si se filtra uno; el refresh token (revocable, server-side) renueva sin re-login. Tokens de larga vida no se pueden invalidar.
+
+```csharp
+builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+    .AddJwtBearer(o => o.TokenValidationParameters = new()
+    {
+        ValidateIssuer = true, ValidateAudience = true, ValidateLifetime = true,
+        ValidateIssuerSigningKey = true, ClockSkew = TimeSpan.FromSeconds(30)
+    });
+```
+
+## 5.2 Secrets in User-Secrets / Key Vault — CRITICAL
+
+Nunca claves ni connection strings en `appsettings.json` (van al repo). En dev `dotnet user-secrets`; en prod Azure Key Vault o variables de entorno.
+
+**Incorrecto:**
+```json
+{ "Jwt": { "Key": "super-secret-signing-key" } } // en el repo
+```
+**Correcto:**
+```csharp
+// dotnet user-secrets set "Jwt:Key" "..." (dev)
+builder.Configuration.AddAzureKeyVault(vaultUri, new DefaultAzureCredential()); // prod
+```
+
+## 5.3 Authorize by Policies, Not Manual Role Checks — HIGH
+
+Las policies centralizan la regla de autorización; los `if (user.Role == "Admin")` dispersos se desincronizan y se olvidan.
+
+**Incorrecto:**
+```csharp
+if (!ctx.User.IsInRole("Admin")) return Results.Forbid(); // lógica esparcida
+```
+**Correcto:**
+```csharp
+builder.Services.AddAuthorizationBuilder()
+    .AddPolicy("CanManageOrders", p => p.RequireRole("Admin").RequireClaim("scope", "orders:write"));
+app.MapPost("/orders", Handler).RequireAuthorization("CanManageOrders");
+```
+
+## 5.4 HTTPS, HSTS and Rate Limiting — HIGH
+
+Forzar HTTPS + HSTS evita downgrade/MITM. El middleware `RateLimiter` integrado protege de abuso y brute-force.
+
+```csharp
+builder.Services.AddRateLimiter(o => o.AddFixedWindowLimiter("api", w =>
+    { w.PermitLimit = 100; w.Window = TimeSpan.FromMinutes(1); }));
+app.UseHsts();
+app.UseHttpsRedirection();
+app.UseRateLimiter();
+```
+
+## 5.5 Don't Log Sensitive Data; Validate Input — HIGH
+
+Nunca loggear passwords, tokens ni PII. Validar todo input con FluentValidation. Las queries de EF Core son parametrizadas por defecto (no concatenar SQL crudo) y `[ValidateAntiForgeryToken]` donde haya cookies/formularios.
+
+```csharp
+public sealed class CreateOrderValidator : AbstractValidator<CreateOrderRequest>
+{
+    public CreateOrderValidator()
+    {
+        RuleFor(x => x.CustomerId).NotEmpty();
+        RuleFor(x => x.Items).NotEmpty();
+    }
+}
+// EF Core parametriza: db.Users.Where(u => u.Email == input) — nunca string-interpolated FromSqlRaw
+```
+
+_Ref: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/configure-jwt-bearer-authentication · https://learn.microsoft.com/en-us/aspnet/core/performance/rate-limit_

package/skills/dotnet-best-practices/references/testing.md

@@ -0,0 +1,76 @@
+# 8. Testing (MEDIUM-HIGH)
+
+## 8.1 Integration Tests with WebApplicationFactory — HIGH
+
+`WebApplicationFactory<T>` levanta la app en memoria con el pipeline real (DI, middleware, routing), probando el comportamiento de verdad y no mocks.
+
+**Correcto:**
+```csharp
+public class OrdersApiTests(WebApplicationFactory<Program> factory)
+    : IClassFixture<WebApplicationFactory<Program>>
+{
+    [Fact]
+    public async Task GetOrders_ReturnsOk()
+    {
+        var client = factory.CreateClient();
+        var response = await client.GetAsync("/api/v1/orders");
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+    }
+}
+```
+
+## 8.2 Real Postgres via Testcontainers — HIGH
+
+El provider in-memory miente sobre el comportamiento relacional (transacciones, constraints, SQL). Testcontainers levanta un Postgres real y desechable.
+
+**Incorrecto:**
+```csharp
+options.UseInMemoryDatabase("test"); // no valida FKs, constraints ni SQL real
+```
+**Correcto:**
+```csharp
+var pg = new PostgreSqlBuilder().WithImage("postgres:17").Build();
+await pg.StartAsync();
+options.UseNpgsql(pg.GetConnectionString());
+```
+
+## 8.3 Don't Mock DbContext — MEDIUM-HIGH
+
+Mockear `DbContext` o `IQueryable` reimplementa LINQ-to-SQL en LINQ-to-Objects y da falsos verdes. Probar handlers/slices contra una base real.
+
+**Incorrecto:**
+```csharp
+var mock = new Mock<AppDbContext>(); // no traduce queries como el provider real
+```
+**Correcto:**
+```csharp
+var handler = new CreateOrderHandler(realDbContext);
+var result = await handler.Handle(command, CancellationToken.None);
+```
+
+## 8.4 Arrange-Act-Assert with FluentAssertions — MEDIUM
+
+Estructurar cada test en AAA y usar `FluentAssertions` para aserciones legibles y mensajes de error claros.
+
+**Correcto:**
+```csharp
+[Fact]
+public void Discount_AppliesPercentage()
+{
+    var order = new Order(100m);              // Arrange
+    order.ApplyDiscount(0.10m);               // Act
+    order.Total.Should().Be(90m);             // Assert
+}
+```
+
+## 8.5 Deterministic Tests — MEDIUM
+
+Evitar `DateTime.Now`, GUIDs aleatorios o dependencias de orden: inyectar `TimeProvider` para que los tests sean reproducibles.
+
+**Correcto:**
+```csharp
+var time = new FakeTimeProvider(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero));
+var service = new SubscriptionService(time); // sin reloj real, resultado estable
+```
+
+_Ref: https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests · https://learn.microsoft.com/en-us/dotnet/core/testing/ · https://learn.microsoft.com/en-us/dotnet/architecture/microservices/multi-container-microservice-net-applications/test-aspnet-core-services-web-apps_

package/skills/dotnet-scaffold/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: dotnet-scaffold
+description: "Scaffold de API ASP.NET Core (.NET 10) production-ready: Vertical Slice o Clean Architecture, Minimal APIs, EF Core + PostgreSQL, JWT + Identity, ProblemDetails, health checks y testing. Usar para iniciar un backend .NET nuevo."
+category: "backend"
+argument-hint: "[project-name]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit, Task
+---
+# dotnet-scaffold — ASP.NET Core API Scaffolder
+
+## MANDATORY WORKFLOW
+
+**Antes de generar cualquier código, completar estos pasos en orden.** Confirmar las decisiones del Step 0 con el usuario antes de escribir archivos (Question → Decision → Approval).
+
+### Step 0: Gather Requirements
+1. **Nombre del servicio** (PascalCase para la solución, ej. `OrdersApi`)
+2. **Arquitectura:** Vertical Slice (default) / Clean Architecture — ver skill `dotnet-architecture` para elegir
+3. **Transport:** Web API REST con Minimal APIs (default) / Controllers / gRPC
+4. **ORM:** EF Core (default) / Dapper
+5. **DB:** PostgreSQL (default) / SQL Server
+6. **Auth:** JWT + ASP.NET Identity (default) / OAuth / ninguna
+7. **Deploy:** Docker (default) / Azure App Service
+
+> Si el dominio es CRUD/simple → **Vertical Slice**. Si es complejo y long-lived con varios devs → **Clean Architecture**.
+
+### Step 1: Crear base
+```bash
+dotnet new sln -n <Name>
+dotnet new webapi -n <Name>.Api                       # Minimal APIs (default en .NET 8+); para Controllers: --use-controllers
+dotnet sln add <Name>.Api
+dotnet new xunit -n <Name>.Tests && dotnet sln add <Name>.Tests
+cd <Name>.Api
+dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL
+dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
+dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
+dotnet add package FluentValidation.DependencyInjectionExtensions    # core + DI; FluentValidation.AspNetCore (auto-validation) está deprecado
+dotnet add package Serilog.AspNetCore
+```
+
+### Step 2: Estructura
+
+**Vertical Slice (default)** — un folder por feature/use-case:
+```
+src/
+  Features/
+    Orders/   { CreateOrder.cs, GetOrder.cs, OrderEndpoints.cs }  # request+handler+validator+endpoint por slice
+    Users/    { ... }
+  Infrastructure/  { AppDbContext.cs, Migrations/ }
+  Common/    { Behaviors/, Results/, ProblemDetails/ }
+  Program.cs
+```
+
+**Clean Architecture** — proyectos por capa (deps apuntan hacia adentro):
+```
+<Name>.Domain/          # entities, value objects — cero deps externas
+<Name>.Application/      # use cases, interfaces (IAppDbContext), DTOs
+<Name>.Infrastructure/   # EF Core, Identity, implementaciones
+<Name>.Api/             # endpoints/controllers, DI, Program.cs
+```
+
+### Step 3: Defaults no negociables (`Program.cs` / `.csproj`)
+- `<Nullable>enable</Nullable>` + `<TreatWarningsAsErrors>true</TreatWarningsAsErrors>` en el `.csproj`
+- **Async end-to-end**: handlers `async Task<>`, `CancellationToken` propagado a EF Core y HTTP; nunca `.Result`/`.Wait()`
+- **DI por constructor** (primary constructors); registrar servicios con scope correcto (`AddScoped` para DbContext/handlers)
+- **Validación**: FluentValidation por slice, invocada manualmente (pipeline behavior MediatR o endpoint filter — no auto-validation) → responder `ValidationProblemDetails` (RFC 7807)
+- **Errores**: `AddProblemDetails()` + exception handler global → `ProblemDetails` consistente, sin filtrar stack traces
+- **EF Core**: migraciones versionadas (`dotnet ef migrations add`), **nunca** `EnsureCreated()` en prod; `DbContext` como Unit of Work (sin repos genéricos salvo necesidad)
+- **Auth**: JWT de vida corta + refresh, secretos en `user-secrets`/secret manager, authorization por policies declarativas
+- **Observabilidad**: Serilog structured logging (JSON) + health checks (`AddHealthChecks`) + OpenTelemetry opcional
+- **Graceful shutdown**: respetar `IHostApplicationLifetime` / `CancellationToken` del host
+
+### Step 4: Agregar piezas (invocar skills relacionadas)
+- `dotnet-architecture` — estructura de slices/capas en detalle
+- `database` / `data-migrations` — modelado EF Core + migraciones
+- `jwt-strategy` / `auth-strategy` / `rbac-abac` — auth y authorization
+- `api-design` / `api-versioning` / `api-docs` — contrato REST + OpenAPI
+- `testing` / `contract-testing` — xUnit + Testcontainers (Postgres real en tests)
+
+### Step 5: Verificar
+`dotnet build` + `dotnet test`. Revisar contra la rule `dotnet-code` y el skill `dotnet-best-practices`. Build + tests verdes → scaffold **READY**.
+
+## Stack Defaults
+
+| Componente | Default |
+|------------|---------|
+| Runtime | .NET 10 LTS (C# 14) |
+| Framework | ASP.NET Core — Minimal APIs |
+| Arquitectura | Vertical Slice (Clean opcional) |
+| ORM | EF Core 10 |
+| DB | PostgreSQL (Npgsql) |
+| Auth | JWT + ASP.NET Identity |
+| Validación | FluentValidation → ProblemDetails |
+| Logging | Serilog (JSON) |
+| Testing | xUnit + Testcontainers |
+| Deploy | Docker |
+
+---
+
+_Inspirado en [dotnet/skills](https://github.com/dotnet/skills) (oficial Microsoft), [github/awesome-copilot](https://github.com/github/awesome-copilot) (dotnet-best-practices) y los templates [ardalis/CleanArchitecture](https://github.com/ardalis/CleanArchitecture) y [nadirbad/VerticalSliceArchitecture](https://github.com/nadirbad/VerticalSliceArchitecture). Adaptado al formato Arcane._

package/skills/install-mcp/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: install-mcp
+description: "Instala y registra el MCP de Unity (CoplayDev MCP for Unity) en un proyecto Unity + Claude Code: agrega el package UPM, registra el server MCP y verifica la conexion. Usar para: instalar mcp unity, conectar Claude con Unity, setup MCP Unity."
+category: "gamedev"
+argument-hint: "[--secondary] [project-path]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+# install-mcp — Unity MCP Setup
+
+Instala el package MCP del lado Unity y registra el server MCP en Claude Code, replicando el setup usado en los proyectos de tesis (TesisUade).
+
+- **Package primario:** `com.coplaydev.unity-mcp` (CoplayDev "MCP for Unity"). Server Python vía `uv`/`uvx`, transport HTTP en `127.0.0.1:8080`. El server se levanta y auto-configura desde Unity en `Window → MCP for Unity`.
+- **Package secundario (opcional, flag `--secondary`):** `com.gamelovers.mcp-unity` (CoderGamester). Server Node.
+
+> El flujo de Unity (`Window → MCP for Unity`) requiere la GUI del Editor — Claude no puede manejarla. La skill automatiza lo que sí puede (editar `manifest.json`, registrar el cliente MCP, verificar) y **guía** el paso del Editor.
+
+## Input
+
+- `project-path` (opcional): raíz del proyecto Unity. Default: directorio actual.
+- `--secondary` (opcional): además del primario, instala el package CoderGamester.
+
+---
+
+## Workflow
+
+### 1. Detectar proyecto Unity
+
+Desde `project-path` (o cwd), confirmar que existen:
+- `Packages/manifest.json`
+- `ProjectSettings/ProjectVersion.txt`
+
+Si falta alguno, **abortar** con: "No parece un proyecto Unity (falta Packages/manifest.json o ProjectSettings/ProjectVersion.txt). Pasá la ruta del proyecto con `/install-mcp <project-path>`."
+
+### 2. Verificar prerrequisitos
+
+- `uv --version` y `uvx --version` (server del primario). Si falta `uv`, **no abortar**: avisar y dar el comando de install y seguir editando el manifest:
+  - Windows: `winget install astral-sh.uv`
+  - alternativa: `pipx install uv`
+- Solo con `--secondary`: `node --version`. Si falta, avisar (el server CoderGamester no podrá correr).
+
+### 3. Agregar el package UPM (lado Unity)
+
+Leer `Packages/manifest.json`. Dentro de `"dependencies"`, agregar **solo si la key no existe** (idempotente — nunca duplicar):
+
+```json
+"com.coplaydev.unity-mcp": "https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main"
+```
+
+Con `--secondary`, agregar también:
+
+```json
+"com.gamelovers.mcp-unity": "https://github.com/CoderGamester/mcp-unity.git"
+```
+
+Usar `Edit` puntual sobre el bloque `dependencies` preservando el JSON válido (indentación, comas). Si la key ya estaba, reportar "ya presente, sin cambios".
+
+> **Antes de escribir**, mostrar el diff propuesto sobre `manifest.json` (y el `.mcp.json` del paso 4B si aplica) y pedir aprobación al usuario. No editar sin confirmación.
+
+### 4. Registrar el server MCP en Claude Code
+
+Dos caminos, en orden de preferencia:
+
+**A. Recomendado (auto-config desde Unity).** Instruir al usuario:
+1. Abrir el proyecto en Unity (Unity importará el package nuevo).
+2. `Window → MCP for Unity`.
+3. En esa ventana, usar el botón de auto-configuración para **Claude Code** — instala el server `uv` y registra el cliente MCP automáticamente.
+
+**B. Fallback manual.** Si el usuario no puede usar el Editor ahora, registrar el transport HTTP que usa CoplayDev:
+
+```bash
+claude mcp add --transport http unity-mcp http://127.0.0.1:8080
+```
+
+(equivalente: escribir un `.mcp.json` de proyecto con
+`{"mcpServers":{"unity-mcp":{"type":"http","url":"http://127.0.0.1:8080"}}}`).
+
+> El server solo responde cuando Unity está abierto con `MCP for Unity` activo. Registrar el cliente no levanta el server.
+
+### 5. Verificar
+
+Correr:
+
+```bash
+claude mcp list
+```
+
+Reportar si `unity-mcp` aparece **conectado**. Seguir la guía de TesisUade: **si NO está conectado, avisar explícitamente** y aclarar que las operaciones de engine (scenes, SOs, prefabs, UI wiring) NO se aplicaron — no asumir éxito.
+
+### 6. Resumen
+
+Reportar:
+- Qué keys se agregaron a `manifest.json` (o si ya estaban).
+- Estado del registro MCP (auto-config pendiente en Unity vs. fallback aplicado).
+- Resultado de `claude mcp list`.
+- Próximo paso manual: abrir Unity → `Window → MCP for Unity`.
+
+**Verdict:**
+- **READY** — package en `manifest.json` + cliente registrado + `unity-mcp` conectado en `claude mcp list`.
+- **PENDING** — package y cliente listos, pero falta abrir Unity (`Window → MCP for Unity`) para que el server conecte. Avisar que las operaciones de engine aún NO están disponibles.
+- **BLOCKED** — falta un prerrequisito (`uv` ausente) o no es un proyecto Unity válido. Indicar el fix.
+
+Tras conectar, seguir con `/unity-game-architecture` o `/scaffold-unity` para trabajar el proyecto.
+
+---
+
+> → Read references/manual-setup.md for [pasos detallados del flujo Window → MCP for Unity, troubleshooting (uv no encontrado, puerto 8080 ocupado, MCP no conecta) y la variante secundaria CoderGamester]

package/skills/install-mcp/references/manual-setup.md

@@ -0,0 +1,92 @@
+# Manual setup — Unity MCP
+
+Referencia detallada para el flujo manual y troubleshooting de `/install-mcp`.
+
+## Primario: CoplayDev "MCP for Unity" (`com.coplaydev.unity-mcp`)
+
+### Package UPM
+
+En `Packages/manifest.json`, dentro de `dependencies`:
+
+```json
+"com.coplaydev.unity-mcp": "https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main"
+```
+
+Al abrir el proyecto, Unity descarga e importa el package desde el git URL.
+
+### Levantar y registrar el server (desde Unity)
+
+1. Abrir el proyecto en Unity.
+2. `Window → MCP for Unity` abre el panel del package.
+3. En el panel:
+   - El package instala/usa el server Python vía `uv`/`uvx` (paquete `mcp-for-unity`), transport HTTP en `127.0.0.1:8080`.
+   - Usar el botón de auto-config para el cliente **Claude Code** — escribe la config del cliente MCP y deja el server listo.
+4. Dejar Unity abierto: el server MCP solo responde mientras el Editor está corriendo con el panel activo.
+
+### Registro manual del cliente (sin GUI)
+
+Si no se puede usar el botón de auto-config:
+
+```bash
+claude mcp add --transport http unity-mcp http://127.0.0.1:8080
+```
+
+O escribir un `.mcp.json` en la raíz del proyecto:
+
+```json
+{
+  "mcpServers": {
+    "unity-mcp": {
+      "type": "http",
+      "url": "http://127.0.0.1:8080"
+    }
+  }
+}
+```
+
+### Verificar
+
+```bash
+claude mcp list
+```
+
+`unity-mcp` debe figurar conectado. Si no, ver troubleshooting.
+
+## Troubleshooting
+
+| Síntoma | Causa probable | Fix |
+|---------|----------------|-----|
+| `uv: command not found` | `uv` no instalado / no en PATH | `winget install astral-sh.uv` (o `pipx install uv`), reabrir terminal |
+| `claude mcp list` no muestra `unity-mcp` | Cliente no registrado | Re-correr el paso 4 (auto-config o `claude mcp add`) |
+| `unity-mcp` aparece pero **no conecta** | Unity cerrado o panel inactivo | Abrir Unity y `Window → MCP for Unity` |
+| Puerto `8080` ocupado | Otro proceso usa 8080 | Cambiar el puerto en el panel de MCP for Unity y ajustar la URL en el registro del cliente |
+| Operaciones de engine no se aplican | MCP desconectado | No asumir éxito: verificar conexión antes de operar; avisar al usuario |
+
+## Secundario (opcional): CoderGamester `mcp-unity` (`com.gamelovers.mcp-unity`)
+
+Server Node. Instalar con el flag `--secondary`.
+
+### Package UPM
+
+```json
+"com.gamelovers.mcp-unity": "https://github.com/CoderGamester/mcp-unity.git"
+```
+
+### Server
+
+Requiere `node` en PATH. El package incluye un server Node en `Server~/build/index.js` dentro del package cache (`Library/PackageCache/com.gamelovers.mcp-unity@.../Server~`). El registro del cliente apunta a ese `index.js`:
+
+```json
+{
+  "mcpServers": {
+    "mcp-unity": {
+      "command": "node",
+      "args": ["<ruta absoluta a Server~/build/index.js>"]
+    }
+  }
+}
+```
+
+En TesisUade esta ruta la genera un editor tool propio (`Tools → Update MCP Unity Route`). Fuera de ese proyecto, ubicar el `index.js` en el `PackageCache` y registrar la ruta a mano.
+
+> El primario (CoplayDev) es el oficial del set unity-dev. El secundario se mantiene solo por compatibilidad con proyectos que ya lo declaran.

package/skills/interview-prep/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: interview-prep
+description: "Prepare for a job interview: company research, likely question bank by role, STAR answers built from your real experience, smart questions to ask, and red flags to watch for. Triggers: preparar entrevista, interview prep, preguntas de entrevista, respuestas STAR, que preguntar en una entrevista, mock interview, red flags entrevista."
+argument-hint: "[application-note | company + role + round]"
+category: "career"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Write, Edit, WebFetch
+---
+
+# Interview Prep — Preparación de entrevista
+
+Preparás al usuario para una entrevista concreta: research de la empresa, banco de preguntas probable según rol y ronda, respuestas **STAR** construidas desde su experiencia real, preguntas inteligentes para hacer, y red flags a detectar. El output queda en una nota de `06-Entrevistas/`.
+
+## Inputs
+
+- **Aplicación / empresa / rol** (`03-Aplicaciones/`, `04-Empresas/`) y la **ronda** (recruiter screen, técnica, system design, hiring manager, cultural, final).
+- **Perfil maestro** (`01-Perfiles/`) — de ahí salen las historias para las respuestas STAR.
+- **Entrevistadores** si se conocen (research de background ayuda).
+
+## Qué producís
+
+### 1. Research de la empresa
+- Qué hacen, producto, modelo de negocio, etapa, tamaño.
+- Cultura y valores (de su sitio, blog, reviews).
+- Noticias recientes / financiación / lanzamientos.
+- Stack técnico conocido.
+- Cómo conectar tu perfil con su contexto.
+
+### 2. Banco de preguntas por ronda
+- **Recruiter screen:** motivación, expectativas salariales, disponibilidad, "contame de vos".
+- **Técnica:** según stack del JD — fundamentos, problemas, debugging, code review.
+- **System design** (si aplica): patrones, trade-offs, escala.
+- **Hiring manager / comportamiento:** liderazgo, conflicto, fracaso, impacto.
+- **Cultural:** valores, formas de trabajo, por qué esta empresa.
+- Marcar las **3–5 más probables** para este rol específico.
+
+### 3. Respuestas STAR
+- Construir respuestas con el método **STAR** (Situación, Tarea, Acción, Resultado) usando logros reales del perfil maestro.
+- Cada respuesta: concreta, con métrica, 60–90 segundos hablada.
+- Ver `references/star-framework.md`.
+
+### 4. Preguntas para hacer
+- 5–7 preguntas inteligentes que demuestran research y filtran si la empresa te conviene (equipo, expectativas de los primeros 90 días, cómo miden éxito, deuda técnica, proceso).
+
+### 5. Red flags a detectar
+- Señales de mala empresa/equipo durante la entrevista (proceso caótico, evasión sobre cultura/turnover, expectativas irreales, falta de claridad de rol, hostilidad).
+- Qué preguntar para sacarlas a la luz.
+
+## Salario / negociación (si la ronda lo toca)
+
+- No dar número primero si se puede evitar; preguntar rango.
+- Anclar en research de mercado + tu valor (logros).
+- Tener un rango (mínimo aceptable / objetivo / ambicioso) listo.
+
+## Proceso
+
+1. Leer aplicación + empresa + perfil. WebFetch del sitio/notas de la empresa.
+2. Crear nota en `06-Entrevistas/` con el template `Entrevista`.
+3. Llenar research, banco de preguntas (marcando las top), STAR de las 3–5 historias clave, preguntas a hacer, red flags.
+4. Ofrecer un **mock**: vos hacés de entrevistador y das feedback sobre las respuestas.
+5. Post-entrevista: ayudar a registrar feedback y definir próximo paso / follow-up (con `/cold-outreach`).
+
+## Idioma
+
+En el idioma de la entrevista. Preparar respuestas en inglés si el rol es internacional, aunque la prep se converse en español.
+
+## Handoff
+
+Pedí aprobación (approval) antes de escribir la nota en `06-Entrevistas/`. Cuando la prep está READY, ofrecé un mock; post-entrevista, seguí con `/cold-outreach` para el follow-up.

package/skills/interview-prep/references/star-framework.md

@@ -0,0 +1,42 @@
+# STAR Framework — Respuestas de comportamiento
+
+STAR estructura respuestas a preguntas de comportamiento ("contame de una vez que…") para que sean concretas, completas y memorables. La mayoría de los candidatos divaga; STAR te da una historia con resultado.
+
+## Las 4 partes
+
+- **S — Situación:** el contexto, breve. Dónde, cuándo, qué estaba pasando. (1–2 oraciones)
+- **T — Tarea:** tu responsabilidad / el problema a resolver. (1 oración)
+- **A — Acción:** qué hiciste *vos* (no "el equipo"). El grueso de la respuesta. Decisiones concretas. (2–4 oraciones)
+- **R — Resultado:** el impacto, **con número** siempre que se pueda. Qué aprendiste. (1–2 oraciones)
+
+Objetivo: 60–90 segundos hablado. Ni telegrama, ni monólogo de 5 minutos.
+
+## Ejemplo
+
+> **Pregunta:** "Contame de una vez que mejoraste el rendimiento de un sistema."
+>
+> **S:** En Acme nuestro servicio de matchmaking tenía picos de latencia que cortaban partidas.
+> **T:** Como backend lead, me tocó bajar la latencia sin agregar infra.
+> **A:** Perfilé el hot path, encontré queries N+1 y serialización redundante; introduje caching por sesión y batch de writes, y agregué métricas para validar.
+> **R:** Latencia -25% y estabilidad del server +40%; duplicamos jugadores concurrentes sin sumar costos. Aprendí a medir antes de optimizar.
+
+## Banco de historias (preparar 5–6)
+
+Construí 5–6 historias STAR reutilizables desde el perfil maestro, cubriendo:
+
+1. **Logro/impacto** del que estés orgulloso (con métrica).
+2. **Problema técnico difícil** que resolviste.
+3. **Conflicto / desacuerdo** con un compañero o stakeholder.
+4. **Fracaso / error** y qué aprendiste (mostrá ownership, no excusas).
+5. **Liderazgo / iniciativa** (lideraste algo, mentoreaste, empujaste un cambio).
+6. **Ambigüedad / cambio de prioridades** que manejaste.
+
+La misma historia puede servir para varias preguntas — lo que cambia es qué parte enfatizás.
+
+## Errores comunes
+
+- Quedarse en "nosotros" — la entrevista evalúa *tu* aporte. Decí "yo".
+- Saltearse el Resultado, o un resultado sin número.
+- Demasiada Situación, poca Acción.
+- Historias vagas/inventadas que no aguantan repreguntas.
+- No tener la historia de fracaso preparada (la piden casi siempre).