Importar un patrón

Puedes adoptar cualquier patrón de dos maneras. Puedes pegar su token en cualquier asistente de IA conectado, para que Pathrule escriba las piezas en las rutas correctas por ti, o copiar el paquete a mano desde el catálogo.

El token de referencia

Cada patrón tiene un token de referencia con esta forma:

::pathrule:package:<slug>

Por ejemplo, el patrón de Next.js App Router es ::pathrule:package:nextjs-app-router. El token aparece en cada página del catálogo, listo para copiar.

El prefijo ::pathrule: es un espacio de nombres reservado. Se evalúa antes que la ruta de invocación ::skill-name, así que un token de patrón nunca se confunde con una skill ni activa el descubrimiento de skills. Esa separación se mantiene tanto en el hook de prompt como en la solicitud de contexto.

Pega el token como texto plano. Igual que con la invocación de una skill, un token dentro de comillas invertidas o de un bloque de código se trata como código citado y se ignora. Puedes poner varios tokens en un mismo prompt; cada patrón se toma una sola vez.

Importar con el token

Para agregar un patrón, pega su token en un prompt dentro de un espacio de trabajo conectado. A partir de ahí, Pathrule se encarga del resto:

1. Reconoce el token. Cuando Pathrule arma el contexto para tu prompt, detecta el marcador ::pathrule:package:<slug> y presenta una directiva de importación para ese slug.
2. Muestra una vista previa antes de escribir. Una ejecución de prueba resuelve el patrón y devuelve su versión, el problema que resuelve, sus piezas y las rutas que pretende usar, sin cambiar nada todavía. Esta vista previa también informa las rutas, los stacks y las dependencias que declara el patrón, para que el asistente pueda ajustarlo a tu proyecto real.
3. Elige rutas que coinciden con tu árbol. Un patrón declara rutas sugeridas, pero cada repositorio es distinto. El asistente elige una base que coincide con tu estructura y reubica bajo ella las rutas del patrón, para que las piezas queden donde realmente corresponden. En un monorepo, las reglas de /app de un patrón de Next.js pueden quedar bajo /apps/web/app.
4. Pide confirmación si algo no coincide. Si el patrón apunta a un stack que tu proyecto no parece usar, por ejemplo un patrón de React Native en un proyecto sin Expo, el asistente se detiene y te pregunta si quieres agregarlo y dónde, en lugar de importarlo a ciegas.
5. Escribe el paquete. Cuando confirmas, cada pieza se crea mediante la vía de escritura normal: una memoria se convierte en una memoria, una regla se convierte en una regla con su tipo de alcance y su prioridad, y una skill se convierte en una skill invocable etiquetada con el patrón del que proviene. Los nodos que falten en cada ruta se crean según se necesiten.

Después, el asistente te muestra un resumen de una línea, por ejemplo cuántas reglas, memorias y skills se importaron, cuántas ya existían y cuántas fallaron.

Tras la importación, las piezas son contenido normal del espacio de trabajo. Aparecen mediante los mismos hooks y la misma recuperación que cualquier cosa que hayas escrito tú, y las editas de la misma forma. Una regla importada llega como orientativa: viaja como contexto y no bloquea una edición a menos que una persona apruebe una restricción ejecutable para ella (consulta Reglas como barreras de protección).

La importación escribe en tu nombre. Cada pieza pasa por la misma verificación de acceso que cualquier otra escritura, así que en un equipo necesitas permiso de escritura en el espacio de trabajo de destino: un Viewer no puede importar. Consulta Roles y permisos.

Importar copiando a mano

No necesitas el token para usar un patrón. Cada página del catálogo tiene una acción "Manual copy (full bundle)" que copia el paquete completo como Markdown plano, con cada pieza etiquetada según su tipo y su ruta de destino, y cada regla etiquetada con su alcance y su prioridad. Pégalo en tu asistente, o en tus propias notas, y recrea las piezas donde quieras. Esto funciona sin configuración y sin cuenta.

Cada patrón también está disponible como Markdown sin procesar en /patterns/<slug>/raw, lo cual resulta práctico cuando quieres que un asistente lea el paquete completo desde un enlace.

Sembrar, no suscribirse

Importar un patrón es una siembra única. La copia en tu espacio de trabajo es tuya desde ese momento; no queda vinculada al catálogo y no va a cambiar sin que lo sepas. Pathrule no registra qué versión importaste ni te avisa cuando se publica una versión más nueva, así que nunca se sincroniza nada encima del contenido que ya adaptaste.

Para saber si un patrón cambió desde que lo importaste, compara la versión y la fecha de actualización en su página del catálogo, y lee su registro de cambios en el paquete abierto. Volver a importar no trae los cambios, porque se omite cada pieza cuyo título ya existe. Para adoptar una versión más nueva, elimina el paquete y vuelve a importarlo, sabiendo que esto reemplaza los cambios que hayas hecho en las piezas importadas. Si solo quieres una pieza mejorada, cópiala a mano desde la página del catálogo.

Volver a importar y eliminar

• Volver a importar nunca duplica. Ejecutar la misma importación de nuevo omite cada pieza cuyo título ya existe e informa qué se agregó y qué ya estaba. Una memoria cuenta como existente cuando hay una memoria con el mismo título en su ruta; una regla o una skill cuenta como existente cuando hay una con el mismo nombre en cualquier parte del espacio de trabajo. Las piezas omitidas se dejan exactamente como están, con tus cambios incluidos. Una pieza a la que le cambiaste el nombre después de importarla ya no se reconoce, así que una nueva importación la vuelve a agregar.
• Eliminar es un solo paso. La definición de un patrón es su propio manifiesto de títulos y rutas, así que puedes pedirle a tu asistente que elimine el patrón y una sola llamada deshace el paquete completo. Si importaste bajo una ruta base, indica la misma base al eliminar; las piezas que no se encuentren ahí se informan como no encontradas en lugar de tratarse como errores.

Qué afecta la eliminación

La eliminación encuentra cada pieza por su título en su ruta, no recordando lo que creó la importación. Eso tiene tres consecuencias que conviene conocer antes de ejecutarla:

• También se eliminan las piezas editadas. Una memoria, regla o skill importada que hayas editado después se elimina junto con tus cambios, siempre que su título y su ruta no hayan cambiado.
• Se elimina tu propio elemento con el mismo título. Si escribiste tú una memoria, regla o skill con el mismo título que una de las piezas del patrón, en la misma ruta, la eliminación también la borra. Los títulos se comparan sin distinguir entre mayúsculas y minúsculas.
• Las piezas renombradas o movidas se conservan. Cambiar el nombre de una pieza o moverla a otra ruta la deja fuera del alcance de la eliminación, y esa es la forma de conservar una pieza mientras eliminas el resto.

Los elementos eliminados se archivan en lugar de borrarse. En un espacio de trabajo de Cloud permanecen en el archivo del espacio de trabajo hasta que se borran de forma permanente, y desde ahí un propietario o administrador puede restaurarlos en la configuración de la consola web, en Workspace, Archive.

Dónde funciona

La importación con token y la eliminación usan las herramientas MCP locales por stdio, incluso cuando ese entorno de ejecución está conectado a un espacio de trabajo de Cloud. Remote MCP no expone estas utilidades. Un cliente remoto puede leer el paquete sin procesar y crear las entradas que elija con las herramientas de conocimiento que tenga disponibles.

La importación se comporta igual en Claude Code, Codex, Cursor, Windsurf y GitHub Copilot conectados mediante Pathrule CLI o la extensión de VS Code. La importación y la eliminación funcionan igual en un espacio de trabajo local y en un espacio de trabajo de Pathrule Cloud. En Claude Code y Codex, el hook de prompt detecta el token antes de que el agente actúe. Cursor, GitHub Copilot y Windsurf no tienen hook de prompt, así que ahí el asistente aprende el mismo flujo de importación y eliminación a partir de la solicitud de contexto y de las indicaciones del protocolo en sus archivos de instrucciones.

Qué leer a continuación

• Introducción a los patrones para tener el panorama general.
• Anatomía de un patrón para saber qué contiene un paquete y cómo funciona el control de versiones.
• Cómo funcionan los hooks para ver cómo se entregan las piezas importadas una vez que están en tu espacio de trabajo.