GitHub Copilot

O GitHub Copilot se conecta ao seu espaço de trabalho do Pathrule pelo Pathrule CLI ou pela extensão do VS Code. Ele recebe o conhecimento do espaço de trabalho, com escopo definido, por meio de hooks de sessão e de ferramenta, arquivos de instruções e do servidor MCP local. O Copilot não tem hook de envio de prompt, então o contexto chega no início da sessão e em torno das chamadas de ferramenta, e não a cada prompt. A configuração de Remote MCP não está documentada para o Copilot. O Copilot é um caso à parte porque um único conjunto de arquivos no nível do repositório alimenta três superfícies ao mesmo tempo: o modo agente do VS Code, o Copilot CLI e o agente de programação.

Esta página explica o que o Pathrule grava para o Copilot, como as superfícies diferem entre si, como os eventos de hook se correspondem e como verificar a integração.

O que o Pathrule grava

Quando você ativa o Copilot, o Pathrule grava nos caminhos do próprio Copilot em vez de inventar novos. Todos os arquivos ficam em .github/, que é onde o Copilot já procura.

Quando o hook do Copilot está instalado, o protocolo vai pelo hook sessionStart em vez do arquivo de instruções e o conhecimento dos caminhos chega pelos hooks, então nenhum arquivo de conhecimento é gravado na sua árvore. Sem o hook, o Pathrule também grava um arquivo .github/instructions/pathrule-k-*.instructions.md com escopo por applyTo para cada diretório que tem conhecimento associado.

As skills têm um detalhe. O Copilot também lê .claude/skills. Se você tiver o Claude Code e o Copilot ativados no mesmo espaço de trabalho, o Pathrule pula .github/skills para que o Copilot não veja cada skill duas vezes. Ativar os dois clientes não gera skills duplicadas nem protocolo duplicado no contexto do Copilot.

Você pode conferir o que foi gravado:

cat .github/copilot-instructions.md
cat .github/hooks/pathrule.json

Três superfícies, um conjunto de arquivos

Os mesmos arquivos em .github/ ativam cada superfície do Copilot, mas as superfícies diferem na forma como os hooks e o MCP chegam até elas.

No VS Code, a chave raiz da configuração do MCP é servers, e não mcpServers. Se você usa a extensão do Pathrule para VS Code, o modo agente do Copilot é registrado para você no editor, sem nenhum arquivo de MCP para editar à mão.

O agente de programação é a única superfície que o Pathrule não consegue configurar a partir do disco. Ele trabalha com o que está commitado no repositório, e os servidores MCP dele são definidos nas configurações do repositório no github.com, fora de qualquer arquivo que o Pathrule gerencia, por isso o Pathrule não configura o MCP para ele. Para que ele receba as instruções e as skills, faça commit dos arquivos em .github/. Se o seu espaço de trabalho tiver um .gitignore, as skills materializadas aparecem listadas em uma seção do Pathrule nesse arquivo; apague essas linhas para commitá-las. A configuração de hooks executa o hook do Pathrule instalado na máquina que a gravou, então o contexto no momento do hook e o bloqueio valem onde o Pathrule está instalado: no modo agente do VS Code e no Copilot CLI.

Cobertura de eventos de hook

Os eventos de hook do Copilot correspondem aos mesmos pontos de injeção que o Pathrule usa no Cursor e no Claude Code.

• sessionStart. Quando uma sessão começa. O Pathrule retorna os metadados do espaço de trabalho, o protocolo e o contexto da sua equipe, o mesmo contexto inicial que o Claude Code recebe no início da sessão.
• postToolUse. Depois que uma ferramenta termina. O Pathrule entrega o contexto vinculado ao caminho que o agente acabou de mexer e registra a atividade.
• preToolUse. Antes de uma ferramenta rodar. É aqui que uma regra com um padrão de bloqueio aprovado nega uma edição correspondente antes que a mudança seja aplicada, informando como motivo a regra e a correção aprovada. No modo agente do VS Code, esse evento também pode levar o contexto vinculado ao caminho; o Copilot CLI só recebe contexto em sessionStart e postToolUse.
• agentStop, subagentStop e sessionEnd. Encerram o turno e a sessão.

O evento por prompt não é conectado, de propósito. A saída do Copilot para esse evento não leva contexto adicional, então tratá-lo gastaria um processo por prompt sem nenhuma injeção. SessionStart mais PostToolUse cobrem o mesmo terreno. O resultado é paridade com o perfil de injeção do Cursor.

Um único script de hook compartilhado atende todos os clientes. Ele detecta o formato do payload do Copilot, normaliza esse payload para uma forma canônica, executa a mesma seleção de regras e memórias usada para todos os outros clientes e depois responde no schema do Copilot. Você não configura nada disso por superfície. O script falha de forma aberta, por design: um payload não reconhecido ou malformado não retorna nada, em vez de quebrar sua sessão do Copilot.

Instalação

Pela Pathrule CLI:

pathrule setup

Execute o comando na pasta do projeto e escolha GitHub Copilot quando ele perguntar quais ferramentas de IA você usa. O setup faz você entrar no Pathrule Cloud quando necessário, associa a pasta a um espaço de trabalho, instala as entradas de MCP, guarda sua escolha para esta pasta e grava os arquivos em .github/. Se preferir usar o Pathrule sem conta, execute pathrule setup --local.

Para configurar as partes manualmente em uma pasta que já está associada:

pathrule install copilot
pathrule sync
pathrule doctor

pathrule install copilot grava o servidor do Pathrule nas duas configurações de MCP, ~/.copilot/mcp-config.json para o Copilot CLI e o mcp.json de usuário do VS Code, e não mexe em nenhum outro servidor nesses arquivos. pathrule sync grava os arquivos do projeto para as ferramentas de IA escolhidas para esta pasta ou, se nenhuma foi escolhida, para as que ele detectar na pasta.

Pela extensão do Pathrule para VS Code, escolha GitHub Copilot em Connect AI Clients. A extensão registra o modo agente do Copilot no editor e grava os arquivos de instruções e a configuração de hooks para você.

Verificação

Abra um espaço de trabalho que você associou ao Pathrule e inicie uma sessão do Copilot na superfície que você usa.

• Modo agente do VS Code ou Copilot CLI. Inicie um novo chat. O contexto vinculado ao caminho deve chegar antes da primeira chamada de ferramenta. Edite um arquivo em um caminho com conhecimento associado e veja as regras e memórias relevantes aparecerem.
• Agente de programação. Depois que os arquivos em .github/ forem commitados, o agente de programação lê as instruções e as skills do repositório. Adicione um servidor MCP nas configurações do repositório no github.com se quiser que ele chame ferramentas.

Se a integração não der sinal de vida:

pathrule doctor

O doctor é somente leitura. Ele informa seu login, o espaço de trabalho e se esta pasta está associada, lista o Copilot duas vezes, uma para a configuração do Copilot CLI e outra para o mcp.json do VS Code, para que uma instalação pela metade fique visível, e mostra quais arquivos gerenciados pelo Pathrule estão na pasta e quem os gravou. Adicione --json para ver o relatório completo, que indica cada caminho de configuração e também aponta uma entrada de MCP que aponta para um runtime que não existe mais. Para corrigir isso, execute:

pathrule repair

O repair reescreve entradas de MCP do Pathrule desatualizadas, não mexe nos seus outros servidores, sincroniza de novo os arquivos do projeto e executa o doctor outra vez. pathrule uninstall copilot remove a entrada do Pathrule das duas configurações de MCP, e desativar o Copilot para a pasta remove todos os arquivos que o Pathrule mantém para ele.

O que continua igual

Tudo o que você escreve no Pathrule chega ao Copilot no mesmo formato em que chega ao Claude Code e ao Cursor.

• Uma memória escrita com o CLI, com a extensão do VS Code ou pelo MCP aparece no Copilot.
• Uma regra com um padrão de bloqueio aprovado bloqueia uma edição correspondente no Copilot.
• Uma skill pode ser invocada pelo nome no Copilot.
• As ferramentas MCP (pathrule_get_context, pathrule_write_memory e as demais) se comportam da mesma forma.

Você escreve o conhecimento uma vez e todos os agentes compatíveis o leem.

O que ler em seguida

• Cursor, para a integração de hooks equivalente.
• MCP local e Remote MCP, para entender por que a mesma superfície de ferramentas chega a todos os clientes.
• Como os hooks funcionam, para o modelo de entrega por trás de tudo.
• Pathrule para VS Code, para o registro do modo agente do Copilot dentro do editor.