wizz-method 1.4.0 → 1.5.0

package/src/modules/wizz/overrides/wizz-agent-architect.toml

@@ -8,14 +8,17 @@ activation_steps_prepend = [
   "WIZZ CEREBRO: rode /cerebro ver para puxar decisões de arquitetura e stack já registradas (de forma leve).",
 ]
 
+# Regra de comunicação + template de encerramento: fonte única no módulo wizz (_shared/).
+include = ["../wizz/_shared/communication-rules.md"]
+
 activation_steps_append = [
-  "WIZZ COMUNICAÇÃO: não narre o passo a passo enquanto trabalha. Isso gasta token e polui a conversa. Trabalhe direto e, se aparecer uma decisão que é do usuário ou algo difícil de desfazer, PAUSE e pergunte antes de seguir. Feche sempre com um resumo curto, em linguagem simples e fácil de entender.",
-  "WIZZ ENCERRAMENTO: finalize SEMPRE com '✅ O que fiz' + '➡️ Próximo passo' (ex: chamar o dev) + '🎯 Comando: /wizz:<algo>'. Acrescente '💾 Quer que eu salve no cerebro?' (decisão de arquitetura quase sempre vale salvar).",
+  "PRÓXIMO PASSO: normalmente chamar o dev. Decisão de arquitetura quase sempre vale salvar no cerebro, lembre de oferecer.",
 ]
 
 persistent_facts = [
   "Sou parte do Wizz Method. Falo PT-BR fácil e explico trade-offs em linguagem simples.",
   "Modo confirmado: sugiro o próximo agente, mas quem dispara é o usuário.",
+  "Para operar Supabase de verdade (SQL, migrations, schema, RLS, logs) uso o MCP 'supabase' quando estiver ativo; nunca exponho o SUPABASE_ACCESS_TOKEN em log ou commit.",
 ]
 
 principles = [
@@ -27,7 +30,7 @@ principles = [
 [[agent.menu]]
 code = "DB"
 description = "Revisar schema, queries, performance e RLS do banco"
-prompt = "Invoque a skill GLOBAL 'database-reviewer' via a ferramenta Skill (ou o agente database-reviewer)."
+prompt = "Invoque a skill GLOBAL 'supabase-postgres-best-practices' via a ferramenta Skill para revisar schema, queries, performance e RLS. Se o problema for escala/capacidade, complemente com database-scaling; se for dependência/vulnerabilidade, complemente com database-and-deps."
 
 [[agent.menu]]
 code = "SEC"
@@ -38,3 +41,8 @@ prompt = "Invoque a skill GLOBAL 'web-security' via a ferramenta Skill."
 code = "MAP"
 description = "Entender a arquitetura de um projeto existente"
 prompt = "Para mapear a arquitetura de um codebase existente: primeiro tente '/graphify query'. Se 'gsd:map-codebase' estiver instalada, pode usá-la. Senão, mapeie você mesmo: camadas, dependências, integrações (DB/API/Auth/externos) e pontos de risco, resumindo em PT-BR fácil."
+
+[[agent.menu]]
+code = "SB"
+description = "Operar Supabase de verdade (SQL, migrations, schema, RLS, logs)"
+prompt = "Use o MCP 'supabase' (via ToolSearch para carregar as ferramentas) para rodar SQL, inspecionar schema/RLS e ler logs reais. Prefira o escopo mais restrito disponível (ex: --read-only/--project-ref) para operações de leitura; nunca exponha o token em log ou commit."

package/src/modules/wizz/overrides/wizz-agent-dev.toml

@@ -8,9 +8,11 @@ activation_steps_prepend = [
   "WIZZ CEREBRO: rode /cerebro ver para puxar onde o projeto parou e o que falta (de forma leve).",
 ]
 
+# Regra de comunicação + template de encerramento: fonte única no módulo wizz (_shared/).
+include = ["../wizz/_shared/communication-rules.md"]
+
 activation_steps_append = [
-  "WIZZ COMUNICAÇÃO: não narre o passo a passo enquanto trabalha. Isso gasta token e polui a conversa. Trabalhe direto e, se aparecer uma decisão que é do usuário ou algo difícil de desfazer, PAUSE e pergunte antes de seguir. Feche sempre com um resumo curto, em linguagem simples e fácil de entender.",
-  "WIZZ ENCERRAMENTO: finalize SEMPRE com '✅ O que fiz' + '➡️ Próximo passo' (ex: chamar o wizz-qa para testar) + '🎯 Comando: /wizz:<algo>'. Acrescente '💾 Quer que eu salve no cerebro?' se resolveu um bug não-óbvio ou armadilha.",
+  "PRÓXIMO PASSO: normalmente chamar o wizz-qa para testar. Se resolveu um bug não-óbvio ou armadilha, lembre de oferecer salvar no cerebro.",
 ]
 
 persistent_facts = [
@@ -28,12 +30,12 @@ principles = [
 [[agent.menu]]
 code = "TDD"
 description = "Escrever testes primeiro (red/green/refactor)"
-prompt = "Invoque a skill GLOBAL 'tdd-guide' via a ferramenta Skill (ou o agente tdd-guide) para guiar TDD."
+prompt = "Guie TDD diretamente: escreva o teste primeiro (red), implemente o mínimo para passar (green), refatore com a suíte verde e registre evidência. Para fluxo completo de implementação, use wizz-quick-dev quando for ajuste pontual."
 
 [[agent.menu]]
 code = "REV"
 description = "Revisão de código após implementar"
-prompt = "Invoque a skill GLOBAL 'code-reviewer' via a ferramenta Skill (ou o agente code-reviewer)."
+prompt = "Invoque a skill GLOBAL 'wizz-code-review' via a ferramenta Skill."
 
 [[agent.menu]]
 code = "DBG"

package/src/modules/wizz/overrides/wizz-agent-pm.toml

@@ -8,9 +8,11 @@ activation_steps_prepend = [
   "WIZZ CEREBRO: rode /cerebro ver para puxar visão de produto e decisões já tomadas (de forma leve).",
 ]
 
+# Regra de comunicação + template de encerramento: fonte única no módulo wizz (_shared/).
+include = ["../wizz/_shared/communication-rules.md"]
+
 activation_steps_append = [
-  "WIZZ COMUNICAÇÃO: não narre o passo a passo enquanto trabalha. Isso gasta token e polui a conversa. Trabalhe direto e, se aparecer uma decisão que é do usuário ou algo difícil de desfazer, PAUSE e pergunte antes de seguir. Feche sempre com um resumo curto, em linguagem simples e fácil de entender.",
-  "WIZZ ENCERRAMENTO: finalize SEMPRE com '✅ O que fiz' + '➡️ Próximo passo' (ex: chamar o arquiteto ou o dev) + '🎯 Comando: /wizz:<algo>'. Acrescente '💾 Quer que eu salve no cerebro?' se decidiu escopo/prioridade.",
+  "PRÓXIMO PASSO: normalmente chamar o arquiteto ou o dev. Se decidiu escopo/prioridade, lembre de oferecer salvar no cerebro.",
 ]
 
 persistent_facts = [

package/src/modules/wizz/overrides/wizz-agent-tech-writer.toml

@@ -8,10 +8,8 @@ activation_steps_prepend = [
   "WIZZ CEREBRO: rode /cerebro ver para puxar o contexto e a documentação existente do projeto (de forma leve).",
 ]
 
-activation_steps_append = [
-  "WIZZ COMUNICAÇÃO: não narre o passo a passo enquanto trabalha. Isso gasta token e polui a conversa. Trabalhe direto e, se aparecer uma decisão que é do usuário ou algo difícil de desfazer, PAUSE e pergunte antes de seguir. Feche sempre com um resumo curto, em linguagem simples e fácil de entender.",
-  "WIZZ ENCERRAMENTO: finalize SEMPRE com '✅ O que fiz' + '➡️ Próximo passo' + '🎯 Comando: /wizz:<algo>'.",
-]
+# Regra de comunicação + template de encerramento: fonte única no módulo wizz (_shared/).
+include = ["../wizz/_shared/communication-rules.md"]
 
 persistent_facts = [
   "Sou parte do Wizz Method. Escrevo PT-BR fácil, com analogias simples e diagramas no lugar de paredes de texto.",
@@ -28,4 +26,4 @@ principles = [
 [[agent.menu]]
 code = "DOC"
 description = "Atualizar codemaps e documentação do projeto"
-prompt = "Invoque a skill GLOBAL 'doc-updater' via a ferramenta Skill (ou o agente doc-updater)."
+prompt = "Invoque a skill GLOBAL 'wizz-document-project' via a ferramenta Skill para atualizar documentação e codemaps do projeto. Para indexar documentação existente, use wizz-index-docs quando esse for o objetivo."

package/src/modules/wizz/overrides/wizz-agent-ux-designer.toml

@@ -10,9 +10,11 @@ activation_steps_prepend = [
   "WIZZ CEREBRO: rode /cerebro ver para puxar público-alvo e decisões de UX já tomadas (de forma leve).",
 ]
 
+# Regra de comunicação + template de encerramento: fonte única no módulo wizz (_shared/).
+include = ["../wizz/_shared/communication-rules.md"]
+
 activation_steps_append = [
-  "WIZZ COMUNICAÇÃO: não narre o passo a passo enquanto trabalha. Isso gasta token e polui a conversa. Trabalhe direto e, se aparecer uma decisão que é do usuário ou algo difícil de desfazer, PAUSE e pergunte antes de seguir. Feche sempre com um resumo curto, em linguagem simples e fácil de entender.",
-  "WIZZ ENCERRAMENTO: finalize SEMPRE com '✅ O que fiz' + '➡️ Próximo passo' + '🎯 Comando: /wizz:<algo>'. Para visual premium/landing/motion, indique o wizz-designer.",
+  "PRÓXIMO PASSO: para visual premium/landing/motion, indique o wizz-designer.",
 ]
 
 persistent_facts = [

package/src/modules/wizz/scripts/wizz-init.mjs

@@ -152,7 +152,9 @@ async function main() {
 
   console.log('✅ wizz-init concluído:');
   for (const d of done) console.log(`   - ${d}`);
-  console.log('\n➡️ Próximo passo: invoque o wizz-maestro e mande seu pedido. Ele escolhe o agente certo.');
+  console.log(
+    '\n➡️ Próximo passo: invoque o wizz-router e mande seu pedido. Ele escolhe o agente certo ou chama o wizz-maestro quando precisar orquestrar.',
+  );
 }
 
 try {

package/src/scripts/memlog.py

@@ -34,6 +34,15 @@ Three invariants make it trustworthy:
 Atomicity: every write goes to a temp file, is flushed and fsync'd, then atomically
 renamed over the target, so a crash never leaves a half-written entry.
 
+Known limitation (by design, not a bug): there is no compaction, archival, or size
+cap. Append-only + no lifecycle status (invariant 3 above) means a `.memlog.md` grows
+without bound for the life of the workspace — fine for a single brainstorm/spec/
+architecture session (dozens to low hundreds of entries), but a caller resuming a very
+long-running or repeatedly-reused workspace pays an ever-larger read on every resume.
+If that ever becomes a real problem, the fix is a new host-skill-driven step (e.g.
+"archive entries older than the last milestone to a sibling file"), not a change to
+this script's invariants — memlog stays a dumb, trustworthy, append-only primitive.
+
 The file shape (.memlog.md):
 
     ---

package/src/scripts/resolve_customization.py

@@ -31,10 +31,26 @@ Merge rules (purely structural — no field-name special-casing):
 No removal mechanism — overrides cannot delete base items. To suppress
 a default, fork the skill or override the item by code with a no-op
 description/prompt.
+
+Optional `include` (aditivo, opcional):
+  Any table may carry an `include = ["path/to/file.md", ...]` key. Each
+  path is resolved relative to the directory of the TOML file that
+  declared it (the skill's own directory for the base `customize.toml`
+  layer; `{project-root}/_wizz/custom/` for the team/user layers, since
+  that is where those files physically live once installed). Each
+  referenced file is split into paragraphs (blocks separated by a blank
+  line; blocks made only of `#` comment/heading lines are dropped) and
+  the resulting strings are prepended onto that same table's
+  `activation_steps_append` array, i.e. injected at the exact point
+  where hand-copied instruction text used to live. Missing/unreadable
+  include files warn to stderr and are skipped (fail-open, matching the
+  rest of this resolver); they never abort resolution. A toml with no
+  `include` key resolves exactly as before this feature existed.
 """
 
 import argparse
 import json
+import re
 import sys
 from pathlib import Path
 
@@ -93,6 +109,80 @@ def load_toml(file_path: Path, required: bool = False) -> dict:
         return {}
 
 
+_INCLUDE_TARGET_FIELD = "activation_steps_append"
+
+
+def _read_include_file(path: Path):
+    """Read an include file's raw text. Returns None (and warns to stderr)
+    when the file is missing or unreadable, so a broken/renamed include
+    never aborts resolution — same fail-open philosophy as the optional
+    team/user layers above."""
+    if not path.is_file():
+        sys.stderr.write(f"warning: include not found, skipping: {path}\n")
+        return None
+    try:
+        return path.read_text(encoding="utf-8")
+    except OSError as error:
+        sys.stderr.write(f"warning: failed to read include {path}: {error}\n")
+        return None
+
+
+def _split_include_paragraphs(text: str):
+    """Split an included markdown file into instruction strings.
+
+    Blocks separated by a blank line become one string each (internal
+    newlines collapsed to single spaces). Blocks made up only of `#`
+    lines (markdown headings, or plain comment lines using the same
+    convention) are dropped — they document the shared file for the
+    humans editing it, not instructions meant for the agent."""
+    paragraphs = []
+    for block in re.split(r"\n\s*\n", text.strip()):
+        lines = [line.strip() for line in block.splitlines() if line.strip()]
+        if not lines or all(line.startswith("#") for line in lines):
+            continue
+        paragraphs.append(" ".join(lines))
+    return paragraphs
+
+
+def resolve_includes(data, base_dir: Path):
+    """Expand `include = [...]` keys found in any table of `data`.
+
+    Purely additive: a table without `include` comes back unchanged. When
+    present, each referenced file's paragraphs (see
+    `_split_include_paragraphs`) are prepended onto that table's
+    `activation_steps_append` array (created if absent), so shared content
+    leads and any table-specific entries that remain follow it. Paths in
+    `include` resolve relative to `base_dir`. Recurses into nested tables
+    so `include` works at any depth, not just the top level."""
+    if not isinstance(data, dict):
+        return data
+
+    included_paragraphs = []
+    if isinstance(data.get("include"), list):
+        for rel_path in data["include"]:
+            if not isinstance(rel_path, str):
+                sys.stderr.write(f"warning: include entries must be strings, got: {rel_path!r}\n")
+                continue
+            text = _read_include_file((base_dir / rel_path).resolve())
+            if text is not None:
+                included_paragraphs.extend(_split_include_paragraphs(text))
+    elif "include" in data:
+        sys.stderr.write(f"warning: 'include' must be an array of strings, got: {data['include']!r}\n")
+
+    result = {}
+    for key, value in data.items():
+        if key == "include":
+            continue
+        result[key] = resolve_includes(value, base_dir) if isinstance(value, dict) else value
+
+    if included_paragraphs:
+        existing = result.get(_INCLUDE_TARGET_FIELD, [])
+        existing_list = existing if isinstance(existing, list) else []
+        result[_INCLUDE_TARGET_FIELD] = included_paragraphs + existing_list
+
+    return result
+
+
 def _detect_keyed_merge_field(items):
     """Return 'code' or 'id' if every table item carries that *same* field.
 
@@ -204,7 +294,7 @@ def main():
     skill_name = skill_dir.name
     defaults_path = skill_dir / "customize.toml"
 
-    defaults = load_toml(defaults_path, required=True)
+    defaults = resolve_includes(load_toml(defaults_path, required=True), defaults_path.parent)
 
     # Prefer the project that contains this skill. Only fall back to cwd if
     # the skill isn't inside a recognizable project tree (unusual but possible
@@ -216,8 +306,8 @@ def main():
     user = {}
     if project_root:
         custom_dir = project_root / "_wizz" / "custom"
-        team = load_toml(custom_dir / f"{skill_name}.toml")
-        user = load_toml(custom_dir / f"{skill_name}.user.toml")
+        team = resolve_includes(load_toml(custom_dir / f"{skill_name}.toml"), custom_dir)
+        user = resolve_includes(load_toml(custom_dir / f"{skill_name}.user.toml"), custom_dir)
 
     merged = deep_merge(defaults, team)
     merged = deep_merge(merged, user)

package/src/skills-lib/adversarial-reviewer/SKILL.md

@@ -5,6 +5,8 @@ description: Adversarial code review that assumes bugs exist and hunts for them.
 
 # Adversarial Code Reviewer
 
+> **Which review skill do I want?** This is the standalone, single-pass skill — use it for a quick adversarial read of code you paste or point at, no project context, no workflow. For a full triaged review of a real diff (parallel layers + acceptance-criteria check + severity triage), use `wizz-code-review` instead — it runs this same mindset as one of three parallel layers (via `wizz-review-adversarial-general`) plus an Edge Case Hunter and an Acceptance Auditor.
+
 You are a hostile reviewer. Your job is to find bugs, not to be helpful. Assume the code is broken and prove yourself right.
 
 ## Mindset