funifier-mcp 0.3.18 → 0.3.19

package/skills/funifier/references/create-aggregate.md

@@ -1,6 +1,6 @@
 # funifier-create-aggregate
 
-Create a Funifier prepared aggregate — guided workflow for building MongoDB aggregate pipelines for reports and dashboards
+Create/edit a Funifier prepared aggregate — a saved pipeline with _id, $param placeholders, optional Groovy script, cache and execution via POST /v3/find/{id}; for reusable dashboards and parametrized reports
 
 ---
 
@@ -48,7 +48,7 @@ Note que `aggregate` é uma **string** contendo JSON serializado (com `\n` e `\"
 Use the `funifier_search_docs` MCP tool to load only what you need:
 
 ```
-funifier_search_docs "aggregate mongodb pipeline report dashboard query prepared"
+funifier_search_docs "aggregate mongodb pipeline prepared dashboard param script find reusable"
 ```
 
 Then read the most relevant results with `funifier_read_doc path=<path>`.
@@ -63,118 +63,138 @@ If search returns insufficient results, read these directly:
 
 ## Steps
 
-> **Prepared aggregate** = pipeline MongoDB salvo na plataforma com `_id` e executado por ID via `POST /v3/find/<id>`, com parâmetros dinâmicos (`"$param:nome"`). Diferente do aggregate **ad-hoc** (`POST /v3/database/{collection}/aggregate`), usado para testar pipelines.
+> **Prepared aggregate** = pipeline MongoDB **salvo** na plataforma (coleção `prepared_aggregate`) com `_id`, parâmetros dinâmicos (`"$param:nome"`) e um `script` Groovy opcional, executado por ID via `POST /v3/find/<id>`. Use para dashboards e relatórios **reutilizáveis**. Para uma consulta **pontual sem salvar**, use a skill `funifier-query-aggregate` (ad-hoc).
 
-### Coleções principais
+> ⚠️ **"Salvo" ≠ "funcionando".** O `funifier_save type=aggregate` persiste via `PUT /v3/database/prepared_aggregate` (upsert genérico de banco) e **NÃO compila** o `script`. Um script quebrado é "salvo com sucesso" e só falha — silenciosamente — na execução. Por isso o fluxo abaixo é **montar → salvar → verificar**, nunca só salvar.
 
-| Coleção | Conteúdo chave |
-|---|---|
-| `achievement` | Conquistas — `type`: 0=Point, 1=Challenge, 2=VirtualGood, 3=Level |
-| `action_log` | Ações executadas — `actionId`, `userId`, `attributes`, `time` |
-| `player` | Jogadores — `_id`, `name`, `teams`, `extra` |
-| `challenge` | Desafios — `_id`, `challenge`, `rules`, `points` |
-| `point_category` | Tipos de ponto — `_id`, `category`, `shortName` |
-| `catalog_item` | Loja virtual — `_id`, `catalogId`, `name`, `requires` |
+### 1. Definir a consulta e montar o pipeline
 
-Se o pipeline filtrar ou criar campos de data, leia também `references/date-handling.md` antes de montar o payload.
+- Qual coleção, filtro, agrupamento, ordenação e limite? Quais valores serão **parâmetros** (`$param`)?
+- Monte/teste o pipeline como uma consulta **ad-hoc** primeiro (skill `funifier-query-aggregate`) — não reensine a execução direta aqui. As relações de coleção para `$lookup` estão lá e em `aggregates.md` §3.
+- Confira se já existe: `funifier_list type=aggregate search=<titulo>`.
 
-### Expressões de data Funifier
+### 2. Campos do recurso
 
-Para regras completas de criação/edição/consulta de datas via REST, triggers, schedulers, aggregate e prepared aggregate, leia `references/date-handling.md`.
+Todos embasados em `PreparedAggregate` (funifier-service). Apenas `_id`, `title`, `collection`, `aggregate` são essenciais; o resto é opcional.
 
-| Expressão | Significado |
+| Campo | Semântica |
 |---|---|
-| `{"$date": "-0d-"}` | Início do dia atual |
-| `{"$date": "-0M-"}` | Início do mês atual |
-| `{"$date": "-0M+"}` | Fim do mês atual |
-| `{"$date": "-0y-"}` | Início do ano atual |
-| `{"$date": "-1d-"}` | Início do dia anterior |
+| `_id` | Identificador do recurso (usado em `POST /v3/find/<id>`). |
+| `title` | Nome legível. |
+| `description` | Descrição livre (opcional). |
+| `collection` | Coleção-base sobre a qual o pipeline roda. |
+| `aggregate` | **String** contendo um array JSON válido (o pipeline). Ver §3. |
+| `script` | Groovy opcional `void prepare(aggregations, params)` (`""` se não precisar). Ver §6. |
+| `timeout` | Sobrescreve o timeout padrão de **5s** do script (em segundos). |
+| `cache` | Expressão de duração Funifier (ex.: `"30m"`, `"3h"`) — TTL do resultado em cache, servido pelo mesmo `POST /v3/find/<id>`. |
+| `cache_before_find` | Aplica o cache antes do find (caso avançado). |
+| `parent` | Consulta o resultado **em cache de outro find** em vez de uma coleção (find-sobre-find, **um nível**; o parent deve usar `collection`). |
 
-**Importante:** em aggregate direto e prepared aggregate, prefira expressões relativas Funifier dentro de `$date` (`-0M-`, `-0M+`) ou timestamps em milissegundos para datas absolutas. Para datas absolutas parametrizadas em prepared aggregate, normalize no `script` com `DateUtil.parse(...)` e substitua diretamente em `$gte`/`$lte`.
+### 3. Formato do campo `aggregate` (string JSON)
 
----
+O campo `aggregate` é uma **`String`** lida na execução com `JsonUtil.fromJson(aggregate, List.class)`. **Só importa a validade do JSON** — indentação, `\n` e minificação são irrelevantes. Construa um array nativo e serialize com `JSON.stringify(pipeline)`, deixando o escape com o MCP.
 
-## Steps
+> ⚠️ **Não envie um array JSON nativo** em `aggregate` — o campo da entidade é `String`; um array nativo gera um recurso que falha na execução. Minificado em uma linha **é aceito** (não existe regra de "identado, nunca minificado").
 
-### 1. Identificar a necessidade
+Exemplo (identado só por legibilidade — minificado também funciona):
+```json
+{
+  "_id": "top_players_month",
+  "title": "Top Players Month",
+  "collection": "achievement",
+  "aggregate": "[{\"$match\":{\"type\":0,\"item\":\"xp\"}},{\"$group\":{\"_id\":\"$player\",\"total\":{\"$sum\":\"$total\"}}},{\"$sort\":{\"total\":-1}},{\"$limit\":10}]",
+  "script": "",
+  "cache": "30m"
+}
+```
 
-- Qual collection tem os dados? (ver tabela acima)
-- Qual o filtro? (período, jogador, tipo de conquista)
-- Qual o agrupamento? (por jogador, por dia, por equipe)
-- Qual ordenação e limite?
+> Via `funifier_save type=aggregate file=...`, o pipeline pode vir do arquivo companheiro `.pipeline.json` — o MCP serializa e escapa para você.
 
-### 2. Verificar se já existe
+### 4. Parâmetros `$param`
 
-```
-funifier_list type=aggregate search=<titulo>
-```
+- Um placeholder deve ser o **valor de string JSON inteiro**: `"$param:nome"`. A substituição é a **nível de valor** (sem concatenação/interpolação de substring) e o valor assume o **tipo** do param: string, número, `Long` (millis), `Date`, array ou objeto.
+- **Param ausente vira `null`** → filtro silenciosamente não casa nada. Confirme os nomes esperados com `funifier_execute type=aggregate id=<id> mode=params` (varredura literal de `"$param:NOME"` na string salva).
+- Avançado: pode-se injetar um **sub-pipeline**, nome de **coleção** ou `Map`/`List` via param (ex.: `"$param:collection"`, `"$param:pipelineSearch"`) quando o `script` faz `params.put` de um valor real.
 
-### 3. Construir e testar o pipeline
+### 5. Datas parametrizadas
 
-Top 10 jogadores com mais pontos no mês:
-```json
-[
-  {"$match": {"type": 0, "item": "xp", "time": {"$gte": {"$date": "-0M-"}, "$lte": {"$date": "-0M+"}}}},
-  {"$group": {"_id": "$player", "total": {"$sum": "$total"}}},
-  {"$sort": {"total": -1}},
-  {"$lookup": {"from": "player", "localField": "_id", "foreignField": "_id", "as": "p"}},
-  {"$unwind": "$p"},
-  {"$project": {"_id": 1, "player": "$p.name", "total": 1}},
-  {"$limit": 10}
-]
-```
+A gramática `{"$date": "-0M-"}` (relativa, não-parametrizada) pode ir **direto** no pipeline salvo — detalhada em `aggregates.md` §4 (dono único; `funifier_read_doc path=guides/aggregates`). Para uma data **dinâmica vinda de param**, o padrão real é:
 
-Testar diretamente antes de registrar:
 ```
-POST /v3/database/achievement/aggregate
+pipeline:  { "$match": { "time": { "$gte": {"$date": "$param:start"}, "$lte": {"$date": "$param:end"} } } }
+script:    params.put("start", startDate.getTime())   // millis (Long) — ou injete um Date
 ```
 
-### 4. Registrar como Prepared Aggregate
+Omitir o param de data na execução → o engine substitui por `null` e o filtro não casa nada. Ver também a skill `funifier-date-handling`.
 
-**Formatação obrigatória:** o campo `aggregate` é o pipeline serializado como **string identada**, com `\n` ao fim de cada linha (equivalente a `JSON.stringify(pipeline, null, 4)`) — **nunca** minificado em uma linha única. O `script` Groovy também preserva indentação e `\n`. Os escapes (`\"`, `\\`) seguem a seção "Formato do payload" acima.
+### 6. Script Groovy `prepare()` (opcional)
 
-```json
-{
-  "_id": "top_players_month",
-  "title": "Top Players Month",
-  "collection": "achievement",
-  "aggregate": "[\n    {\n        \"$match\": {\n            \"type\": 0,\n            \"item\": \"xp\"\n        }\n    },\n    {\n        \"$group\": {\n            \"_id\": \"$player\",\n            \"total\": {\n                \"$sum\": \"$total\"\n            }\n        }\n    },\n    {\n        \"$sort\": {\n            \"total\": -1\n        }\n    },\n    {\n        \"$limit\": 10\n    }\n]",
-  "script": ""
+Se o pipeline só usa placeholders `"$param:nome"`, `script: ""` é válido — não precisa de `prepare()`. Quando precisar de lógica (resolver janela de datas, guardas), o contrato é:
+
+- **Assinatura de entrada:** `void prepare(aggregations, params)`. Métodos auxiliares extras são permitidos.
+- **Ambiente:** roda dentro de uma `class FunifierTrigger` gerada, que já importa `DateUtil`, `JsonUtil`, `manager` (`ManagerFactory`), as entidades, e o default `java.util.*` do Groovy. O `context` expõe **apenas** `player`. `println(...)` é capturado (visível no `script_outputs` do analyze). **Timeout padrão 5s** (sobrescrevível via `timeout`).
+- **Sandbox:** compilado sob um whitelist de tokens de operador (`SecureASTCustomizer` + `TriggerExpressionChecker`) — **sem ternário `?:`**, **sem bitwise**. Mantenha a lógica simples.
+
+Exemplo (resolve janela do mês e guarda usuário inativo):
+```groovy
+void prepare(aggregations, params) {
+    params.put("start", DateUtil.fromKeyword("-0M-").getTime());
+    params.put("end", DateUtil.fromKeyword("-0M+").getTime());
+    String player = context.get("player");
+    if (player == null || isInactive(player)) {
+        params.put("player", "__none__"); // sentinela → resultado vazio controlado
+    } else {
+        params.put("player", player);
+    }
 }
-```
 
-```
-funifier_save type=aggregate payload=<json>
+boolean isInactive(String player) {
+    def p = manager.getJongoConnection().getCollection("player").findOne("{_id:#}", player).as(Map.class);
+    return p == null;
+}
 ```
 
-### 5. Validar
+### 7. Antes de salvar: índices e forma da query
+
+1. Liste os campos que dirigem o plano: filtros de `$match`, campos de `$sort`, e `localField`/`foreignField` de cada `$lookup` (atenção ao `foreignField` na coleção `from`).
+2. Cheque/crie índices: `funifier_index action=list collection=<coll>`; crie os single-field faltantes com `funifier_index action=create`. Índice **composto** (ex.: `{player:1,time:-1}`) → REST é single-field apenas; use o caminho Groovy `createIndex(...append...)` (ver skill `funifier-manage-indexes`).
+3. Boas práticas: `$match` cedo · reduzir com `$project`/`$match` antes do `$lookup` · `$sort` seguido de `$limit` · cuidado com explosão do `$unwind` · `$lookup.foreignField` indexado.
+4. Prepared usa `allowDiskUse(true)`; ainda assim raciocine a cobertura de índice sobre o **`aggregate_step_3`** (pipeline já com `$param` resolvido), pois os valores de param mudam o filtro efetivo. Ao **editar** um aggregate, refaça esta checagem nos estágios alterados.
+
+### 8. Salvar
 
 ```
-funifier_list type=aggregate search=<titulo>
+funifier_save type=aggregate payload=<json>
 ```
 
-### 6. Executar o Prepared Aggregate
+Isto persiste, mas **não verifica** nada (ver aviso no topo). "Salvo" é um estado; "verificado funcionando" é outro, alcançado no passo 9.
 
-**Endpoint correto:** `POST /v3/find/<id>` com os parâmetros no corpo JSON.
+### 9. Verificar (obrigatório)
 
-> ⚠️ NÃO use `GET /v3/database/aggregate/{id}` — retorna null/405 silenciosamente, sem mensagem de erro. O endpoint de execução foge do padrão CRUD da plataforma.
+Use os modos do `funifier_execute` (o REST cru é só fallback):
 
-Via MCP (`params` é uma string JSON):
 ```
-funifier_execute type=aggregate id=<id> params={"player":"abc"}
+funifier_execute type=aggregate id=<id> mode=params              # nomes de $param esperados
+funifier_execute type=aggregate id=<id> mode=analyze params={...} # dry-run: NÃO roda no Mongo
+funifier_execute type=aggregate id=<id> params={...}              # mode=run (default): resultado real
 ```
 
-Via frontend:
-```js
-api.post('/v3/find/<id>', { player: 'abc' })
-```
+O `mode=analyze` é uma **inspeção (dry-run)** — compila/roda o `script`, aplica a substituição de `$param` e devolve:
+
+| Campo | Conteúdo |
+|---|---|
+| `script_exceptions` | Erros de compilação/execução do Groovy — **vazio = script ok** |
+| `script_outputs` | Saídas de `println` do `prepare()` |
+| `obj` | A **definição salva** (a entidade, não os resultados) |
+| `aggregate_step_2` | Pipeline **após** o `prepare()` |
+| `aggregate_step_3` | Pipeline **após** a substituição dos `"$param:nome"` |
+
+Diagnóstico: resultado de `mode=run` vazio **ou** recurso com `script` não-vazio → rode `mode=analyze` e leia `script_exceptions` (script quebrado) e `aggregate_step_3` (se um param virou `null`, o `$match` não casa nada — isso distingue "script quebrado" de "resultado legitimamente vazio").
+
+> ⚠️ NÃO execute via `GET /v3/database/aggregate/{id}` — retorna null/405 silenciosamente. A execução é `POST /v3/find/<id>` (corpo JSON, nunca query string). Via frontend: `api.post('/v3/find/<id>', { player: 'abc' })`.
 
-| Regra | Detalhe |
-|-------|---------|
-| Método HTTP | POST obrigatório |
-| Params | No corpo JSON — não na query string |
-| Substituição | Cada chave do corpo substitui `"$param:<chave>"` no pipeline diretamente |
-| `context` no Groovy | Só expõe o player autenticado — `context.get("outro")` retorna `null` |
-| Script vazio | Se o pipeline só usa `"$param:nome"`, o `script` pode ser `""` — não precisa de `prepare()` |
+## Verified References
 
-Se o resultado vier vazio ou inesperado: `GET /v3/find/<id>/params` lista os params que o pipeline espera, e `POST /v3/prepared/aggregate/<id>/analyze` (mesmo corpo da execução) retorna outputs/exceções do script e o resultado de cada etapa do pipeline (`aggregate_step_N`) — veja `references/debug.md`.
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| DatabaseManager provides MongoDB connection and collection access for aggregate queries in Groovy scripts | ✓ verified | Class:src/main/java/com/funifier/engine/database/DatabaseManager.java:DatabaseManager |

package/skills/funifier/references/create-audit.md

@@ -113,3 +113,11 @@ Filtros combináveis em `$match`: `user`/`login` (ator), `type` (`studio`/`playe
 ### 6. Exclusão (cuidado)
 
 `funifier_delete type=audit id=<id>` remove a config **e todos os seus logs em cascata**. Confirme com o usuário antes.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Audit config fields are _id, title, active, entity, event, clean, type with event constants create/update/delete and type constants studio/player/all | ✓ verified | Class:src/main/java/com/funifier/engine/audit/Audit.java:Audit |
+| AuditManager.log only writes an AuditLog when an active Audit matches entity+event and the config type matches the operation origin | ✓ verified | Class:src/main/java/com/funifier/engine/audit/AuditManager.java:AuditManager |
+| clearExpiredLogs purges audit_log entries older than each config's clean retention and is invoked from AsyncProcessor | ✓ verified | Method:src/main/java/com/funifier/engine/audit/AuditManager.java:AuditManager.clearExpiredLogs#0 |

package/skills/funifier/references/create-challenge.md

@@ -114,3 +114,10 @@ funifier_get type=challenge id=<_id>
 ```
 
 Não use `funifier_logs` — isso é só para triggers e schedulers.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Challenge is the core entity class storing action rules and reward configuration in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/challenge/Challenge.java:Challenge |
+| ChallengeManager manages challenge lifecycle including progress checking and achievement dispatch | ✓ verified | Class:src/main/java/com/funifier/engine/challenge/ChallengeManager.java:ChallengeManager |

package/skills/funifier/references/create-competition.md

@@ -96,3 +96,10 @@ POST /v3/competition/join   { "competition": "<_id>", "player": "<player_id>" }
 POST /v3/competition/leader/aggregate?id=<_id>
 GET /v3/competition/<_id>/execute   (manual execution only)
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Competition is the entity class for timed ranking contests with enrollment and position-based rewards in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/competition/Competition.java:Competition |
+| CompetitionManager manages competition execution, ranking computation, and reward distribution in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/competition/CompetitionManager.java:CompetitionManager |

package/skills/funifier/references/create-crossword.md

@@ -572,3 +572,9 @@ funifier_list type=crossword search=<titulo>
 ```
 
 Teste o jogo no Studio e verifique que as dicas e palavras estão corretas.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Crossword is the entity class for word puzzle games with title, words, and clue positions in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/crossword/Crossword.java:Crossword |

package/skills/funifier/references/create-custom-object.md

@@ -89,3 +89,9 @@ DELETE /v3/database/car__c?q=_id:'car001'
 ### 7. Usar em triggers
 
 Para executar trigger em eventos da coleção, use `entity: "car__c"` no payload do trigger.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| DatabaseManager provides MongoDB connection for custom __c collection CRUD operations in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/database/DatabaseManager.java:DatabaseManager |

package/skills/funifier/references/create-custom-page.md

@@ -133,3 +133,9 @@ PUT /v3/database/studio_page   { "_id": "...", "display": true, "title": "...",
 
 Acesse `/studio/custom/<slug>` no browser para testar.
 Para CRUD completo: crie página de lista (`display: true`) + formulário (`display: false`, slug com `/:id`).
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| DatabaseManager provides MongoDB connection access for aggregate-backed Studio custom pages | ✓ verified | Class:src/main/java/com/funifier/engine/database/DatabaseManager.java:DatabaseManager |

package/skills/funifier/references/create-folder.md

@@ -102,3 +102,10 @@ funifier_save type=folder-log payload=<json>
 funifier_folder operation=progress   { "folder": "<root_id>", "player": "player123" }
 funifier_folder operation=inside     { "folder": "<root_id>" }
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Folder is the entity class for learning trail nodes with unlock_policy, parent, and position fields in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/folder/Folder.java:Folder |
+| FolderManager handles folder tree traversal, progress computation, and cascade deletion in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/folder/FolderManager.java:FolderManager |

package/skills/funifier/references/create-lastmile.md

@@ -641,3 +641,9 @@ funifier_list type=lastmile
 ```
 
 Simule progresso do jogador até 80% do desafio e verifique se a mensagem é disparada.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| LastMile is the entity class for threshold-triggered motivational messages linked to challenge progress in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/lastmile/LastMile.java:LastMile |

package/skills/funifier/references/create-leaderboard.md

@@ -124,3 +124,9 @@ funifier_list type=leaderboard search=<title>
 ```
 
 If scores look wrong, reset cache: `GET /v3/leaderboard/reset`
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| LeaderBoardManager manages leaderboard ranking computation and cache reset in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/leader/LeaderBoardManager.java:LeaderBoardManager |

package/skills/funifier/references/create-level.md

@@ -92,3 +92,10 @@ funifier_list type=level
 ```
 
 Confirme que os níveis estão em ordem crescente de `minPoints`.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Level is the entity class defining level thresholds and point item reference in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/level/Level.java:Level |
+| LevelManager tracks player level progression and threshold evaluation | ✓ verified | Class:src/main/java/com/funifier/engine/level/LevelManager.java:LevelManager |

package/skills/funifier/references/create-lottery.md

@@ -911,3 +911,10 @@ GET /v3/lottery/participants?lottery=<_id>
 ```
 
 To undo: `DELETE /v3/lottery/:id/execute`
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Lottery is the entity class for ticket-based prize draws with drawDate, choiceMethod, and maxWinners in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/lottery/Lottery.java:Lottery |
+| LotteryManager handles ticket generation, draw execution, and winner selection in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/lottery/LotteryManager.java:LotteryManager |

package/skills/funifier/references/create-mystery.md

@@ -767,3 +767,9 @@ funifier_save type=mystery payload=<json>
 GET /v3/mystery/evaluate/<_id>?player=<player_id>
 GET /v3/mystery/execute/<_id>?player=<player_id>
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| MysteryBox is the entity class for probability-based instant games with options, win_chart, and requirements in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/mystery/MysteryBox.java:MysteryBox |

package/skills/funifier/references/create-notification.md

@@ -73,3 +73,9 @@ funifier_list type=notification
 ```
 
 Dispare o evento correspondente e verifique se a notificação é entregue.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Notification is the entity class for automated player feedback messages with event, scope, and content fields in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/notify/Notification.java:Notification |

package/skills/funifier/references/create-point.md

@@ -93,3 +93,10 @@ funifier_list type=point search=<_id>
 ```
 
 Do NOT use `funifier_logs` — that is only for triggers and schedulers.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| PointCategory is the entity class with category, shortName, and techniques fields for defining point types | ✓ verified | Class:src/main/java/com/funifier/engine/point/PointCategory.java:PointCategory |
+| PointManager manages point accumulation and balance queries in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/point/PointManager.java:PointManager |

package/skills/funifier/references/create-quiz.md

@@ -96,3 +96,10 @@ POST /v3/quiz/start   { "quiz": "<id>", "player": "<player_id>" }
 POST /v3/question/log/bulk   [{ "quiz": "<id>", "quiz_log": "<log_id>", "question": "<q_id>", "answer": ["1"], "player": "<player_id>" }]
 POST /v3/quiz/finish  { "quiz_log": "<log_id>" }
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Quiz is the entity class storing questions and answer configuration in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/quiz/Quiz.java:Quiz |
+| QuizManager handles quiz scoring, lifecycle, and player response processing | ✓ verified | Class:src/main/java/com/funifier/engine/quiz/QuizManager.java:QuizManager |

package/skills/funifier/references/create-scheduler.md

@@ -139,3 +139,9 @@ funifier_logs type=scheduler id=<_id>
 ```
 
 Confirme que não há erros de compilação ou execução no stack trace.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| SchedulerManager is the class that manages cron-based script execution in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/integration/scheduler/SchedulerManager.java:SchedulerManager |

package/skills/funifier/references/create-story.md

@@ -634,3 +634,9 @@ GET /v3/story/<_id>
 ```
 
 Teste a navegação entre cenas no Studio antes de publicar.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+

package/skills/funifier/references/create-swap.md

@@ -93,3 +93,9 @@ POST /v3/swap/receive   { "swap": "<swap_id>" }
 POST /v3/swap/counter/offer   { "swap": "<swap_id>", "buyer": "jerry", "offer": [{ "total": 1, "type": 0, "item": "coin" }] }
 POST /v3/swap/counter/offer/accept   { "offer": "<offer_id>" }
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Swap is the entity class for player-to-player trade offers with seller, rewards, and requires fields in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/swap/Swap.java:Swap |

package/skills/funifier/references/create-trigger.md

@@ -183,3 +183,11 @@ funifier_logs type=trigger id=<_id>
 ```
 
 Confirme que não há erros de compilação ou execução. Se houver, leia o stack trace e corrija o script.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Achievement constants TYPE_POINT=0, TYPE_CHALLENGE=1, TYPE_VIRTUAL_GOOD=2, TYPE_LEVEL=3 are defined in the Achievement class | ✓ verified | Class:src/main/java/com/funifier/engine/achievement/Achievement.java:Achievement |
+| ActionLog is the entity class for action triggers with fields actionId, userId, attributes (Map), time, and id | ✓ verified | Class:src/main/java/com/funifier/engine/action/ActionLog.java:ActionLog |
+| TriggerManager is the class that manages trigger script execution and lifecycle in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/integration/trigger/TriggerManager.java:TriggerManager |

package/skills/funifier/references/create-virtual-good.md

@@ -94,3 +94,9 @@ Para testar uma compra:
 ```
 POST /v3/virtualgoods/purchase   { "player": "<id>", "item": "<item_id>", "total": 1 }
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| CatalogManager is the class managing virtual goods catalog items, pricing, and purchase lifecycle in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/catalog/CatalogManager.java:CatalogManager |

package/skills/funifier/references/create-webhook.md

@@ -70,3 +70,9 @@ funifier_list type=webhook
 ### 5. Testar
 
 Dispare um evento (ex: log uma ação que gera conquista) e verifique se o endpoint externo recebeu o payload.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Webhook is the entity class for outbound event notifications to external HTTP endpoints in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/webhook/Webhook.java:Webhook |

package/skills/funifier/references/create-websocket.md

@@ -69,3 +69,9 @@ funifier_list type=websocket
 ```
 
 Conecte um cliente WebSocket e dispare um evento para confirmar que as mensagens chegam em tempo real.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| WebSocket is the entity class for real-time bidirectional communication configuration in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/websocket/WebSocket.java:WebSocket |

package/skills/funifier/references/create-widget.md

@@ -74,3 +74,9 @@ Cole o código de embed na página destino (intranet, LMS, etc.) e verifique que
 funifier_list type=widget
 GET /v3/widget/<_id>
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Widget is the entity class for embeddable visual gamification components with type, configuration, and display settings in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/widget/Widget.java:Widget |

package/skills/funifier/references/date-handling.md

@@ -170,3 +170,9 @@ Não coloque o parâmetro convertido para `Date` dentro de `{ "$date": "$param:s
 - [ ] Em prepared aggregate, usar `"$param:nome"` exatamente como string.
 - [ ] Para data absoluta em prepared aggregate, converter no `script` com `DateUtil.parse`, validar `null`, e substituir o `Date` diretamente em `$gte`/`$lte`.
 - [ ] Testar aggregate direto antes de salvar como prepared aggregate.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+

package/skills/funifier/references/debug.md

@@ -90,3 +90,9 @@ Leia o arquivo de doc específico para o módulo com problema:
 - Scheduler → `funifier_read_doc path=modules/scheduler`
 - Aggregate → `funifier_read_doc path=guides/aggregates`
 - Security/Auth → `funifier_read_doc path=modules/security`
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| TriggerManager is the entry point for trigger script execution and error capture in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/integration/trigger/TriggerManager.java:TriggerManager |

package/skills/funifier/references/help.md

@@ -79,3 +79,9 @@ Baseado na tabela acima, instrua o usuário a usar a skill específica.
 ### 4. Se não encontrar skill específica
 
 Consulte `funifier_read_doc path=index` e leia o módulo relevante diretamente.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Achievement is the core entity class representing all gamification rewards in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/achievement/Achievement.java:Achievement |

package/skills/funifier/references/implement-frontend.md

@@ -122,3 +122,10 @@ await fetch('/v3/database/cycle__c?strict=true', {
 ### 5. Hospedar no Funifier (opcional)
 
 Para arquivos estáticos, leia `funifier_read_doc path=modules/static-repo`.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| PlayerManager handles player authentication and session management in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/player/PlayerManager.java:PlayerManager |
+| ActionManager processes action event registration from frontend clients | ✓ verified | Class:src/main/java/com/funifier/engine/action/ActionManager.java:ActionManager |

package/skills/funifier/references/import-csv.md

@@ -73,3 +73,9 @@ Após import, verifique se os registros foram criados:
 ```
 funifier_list type=player search=<nome_importado>
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+

package/skills/funifier/references/manage-indexes.md

@@ -83,3 +83,9 @@ Get the index name from `action=list`. The `_id_` index cannot be dropped.
 | Unique email | `{"email": 1}` (uniqueness enforced by MongoDB, not this API) |
 
 For a composite (e.g. `{player: 1, time: -1}` to back filter+sort in one plan), use the Groovy/trigger path shown in the Limitation section — not this tool.
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+

package/skills/funifier/references/manage-player.md

@@ -80,3 +80,10 @@ GET /v3/player/<_id>/status
 ```
 GET /v3/team/<team_id>/member/add/<player_id>
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Player is the entity class with _id, name, email, teams, extra fields in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/player/Player.java:Player |
+| PlayerManager handles player CRUD, authentication, and status queries in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/player/PlayerManager.java:PlayerManager |

package/skills/funifier/references/manage-team.md

@@ -74,3 +74,9 @@ GET /v3/team/sales/status
 ```
 GET /v3/team/sales/member/remove/tom
 ```
+
+## Verified References
+
+| Claim | Status | Evidence |
+|-------|--------|----------|
+| Team is the entity class for player groups with _id, name, members, owner fields in funifier-service | ✓ verified | Class:src/main/java/com/funifier/engine/team/Team.java:Team |