Mnemoclaw/immune

Sistema Imune v5.1 — Cheatsheet Híbrido + Imune

Você opera um sistema adaptativo híbrido com duas memórias complementares:

• Cheatsheet (padrões positivos): estratégias específicas de domínio injetadas ANTES da geração para melhorar a qualidade da saída
• Imune (padrões negativos): anticorpos que detectam erros conhecidos e descobrem novas ameaças APÓS a geração

Ambas as memórias usam a classificação Quente/Frio para manter o contexto enxuto. Todo acesso a dados passa pela CLI adaptadora (node ~/.claude/skills/immune/immune-adapter.js).

Análise da Entrada

O usuário invoca com conteúdo para escanear. Analise estes parâmetros:

• input: O texto/código/conteúdo a ser escaneado (obrigatório — inline ou do contexto)
• domain: Um dos: fitness, code, writing, research, strategy, webdesign, _global (padrão: detecção automática)
• domains: Array de domínios (substitui domínio único). Exemplo: domains=fitness,code
• constraints: Quaisquer requisitos específicos que a saída deve satisfazer (opcional)
• mode: full (cheatsheet + varredura, padrão) | scan-only (ignorar cheatsheet) | cheatsheet-only (retornar apenas cheatsheet, sem varredura)

Se nenhum texto inline for fornecido, escaneie a última saída substancial na conversa.

Detecção automática de domínio: Leia ~/.claude/skills/immune/config.yaml e compare o conteúdo com domain_keywords. Se nenhuma correspondência forte for encontrada, use ["_global"]. Se for fornecida uma string domain única, envolva em array: domains = [domain].

Execução

Passo -1 — Busca de Contexto (consciência de sessões passadas)

Busque sessões passadas relevantes para informar a varredura atual:

node ~/.claude/skills/immune/immune-adapter.js get-context --query "{palavras-chave da tarefa ou domínio}" --days 90 --limit 5

Se resultados forem encontrados, anote padrões recorrentes ou problemas passados para o domínio. Isso enriquece a varredura com consciência histórica — o scanner saberá se conteúdo similar foi sinalizado antes.

Log: [IMMUNE] Contexto: {contagem} sessões passadas relevantes encontradas

Passo 0 — Injeção de Cheatsheet (padrões positivos)

Pule este passo se mode == "scan-only".

0a. Carregar estratégias QUENTES via adaptador:

Execute:

node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier hot --limit 15

Analise a saída JSON. O adaptador retorna estratégias pré-filtradas por domínio, classificadas como QUENTES, ordenadas por eficácia decrescente e limitadas a 15.

0b. Carregar resumo das estratégias FRIAS:

Execute:

node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier cold

Extraia uma palavra-chave curta do campo pattern de cada estratégia FRIA. Junte como lista separada por vírgulas.

0c. Construir bloco de cheatsheet: Formate as estratégias QUENTES como XML:

<cheatsheet domain="{domains}">
  <strategy id="{id}" effectiveness="{effectiveness}">
    {pattern}
    Exemplo: {example}
  </strategy>
  ...
</cheatsheet>

Se houver estratégias FRIAS, adicione uma linha única:

<cheatsheet_cold>Considere também: {palavras-chave dos padrões FRIOS separadas por vírgulas}</cheatsheet_cold>

Se mode == "cheatsheet-only", produza o bloco de cheatsheet e pare aqui.

Log:

[IMMUNE] Cheatsheet: {n_quentes} QUENTES + {n_frias} FRIAS estratégias (domínios: {domains})

0d. Apresentar cheatsheet ao usuário: Se executado de forma independente (/immune), mostre o cheatsheet como contexto que o usuário deve aplicar à sua próxima geração. Se chamado pela Chimera, retorne o bloco XML para injeção em prompts PRISM.

Passo 1 — Carregar e Classificar Anticorpos (Quente/Frio)

1a. Carregar anticorpos QUENTES via adaptador:

Execute:

node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier hot --limit 15

O adaptador retorna anticorpos pré-filtrados por domínio, classificados como QUENTES (severidade=crítica OU seen_count>=3 OU last_seen<30d), ordenados por severidade e depois seen_count, limitados a 15.

1b. Carregar resumo dos anticorpos FRIOS:

Execute:

node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier cold

Para cada anticorpo FRIO, extraia uma palavra-chave curta do campo pattern. Junte como lista separada por vírgulas.

Log:

[IMMUNE] Divisão de camadas: {n_quentes} QUENTES + {n_frias} FRIAS / {n_quentes + n_frias} total (domínios: {domains})

Passo 2 — Varredura

Crie o agente immune-scan (Haiku) com o seguinte prompt estruturado em XML:

<scan_request>
  <domains>{domínios_detectados como array JSON}</domains>
  <task>{descrição da tarefa ou "Escaneie o seguinte conteúdo para erros e ameaças"}</task>
  <constraints>{restrições ou "nenhuma"}</constraints>

  <content>
{o texto/código/conteúdo de entrada para escanear}
  </content>

  <hot_antibodies>
{array JSON dos anticorpos QUENTES — objetos completos com id, domains, pattern, severity, correction}
  </hot_antibodies>

  <cold_summary>
Padrões dormentes (não detalhados, apenas para conscientização): {palavras-chave FRIAS separadas por vírgulas}
  </cold_summary>

  <cheatsheet_applied>
{lista de IDs de estratégias e padrões que foram injetados no Passo 0, ou "nenhum" se modo scan-only}
  </cheatsheet_applied>
</scan_request>

Log: [IMMUNE] Escaneando... ({n_quentes} anticorpos ativos) Aguarde o resultado.

Se correções foram aplicadas: Log: [IMMUNE] Correspondência {antibody_id}: {original} → {corrigido} Se novas ameaças detectadas: Log: [IMMUNE] Nova ameaça: {pattern} Se novas estratégias detectadas: Log: [IMMUNE] Nova estratégia: {pattern}

Passo 3 — Atualizar Memória Imune (com deduplicação Fria)

3a. Anticorpos QUENTES correspondidos: Para cada anticorpo correspondido pelo scanner, atualize via adaptador:

node ~/.claude/skills/immune/immune-adapter.js update-antibody --id {antibody_id} --increment_seen true --last_seen {hoje}

3b. Novas ameaças — deduplicar via pontuação de similaridade: Para cada nova ameaça em new_threats_detected:

1. Verifique duplicata usando similaridade multi-critério (Jaccard + substring + domínio):

node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type antibody

Retorna { duplicate: true/false, best_match: { id, score, pattern }, threshold: 0.7 }

2. Se duplicata for verdadeira (score >= 0.7, mesmo domínio + padrão similar) → REATIVAR:
   • Atualize o anticorpo correspondido: update-antibody --id {matched_id} --increment_seen true --last_seen {hoje}
   • Log: [IMMUNE] Anticorpo FRIO reativado {id}: {pattern}
   • NÃO crie um novo anticorpo (previne duplicatas)
3. Se não houver correspondência E auto_add_threats for verdadeiro → CRIAR novo anticorpo:

node ~/.claude/skills/immune/immune-adapter.js add-antibody --json '{"id":"AB-{próximo_número}","domains":{domains},"pattern":"{pattern}","severity":"{severity}","correction":"{correction}","seen_count":1,"first_seen":"{hoje}","last_seen":"{hoje}"}'

• Log: [IMMUNE] + Novo anticorpo {id}: {pattern}

3c. Obter estatísticas atualizadas:

node ~/.claude/skills/immune/immune-adapter.js stats

Log: [IMMUNE] Memória: {total} anticorpos ({n_quentes} quentes, {n_frias} frias) | +{novos} adicionados | Reativados: {reativados}

Passo 3b — Atualizar Memória Cheatsheet (padrões positivos)

Pule se mode == "scan-only" ou se não houver new_strategies_detected no resultado da varredura.

3b-i. Deduplicar via pontuação de similaridade: Para cada nova estratégia em new_strategies_detected:

1. Verifique duplicata usando similaridade multi-critério:

node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type strategy

2. Se duplicata for verdadeira (score >= 0.7, domínios sobrepostos + padrão similar) → REFORÇAR:
   • Calcule nova eficácia: new_eff = old_eff * 0.8 + reported_eff * 0.2 (média móvel exponencial)
   • Atualize: update-strategy --id {matched_id} --increment_seen true --last_seen {hoje} --effectiveness {new_eff}
   • Log: [IMMUNE] Estratégia reforçada {id}: {pattern} (eff: {antiga}→{nova})
3. Se não houver correspondência E auto_add_strategies for verdadeiro → CRIAR nova estratégia:

node ~/.claude/skills/immune/immune-adapter.js add-strategy --json '{"id":"{prefixo}-{próximo_número}","domains":{domains},"pattern":"{pattern}","example":"{example}","effectiveness":{eff},"seen_count":1,"first_seen":"{hoje}","last_seen":"{hoje}"}'

• Log: [IMMUNE] + Nova estratégia {id}: {pattern}

3b-ii. Podar baixa eficácia: Se alguma estratégia tiver effectiveness < 0.2 E seen_count >= 5, anote para revisão manual.

Log: [IMMUNE] Cheatsheet: {total} estratégias | +{novas} adicionadas | Reforçadas: {reforçadas}

Passo 4 — Pontuação

Calcule a pontuação universal via adaptador:

node ~/.claude/skills/immune/immune-adapter.js score --domains '{domains_json}' --severities '[{"severity":"critical","count":N},{"severity":"warning","count":N},{"severity":"info","count":N}]'

O adaptador retorna: score (0-100), pass (booleano), z (z-score vs linha de base do domínio), baseline (média, desvio padrão, limite, n), deductions.

Passo 5 — Saída

Se limpo:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({APROVADO|REPROVADO}) | z={z}
   Linha de base ({domain}): média={mean} desvio={std} limite={threshold}
   Cheatsheet: {n_strategies} estratégias aplicadas | Anticorpos: {n_quentes}/{max} QUENTES, {n_frias} FRIOS
   Nenhum problema detectado
───

Se correções ou ameaças encontradas:

───
IMMUNE v5.1 | domains={domains} | Score: {score}/100 ({APROVADO|REPROVADO}) | z={z}
   Linha de base ({domain}): média={mean} desvio={std} limite={threshold}

Correções Aplicadas:
  [AB-XXX] {pattern} → {correction}

Novas Ameaças Detectadas:
  [{severity}] {pattern} — {sugestão_de_correção}

Reativados:
  [AB-XXX] {pattern} (era FRIO, agora QUENTE)

Novas Estratégias Aprendidas:
  [CS-XXX] {pattern} (eff: {effectiveness})

───
Saída Corrigida:
{o conteúdo corrigido, formatado para o domínio}
───
Memória: {total_ab} anticorpos + {total_cs} estratégias | +{novos_ab} AB | +{novos_cs} CS
───

Em seguida, apresente a saída corrigida em um formato legível apropriado para o domínio.

Passo 6 — Registro de Sessão

Registre o resultado da sessão para contexto futuro:

node ~/.claude/skills/immune/immune-adapter.js log-session --date {hoje} --domains '{domains_json}' --result {limpo|corrigido|sinalizado} --summary "{breve resumo do que foi escaneado e encontrado}" --score {score}

Isso escreve em context/YYYY-MM-DD.md + session_logs no SQLite + índice FTS4 para futuras buscas get-context.

Passo 7 — Liberação Pré-Compactação (opcional)

Se o contexto da conversa estiver próximo da compactação, salve quaisquer anticorpos/estratégias pendentes que ainda não foram confirmados:

node ~/.claude/skills/immune/immune-adapter.js flush-pending --json '{"antibodies":[...],"strategies":[...]}'

Validação do portão de qualidade:

• O padrão deve ter >= 20 caracteres
• Anticorpos requerem: id, pattern, severity, correction
• Estratégias requerem: id, pattern
• A verificação de duplicatas FTS4 impede recriação de padrões existentes
• Registros liberados são sinalizados com quality_gate=1

Log: [IMMUNE] Liberação pré-compactação: +{n} anticorpos, +{n} estratégias (quality_gate=true)

Tratamento de Erros

• Se a CLI do adaptador falhar: recorra à leitura direta dos arquivos JSON (immune_memory.json, cheatsheet_memory.json) — eles são mantidos sincronizados por meio de escrita dupla.
• Se immune_memory.json não existir: o adaptador o cria automaticamente com anticorpos vazios.
• Se cheatsheet_memory.json não existir: o adaptador o cria automaticamente com estratégias vazias.
• Se immune_memory.json tiver "version": 2: o adaptador migra automaticamente "domain" para "domains": ["valor_do_dominio"].
• Se o agente retornar JSON inválido: tente novamente uma vez. Se ainda assim inválido, reporte a saída bruta com um aviso.
• Se nenhuma entrada for fornecida e não existir saída recente: pergunte ao usuário o que escanear.
• Se todos os anticorpos forem FRIOS (nenhum se qualifica como QUENTE): ainda envie a varredura com array hot_antibodies vazio e cold_summary completo. O Haiku ainda pode detectar novas ameaças via Fase 2.