Importando um padrão

Você pode adotar qualquer padrão de duas formas. Pode colar o token dele em qualquer assistente de IA conectado, o que deixa o Pathrule gravar os itens nos caminhos certos para você, ou copiar o pacote manualmente do catálogo.

O token de referência

Todo padrão tem um token de referência no formato:

::pathrule:package:<slug>

Por exemplo, o padrão do Next.js App Router é ::pathrule:package:nextjs-app-router. O token aparece em cada página do catálogo, pronto para copiar.

O prefixo ::pathrule: é um namespace reservado. Ele é verificado antes do caminho de invocação ::skill-name, então um token de padrão nunca é confundido com uma skill e nunca dispara a descoberta de skills. Essa separação vale tanto no hook de prompt quanto na requisição de contexto.

Cole o token como texto simples. Assim como acontece com a invocação de uma skill, um token entre crases ou dentro de um bloco de código é tratado como código citado e ignorado. Você pode colocar vários tokens em um mesmo prompt; cada padrão é processado uma única vez.

Importando por token

Para adicionar um padrão, cole o token dele em um prompt dentro de um espaço de trabalho conectado. A partir daí, o Pathrule cuida do resto:

1. Ele reconhece o token. Quando o Pathrule monta o contexto do seu prompt, ele detecta o marcador ::pathrule:package:<slug> e apresenta uma diretiva de importação para esse slug.
2. Ele mostra uma prévia antes de gravar. Um dry run resolve o padrão e retorna a versão, o problema que ele resolve, os itens e os caminhos que pretende usar, sem alterar nada ainda. Essa prévia também informa os caminhos, as stacks e as dependências declarados pelo padrão, para que o assistente possa alinhar o padrão ao seu projeto real.
3. Ele escolhe caminhos que correspondem à sua árvore. Um padrão declara caminhos sugeridos, mas cada repositório é diferente. O assistente escolhe uma base que corresponde à sua estrutura e reposiciona os caminhos do padrão abaixo dela, para que os itens fiquem onde realmente devem ficar. Em um monorepo, as regras de /app de um padrão Next.js podem ir para /apps/web/app.
4. Ele confirma quando há divergência. Se o padrão é voltado para uma stack que o seu projeto aparentemente não usa, por exemplo um padrão de React Native em um projeto sem Expo, o assistente para e pergunta se e onde você quer adicioná-lo, em vez de importar às cegas.
5. Ele grava o pacote. Com a confirmação, cada item é criado pelo fluxo normal de gravação: uma memória vira uma memória, uma regra vira uma regra com seu tipo de escopo e sua prioridade, e uma skill vira uma skill invocável marcada com o padrão de onde veio. Os nós que faltarem em cada caminho são criados conforme a necessidade.

Em seguida, o assistente apresenta um resumo de uma linha, por exemplo quantas regras, memórias e skills foram importadas, quantas já existiam e quantas falharam.

Depois da importação, os itens são conteúdo comum do espaço de trabalho. Eles aparecem pelos mesmos hooks e pela mesma recuperação que qualquer coisa que você mesmo escreveu, e você os edita da mesma forma. Uma regra importada chega como consultiva: ela acompanha o contexto e não bloqueia uma edição, a menos que uma pessoa aprove uma restrição executável para ela (veja Regras como guardrails).

A importação grava em seu nome. Cada item passa pela mesma verificação de acesso que qualquer outra gravação, então, em uma equipe, você precisa de permissão de escrita no espaço de trabalho de destino: um Viewer não consegue importar. Veja Funções e permissões.

Importando por cópia manual

Você não precisa do token para usar um padrão. Cada página do catálogo tem uma ação "Manual copy (full bundle)" que copia o pacote completo como Markdown simples, com cada item identificado pelo tipo e pelo caminho de destino, e cada regra identificada com seu escopo e sua prioridade. Cole isso no seu assistente, ou nas suas próprias anotações, e recrie os itens onde quiser. Isso funciona sem nenhuma configuração e sem conta.

Todo padrão também está disponível como Markdown bruto em /patterns/<slug>/raw, o que é prático quando você quer que um assistente leia o pacote inteiro a partir de um link.

Ponto de partida, não assinatura

Importar um padrão é um ponto de partida único. A cópia no seu espaço de trabalho passa a ser sua a partir desse momento; ela não fica vinculada ao catálogo e não vai mudar por baixo de você. O Pathrule não registra qual versão você importou e não avisa quando uma versão mais nova é publicada, então nada jamais é sincronizado por cima de conteúdo que você já adaptou.

Para saber se um padrão mudou desde que você o importou, compare a versão e a data de atualização na página do catálogo e leia o changelog no pacote aberto. Reimportar não traz as mudanças, porque todo item cujo título já existe é pulado. Para adotar uma versão mais nova, remova o pacote e importe de novo, sabendo que isso substitui as suas edições nos itens importados. Se você só quer um item melhorado, copie-o manualmente da página do catálogo.

Reimportando e removendo

• Reimportar nunca duplica. Rodar a mesma importação de novo pula todo item cujo título já existe e informa o que foi adicionado e o que já estava lá. Uma memória conta como existente quando há uma memória com o mesmo título no caminho dela; uma regra ou uma skill conta como existente quando há uma com o mesmo nome em qualquer lugar do espaço de trabalho. Os itens pulados ficam exatamente como estão, com as edições. Um item que você renomeou depois da importação deixa de ser reconhecido, então uma reimportação o adiciona de novo.
• Remover é um passo só. A definição de um padrão é o seu próprio manifesto de títulos e caminhos, então você pode pedir ao assistente que remova o padrão e uma única chamada desfaz o pacote inteiro. Se você importou sob um caminho base, informe a mesma base ao remover; itens que não forem encontrados ali são reportados como não encontrados em vez de tratados como erros.

O que a remoção atinge

A remoção encontra cada item pelo título no seu caminho, e não lembrando o que a importação criou. Isso tem três consequências que vale conhecer antes de executá-la:

• Itens editados também são removidos. Uma memória, regra ou skill importada que você editou depois é removida junto com as suas edições, desde que o título e o caminho não tenham mudado.
• Um item seu com o mesmo título é removido. Se você mesmo escreveu uma memória, regra ou skill com o mesmo título de um dos itens do padrão, no mesmo caminho, a remoção também a exclui. Os títulos são comparados sem diferenciar maiúsculas e minúsculas.
• Itens renomeados ou movidos permanecem. Renomear um item ou movê-lo para outro caminho o tira do alcance da remoção, e essa é a forma de manter um item enquanto remove o resto.

Os itens removidos são arquivados, não apagados. Em um espaço de trabalho do Cloud, eles ficam no arquivo do espaço de trabalho até serem excluídos permanentemente, e um proprietário ou administrador pode restaurá-los nas configurações do console web, em Workspace, Archive.

Onde funciona

A importação e a remoção por token usam as ferramentas MCP locais via stdio, inclusive quando esse runtime está conectado a um espaço de trabalho do Cloud. O Remote MCP não expõe esses auxiliares. Um cliente remoto pode ler o pacote bruto e criar as entradas escolhidas com as ferramentas de conhecimento que tiver disponíveis.

A importação se comporta da mesma forma no Claude Code, Codex, Cursor, Windsurf e GitHub Copilot conectados pelo Pathrule CLI ou pela extensão do VS Code. A importação e a remoção funcionam da mesma forma em um espaço de trabalho local e em um espaço de trabalho do Pathrule Cloud. No Claude Code e no Codex, o hook de prompt identifica o token antes de o agente agir. Cursor, GitHub Copilot e Windsurf não têm hook de prompt, então, nesses casos, o assistente aprende o mesmo fluxo de importação e remoção pela requisição de contexto e pelas orientações de protocolo nos seus arquivos de instruções.

O que ler em seguida

• Visão geral dos padrões para ter o panorama completo.
• Anatomia de um padrão para saber o que há dentro de um pacote e como funciona o versionamento.
• Como os hooks funcionam para entender como os itens importados são entregues depois que estão no seu espaço de trabalho.