Você corrigiu o arquivo, o kernel continuou rodando o código antigo: agora o execute_code avisa


Você pede ao Hermes para corrigir um bug pequeno: calc_rate() deveria retornar 2 e retorna 1. Ele lê o arquivo, edita o código, roda via execute_code para conferir — e a saída continua 1. Ele lê o arquivo de novo, confirma que a mudança está mesmo lá, e então pede desculpas. Ou pior: “corrige” o código agora correto uma segunda vez, ou desiste e culpa o ambiente.

O que aconteceu de fato é simples. O código estava certo; o 1 vinha de um módulo stale em memória. O kernel da sessão mantém sys.modules vivo entre chamadas, o arquivo mudou em disco e nada avisou. O resultado parecia completamente normal, e é exatamente por isso que o erro era invisível.

O PR #153665, mergeado em 12 de novembro, torna isso visível: o execute_code agora nomeia os módulos que foram editados depois que o kernel os carregou.

Por que isso acontece: o Python importa uma vez

Num script comum não há problema. Cada python script.py é um processo novo, então os imports começam do zero.

O execute_code não é isso. Para deixar uma variável definida numa célula sobreviver para a próxima, ele mantém um processo de kernel vivo e roda as células dentro dele. O custo é que os objetos de módulo em sys.modules também continuam vivos — se o seu import calc_rate aconteceu antes da edição, aquele objeto é a versão antiga para sempre.

Isso gera um tipo de inconsistência especialmente irritante: o arquivo está correto, o read_file mostra o conteúdo correto, o raciocínio do modelo está correto, e só o resultado da execução está stale. Nada na saída distingue o caso, então o modelo tem que adivinhar.

O que mudou: um registro de mtime por célula

O kernel agora faz duas coisas:

  • Depois que cada célula roda, ele registra o mtime da fonte de todo módulo do projeto que a sessão importou.
  • Antes de rodar a célula seguinte, ele compara: qualquer arquivo cujo mtime mudou tem seu nome colocado no warning do resultado.

Módulos da biblioteca padrão e de site-packages / dist-packages são ignorados — você não precisa saber o que um pacote pip fez. A varredura lê o dict de cada módulo e ignora o que não consegue ler, então uma entrada estranha em sys.modules (um módulo lazy, um objeto que não é módulo) nunca faz uma célula falhar. Os nomes vêm do processo da célula, então o host guarda apenas identificadores pontuados simples e os redige do mesmo jeito que redige o stdout.

O resultado fica assim (verbatim; kernels locais colocam em warning, kernels remotos em kernel.warning):

Edited on disk after this kernel imported it: calc_rate. If this cell used it
without reloading, it ran the OLD code. Run importlib.reload(<module>) (and
re-import any names taken from it), or call again with reset=true to start
from fresh imports.

O mesmo prompt nas duas árvores, com nvidia/nemotron-3.5-super-vl no Nous Portal:

Antes Depois
Saída da terceira célula rate 1 rate 1
Resultado da terceira célula sem warning warning nomeando calc_rate e as duas correções
Relato do próprio modelo “printed rate 1 and there was no warning text” “printed rate 1 and warned: edited on disk after this kernel imported it”
Estado do kernel mantido mantido

Essa última linha é a importante: nada é descartado. Variáveis, imports e handles abertos sobrevivem todos. O resultado apenas ganha um campo. Cada edição é nomeada uma vez, e um módulo que foi recarregado ou reimportado depois da edição não é nomeado de novo.

Duas correções, custos diferentes

Opção um: importlib.reload(). Mantenha suas variáveis, recarregue o módulo:

import importlib
import calc_rate

importlib.reload(calc_rate)
calc_rate.rate()   # now runs the new code from disk

Um detalhe que o warning também menciona: from mod import f liga o nome ao objeto antigo, e um reload não muda isso. Ou reimporte, ou sempre chame pelo módulo (mod.f()).

Opção dois: reset=true. Comece um kernel novo com imports limpos. O custo é que toda variável da sessão se vai — se você acabou de gastar dez minutos carregando um DataFrame grande, não faça isso.

Por que não simplesmente reiniciar o kernel a cada mudança de arquivo

Um PR anterior (#127819) fazia exatamente isso: qualquer arquivo .py editado sob a pasta de trabalho reiniciava o kernel inteiro. Grosseiro, mas simples — exceto que jogava fora toda variável e todo dataset carregado, mesmo quando o arquivo editado nunca tinha sido importado.

A abordagem que entrou é mais estreita: o kernel continua vivo, só módulos que o kernel realmente importou são reportados, e a mensagem declara o custo. Os trade-offs aparecem no que ela deliberadamente não cobre, e conhecer esses limites é mais útil do que conhecer a feature:

  • Módulos de extensão compilada (.so, .pyd) e módulos sem um __file__ .py não são observados.
  • Um módulo importado e depois editado dentro da mesma célula não é reportado — o kernel não consegue distinguir essa ordem do usual escrever-e-importar.
  • Uma edição seguida de um reload que falha (um SyntaxError, por exemplo) deixa o código antigo carregado, e nenhuma célula posterior avisa de novo; o traceback fica no resultado daquela célula.
  • A varredura não consegue dizer se a célula realmente usou o módulo, então o texto é condicional (“se esta célula o usou sem recarregar”) em vez de uma afirmação.

O que isso muda no dia a dia

Se o seu loop é “o agente escreve código → roda → vê uma falha → edita → roda de novo”, este warning elimina várias rodadas de adivinhação. Quando você o vê, o movimento certo é um reload ou um reset, não outra olhada na edição.

Dois casos vizinhos que também parecem bugs mas não são: o detector de loop disparando em trabalho legítimo e replays depois de editar e reenviar. A lista completa de argumentos da ferramenta, incluindo reset, está na referência de comandos.

Status de release

O PR #153665 entrou em main em 12 de novembro de 2026, e o título dele diz abertamente que substitui o #127819. A v0.23.1 saiu em 10 de novembro e não o inclui — espere o próximo release ou instale a partir de main. O novo parágrafo “Edited modules” em code-execution.md entrou no mesmo commit.

Atualização (17/11/2026): essas mudanças saíram na v0.23.2 (16 de novembro): um hermes update as traz. O « não está na v0.23.1 » acima é um retrato da data de publicação.