Windsurf

O Windsurf se conecta ao seu espaço de trabalho do Pathrule pelo Pathrule CLI ou pela extensão para VS Code. O Pathrule grava uma entrada de servidor MCP local e um arquivo de regras complementar que o Windsurf lê no início da sessão. O Windsurf não tem hooks, então, diferente do Claude Code, do Codex, do Cursor e do GitHub Copilot, ele não recebe nenhum contexto por hooks: o arquivo de regras traz o protocolo e a visão geral do espaço de trabalho, e as ferramentas MCP entregam todo o resto, com mais profundidade. O Windsurf usa o servidor MCP local; a configuração de Remote MCP não está documentada para o Windsurf.

Esta página explica o que o Pathrule grava no seu projeto para o Windsurf, por que o mesmo conteúdo chega ao Windsurf e a todas as outras ferramentas, e como verificar a integração por conta própria.

O que o Pathrule grava

Ao instalar o Pathrule no Windsurf, você recebe:

• Uma entrada de servidor MCP em ~/.codeium/windsurf/mcp_config.json. Ela aponta o assistente para o servidor MCP local do Pathrule, para que ele possa chamar as ferramentas pathrule_*, e não mexe nos seus outros servidores.
• Um arquivo de instruções complementar, .windsurf/rules/pathrule-protocol.md, mais o .windsurfrules para versões mais antigas do Windsurf. Ele traz a visão geral do espaço de trabalho e o protocolo do Pathrule, o mesmo conteúdo que os outros clientes recebem nos seus próprios formatos nativos.
• Arquivos de conhecimento por caminho. Uma regra .windsurf/rules/pathrule-k-*.md para cada diretório que tem conhecimento associado, com um cabeçalho indicando o diretório ao qual se aplica.
• Skills materializadas em .windsurf/skills/<name>/SKILL.md, para que o Windsurf possa invocá-las pelo nome.

O Windsurf não tem hook do Pathrule, então são esses arquivos que levam o protocolo e o conhecimento até ele no início da sessão. Nos clientes com suporte a hooks, o Pathrule agora entrega o mesmo protocolo pelo hook de início de sessão e mantém só uma nota curta no arquivo de instruções; o Windsurf mantém o arquivo completo porque nada mais o levaria até ele.

O arquivo complementar não é copiado à mão para cada cliente. O Pathrule o gera a partir de um renderizador compartilhado que também produz as instruções do Claude Code, do Cursor e do Codex, então os quatro continuam sincronizados em vez de divergirem com o tempo.

Como o conteúdo chega ao Windsurf

Qualquer ferramenta que fale MCP pode usar o Pathrule por stdio: basta adicionar o comando MCP do Pathrule à configuração do cliente, e o assistente passa a ver o mesmo conjunto de ferramentas. No caso do Windsurf, o Pathrule CLI grava essa configuração e gera o arquivo complementar junto com ela. O arquivo complementar entrega a visão geral do espaço de trabalho e o protocolo no início da sessão; as ferramentas MCP entregam todo o resto, com mais profundidade, sob demanda.

Dois fatos fazem isso funcionar sem divergência entre clientes.

• Um único contrato de ferramentas. As ferramentas MCP (pathrule_get_context, pathrule_read_memory, pathrule_write_memory e as demais) são o mesmo conjunto que o Claude Code e o Cursor chamam. O assistente busca contexto e grava memórias, regras e skills pela mesma interface; a configuração do cliente é a única coisa que muda.
• Uma única fonte de verdade. O arquivo complementar e as skills materializadas são visões geradas, não a cópia canônica. Uma memória gravada pelo CLI, pela extensão para VS Code ou por MCP chega ao Windsurf com o mesmo formato com que chega a qualquer outro cliente.

O Pathrule não envia automaticamente o código-fonte do seu repositório. As ferramentas locais de aprendizado do projeto podem inspecionar os arquivos associados a uma descoberta para validá-la. O que fica armazenado é o conhecimento da sua equipe (memórias, regras, skills), a atividade que os agentes registram, as descobertas que os agentes registram junto com os arquivos em que se baseiam e, em um espaço de trabalho no Cloud, os pares de caminhos de arquivos que o Pathrule lê do histórico recente do git para aprender quais arquivos mudam juntos. Veja o que o Pathrule calcula para saber o que é enviado e armazenado no modo Cloud.

Uma camada de conteúdo, vários formatos de entrega

O formato de instruções que cada cliente lê é diferente, então o Pathrule produz todos os arquivos complementares a partir do mesmo renderizador compartilhado, em vez de copiar um à mão para cada ferramenta. Isso mantém o protocolo do Windsurf idêntico em substância às versões do Claude Code, do Cursor e do Codex, mesmo com formatos de arquivo diferentes.

O investimento fica na camada de conteúdo, não no cliente. As mesmas memórias, regras e skills atendem o Windsurf e todos os outros clientes sem reescrever nada.

Pela extensão para VS Code

O Windsurf é um fork do VS Code. Se você usar a extensão do Pathrule para VS Code dentro do Windsurf, a extensão detecta o host e grava a mesma entrada MCP gerenciada pelo instalador que o CLI usa, sem editar JSON à mão. Essa entrada aponta para o runtime do Pathrule incluído na extensão e nunca contém segredos.

É apenas mais um ponto de entrada para o mesmo espaço de trabalho, não uma integração separada. Veja Pathrule para VS Code para saber o que a extensão faz e MCP local e Remote MCP para as diferenças entre stdio local e Remote MCP.

Isolamento por cliente

O Windsurf convive com o Claude Code, o Cursor e o Codex na mesma máquina. Você pode instalar um cliente, vários ou todos.

• Eles compartilham o mesmo espaço de trabalho do Pathrule, o mesmo servidor MCP e a mesma árvore de conteúdo.
• As configurações que cada cliente lê são independentes. Instalar o Windsurf não afeta os outros.
• Remover um cliente não afeta os demais nem o conteúdo.

A escolha é a que você fizer quando a configuração do Pathrule perguntar quais ferramentas de IA você usa, no pathrule setup ou na extensão para VS Code.

Instalação

Pelo Pathrule CLI:

pathrule setup

Execute o comando na pasta do projeto e escolha Windsurf quando ele perguntar quais ferramentas de IA você usa. O setup faz você entrar no Pathrule Cloud quando necessário, vincula a pasta a um espaço de trabalho, instala a entrada MCP, guarda a sua escolha para esta pasta e grava os arquivos do Windsurf. Para usar o Pathrule sem conta, execute pathrule setup --local.

Para configurar as peças manualmente em uma pasta que já está vinculada:

pathrule install windsurf
pathrule sync
pathrule doctor

pathrule install windsurf adiciona a entrada MCP a ~/.codeium/windsurf/mcp_config.json. pathrule sync gera 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.

Você também pode usar a extensão para VS Code dentro do Windsurf, como descrito acima.

Verificação

Abra o Windsurf em um diretório que você vinculou a um espaço de trabalho. O assistente deve ler o arquivo complementar no início da sessão e conseguir chamar pathrule_get_context para o seu diretório de trabalho.

Envie um prompt que envolva um caminho com conteúdo. O assistente deve trazer esse conteúdo pelas ferramentas MCP. Se não conseguir:

pathrule doctor

O doctor é somente leitura. Ele informa o seu login, o espaço de trabalho e se esta pasta está vinculada, se a entrada MCP do Pathrule está instalada para o Windsurf e para cada um dos outros clientes, e quais arquivos gerenciados pelo Pathrule estão na pasta e quem os gravou. Adicione --json para ver o relatório completo, que também aponta uma entrada MCP que aponta para um runtime que não existe mais. pathrule repair reescreve uma entrada desatualizada, gera de novo os arquivos complementares e executa o doctor outra vez.

O que continua igual

A camada de conteúdo é idêntica em todos os clientes.

• A mesma memória que aparece para o Claude Code pelo hook aparece para o Windsurf pelas ferramentas MCP.
• Uma regra chega ao Windsurf pelo arquivo complementar e por MCP. O Windsurf não tem hooks, então uma regra não consegue bloquear uma edição nele; o bloqueio antes da gravação só está disponível em clientes com hooks de ferramenta: Claude Code, Codex, Cursor e GitHub Copilot.
• Uma skill pode ser invocada pelo nome.
• As ferramentas MCP se comportam da mesma forma.

Se a sua equipe escreve conteúdo para um assistente, todos os assistentes o recebem.

O que ler em seguida

• Cursor, a integração irmã, também um fork do VS Code, com hooks nativos.
• MCP local e Remote MCP, para entender por que o conjunto de ferramentas é o mesmo em todo lugar.
• Pathrule para VS Code, a extensão que pode registrar o Windsurf de dentro do editor.
• Como os hooks funcionam, o modelo de entrega por trás do conteúdo.