create-writerkit 1.1.1 → 1.1.2

package/README.md

@@ -0,0 +1,264 @@
+# create-writerkit
+
+[![npm version](https://img.shields.io/npm/v/create-writerkit.svg)](https://www.npmjs.com/package/create-writerkit)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# Versão em Português
+
+O create-writerkit é uma ferramenta de linha de comando (CLI) desenvolvida para inicializar, estruturar e gerenciar projetos de livros técnicos e científicos escritos em LaTeX.
+
+A ferramenta prepara um ambiente profissional completo, estruturando pastas padronizadas, analisando automaticamente templates LaTeX customizados para extrair regras e estilos (o DNA do template), injetando habilidades (skills) de inteligência artificial no assistente Antigravity (Gemini), e preparando um ambiente virtual Python para verificação automatizada de referências e compilações.
+
+## Instalação
+
+Como o create-writerkit foi desenhado para ser um inicializador de projetos (estilo create-react-app), a forma recomendada de utilizá-lo é diretamente via npx, sem necessidade de instalação global permanente:
+
+```bash
+npx create-writerkit nome-do-seu-projeto
+```
+
+Caso prefira instalar globalmente no sistema, utilize o gerenciador de pacotes npm:
+
+```bash
+npm install -g create-writerkit
+```
+
+E execute o comando da seguinte forma:
+
+```bash
+create-writerkit nome-do-seu-projeto
+```
+
+## Como Usar (Menu Interativo)
+
+Ao executar o comando, o assistente iniciará um questionário interativo no terminal para configurar o escopo do projeto.
+
+```
+Bem-vindo ao assistente de configuração do WriterKit!
+Configuração dos parâmetros iniciais do projeto.
+```
+
+### Perguntas do Assistente:
+
+1. Nome do livro ou projeto: define o título do livro (por exemplo, Algoritmos e Estruturas de Dados).
+2. Tipo de obra: escolha entre as opções disponíveis:
+   * Livro Texto (Didático)
+   * Manual Técnico / Documentação
+   * Tese / Dissertação Acadêmica
+   * Monografia / TCC
+   * Artigo Científico Extenso
+3. Tom principal da escrita: define a personalidade do texto gerado ou revisado pela inteligência artificial:
+   * Científico Rigoroso (foco em formalismo matemático e teórico)
+   * Acadêmico Padrão (linguagem formal, citações e pesquisa)
+   * Técnico / Pragmático (direto ao ponto, focado no mercado)
+   * Didático / Acessível (linguagem amigável, analogias e passo a passo)
+4. Template LaTeX próprio: selecione se você possui um template existente (arquivos .cls, .sty, etc.). Caso selecione Sim, o assistente solicitará o caminho do diretório onde o template está armazenado para copiar e analisar o código automaticamente.
+5. Confirmação de Estrutura: autorização para criar a estrutura padrão de diretórios.
+6. Exemplos de Código: define se o livro conterá blocos de código e a linguagem de programação principal (por exemplo, Python, TypeScript, Rust, C++, etc.).
+
+## Estrutura de Diretórios Gerada
+
+Abaixo está a estrutura de diretórios gerada no projeto:
+
+```text
+meu-livro/
+├── chapters/          # Arquivos .tex contendo os capítulos divididos
+├── codes/             # Códigos fonte de exemplo estruturados por capítulo
+├── images/            # Imagens (PNG, SVG) e diagramas TikZ
+├── configs/           # Arquivos de estilo (.sty) e classe (.cls)
+├── fonts/             # Fontes personalizadas utilizadas no documento
+├── templates/         # Arquivos originais do template LaTeX importado
+├── output/            # Estrutura compilável final e PDFs de saída
+├── memory/
+│   └── memory.json    # Arquivo de estado e controle de metadados
+├── venv/              # Ambiente virtual Python isolado
+└── main.tex           # Arquivo mestre de compilação LaTeX
+```
+
+### O Arquivo memory.json
+
+Este arquivo é o núcleo de integração entre o projeto LaTeX e as inteligências artificiais de escrita (como o Antigravity ou Gemini). Ele armazena as seguintes informações:
+
+* Metadados da obra: título, tom de escrita, idioma e linguagem de programação.
+* DNA do Template: comandos e ambientes LaTeX permitidos, cores institucionais identificadas nos arquivos .cls ou .sty e configurações do pacote listings.
+* Log de Decisões: histórico cronológico de alterações, revisões e decisões tomadas no projeto, permitindo que a inteligência artificial mantenha consistência histórica.
+
+## Análise Automática de Templates (DNA Extraction)
+
+Ao fornecer o caminho para um template LaTeX existente durante o assistente, o CLI lê os arquivos .cls, .sty e .tex buscando por:
+
+* Comandos customizados: mapeamento de newcommand, renewcommand e def.
+* Ambientes: definições de newenvironment.
+* Cores do tema: definições de definecolor.
+* Configurações de listings: parametrização do pacote lstset.
+
+### Injeção de Regras e Diretrizes via Comentários
+
+Você pode instruir a inteligência artificial diretamente a partir de comentários nos seus arquivos LaTeX de template. O processador analisa linhas com palavras-chave específicas e as insere automaticamente como regras obrigatórias de estilo na memória do projeto.
+
+Use os seguintes formatos no seu template:
+
+```latex
+% REGRA: Use sempre a macro \codebox{} para destacar trechos de terminal.
+% ATENÇÃO: Nunca compile imagens fora do ambiente TikZ oficial.
+% IMPORTANTE: Todas as listagens de código devem ter legenda e label descritivo.
+```
+
+## Integração com o Antigravity (Gemini CLI)
+
+Ao finalizar a execução, o create-writerkit instala automaticamente as habilidades (skills) essenciais no diretório do seu assistente Gemini local em `~/.gemini/antigravity/skills/writerkit/`:
+
+1. `writerkit-init`: orquestra as etapas de inicialização e as regras de estruturação.
+2. `writerkit-setup`: realiza o alinhamento de pilares editoriais e extração de DNA de templates.
+3. `writerkit-planning`: cria roteiros didáticos e planejamentos de conteúdo para novos capítulos.
+4. `writerkit-chapter`: orquestra o fluxo de produção de um capítulo.
+5. `writerkit-drafting`: gera conteúdo conceitual preliminar em LaTeX.
+6. `writerkit-code`: desenvolve e valida algoritmos no padrão da memória.
+7. `writerkit-integration`: consolida texto, código e diagramas TikZ.
+8. `writerkit-review`: realiza análises crítica e pedagógica.
+9. `writerkit-validation`: faz a verificação técnica de estrutura e referências bibliográficas.
+10. `writerkit-revision`: refatora o conteúdo com base nos feedbacks recebidos.
+11. `writerkit-publication`: prepara o arquivo final pronto para compilação.
+
+### Ambiente Virtual Python (venv)
+
+O CLI cria automaticamente a pasta venv no ambiente local. Esse ambiente isolado é preparado para rodar ferramentas auxiliares integradas com as habilidades de inteligência artificial, como scripts de validação de referências bibliográficas (reference_checker.py), garantindo que nenhuma dependência quebre no sistema global.
+
+## Sugestões de Melhoria e Feedback
+
+Este projeto é mantido por Ricardo Sekeff. Caso encontre falhas, tenha ideias de novas funcionalidades ou queira sugerir melhorias no processo de injeção e análise de templates LaTeX, envie uma mensagem para o endereço:
+
+[ricardosekeff@gmail.com](mailto:ricardosekeff@gmail.com)
+
+O seu feedback é muito importante para tornar o fluxo de escrita acadêmica com inteligência artificial mais robusto.
+
+---
+
+# English Version
+
+create-writerkit is a command-line interface (CLI) tool designed to initialize, structure, and manage technical and scientific book projects written in LaTeX.
+
+The tool configures a complete, professional authoring environment by generating standardized folder trees, automatically parsing custom LaTeX templates to extract styles and rules (template DNA), injecting specialized AI skills into your Antigravity (Gemini) assistant, and setting up an isolated Python virtual environment for automated reference validation and compilation tasks.
+
+## Installation
+
+Since create-writerkit is designed to be a project bootstrapper (similar to create-react-app), the recommended way to use it is directly via npx, without installing it globally:
+
+```bash
+npx create-writerkit your-project-name
+```
+
+If you prefer to install it globally on your machine, run the following npm command:
+
+```bash
+npm install -g create-writerkit
+```
+
+Then, run it anytime using:
+
+```bash
+create-writerkit your-project-name
+```
+
+## Usage (Interactive Wizard)
+
+When you run the command, an interactive setup wizard will guide you through configuring your book parameters in your terminal.
+
+```
+Welcome to the WriterKit setup wizard!
+Configure the initial parameters of your project.
+```
+
+### Setup Wizard Questions:
+
+1. Book or Project Name: set your book title (for example, Algorithms and Data Structures).
+2. Book Type: choose from the available options:
+   * Textbook (Didactic)
+   * Technical Manual / Documentation
+   * Thesis / Dissertation
+   * Graduation Project / Thesis (TCC)
+   * Extended Scientific Paper
+3. Writing Tone: establishes the personality of the AI-generated or AI-reviewed text:
+   * Rigorous Scientific (focused on mathematical and theoretical formalism)
+   * Standard Academic (formal language, heavy focus on research and citations)
+   * Technical / Pragmatic (straight to the point, industry and execution-focused)
+   * Didactic / Accessible (friendly language, analogies and step-by-step approach)
+4. Custom LaTeX Template: select if you have your own LaTeX template files (.cls, .sty, etc.). If you select Yes, you will be asked to provide the path to your template folder so the CLI can scan it.
+5. Structure Confirmation: confirm the generation of the default WriterKit directory tree.
+6. Code Examples: indicate if your book contains code blocks, and choose the primary programming language (for example, Python, TypeScript, Rust, C++, etc.).
+
+## Directory Structure Generated
+
+Below is the directory structure generated in the project:
+
+```text
+my-book/
+├── chapters/          # .tex files containing divided chapters
+├── codes/             # Source code snippets organized by chapter
+├── images/            # Images (PNG, SVG) and TikZ diagrams
+├── configs/           # Class files (.cls) and style sheets (.sty)
+├── fonts/             # Custom fonts used in the document
+├── templates/         # Copy of your original imported LaTeX templates
+├── output/            # Final compilable outputs and generated PDFs
+├── memory/
+│   └── memory.json    # State and metadata configuration file
+├── venv/              # Isolated Python virtual environment
+└── main.tex           # LaTeX compilation master file
+```
+
+### The memory.json File
+
+This file serves as the bridge between your LaTeX source files and writing assistants (such as Antigravity or Gemini). It keeps track of:
+
+* Project Metadata: title, writing tone, language, and primary programming language.
+* Template DNA: allowed custom LaTeX commands, environments, official color tokens extracted from .cls or .sty files, and listings configuration.
+* Decision Log: a chronological history of editorial decisions and project steps, allowing the AI to understand past context.
+
+## Automated Template Parsing (DNA Extraction)
+
+When providing a custom LaTeX template path, the CLI scans the .cls, .sty, and .tex files to extract:
+
+* Custom Commands: definitions of newcommand, renewcommand and def.
+* Environments: definitions of newenvironment.
+* Theme Colors: color tokens created via definecolor.
+* Listings Configurations: code block customizations defined in lstset.
+
+### Writing AI Instructions via Code Comments
+
+You can write instructions for the AI directly inside your LaTeX template files. The parser checks for comments starting with specific keywords and records them as mandatory guidelines in the project memory.
+
+Use these formats in your template:
+
+```latex
+% REGRA: Always use the \codebox{} macro to highlight console commands.
+% ATENÇÃO: Never compile vector images outside the official TikZ environment.
+% IMPORTANTE: All code listings must have a caption and a label.
+```
+
+## Antigravity (Gemini CLI) Integration
+
+Upon successful setup, create-writerkit automatically installs essential AI skills directly to your local Gemini assistant directory in `~/.gemini/antigravity/skills/writerkit/`:
+
+1. `writerkit-init`: orchestrates project creation steps and folder structures.
+2. `writerkit-setup`: aligns editorial standards and extracts LaTeX template DNA.
+3. `writerkit-planning`: creates pedagogical chapter outlines and content planning.
+4. `writerkit-chapter`: orchestrates the production workflow of a chapter.
+5. `writerkit-drafting`: generates initial conceptual content in LaTeX.
+6. `writerkit-code`: develops and validates code blocks following memory standards.
+7. `writerkit-integration`: consolidates text, code, and TikZ diagrams.
+8. `writerkit-review`: performs critical pedagogical and technical peer-review.
+9. `writerkit-validation`: runs structural validation and reference validation.
+10. `writerkit-revision`: refactors content based on received feedback.
+11. `writerkit-publication`: finalizes the chapter and makes it ready for compilation.
+
+### Python Virtual Environment (venv)
+
+The CLI configures a local venv folder. This isolated environment is ready to execute assistant scripts, such as a bibliography verification script (reference_checker.py), ensuring that system-wide dependencies are not affected.
+
+## Suggestions & Feedback
+
+This project is maintained by Ricardo Sekeff. If you encounter bugs, have feature requests, or want to suggest improvements to the template parser and skill integration, please reach out via email:
+
+[ricardosekeff@gmail.com](mailto:ricardosekeff@gmail.com)
+
+Your suggestions are highly valuable to build a better, AI-assisted academic writing workflow.

package/SUGESTOES_WORKFLOW_AGENTICO.md

@@ -0,0 +1,47 @@
+# Análise e Sugestões de Melhoria no Workflow do WriterKit
+
+Após a análise do repositório, nota-se que o **WriterKit** possui uma estrutura excepcional de orquestração editorial em pipeline linear (fases de 0 a 9) com ênfase rigorosa em _Zero Hallucination_, forte uso de memória de estado (`memory.json`) e ferramentas específicas (ex. `reference_checker.py`). Este design funciona de forma excelente dentro do contexto de _skills_ que rodam no **Antigravity / Gemini CLI**.
+
+No entanto, considerando as **tendências atuais de sistemas agênticos**, podemos aprimorar esse workflow para ir além da execução "passo a passo" dependente da invocação manual do usuário, tornando-o mais autônomo, robusto e multi-modal.
+
+Abaixo, apresento sugestões baseadas nos avanços mais recentes em engenharia agêntica:
+
+---
+
+## 1. Transição de Execução Linear para Grafos Cíclicos (State Machines / DAGs)
+Atualmente, o processo exige que o usuário avance linearmente: `setup` -> `planning` -> `drafting` -> `review` -> `revision` etc.
+
+**Tendência Agêntica:** Sistemas modernos (como implementados em LangGraph) utilizam grafos de fluxo de trabalho não-lineares, permitindo **loops de auto-correção (Self-Correction Loops)**.
+*   **Sugestão:** Integrar um mecanismo onde a fase de `Review` ou `Validation` possa, de forma autônoma, retroceder (devolver a execução) à fase de `Drafting` ou `Code Development` se uma falha for encontrada no checklist (`checklists.md`), sem precisar de um humano dizendo "corrija isso". O log de decisões seria atualizado justificando a regressão temporal.
+
+## 2. Paradigma Multi-Agente (Sistemas de Especialistas Múltiplos)
+Atualmente as skills trocam o "chapéu" do mesmo LLM dependendo do momento.
+**Tendência Agêntica:** Designar personas com "System Prompts" conflitantes/complementares, simulando uma redação humana (Actor-Critic framework).
+*   **Sugestão de Papéis Autônomos:**
+    *   **Agente Pesquisador (Researcher Agent):** Realiza RAG e busca online (`reference_checker.py`), validando links ativamente *enquanto* o capítulo é rascunhado.
+    *   **Agente Redator (Writer Agent):** Foca apenas na escrita e no fluxo da narrativa baseada no tom, ignorando o LaTeX neste momento.
+    *   **Agente Tipógrafo / Engenheiro LaTeX (Typesetter Agent):** Foca exclusivamente na conversão da prosa para LaTeX e TikZ.
+    *   **Agente Revisor Crítico (Reviewer Agent):** Opera como o "Peer Reviewer", aplicando rigorosamente o `checklists.md` e devolvendo o texto ao Agente Redator ou Engenheiro se a nota de aprovação não for atingida.
+
+## 3. Sandboxing Nativo para Validação de Código e Compilação LaTeX
+No modelo atual, há ênfase na não-halucinação de comandos LaTeX, mas não está claro se há uma pré-compilação em "sandbox" automatizada e de código (`developing-code`).
+**Tendência Agêntica:** O LLM cria código e tenta rodar em uma Sandbox (Code Interpreter / Execução de bash), lendo a saída do terminal (Stdout/Stderr) e alterando seu próprio código caso falhe.
+*   **Sugestão:** Implementar na fase `integrating-assets` / `validating-references` uma **Tool Calling de Compilação**. O agente invoca (via `pdflatex` ou `latexmk` em docker local/sandbox) o `main.tex`. O agente lê as primeiras linhas do `main.log`. Se houver "Undefined control sequence", o agente corrige o erro e tenta novamente. O mesmo vale para execução dos códigos gerados na fase de `developing-code`.
+
+## 4. RAG de Memória Longa (Long-term Context & Consistency)
+O `memory.json` já representa um avanço incrível. Contudo, em livros grandes, o contexto pode estourar as janelas atuais ou tornar o processamento ineficiente.
+**Tendência Agêntica:** Vector Databases locais (como ChromaDB, Faiss) ou summarização hierárquica baseada em grafos para manutenção da coesão.
+*   **Sugestão:** Durante a fase de `drafting-content` de um capítulo avançado (ex. Capítulo 5), a skill deve realizar RAG sobre os `.tex` e os logs de decisão dos Capítulos 1 ao 4, para que possa referenciar organicamente: *"Como vimos na Seção 2.3..."*. Essa busca semântica dentro dos capítulos já gerados mantém a coesão sem sobrecarregar a janela de contexto.
+
+## 5. Tool Calling Proativo (Function Calling como Ação Padrão)
+**Tendência Agêntica:** Em vez de depender do prompt instruir o agente, as ferramentas são expostas como nativas à API do modelo (Tool/Function Calling).
+*   **Sugestão:** O `writerkit-init/resources/tools.json` já é um começo. O framework poderia expor comandos de terminal diretamente para o Gemini CLI. Quando o agente precisa verificar uma referência, ele não apenas "pede para rodar" ou finge que rodou: ele emite a chamada de função `check_references(url, doi)`, lê o JSON de retorno real da API (ou de scripts em Python como o `reference_checker.py`), e baseia o texto de forma determinística na resposta.
+
+## 6. Feedback Humano (Human-in-the-Loop - HITL) com Aceleração de UX
+**Tendência Agêntica:** Agentes pedem aprovação do humano apenas em "Portões de Decisão" (Decision Gates) críticos, operando autonomamente no resto.
+*   **Sugestão:** Reduzir a carga do usuário de ter que invocar manualmente cada etapa 0 a 9. Em vez disso, o usuário diz *"Inicie o fluxo do Capítulo 2"*. O sistema roda até gerar o *Blueprint* (`planning`), pausa para o usuário aprovar (Y/n), e então dispara autonomamente as fases de 4 a 8 de uma vez. Pausa novamente só ao fim da validação (`validation`) com um PDF/Log para o humano aprovar e seguir ao próximo passo de revisão/publicação final.
+
+---
+
+### Conclusão e Próximos Passos (Integração Antigravity/Gemini)
+A evolução natural para o **WriterKit** no ecossistema **Gemini CLI / Antigravity** é torná-lo um **"Meta-Agente Orquestrador"**. O usuário conversaria com apenas um agente mestre (ex. `writerkit-orchestrator`), que chamaria em background as skills de inicialização, escrita, revisão e compilação, manipulando o `memory.json` e as pastas locais de forma autônoma e pedindo permissão apenas nas quebras estruturais do projeto.

package/memory/schema.md

@@ -0,0 +1,18 @@
+# Módulo de Memória e Estado
+
+O arquivo de memória (ex: `memory.json`) deve ser mantido e atualizado constantemente pelas *skills*.
+
+## Estrutura de Metadados do Projeto
+* **`title`**: Título da obra.
+* **`theme`**: Tema central e escopo.
+* **`language`**: Idioma da obra (ex: pt-BR).
+* **`depth`**: Nível de profundidade (Graduação, Mestrado, Técnico).
+* **`rigor`**: Nível de formalismo matemático/teórico.
+* **`tone`**: Personalidade do texto (Formal, Professoral, Crítico).
+* **`code_style`**: Linguagem e guia de estilo de código.
+* **`visual_style`**: Padrão para imagens e diagramas (ex: TikZ, preto e branco).
+* **`latex_template`**: Referências aos arquivos `.tex`, `.cls` e `.sty` utilizados.
+
+## Logs e Controle
+* **`chapters`**: Status e metadados de cada capítulo.
+* **`decision_log`**: Histórico temporal (timestamps) de todas as decisões tomadas.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-writerkit",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "CLI para inicializar projetos de livros técnicos em LaTeX com o WriterKit",
   "main": "bin/cli.js",
   "type": "module",

package/scripts/reference_checker.py

@@ -0,0 +1,49 @@
+import re
+import urllib.request
+import urllib.error
+import urllib.parse
+import json
+from typing import Dict
+
+# SCRIPT DE VALIDAÇÃO DE REFERÊNCIAS (Reference Checker)
+# Objetivo: Garantir a veracidade de artigos citados no livro, prevenindo alucinações da IA.
+
+def check_paper_existence(title: str, first_author: str = "") -> bool:
+    base_url = "https://api.crossref.org/works?"
+    query_params = {"query.title": title, "rows": 3}
+    if first_author:
+        query_params["query.author"] = first_author
+        
+    url = base_url + urllib.parse.urlencode(query_params)
+    
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'WriterKit-Antigravity/1.0'})
+        with urllib.request.urlopen(req) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                items = data.get("message", {}).get("items", [])
+                if items:
+                    return True
+                return False
+    except urllib.error.URLError as e:
+        print(f"Erro ao acessar CrossRef: {e}")
+        return False
+
+def validate_bibtex(bibtex_content: str) -> Dict[str, str]:
+    results = {}
+    entries = bibtex_content.split("@")
+    for entry in entries[1:]:
+        title_match = re.search(r'title\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        author_match = re.search(r'author\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        id_match = re.search(r'^[^\{]+\{([^,]+),', entry)
+        
+        if title_match and id_match:
+            ref_id = id_match.group(1).strip()
+            title = title_match.group(1).strip()
+            author = author_match.group(1).split(' and ')[0].strip() if author_match else ""
+            
+            print(f"Verificando referência [{ref_id}]: {title}...")
+            is_valid = check_paper_existence(title, author)
+            results[ref_id] = "VERIFICADA_E_VALIDA" if is_valid else "FALHA_NA_VERIFICACAO"
+            
+    return results

package/skills/writerkit-chapter/SKILL.md

@@ -0,0 +1,21 @@
+name: writerkit-chapter
+description: Orchestrates the end-to-end workflow for producing a book chapter, sequentially invoking individual skills.
+metadata:
+  triggers: chapter production, chapter orchestration, book writing pipeline, writerkit chapter
+---
+
+# Chapter Orchestrator (writerkit-chapter)
+
+Este workflow orquestra o fluxo ponta-a-ponta para a produção de um capítulo, invocando sequencialmente as skills individuais.
+
+## Etapas do Workflow
+1. **Planning** (`/writer-planning`): Define chapter objectives, outline sections, identify code examples.
+2. **Drafting** (`/writer-drafting`): Use chapter template, write conceptual content, add placeholders.
+3. **Code Development** (`/writer-code`): Implement and test code examples externally (mapping accents).
+4. **Integration** (`/writer-integration`): Insert validated code into chapter, add explanations.
+5. **Review** (`/writer-review`): Self-review using the production checklist.
+6. **Validation** (`/writer-validation`): Run validation scripts (including the Reference Checker).
+7. **Revision** (`/writer-revision`): Address issues and improve clarity.
+8. **Publication** (`/writer-publication`): Finalize and publish chapter.
+
+*Nota: Todas as decisões e transições de estado devem ser registradas no `decision_log` da memória.*

package/skills/writerkit-code/SKILL.md

@@ -0,0 +1,17 @@
+name: writerkit-code
+description: Use when the user asks to develop, validate, or insert programming code and algorithms into the LaTeX book project.
+metadata:
+  triggers: code development, algorithm writing, listings configuration, code formatting, syntax highlighting
+---
+
+# Code Development
+
+## When to Use This Skill
+- Writing or refactoring source code snippets for the book.
+- Embedding code blocks using `listings` or `algorithm` environments.
+- Configuring syntax highlighting and code formatting options.
+
+## How to Use It
+1. **Follow Style Guidelines:** Read the code style configuration from `./memory/memory.json` (Action: `READ_CODE_STYLE`).
+2. **Develop & Validate Code:** Write clean, compilable code in the target programming language.
+3. **Accented Characters Mapping (Critical Requirement):** Map Latin accented characters in the `listings` or `algorithm` environments using `literate` dictionary (e.g. `literate={(á}{{\'a}}1 {é}{{\'e}}1 ...}`) to avoid compilation/rendering issues (blank spaces) on TexPage.

package/skills/writerkit-drafting/SKILL.md

@@ -0,0 +1,17 @@
+name: writerkit-drafting
+description: Use when drafting the raw textual and conceptual content for a book chapter in LaTeX.
+metadata:
+  triggers: chapter drafting, conceptual content, raw text generation, writing placeholders
+---
+
+# Chapter Drafting
+
+## When to Use This Skill
+- Writing initial conceptual content for a book chapter.
+- Drafting text sections based on the planning outline.
+- Inserting code or image placeholders.
+
+## How to Use It
+1. **Read Metadata:** Retrieve the project goals, tone, language, and guidelines from `./memory/memory.json` (Action: `READ_METADATA`).
+2. **Draft Conceptual Content:** Write the chapter content in LaTeX, ensuring you adhere to the professor/didactic tone and scientific rigor defined in the setup phase.
+3. **Insert Placeholders:** Use `\INPUTCODE{id}` and `\INPUTIMG{id}` placeholders for code snippets and images to be integrated later.

package/skills/writerkit-init/SKILL.md

@@ -20,7 +20,7 @@ This skill orchestrates the full lifecycle of technical book production, from in
 The workflow is divided into 8 mandatory phases. **Phase 0 is required once per project.**
 
 0. **Initialization** (`writerkit-init`): **MANDATORY FIRST STEP.** 
-   - Copy the `/home/sekeff/.gemini/antigravity/skills/writerkit-init/memory/` directory to the local project root as `./memory/`.
+   - Copy the `/home/sekeff/.gemini/antigravity/skills/writerkit/writerkit-init/memory/` directory to the local project root as `./memory/`.
    - Create the following project structure:
      - `./chapters`: For chapter `.tex` files.
      - `./codes`: For code snippet `.tex` files, organized by `./codes/chapterxx/`.

package/skills/writerkit-init/resources/tools.json

@@ -8,7 +8,7 @@
     {
       "name": "check_references",
       "description": "Verifies the real-world existence of scientific articles",
-      "execute": "python3 /home/sekeff/.gemini/antigravity/skills/writerkit-init/scripts/reference_checker.py"
+      "execute": "python3 /home/sekeff/.gemini/antigravity/skills/writerkit/writerkit-init/scripts/reference_checker.py"
     }
   ]
 }

package/skills/writerkit-integration/SKILL.md

@@ -0,0 +1,18 @@
+name: writerkit-integration
+description: Use to integrate code snippets, TikZ diagrams, and images into the chapter text, replacing placeholders.
+metadata:
+  triggers: content integration, TikZ diagrams, code embedding, cross-references
+---
+
+# Content Integration
+
+## When to Use This Skill
+- Inserting final validated code snippets into the LaTeX chapter files.
+- Generating TikZ diagrams and illustrations.
+- Setting up and validating cross-references between text, code, and figures.
+
+## How to Use It
+1. **Read Chapter Data:** Fetch the current chapter data and plans from `./memory/memory.json` (Action: `READ_CHAPTER_DATA`).
+2. **Replace Placeholders:** Replace the `\INPUTCODE{id}` and `\INPUTIMG{id}` placeholders with the actual validated code files and images.
+3. **Generate TikZ Diagrams:** Create TikZ diagrams following the `visual_style` guidelines.
+4. **Ensure Cross-References:** Verify that all cross-references (`\ref`, `\label`, `\cite`) are functional and correct.

package/skills/writerkit-planning/SKILL.md

@@ -15,4 +15,4 @@ metadata:
 1. **Review Book Metadata:** Load project goals from `./memory/memory.json`.
 2. **Generate Outline:** Create a detailed structure including conceptual sections, code snippets, and TikZ illustrations.
 3. **Set Learning Objectives:** Define what the student/reader should master by the end of the chapter.
-4. **Save Plan:** Record the approved outline in the project memory.
+4. **Save Plan:** Record the approved outline in the project memory (Action: `WRITE_CHAPTER_PLAN`).

package/skills/writerkit-publication/SKILL.md

@@ -0,0 +1,16 @@
+name: writerkit-publication
+description: Use to finalize the chapter and update the global book index for compilation on TexPage.
+metadata:
+  triggers: finalize chapter, book publication, global index update, compile ready
+---
+
+# Chapter Publication
+
+## When to Use This Skill
+- Preparing a completed, revised chapter for production.
+- Compiling the final LaTeX output files.
+- Updating the global book indices.
+
+## How to Use It
+1. **Generate Final LaTeX:** Ensure the LaTeX code for the chapter is clean, complete, and placed in the target output structure.
+2. **Finalize Chapter State:** Mark the chapter as completed and update the global index in the project memory (Action: `FINALIZE_CHAPTER`).

package/skills/writerkit-review/SKILL.md

@@ -0,0 +1,20 @@
+name: writerkit-review
+description: Use to perform a critical pedagogical and technical peer review of the drafted chapter.
+metadata:
+  triggers: peer review, chapter audit, pedagogical critique, technical verification
+---
+
+# Chapter Review
+
+## When to Use This Skill
+- Auditing a completed chapter draft before final validation.
+- Assessing technical accuracy and educational clarity.
+- Evaluating depth of explanations against target audience level.
+
+## How to Use It
+1. **Read Project Context:** Review book objectives and audience level from the project memory.
+2. **Act as Peer Reviewer:** Critique the draft objectively as a blind peer reviewer. Assess:
+   - Clarity of arguments and explanations.
+   - Technical accuracy of concepts and code.
+   - Pedagogical suitability for the target audience.
+3. **Log Decisions:** Save the review notes, recommendations, and decisions to the decision log in `./memory/memory.json` (Action: `LOG_DECISION`).

package/skills/writerkit-revision/SKILL.md

@@ -0,0 +1,16 @@
+name: writerkit-revision
+description: Use to refactor and improve the chapter based on review feedback and validation findings.
+metadata:
+  triggers: chapter revision, feedback refactoring, style improvement, text editing
+---
+
+# Chapter Revision
+
+## When to Use This Skill
+- Editing chapter content after receiving feedback from the Review and Validation phases.
+- Refactoring sections to improve flow and tone.
+
+## How to Use It
+1. **Apply Corrections:** Address specific review comments and fix any syntax or reference errors found.
+2. **Refine Prose:** Enhance text readability and logical flow while maintaining scientific and academic rigor.
+3. **Update Chapter State:** Record the updated state and revision notes in `./memory/memory.json` (Action: `UPDATE_CHAPTER_STATE`).

package/skills/writerkit-setup/SKILL.md

@@ -23,4 +23,4 @@ metadata:
    - **Primary Programming Language:** For syntax highlighting and accent mapping.
    - **Reference Style:** (e.g., ABNT, IEEE).
 3. **Map Characters:** Configure the `literate` dictionary for the `listings` package to handle accented characters in code.
-4. **Persist State:** Save all configurations, including the **mapped commands/environments and colors**, to `./memory/memory.json` and log the completion in the `decision_log`.
+4. **Persist State:** Save all configurations, including the **mapped commands/environments and colors**, to `./memory/memory.json` (Action: `WRITE_INITIAL_STATE`) and log the completion in the `decision_log`.

package/skills/writerkit-validation/SKILL.md

@@ -0,0 +1,17 @@
+name: writerkit-validation
+description: Use to check LaTeX syntax, environment integrity, and run academic reference validation.
+metadata:
+  triggers: compile check, reference validation, LaTeX syntax, structural check
+---
+
+# Structural & Reference Validation
+
+## When to Use This Skill
+- Verifying LaTeX compilation readiness and syntax.
+- Checking that all LaTeX environments are closed properly.
+- Validating the authenticity of academic citations.
+
+## How to Use It
+1. **Read Metadata:** Load the project's metadata and reference styles from `./memory/memory.json` (Action: `READ_METADATA`).
+2. **Check LaTeX Structure:** Run structural checks on the `.tex` files to verify that all environments (like `\begin` and `\end` tags) are balanced and closed.
+3. **Run Reference Checker:** Invoke the bibliography reference validation script to check the validity of references in the BibTeX or text citations against the database (e.g. using `check_references` tool).

package/skills/writerkit-validation/resources/tools.json

@@ -0,0 +1,9 @@
+{
+  "tools": [
+    {
+      "name": "check_references",
+      "description": "Verifies the real-world existence of scientific articles",
+      "execute": "python3 /home/sekeff/.gemini/antigravity/skills/writerkit/writerkit-validation/scripts/reference_checker.py"
+    }
+  ]
+}

package/skills/writerkit-validation/scripts/reference_checker.py

@@ -0,0 +1,49 @@
+import re
+import urllib.request
+import urllib.error
+import urllib.parse
+import json
+from typing import Dict
+
+# SCRIPT DE VALIDAÇÃO DE REFERÊNCIAS (Reference Checker)
+# Objetivo: Garantir a veracidade de artigos citados no livro, prevenindo alucinações da IA.
+
+def check_paper_existence(title: str, first_author: str = "") -> bool:
+    base_url = "https://api.crossref.org/works?"
+    query_params = {"query.title": title, "rows": 3}
+    if first_author:
+        query_params["query.author"] = first_author
+        
+    url = base_url + urllib.parse.urlencode(query_params)
+    
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'WriterKit-Antigravity/1.0'})
+        with urllib.request.urlopen(req) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                items = data.get("message", {}).get("items", [])
+                if items:
+                    return True
+                return False
+    except urllib.error.URLError as e:
+        print(f"Erro ao acessar CrossRef: {e}")
+        return False
+
+def validate_bibtex(bibtex_content: str) -> Dict[str, str]:
+    results = {}
+    entries = bibtex_content.split("@")
+    for entry in entries[1:]:
+        title_match = re.search(r'title\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        author_match = re.search(r'author\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        id_match = re.search(r'^[^\{]+\{([^,]+),', entry)
+        
+        if title_match and id_match:
+            ref_id = id_match.group(1).strip()
+            title = title_match.group(1).strip()
+            author = author_match.group(1).split(' and ')[0].strip() if author_match else ""
+            
+            print(f"Verificando referência [{ref_id}]: {title}...")
+            is_valid = check_paper_existence(title, author)
+            results[ref_id] = "VERIFICADA_E_VALIDA" if is_valid else "FALHA_NA_VERIFICACAO"
+            
+    return results

package/standards/checklists.md

@@ -0,0 +1,28 @@
+# Padrão de Checklist para Produção de Capítulos
+
+Durante as etapas de **Review** e **Validation**, o agente deve percorrer rigorosamente o checklist abaixo e registrar o resultado na memória.
+
+## 1. Technical Accuracy (Precisão Técnica)
+- [ ] Os exemplos de código foram validados externamente e estão corretos?
+- [ ] As explicações conceituais estão em conformidade com o estado da arte e o rigor matemático exigido?
+- [ ] O uso de APIs/Bibliotecas nos exemplos condiz com a versão mais recente/estável suportada pelo projeto?
+
+## 2. Consistency (Consistência)
+- [ ] A terminologia técnica é uniforme ao longo de todo o capítulo e consistente com os capítulos anteriores?
+- [ ] O estilo de formatação do código (identação, convenção de nomes) segue o `code_style` definido na memória?
+- [ ] O mapeamento de acentuação (literate) no LaTeX está implementado corretamente nos blocos de código?
+
+## 3. Readability (Legibilidade e Fluidez)
+- [ ] O texto possui cadência lógica (introdução, desenvolvimento, conclusão parcial) sem saltos bruscos?
+- [ ] A linguagem está adequada ao tom estabelecido na memória?
+- [ ] Os parágrafos são coesos e evitam jargões desnecessários quando não explicados previamente?
+
+## 4. Completeness (Completude)
+- [ ] Os pré-requisitos lógicos para a compreensão do capítulo foram declarados?
+- [ ] Os objetivos de aprendizagem traçados na fase de *Planning* foram integralmente alcançados?
+- [ ] Há uma seção de fechamento/resumo que consolida o conhecimento adquirido?
+
+## 5. Cross-references (Referências e Navegação)
+- [ ] Todos os *labels* e *refs* internos (imagens, tabelas, algoritmos) foram validados e não apontam para locais nulos?
+- [ ] Todas as citações bibliográficas (\cite) correspondem a uma entrada válida no arquivo BibTeX?
+- [ ] **Validação Externa:** Todas as referências bibliográficas foram verificadas com sucesso em bases acadêmicas (Google Scholar, ScienceDirect, IEEE, etc.)?

package/workflow/orchestrator.md

@@ -0,0 +1,15 @@
+# Workflow Orquestrador: `/writerkit-chapter`
+
+Esta *skill* orquestra o fluxo ponta-a-ponta para a produção de um capítulo, invocando sequencialmente as *skills* individuais.
+
+## Etapas do Workflow
+1. **Planning** (`/writer-planning`): Define chapter objectives, outline sections, identify code examples.
+2. **Drafting** (`/writer-drafting`): Use chapter template, write conceptual content, add placeholders.
+3. **Code Development** (`/writer-code`): Implement and test code examples externally (mapping accents).
+4. **Integration** (`/writer-integration`): Insert validated code into chapter, add explanations.
+5. **Review** (`/writer-review`): Self-review using the production checklist.
+6. **Validation** (`/writer-validation`): Run validation scripts (including the Reference Checker).
+7. **Revision** (`/writer-revision`): Address issues and improve clarity.
+8. **Publication** (`/writer-publication`): Finalize and publish chapter.
+
+*Nota: Todas as decisões e transições de estado devem ser registradas no `decision_log` da memória.*

package/writerkit_antigo/memory/schema.md

@@ -0,0 +1,18 @@
+# Módulo de Memória e Estado
+
+O arquivo de memória (ex: `memory.json`) deve ser mantido e atualizado constantemente pelas *skills*.
+
+## Estrutura de Metadados do Projeto
+* **`title`**: Título da obra.
+* **`theme`**: Tema central e escopo.
+* **`language`**: Idioma da obra (ex: pt-BR).
+* **`depth`**: Nível de profundidade (Graduação, Mestrado, Técnico).
+* **`rigor`**: Nível de formalismo matemático/teórico.
+* **`tone`**: Personalidade do texto (Formal, Professoral, Crítico).
+* **`code_style`**: Linguagem e guia de estilo de código.
+* **`visual_style`**: Padrão para imagens e diagramas (ex: TikZ, preto e branco).
+* **`latex_template`**: Referências aos arquivos `.tex`, `.cls` e `.sty` utilizados.
+
+## Logs e Controle
+* **`chapters`**: Status e metadados de cada capítulo.
+* **`decision_log`**: Histórico temporal (timestamps) de todas as decisões tomadas.

package/writerkit_antigo/scripts/reference_checker.py

@@ -0,0 +1,49 @@
+import re
+import urllib.request
+import urllib.error
+import urllib.parse
+import json
+from typing import Dict
+
+# SCRIPT DE VALIDAÇÃO DE REFERÊNCIAS (Reference Checker)
+# Objetivo: Garantir a veracidade de artigos citados no livro, prevenindo alucinações da IA.
+
+def check_paper_existence(title: str, first_author: str = "") -> bool:
+    base_url = "https://api.crossref.org/works?"
+    query_params = {"query.title": title, "rows": 3}
+    if first_author:
+        query_params["query.author"] = first_author
+        
+    url = base_url + urllib.parse.urlencode(query_params)
+    
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'WriterKit-Antigravity/1.0'})
+        with urllib.request.urlopen(req) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                items = data.get("message", {}).get("items", [])
+                if items:
+                    return True
+                return False
+    except urllib.error.URLError as e:
+        print(f"Erro ao acessar CrossRef: {e}")
+        return False
+
+def validate_bibtex(bibtex_content: str) -> Dict[str, str]:
+    results = {}
+    entries = bibtex_content.split("@")
+    for entry in entries[1:]:
+        title_match = re.search(r'title\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        author_match = re.search(r'author\s*=\s*[{"]([^}"]+)[}"]', entry, re.IGNORECASE)
+        id_match = re.search(r'^[^\{]+\{([^,]+),', entry)
+        
+        if title_match and id_match:
+            ref_id = id_match.group(1).strip()
+            title = title_match.group(1).strip()
+            author = author_match.group(1).split(' and ')[0].strip() if author_match else ""
+            
+            print(f"Verificando referência [{ref_id}]: {title}...")
+            is_valid = check_paper_existence(title, author)
+            results[ref_id] = "VERIFICADA_E_VALIDA" if is_valid else "FALHA_NA_VERIFICACAO"
+            
+    return results

package/writerkit_antigo/skills/skill_code.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-code`
+
+## Objetivo
+Desenvolvimento e validação de algoritmos.
+
+## Instruções de Execução
+Desenvolva o código seguindo o padrão da memória. **Requisito Crítico:** Mapeie caracteres acentuados latinos no ambiente `listings` ou `algorithm` usando `literate={(á}{{\'a}}1 {é}{{\'e}}1 ...}` para evitar falhas de renderização (espaços em branco) no TexPage.
+
+## Interação com a Memória
+**Ação:** `READ_CODE_STYLE`

package/writerkit_antigo/skills/skill_drafting.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-drafting`
+
+## Objetivo
+Geração de conteúdo textual bruto em LaTeX.
+
+## Instruções de Execução
+Escreva o conteúdo conceitual seguindo o outline. Use o tom professoral e rigor científico definidos. Utilize placeholders `\INPUTCODE{id}` e `\INPUTIMG{id}` para futura integração.
+
+## Interação com a Memória
+**Ação:** `READ_METADATA`

package/writerkit_antigo/skills/skill_integration.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-integration`
+
+## Objetivo
+Consolidar texto, código e diagramas TikZ.
+
+## Instruções de Execução
+Substitua placeholders pelos códigos validados. Gere diagramas em TikZ conforme o visual_style. Garanta referências cruzadas funcionais.
+
+## Interação com a Memória
+**Ação:** `READ_CHAPTER_DATA`

package/writerkit_antigo/skills/skill_planning.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-planning`
+
+## Objetivo
+Estruturar a ementa e objetivos do capítulo.
+
+## Instruções de Execução
+Com base no tema do livro, gere um outline detalhado (H1, H2, H3). Identifique onde entrarão exemplos de código e diagramas. Registre o plano aprovado na memória do projeto.
+
+## Interação com a Memória
+**Ação:** `WRITE_CHAPTER_PLAN`

package/writerkit_antigo/skills/skill_publication.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-publication`
+
+## Objetivo
+Finalização para o TexPage.
+
+## Instruções de Execução
+Gere o código LaTeX final pronto para compilação. Atualize o índice global do livro na memória.
+
+## Interação com a Memória
+**Ação:** `FINALIZE_CHAPTER`

package/writerkit_antigo/skills/skill_review.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-review`
+
+## Objetivo
+Análise crítica e pedagógica.
+
+## Instruções de Execução
+Atue como um revisor de pares cego. Critique a clareza, a precisão técnica e se o nível de profundidade está adequado ao público-alvo definido na memória.
+
+## Interação com a Memória
+**Ação:** `LOG_DECISION`

package/writerkit_antigo/skills/skill_revision.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-revision`
+
+## Objetivo
+Refatoração do conteúdo pós-revisão.
+
+## Instruções de Execução
+Aplique as correções sugeridas na etapa de Review e Validation. Melhore a fluidez do texto mantendo o rigor científico.
+
+## Interação com a Memória
+**Ação:** `UPDATE_CHAPTER_STATE`

package/writerkit_antigo/skills/skill_setup.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-setup`
+
+## Objetivo
+Inicializar projeto e assimilar padrões LaTeX.
+
+## Instruções de Execução
+Analise os arquivos .tex, .cls e .sty fornecidos. Extraia pacotes, comandos customizados e estrutura de preâmbulo. Inicialize o arquivo de memória com os parâmetros de profundidade, idioma e tom definidos pelo usuário.
+
+## Interação com a Memória
+**Ação:** `WRITE_INITIAL_STATE`

package/writerkit_antigo/skills/skill_validation.md

@@ -0,0 +1,10 @@
+# Skill: `/writer-validation`
+
+## Objetivo
+Verificação técnica de estrutura e compilação.
+
+## Instruções de Execução
+Verifique a sintaxe LaTeX, fechamento de ambientes e integridade estrutural. Invoque o script de checagem de referências bibliográficas.
+
+## Interação com a Memória
+**Ação:** `READ_METADATA`

package/writerkit_antigo/standards/checklists.md

@@ -0,0 +1,28 @@
+# Padrão de Checklist para Produção de Capítulos
+
+Durante as etapas de **Review** e **Validation**, o agente deve percorrer rigorosamente o checklist abaixo e registrar o resultado na memória.
+
+## 1. Technical Accuracy (Precisão Técnica)
+- [ ] Os exemplos de código foram validados externamente e estão corretos?
+- [ ] As explicações conceituais estão em conformidade com o estado da arte e o rigor matemático exigido?
+- [ ] O uso de APIs/Bibliotecas nos exemplos condiz com a versão mais recente/estável suportada pelo projeto?
+
+## 2. Consistency (Consistência)
+- [ ] A terminologia técnica é uniforme ao longo de todo o capítulo e consistente com os capítulos anteriores?
+- [ ] O estilo de formatação do código (identação, convenção de nomes) segue o `code_style` definido na memória?
+- [ ] O mapeamento de acentuação (literate) no LaTeX está implementado corretamente nos blocos de código?
+
+## 3. Readability (Legibilidade e Fluidez)
+- [ ] O texto possui cadência lógica (introdução, desenvolvimento, conclusão parcial) sem saltos bruscos?
+- [ ] A linguagem está adequada ao tom estabelecido na memória?
+- [ ] Os parágrafos são coesos e evitam jargões desnecessários quando não explicados previamente?
+
+## 4. Completeness (Completude)
+- [ ] Os pré-requisitos lógicos para a compreensão do capítulo foram declarados?
+- [ ] Os objetivos de aprendizagem traçados na fase de *Planning* foram integralmente alcançados?
+- [ ] Há uma seção de fechamento/resumo que consolida o conhecimento adquirido?
+
+## 5. Cross-references (Referências e Navegação)
+- [ ] Todos os *labels* e *refs* internos (imagens, tabelas, algoritmos) foram validados e não apontam para locais nulos?
+- [ ] Todas as citações bibliográficas (\cite) correspondem a uma entrada válida no arquivo BibTeX?
+- [ ] **Validação Externa:** Todas as referências bibliográficas foram verificadas com sucesso em bases acadêmicas (Google Scholar, ScienceDirect, IEEE, etc.)?

package/writerkit_antigo/workflow/orchestrator.md

@@ -0,0 +1,15 @@
+# Workflow Orquestrador: `/writerkit-chapter`
+
+Esta *skill* orquestra o fluxo ponta-a-ponta para a produção de um capítulo, invocando sequencialmente as *skills* individuais.
+
+## Etapas do Workflow
+1. **Planning** (`/writer-planning`): Define chapter objectives, outline sections, identify code examples.
+2. **Drafting** (`/writer-drafting`): Use chapter template, write conceptual content, add placeholders.
+3. **Code Development** (`/writer-code`): Implement and test code examples externally (mapping accents).
+4. **Integration** (`/writer-integration`): Insert validated code into chapter, add explanations.
+5. **Review** (`/writer-review`): Self-review using the production checklist.
+6. **Validation** (`/writer-validation`): Run validation scripts (including the Reference Checker).
+7. **Revision** (`/writer-revision`): Address issues and improve clarity.
+8. **Publication** (`/writer-publication`): Finalize and publish chapter.
+
+*Nota: Todas as decisões e transições de estado devem ser registradas no `decision_log` da memória.*