Qwen Validation Debugger estrutura de aplicação do prompt

chunk_id
doc_version
source_url
source_file
source_sha256
doc_type
symbol
section_path
heading
content
code_blocks
language_tags
godot_version_tags
api_symbols
token_count
metadata

mapping_id
source_api
target_api
change_type
godot_from
godot_to
confidence
evidence_chunk_ids
match_terms
notes
negative_patterns

prototype_id
label
task_type
input_pattern
expected_finding
recommended_action
evidence_mapping_ids
evidence_chunk_ids
severity
validator_rules

Você é um classificador de itens de teste de código Godot.

Determine se o TEST_ITEM abaixo pode ser testado com a mesma sintaxe/código chunk em Godot 3 e Godot 4, ou se códigos separados para Godot 3 e Godot 4 devem ser criados.

Critérios de julgamento:
- Se for um item que pode ser explicado naturalmente em ambos Godot 3 e 4 usando a mesma sintaxe GDScript e chamadas de API, é **"common"**.
- Se nomes de classes, funções, assinaturas, nomes de nós, modo de chamada ou outras APIs/sintaxes mudam significativamente entre versões, é **"separate"**.
- Em caso de dúvida, escolha **"separate"**. É melhor criar mais testes seguros.
- A resposta deve conter apenas um objeto JSON.

Formato JSON:
{
  "syntax_scope": "common ou separate",
  "label": "rótulo curto em coreano",
  "reason": "por que você chegou a essa conclusão, uma ou duas frases",
  "godot3_focus": "pontos a observar ao gerar código para Godot 3",
  "godot4_focus": "pontos a observar ao gerar código para Godot 4"
}

TEST_ITEM:
${itemTitle}

Você é um gerador de trechos de código de teste para Godot.

${versionInstruction}

Requisitos:
- Não escreva todo o projeto, mas sim em nível de função ou pequenos blocos de código.
- Escreva apenas o código diretamente relacionado ao item de teste.
- O código deve expor a API/sintaxe necessária para determinar a versão.
- A resposta deve conter exatamente um objeto JSON.
- Não use fences de código Markdown.

Formato JSON:
{
  "godot_version": "${targetVersion}",
  "syntax_scope": "${syntaxScope}",
  "source_code": "GDScript código chunk",
  "notes": "Pontos principais a serem verificados no código"
}

TEST_ITEM:
${itemTitle}

Você é um gerador JSONL para teste de RAG no Godot.

Objetivo:
${slotCase.goal}

Tabela alvo:
${table.label}

Uso da tabela:
${table.purpose}

Lista de campos:
${table.schema.map((field) => `- ${field}`).join('\n')}

Campos importantes para julgamento de correspondência direta:
${table.directFields.map((field) => `- ${field}`).join('\n')}

Regras de geração:
- A resposta deve conter exatamente um objeto JSON.
- Não use fences de código Markdown.
- ${slotCase.generationRule}
- docs_chunks são correspondências de base explicativa, e api_mapping e label_prototypes são correspondências de base de migração de origem.
- Código já aplicado na forma de destino do Godot 4 ou código de sintaxe comum não são bases de “necessita conversão” em api_mapping/label_prototypes.
- negative_patterns e reject_when_seen_in_code são condições de rejeição. As strings inseridas nesses campos devem ser interpretadas como bases “não” e não como bases “sim”.
- Não se limite a palavras‑chave amplas; faça a distinção entre relacionado e não relacionado com base em strings reais/chamadas de API.
- Não adicione campos arbitrariamente que estejam fora do uso da tabela.
- Os valores de source_url, source_file, *_id devem ser criados de forma natural para fins de teste.

ITEM_DE_TESTE:
${itemTitle}

VERSÃO_DO_CÓDIGO:
${versionLabel}

${isMigrationPair ? `CÓDIGO_FONTE_GODOT3:
${sourceCode}

CÓDIGO_ALVO_GODOT4:
${targetCode}` : `CÓDIGO_FONTE:
${sourceCode}`}

- nos docs_chunks, “sim” só é permitido quando o JSONL descreve diretamente a ação central do SOURCE_CODE.  
- A ação central não é apenas o nome simples da API, mas inclui o que o código calcula, em que alvo ele se aplica e, finalmente, qual estado/resultado ele produz.  
- Mesmo que a mesma API ou método apareça, se o JSONL explicar um propósito diferente, um objeto alvo diferente ou um resultado diferente, ele será apenas um candidato de busca, não uma evidência direta, portanto “não”.  
- Se o JSONL fornecer apenas uma descrição geral da mesma API sem detalhar os recursos específicos, ramificações, loops ou mudanças de estado do SOURCE_CODE, não será uma evidência direta, portanto “não”.  
- Se o SOURCE_CODE envolver execução em loop, execução única, transição de estado ou troca de recurso e o fluxo descrito no JSONL for diferente, “não”.  
- Funções que aparecem juntas no mesmo arquivo ou fluxo de jogo podem ser candidatos de busca entre si. Mesmo assim, só será “sim” quando o objetivo final, o alvo e o resultado do SOURCE_CODE coincidirem com os descritos no JSONL.  
- Mesmo que api_symbols ou headings contenham nomes de chamadas presentes no SOURCE_CODE, se content/code_blocks descrevem um fluxo de trabalho diferente, não são evidências diretas.  
- Evidências que consistem apenas em pistas recorrentes em vários códigos, como funções de ciclo de vida, tipos comuns ou nomes de propriedades genéricas, não são evidências diretas.  
- Se os code_blocks do JSONL descrevem um exemplo de código diferente do SOURCE_CODE, mesmo que algumas APIs coincidam, “não”.  
- Não inferir que APIs de significado semelhante ou casos de uso parecidos são equivalentes com base no seu conhecimento. O JSONL deve expor diretamente o objetivo/alvo/resultado do SOURCE_CODE atual.  
- Quando JSONL_GENERATED_FROM_CODE_VERSION e VERIFY_TARGET_CODE_VERSION forem diferentes, primeiro verifique se o JSONL descreve o comportamento do código da versão que está sendo verificada.  
- Mesmo com versões diferentes, pode ser “sim” se houver uma explicação explícita de APIs/comportamentos comuns; porém, se os code_blocks/api_symbols do JSONL não corresponderem à sintaxe real ou chamadas de API do SOURCE_CODE atual, será “não”, mesmo que pareçam a mesma funcionalidade.

- As perguntas sobre **api_mapping** e **label_prototypes** não são “Será que JSONL e código têm alguma relação?” mas sim “Com base neste JSONL, devemos alterar o **SOURCE_CODE** agora?”.
- Primeiro, determine em qual das categorias o **SOURCE_CODE** atual se encaixa, considerando o JSONL: código antes da mudança, código já alterado, código irrelevante ou código que não precisa ser convertido.
- Responda **“sim”** apenas quando o **SOURCE_CODE** atual for código antes da mudança e a conversão indicada pelo JSONL precisar ser aplicada agora.
- O JSONL de integração 3→4 foi criado a partir da comparação entre o código antes da mudança do Godot 3 e o código depois da mudança do Godot 4. Na verificação, separe se o **SOURCE_CODE** atual corresponde ao código antes ou ao código depois da mudança.
- Se o **SOURCE_CODE** já estiver no formato alvo do Godot 4, mesmo que o JSONL pareça relacionado à migração, considere‑o “já aplicado” e responda **“não”**.
- O julgamento de “necessidade de conversão” em **label_prototypes** só deve ser **“sim”** quando o **SOURCE_CODE** atual ainda contiver o padrão de uso, a composição de argumentos e o padrão de chamada anteriores.
- Um JSONL de conversão irrelevante recebe resposta **“não”** se, mesmo que o alvo da verificação seja código Godot 3, a conversão não for aplicável ao **SOURCE_CODE** atual.
- Conteúdos nas categorias `source/before/required` servem como evidência de código antes da mudança; conteúdos em `target/after/recommended` representam a forma após a mudança; conteúdos em `negative/reject` indicam condições nas quais a conversão **não** deve ser aplicada.
- Mesmo que o nome da função seja o mesmo, a resposta será **“sim”** somente se o **SOURCE_CODE** ainda mantiver o padrão anterior descrito no JSONL (por exemplo, argumentos de chamada, tratamento de retorno, nó herdado, estrutura de código ao redor etc.).
- `source_api` e `target_api` podem compartilhar o mesmo nome ou conter termos de correspondência (`match_terms`) tanto para fonte quanto para alvo. Nesse caso, apenas a coincidência de um nome de função ou de termos amplos **não** basta para responder **“sim”**.
- Funcionalidades que aparecem no mesmo arquivo ou no mesmo fluxo de jogo podem ser candidatos de busca entre si, mas se o padrão anterior não estiver presente no **SOURCE_CODE** atual, a resposta será **“não”**.
- Se `JSONL_GENERATED_FROM_CODE_VERSION` e `VERIFY_TARGET_CODE_VERSION` forem diferentes, primeiro identifique se o **SOURCE_CODE** atual corresponde ao código antes da mudança ou já ao código depois da mudança descrito no JSONL.
- Quando `JSONL_GENERATED_FROM_CODE_VERSION` representa um slot de versão única (não uma migração), responda **“sim”** apenas se o padrão `source/before/required` estiver presente no código que está sendo verificado.
- Se o **SOURCE_CODE** atual já estiver no formato `target/after/recommended` do JSONL ou for ainda mais recente, considere‑o “já aplicado” e responda **“não”**.
- Quando a versão alvo da verificação for Godot 4 ou “common” e o **SOURCE_CODE** já estiver no formato `target/after`, mesmo que o JSONL contenha conhecimento de migração correto, a resposta deve ser **“não”**.
- Se `change_type` for `signature_stable`, `no_change`, `common` ou outro que indique que nenhuma alteração é necessária, responda **“não”**.
- Mesmo que um JSONL de migração esteja anexado a código Godot 4 ou a código com sintaxe comum, se nenhuma transformação adicional for necessária, a resposta deve ser **“não”**.

- Antes da avaliação, capture a ação principal do SOURCE_CODE em uma frase, capture também o principal fundamento descrito pelo JSONL em uma frase e compare os dois.  
- Considere como evidência direta apenas quando o objeto alvo, o propósito da chamada, o fluxo de entrada/parâmetro e o resultado final estiverem na mesma direção.  
- Mesmo que pareça um candidato de busca semelhante, se não explicar o SOURCE_CODE atual ou não servir como base para aplicá‑lo ao SOURCE_CODE atual, é “não”.

Você é um avaliador de correspondência de evidências JSONL.

${question}

Tabela:
${table.label}

Uso da tabela:
${table.purpose}

Critérios de avaliação:
- ${firstRule}
- Campos JSONL a serem revisados: ${table.directFields.join(', ')}
- ${tableRules.join('\n- ')}
- ${decisionRules.join('\n- ')}
- Se apenas palavras amplas como Godot, Godot3, Godot4, migration, 2D, physics coincidirem, não há relação.
- Conteúdos mencionados negativamente no JSONL, como "does not describe", "not related", "unrelated", "does not apply", não são reconhecidos como evidência relevante.
- Se o JSONL tratar de outra API, outro nó ou outro sistema, a resposta é "não".
- Não use o conhecimento de Godot que você possui; utilize apenas as evidências de texto presentes no JSONL.
- A resposta deve ser apenas "sim" ou "não".

JSONL_GENERATED_FROM_CODE_VERSION:
${sourceVersionKey}

VERIFY_TARGET_CODE_VERSION:
${targetVersionKey}

SOURCE_CODE:
${sourceCode}

JSONL:
${jsonlText}

Você é um gerador de JSONL para teste Godot RAG.

Objetivo: ${slotCase.goal}
Tabela alvo: ${table.label}
Uso da tabela: ${table.purpose}
Campos de correspondência direta: ${table.directFields.join(', ')}

TEST_ITEM: ${itemTitle}
CODE_VERSION: ${versionLabel}

${isMigrationPair ? `GODOT3_SOURCE_CODE:
${sourceCode || '(Código gerado automaticamente após criação do Godot 3)'}

GODOT4_TARGET_CODE:
${targetCode || '(Código gerado automaticamente após criação do Godot 4)'}` : `SOURCE_CODE:
${sourceCode || '(Código gerado automaticamente após criação)'}`}