@aksp/opencrew 1.4.1 → 1.5.0

package/templates/_opencrew/core/best-practices/instagram-feed.md

@@ -8,14 +8,14 @@ whenToUse: |
 constraints:
   caption_max_chars: 2200
   caption_visible_chars: 125
-  max_hashtags: 30
+  hashtags_max: 30
   recommended_hashtags: "5-15"
-  carousel_max_slides: 20
+  carousel_max_slides: 10
   recommended_slides: "8-10"
   min_words_per_slide: 40
   max_words_per_slide: 80
-  image_ratio: "3:4 portrait"
-  image_resolution: "1080x1440px"
+  image_ratio: "4:5 portrait"
+  image_resolution: "1080x1350px"
 version: "1.0.0"
 ---
 

package/templates/_opencrew/core/best-practices/instagram-reels.md

@@ -11,7 +11,7 @@ constraints:
   aspect_ratio: "9:16 vertical"
   caption_max_chars: 2200
   caption_visible_chars: 125
-  max_hashtags: 30
+  hashtags_max: 30
 version: "1.0.0"
 ---
 

package/templates/_opencrew/core/best-practices/review.md

@@ -22,6 +22,13 @@ version: "1.0.0"
 10. Assign an APPROVE verdict only if overall score is >= 7/10 and no criterion is < 4/10.
 11. Include at least one acknowledged strength, even in REJECT reviews.
 12. Provide a specific fix or rewrite example for every required change.
+13. **Números medidos, nunca estimados** — nunca estime contagens (caracteres, hashtags, links,
+    slides): copie os valores do relatório `--- VERIFICAÇÃO AUTOMÁTICA ---`. Checklist só marca ✓
+    o que o relatório confirma.
+14. **Sem APPROVE com bloqueio** — qualquer bloqueio no relatório da verificação automática é
+    REJECT, seja qual for a nota (exceto `[PREENCHER]`, que vai para o usuário na aprovação final).
+15. **Alerta limita a nota** — com alerta não resolvido nem justificado, a nota máxima é 7/10;
+    liste cada alerta e diga se foi resolvido.
 
 <!-- End Compact Rules. Full reference below. -->
 

package/templates/_opencrew/core/best-practices/social-networks-publishing.md

@@ -150,13 +150,13 @@ Platform:  Instagram (carousel)
 Account:   @brandname
 Skill:     instagram-publisher
 Images:    7 slides
-  1. slide-01.jpg (1080x1440, JPEG, 287KB)
-  2. slide-02.jpg (1080x1440, JPEG, 195KB)
-  3. slide-03.jpg (1080x1440, JPEG, 213KB)
-  4. slide-04.jpg (1080x1440, JPEG, 178KB)
-  5. slide-05.jpg (1080x1440, JPEG, 201KB)
-  6. slide-06.jpg (1080x1440, JPEG, 192KB)
-  7. slide-07.jpg (1080x1440, JPEG, 244KB)
+  1. slide-01.jpg (1080x1350, JPEG, 287KB)
+  2. slide-02.jpg (1080x1350, JPEG, 195KB)
+  3. slide-03.jpg (1080x1350, JPEG, 213KB)
+  4. slide-04.jpg (1080x1350, JPEG, 178KB)
+  5. slide-05.jpg (1080x1350, JPEG, 201KB)
+  6. slide-06.jpg (1080x1350, JPEG, 192KB)
+  7. slide-07.jpg (1080x1350, JPEG, 244KB)
 
 Caption (1,847 / 2,200 chars):
   "You are doing 100 things to grow on Instagram.
@@ -173,7 +173,7 @@ Caption (1,847 / 2,200 chars):
 VALIDATION
   Image format: JPEG (required: JPEG)
   Image count: 7 (required: 2-10)
-  Image dimensions: 1080x1440 (valid carousel)
+  Image dimensions: 1080x1350 (valid carousel)
   Caption length: 1,847 chars (max: 2,200)
   Hashtags: 5 (recommended: 5-8)
   Rate limit: 3/25 posts used in last 24h

package/templates/_opencrew/core/prompts/build.prompt.md

@@ -271,6 +271,10 @@ with placeholders. 1 example acceptable if it is comprehensive; 2 preferred if s
 3. [Specific mistake]: [Why it's harmful]
 4. [Specific mistake]: [Why it's harmful]
 (Minimum 4 items. Each sourced from research on common domain mistakes.)
+**Every agent that writes content** (writer, copywriter, creator, consultant, strategist) MUST
+also include this item, verbatim in meaning: "Never invent cases, testimonials, clients, numbers,
+dates or first-person stories — nunca invente; when real data is missing, write
+`[PREENCHER: o que falta]` so the user fills it in at final approval."
 
 ### Always Do
 1. [Specific positive practice]: [Why it matters]
@@ -390,9 +394,16 @@ model_tier: fast      # ONLY for execution: subagent. fast = lightweight model;
                       # Set fast for: investigator agents (data extraction, Sherlock subagents), researcher agents (web search, data gathering)
                       # Set powerful for: writer, creator, reviewer, strategy agents
                       # Omit model_tier for execution: inline steps
+side_effects: irreversible  # REQUIRED for any step that publishes, posts, sends email or otherwise
+                            # distributes outside the project (it cannot be undone). The Pipeline
+                            # Runner never retries these automatically, and Gate 2c places them last.
+                            # Omit for every other step.
 ---
 ```
 
+**Irreversible steps must run inline** (`execution: inline`), so the user sees the dry run and
+gives the explicit go-ahead in the main conversation.
+
 For **checkpoints**, use this frontmatter instead:
 ```yaml
 ---
@@ -572,6 +583,20 @@ If ANY check fails:
 4. Generate a step file for the new checkpoint that asks the user to review and approve the preceding agent's output before the visual/publish step runs
 5. Re-validate Gate 2b. Max 2 fix attempts — after that, present to user for manual decision.
 
+### Gate 2c: Irreversible Steps Last (BLOCKING)
+
+For EACH step that publishes, posts, sends email or distributes outside the project:
+- [ ] Its frontmatter declares `side_effects: irreversible` and `execution: inline`
+- [ ] It comes AFTER the Review step (the reviewer has already approved the final content)
+- [ ] The IMMEDIATELY preceding step is a `type: checkpoint` (Final Approval) that itself comes after the Review
+- [ ] Only other irreversible steps follow it (nothing is created, rendered or reviewed after publishing)
+
+If ANY check fails:
+1. Add the missing `side_effects: irreversible` / `execution: inline` fields
+2. Move the irreversible step(s) to the end of the pipeline, after Review → Final Approval checkpoint
+   (create the Final Approval checkpoint if it does not exist), and renumber the steps
+3. Re-validate Gate 2c. Max 2 fix attempts — after that, present to user for manual decision.
+
 ### Gate 3: Pipeline Coherence (ADVISORY)
 
 Verify:

package/templates/_opencrew/core/prompts/design.prompt.md

@@ -525,10 +525,14 @@ ERRADO: 5 noticias diferentes = NAO sao angulos, sao pautas distintas
 
 #### Pipeline Patterns
 
-- **Standard (fixed source):** Research → Angle Selection checkpoint → Creation → Content Approval checkpoint → [Execution Steps] → Review → Final Approval checkpoint
-- **News-based (multiple stories):** Research → News Selection checkpoint → Creator[generate-angles] → Angle Selection checkpoint → Creator[create+optimize] → Content Approval checkpoint → [Execution Steps] → Review → Final Approval checkpoint
+- **Standard (fixed source):** Research → Angle Selection checkpoint → Creation → Content Approval checkpoint → [Render Steps] → Review → Final Approval checkpoint → [Publish/Send Steps]
+- **News-based (multiple stories):** Research → News Selection checkpoint → Creator[generate-angles] → Angle Selection checkpoint → Creator[create+optimize] → Content Approval checkpoint → [Render Steps] → Review → Final Approval checkpoint → [Publish/Send Steps]
 
-**Content Approval checkpoint is MANDATORY** whenever the pipeline includes any execution step after content creation (image generation, visual rendering, publishing, distribution, etc.). Never place an execution step immediately after a creation step without a checkpoint in between.
+**Render Steps** (image generation, visual rendering, slides) are reversible and run BEFORE the Review, so the reviewer sees the final visuals.
+
+**Publish/Send Steps** (social media posting, email sending, any distribution outside the project) are IRREVERSIBLE: they ALWAYS come last — after the Review and immediately after the Final Approval checkpoint — and their step files declare `side_effects: irreversible` (see build.prompt.md, Pipeline Step Format and Gate 2c). Never place a publish/send step before the Review. Omit either bracket when the crew has no such step.
+
+**Content Approval checkpoint is MANDATORY** whenever the pipeline includes any render step after content creation. Never place a render step immediately after a creation step without a checkpoint in between.
 
 On reject: loop back to creation step (re-execute full creator, not individual tasks).
 
@@ -555,8 +559,8 @@ I'll create a crew with N agents:
    Format: [format name, if applicable]
 ...
 
-Pipeline (fixed source): [Research] → checkpoint Select Angle → [Creator] → checkpoint Approve Content → [Execution] → [Review] → checkpoint Approve
-Pipeline (news-based): [Research] → checkpoint Select News → [Creator: generate angles] → checkpoint Select Angle → [Creator: create content] → checkpoint Approve Content → [Execution] → [Review] → checkpoint Approve
+Pipeline (fixed source): [Research] → checkpoint Select Angle → [Creator] → checkpoint Approve Content → [Render] → [Review] → checkpoint Final Approval → [Publish/Send]
+Pipeline (news-based): [Research] → checkpoint Select News → [Creator: generate angles] → checkpoint Select Angle → [Creator: create content] → checkpoint Approve Content → [Render] → [Review] → checkpoint Final Approval → [Publish/Send]
 Formats: [list of selected formats, e.g., instagram-feed, twitter-thread]
 
 Reference materials: [list of data files]

package/templates/_opencrew/core/runner.pipeline.md

@@ -20,7 +20,8 @@ Before starting execution:
     optional, opt-in feature that most installs never use (it requires running the
     separate dashboard app from source — see README). Scan the already-loaded
     `preferences.md` for a `Dashboard:` field:
-    - If it reads `Dashboard: enabled` → set `dashboard_enabled = true` for this run.
+    - If its value is `enabled` (as written by onboarding: `- **Dashboard:** enabled`, or the
+      plain form `Dashboard: enabled`) → set `dashboard_enabled = true` for this run.
     - Otherwise (`disabled`, missing, or preferences.md not configured yet) →
       set `dashboard_enabled = false`. This is the default.
     Store `dashboard_enabled` in working memory for the rest of this run. Every
@@ -309,6 +310,15 @@ Before executing any step that references an agent:
    c. Inject this block immediately after the agent definition and BEFORE format/skill context.
    d. Skip sections that are empty or not relevant to the current agent (e.g., skip Design Visual for a writer agent).
    e. If `memories.md` has no accumulated rules → skip injection entirely (no empty block).
+   f. **Truthfulness block (always)** — for every agent step that is not a checkpoint and not a
+      review step (no `on_reject:`), inject right after the crew memory block:
+      ```
+      --- REGRAS DE VERACIDADE ---
+      - Nunca invente casos, depoimentos, clientes, números, datas ou histórias em 1ª pessoa.
+      - Use só fatos do briefing, da pesquisa (com fonte) ou do perfil da empresa.
+      - Faltou um dado real? Escreva [PREENCHER: o que falta] no lugar — o usuário completa
+        na aprovação final. Um [PREENCHER] honesto vale mais que um exemplo inventado.
+      ```
 
 ### Context Compression (Summary-Based Handoff)
 
@@ -546,7 +556,12 @@ Use the **stored transformed path** (after Output Path Transformation Steps 1 an
 
 **Rules:**
 - If ALL output files return `VALIDATION:PASS` → proceed to Veto Condition Enforcement.
-- If ANY output file returns `VALIDATION:FAIL`:
+- **Irreversible step** (`side_effects: irreversible` — publish, post, send) with ANY
+  `VALIDATION:FAIL` → NEVER re-execute it. Tell the user: "⚠️ {Agent Name} did not save its
+  output, but the action may already have happened (post published / email sent). Check
+  before retrying." Then offer: 1. Retry step (only after the user checked) · 2. Mark as done
+  and continue · 3. Abort pipeline.
+- If ANY output file returns `VALIDATION:FAIL` (any other step):
   1. **Retry once**: re-execute the entire step with the same input and context.
   2. After re-execution, run the validation again for all output files.
   3. If second attempt returns `VALIDATION:PASS` for all files → proceed normally.
@@ -612,6 +627,9 @@ After an agent completes a step (before moving to the next step):
    - Ask the agent to fix the specific issue (re-execute with targeted correction)
    - Maximum 2 veto fix attempts per step
    - After 2 failed attempts, present to user for manual decision
+   - **Never auto-fix an irreversible step** (`side_effects: irreversible`): re-executing it
+     would publish/send again. Report the veto, warn the user that
+     the action may already have happened, and let the user decide.
 4. If no veto conditions triggered: proceed to next step
 
 This creates an internal quality loop BEFORE the reviewer sees the content,
@@ -619,11 +637,39 @@ catching obvious issues early and reducing review cycle waste.
 
 ### Review Loops
 
-When a step has `on_reject: {step-id}`:
-- Track the review cycle count
-- If reviewer rejects, go back to the referenced step
-- Pass reviewer feedback to the writer agent
-- If max_review_cycles reached, present to user for manual decision
+When a step has `on_reject: {step-id}` (a review step):
+
+1. **Automatic check BEFORE the reviewer runs** — run the checker on **all outputs** (todas as
+   saídas) of every non-checkpoint step from the `on_reject` step up to the step right before
+   the review, using the transformed paths of this run (run_id/vN):
+   ```bash
+   node _opencrew/core/scripts/verificar.mjs --crew crews/{name} --arquivo "{path1},{path2},…" --formato {blog format id of those steps, if any}
+   ```
+   Save the full output to `crews/{name}/output/{run_id}/verificacao-ciclo-{N}.md` and inject it
+   into the reviewer's context as `--- VERIFICAÇÃO AUTOMÁTICA ---`. The reviewer must copy the
+   measured values from it (see best-practices `review.md`). If the command itself fails (no
+   Node, unexpected error), tell the user "⚠️ A verificação automática não rodou: {motivo}" and
+   continue with the normal review.
+2. **A block cannot be approved** — if the last line of the checker output is
+   `VERIFICACAO:BLOQUEADA`, the verdict is **REJECT** regardless of the score (qualquer que seja a
+   nota). Send the report (blocks first) to the writer together with the reviewer's feedback.
+   If the last line is `VERIFICACAO:AGUARDANDO_USUARIO`, the only blocks are `[PREENCHER: …]`
+   (real data only the user has): do NOT reject for them — the reviewer judges the rest, and the
+   final approval below collects the missing data from the user.
+3. Track the review cycle count. If the reviewer rejects, go back to the referenced step.
+4. If max_review_cycles is reached with blocks remaining, present the report to the user:
+   ```
+   ⚠️ A revisão ainda encontra bloqueios depois de {N} ciclos:
+   {lista de bloqueios do relatório}
+
+   1. Corrigir eu mesmo (eu edito o texto e você verifica de novo)
+   2. Aceitar assim mesmo (fica registrado no histórico da execução)
+   3. Abortar
+   ```
+5. **Final approval checkpoint** (the checkpoint after the review): show the summary of the last
+   report — `Verificação automática: {N} bloqueios, {M} alertas` — plus the list of alerts. If the
+   approved text still contains `[PREENCHER: …]`, ask the user for each missing piece of real
+   information and write it into the text before approving.
 
 ### Dashboard Handoff (between steps)
 
@@ -809,6 +855,9 @@ This archives the run state for the `runs` command while keeping crew history av
 ## Error Handling
 
 - If a subagent fails, retry once. If it fails again, inform the user and offer to skip the step or abort.
+- If an irreversible step (`side_effects: irreversible`) fails, NEVER retry it automatically:
+  the post/email may already have happened. Tell the user so, ask them to check, and let them
+  choose: retry, mark as done, or abort.
 - If a step file is missing, inform the user and suggest running `/opencrew edit {crew}` to fix.
 - If company.md is empty, stop and redirect to onboarding.
 - Never continue past a checkpoint without user input.

package/templates/_opencrew/core/scripts/verificar/leitura.mjs

@@ -0,0 +1,99 @@
+// Leitura para o verificador automático: frontmatter, limites dos formatos (constraints:),
+// seções de um texto e proibições da memória da crew. Node puro, sem dependências.
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+function valorYaml(bruto) {
+  const v = bruto.trim();
+  const aspas = v.match(/^"(.*)"$/) ?? v.match(/^'(.*)'$/);
+  if (aspas) return aspas[1].replace(/\\"/g, '"');
+  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+  return v;
+}
+
+/** Frontmatter YAML simples: `chave: valor` e um nível de bloco (ex.: `constraints:`). */
+export function lerFrontmatter(texto) {
+  const m = texto.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const dados = {};
+  let bloco = null;
+  for (const linha of m[1].split(/\r?\n/)) {
+    const topo = linha.match(/^([\w-]+):\s*(.*)$/);
+    if (topo) {
+      const [, chave, valor] = topo;
+      bloco = valor.trim() === '' ? chave : null;
+      dados[chave] = bloco ? {} : valorYaml(valor);
+      continue;
+    }
+    const filho = linha.match(/^\s+([\w-]+):\s*(.*)$/);
+    if (filho && bloco) dados[bloco][filho[1]] = valorYaml(filho[2]);
+  }
+  return dados;
+}
+
+/** Corpo do texto sem o frontmatter. */
+export function semFrontmatter(texto) {
+  return texto.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+}
+
+/** Limites do formato: `constraints:` de `_opencrew/core/best-practices/<id>.md`. */
+export async function lerLimites(raiz, formatoId) {
+  const arquivo = path.join(raiz, '_opencrew', 'core', 'best-practices', `${formatoId}.md`);
+  if (!existsSync(arquivo)) return null;
+  return lerFrontmatter(await readFile(arquivo, 'utf8'))?.constraints ?? {};
+}
+
+/**
+ * Seções por cabeçalho markdown. O corpo vai até o próximo cabeçalho de nível igual ou
+ * maior, ou até uma linha `---` (separador).
+ */
+export function lerSecoes(texto) {
+  const linhas = semFrontmatter(texto).split(/\r?\n/);
+  const secoes = [];
+  linhas.forEach((linha, i) => {
+    const h = linha.match(/^(#{1,6})\s+(.*)$/);
+    if (!h) return;
+    const nivel = h[1].length;
+    const corpo = [];
+    for (const seguinte of linhas.slice(i + 1)) {
+      const h2 = seguinte.match(/^(#{1,6})\s/);
+      if ((h2 && h2[1].length <= nivel) || /^---\s*$/.test(seguinte)) break;
+      corpo.push(seguinte);
+    }
+    secoes.push({ titulo: h[2].trim(), nivel, corpo: corpo.join('\n').trim() });
+  });
+  return secoes;
+}
+
+const semAcento = (s) => s.normalize('NFD').replace(/\p{Diacritic}/gu, '').toLowerCase();
+export { semAcento };
+
+const ASPAS = /"([^"]+)"|“([^”]+)”|‘([^’]+)’|`([^`]+)`|(?<![\p{L}])'([^']+)'(?![\p{L}])/gu;
+
+/**
+ * Termos proibidos: o que estiver entre aspas nos itens de `## Proibições Explícitas`
+ * do `memories.md` da crew. Itens sem aspas são contados, mas não verificados.
+ */
+export async function lerProibicoes(raiz, crew) {
+  const arquivo = path.join(raiz, crew, '_memory', 'memories.md');
+  if (!existsSync(arquivo)) return { existe: false, termos: [], semAspas: 0 };
+  const secao = lerSecoes(await readFile(arquivo, 'utf8'))
+    .find((s) => s.nivel === 2 && semAcento(s.titulo).startsWith('proibicoes explicitas'));
+  const termos = [];
+  let semAspas = 0;
+  for (const linha of (secao?.corpo ?? '').split('\n').filter((l) => /^\s*[-*]\s+/.test(l))) {
+    const achados = [...linha.matchAll(ASPAS)].map((m) => m.slice(1).find(Boolean));
+    if (achados.length) termos.push(...achados);
+    else semAspas += 1;
+  }
+  return { existe: true, termos, semAspas };
+}
+
+/** Domínio do site da empresa (para separar links internos de externos), se houver. */
+export async function lerDominioDoSite(raiz) {
+  const arquivo = path.join(raiz, '_opencrew', '_memory', 'company.md');
+  if (!existsSync(arquivo)) return null;
+  const m = (await readFile(arquivo, 'utf8')).match(/(?:site|website)[^\n]*?https?:\/\/([^\s/)>\]]+)/i);
+  return m ? m[1].replace(/^www\./, '').toLowerCase() : null;
+}

package/templates/_opencrew/core/scripts/verificar/regras.mjs

@@ -0,0 +1,127 @@
+// Regras do verificador automático (specs/fase-u1-revisor-com-dentes.md §5).
+// Máximos bloqueiam (fácil de corrigir: encurtar); mínimos alertam (podem depender do usuário).
+import { lerFrontmatter, semFrontmatter, semAcento } from './leitura.mjs';
+
+const segmentador = new Intl.Segmenter('pt', { granularity: 'grapheme' });
+
+/** Bloqueio que só o usuário resolve ([PREENCHER: …]). */
+export const FALTA_INFO = 'Falta informação sua';
+
+/** Caracteres visíveis: sem marcadores de negrito/itálico; emoji conta 1. */
+export function contar(texto) {
+  const limpo = String(texto).replace(/\*\*|__/g, '').replace(/\*([^*\n]+)\*/g, '$1').trim();
+  return [...segmentador.segment(limpo)].length;
+}
+
+const contarHashtags = (texto) => (texto.match(/#[\p{L}\p{N}_]+/gu) ?? []).length;
+
+const item = (nome, medido, limite, nivel, detalhe = '') => ({ item: nome, medido, limite, nivel, detalhe });
+
+function maximo(nome, medido, limite) {
+  if (typeof limite !== 'number') return null;
+  return item(nome, medido, limite, medido > limite ? 'bloqueio' : 'ok');
+}
+
+function minimo(nome, medido, limite) {
+  if (typeof limite !== 'number') return null;
+  return item(nome, medido, limite, medido < limite ? 'alerta' : 'ok');
+}
+
+const NAO_CONTA = /^(mailto:|tel:|https?:\/\/(wa\.me|api\.whatsapp\.com)\/)/i;
+
+function contarLinks(corpo, dominio) {
+  const urls = [...corpo.matchAll(/\[[^\]]*\]\(([^)\s]+)[^)]*\)/g)].map((m) => m[1]).filter((u) => !NAO_CONTA.test(u));
+  const interno = (u) => !/^https?:\/\//i.test(u) || (dominio && new URL(u).hostname.replace(/^www\./, '') === dominio);
+  return { internos: urls.filter(interno).length, externos: urls.filter((u) => !interno(u)).length };
+}
+
+/** Blog: frontmatter com título → título, meta description e links. */
+export function regrasBlog(texto, limites, dominio) {
+  const fm = lerFrontmatter(texto);
+  const titulo = fm?.title ?? fm?.titulo;
+  if (titulo == null || !limites) return [];
+  const meta = fm.meta_description ?? fm.meta_descricao;
+  const { internos, externos } = contarLinks(semFrontmatter(texto), dominio);
+  return [
+    maximo('Título (SEO) — caracteres', contar(titulo), limites.title_max_chars),
+    meta != null ? maximo('Meta description — caracteres', contar(meta), limites.meta_description_chars) : null,
+    minimo('Links internos', internos, limites.min_internal_links),
+    minimo('Links externos', externos, limites.min_external_links),
+  ].filter(Boolean);
+}
+
+/** Seções por canal (cabeçalhos "Legenda Instagram", "Post LinkedIn", "Tweet"…). */
+export function regrasCanais(secoes, limitesPorFormato) {
+  const itens = [];
+  for (const s of secoes) {
+    const t = semAcento(s.titulo);
+    const ig = limitesPorFormato['instagram-feed'];
+    if (/instagram/.test(t) && /legenda|caption/.test(t) && ig) {
+      itens.push(maximo('Legenda Instagram — caracteres', contar(s.corpo), ig.caption_max_chars));
+      itens.push(maximo('Legenda Instagram — hashtags', contarHashtags(s.corpo), ig.hashtags_max));
+    } else if (/instagram/.test(t) && /carrossel|carousel/.test(t) && ig) {
+      const slides = (s.corpo.match(/^\s*(?:#{3,6}\s*|\*\*\s*)slide\s*\d+/gim) ?? []).length;
+      if (slides) itens.push(maximo('Carrossel Instagram — slides', slides, ig.carousel_max_slides));
+    }
+    const li = limitesPorFormato['linkedin-post'];
+    if (/linkedin/.test(t) && !/carrossel|carousel/.test(t) && li) {
+      itens.push(maximo('Post LinkedIn — caracteres', contar(s.corpo), li.post_max_chars));
+      itens.push(maximo('Post LinkedIn — hashtags', contarHashtags(s.corpo), li.hashtags_max));
+    }
+    const tw = limitesPorFormato['twitter-post'];
+    if (/tweet|twitter/.test(t) && tw) {
+      s.corpo.split(/\n\s*\n/).filter((p) => p.trim()).forEach((p, i) => {
+        const r = maximo(`Tweet ${i + 1} — caracteres`, contar(p), tw.tweet_max_chars);
+        if (r?.nivel === 'bloqueio') itens.push(r);
+      });
+    }
+  }
+  return itens.filter(Boolean);
+}
+
+const PLACEHOLDERS = [
+  /(?:https?:\/\/)?[^\s()[\]<>"']*?(\d)\1{5,}[^\s()[\]<>"']*/g, // 6+ dígitos repetidos (wa.me/5584999999999)
+  /\[(?:empresa|cliente|nome|feira|evento|produto|cidade|link|url|telefone|e-?mail|data)\b[^\]]*\](?!\()/giu,
+  /lorem ipsum/gi,
+  /\bX{3,}\b/g,
+  /\{\{[^}]+\}\}/g,
+  /\b(?:example\.com|seusite\.com(?:\.br)?|suaempresa\.com(?:\.br)?)\b/gi,
+];
+
+const PRIMEIRA_PESSOA = /(?<!\p{L})(eu|nós|nosso|nossa|nossos|nossas|investimos|atendemos|fizemos|ajudamos|fundamos|começamos|criamos|entregamos|nossa equipe)(?!\p{L})/iu;
+const DADO_CONCRETO = /R\$\s?\d|US\$\s?\d|\d+([.,]\d+)?\s?%|\d+\s+(clientes|empresas|eventos|anos|projetos|pessoas)/iu;
+
+// Ano só conta como dado concreto se for passado: "Congresso 2026" (ano atual/futuro) é nome de
+// evento, não afirmação sobre a história da empresa (achado no uso real).
+function temDadoConcreto(frase) {
+  if (DADO_CONCRETO.test(frase)) return true;
+  const atual = new Date().getFullYear();
+  return [...frase.matchAll(/(?<!\d)((?:19|20)\d{2})(?!\d)/g)].some((m) => Number(m[1]) < atual);
+}
+
+const citar = (frase) => {
+  const limpa = frase.replace(/\*\*|__/g, '').replace(/\*([^*\n]+)\*/g, '$1').trim();
+  return limpa.length > 160 ? `${limpa.slice(0, 160).trimEnd()}…` : limpa;
+};
+
+/** Checagens que valem para qualquer texto. */
+export function regrasGerais(texto, proibidos) {
+  const corpo = semFrontmatter(texto);
+  const itens = [];
+  for (const rx of PLACEHOLDERS) {
+    for (const m of texto.matchAll(rx)) itens.push(item('Placeholder', null, null, 'bloqueio', m[0].replace(/[.,;:!?]+$/, '')));
+  }
+  for (const m of texto.matchAll(/\[PREENCHER:?\s*([^\]]*)\]/giu)) {
+    itens.push(item(FALTA_INFO, null, null, 'bloqueio', m[1].trim() || m[0]));
+  }
+  const normal = semAcento(texto);
+  for (const termo of proibidos) {
+    if (normal.includes(semAcento(termo))) itens.push(item('Termo proibido (memória da crew)', null, null, 'bloqueio', termo));
+  }
+  for (const frase of corpo.split(/(?<=[.!?])\s+|\n+/)) {
+    if (PRIMEIRA_PESSOA.test(frase) && temDadoConcreto(frase)) {
+      itens.push(item('Afirmação a confirmar', null, null, 'alerta', citar(frase)));
+    }
+  }
+  return itens;
+}

package/templates/_opencrew/core/scripts/verificar.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// Verificador automático do OpenCrew — mede o texto ANTES do revisor.
+// Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo <a.md>[,<b.md>] [--formato blog-post|blog-seo]
+// Os limites vêm do frontmatter `constraints:` dos best-practices (fonte única).
+// Última linha da saída: VERIFICACAO:OK ou VERIFICACAO:BLOQUEADA (o runner lê esta linha).
+// Spec: specs/fase-u1-revisor-com-dentes.md (repositório do OpenCrew).
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { lerLimites, lerSecoes, lerProibicoes, lerDominioDoSite } from './verificar/leitura.mjs';
+import { regrasBlog, regrasCanais, regrasGerais, FALTA_INFO } from './verificar/regras.mjs';
+
+const FORMATOS_DE_CANAL = ['instagram-feed', 'linkedin-post', 'twitter-post'];
+
+export async function verificar({ raiz, crew, arquivos, formato = 'blog-post' }) {
+  const notas = [];
+  const limites = {};
+  for (const id of [formato, ...FORMATOS_DE_CANAL]) {
+    limites[id] = await lerLimites(raiz, id);
+    if (!limites[id]) notas.push(`Formato "${id}" não encontrado em _opencrew/core/best-practices/ — sem limites para ele.`);
+  }
+  const proibicoes = await lerProibicoes(raiz, crew);
+  if (!proibicoes.existe) notas.push('Sem proibições registradas (a crew não tem memories.md).');
+  if (proibicoes.semAspas) {
+    const n = proibicoes.semAspas;
+    notas.push(`${n} ${n === 1 ? 'proibição' : 'proibições'} sem termo entre aspas ${n === 1 ? 'não é verificada' : 'não são verificadas'} automaticamente — escreva o termo entre aspas na memória para virar trava.`);
+  }
+  const dominio = await lerDominioDoSite(raiz);
+
+  const resultado = [];
+  for (const rel of arquivos) {
+    const texto = await readFile(path.join(raiz, rel), 'utf8');
+    const itens = [
+      ...regrasBlog(texto, limites[formato], dominio),
+      ...regrasCanais(lerSecoes(texto), limites),
+      ...regrasGerais(texto, proibicoes.termos),
+    ];
+    resultado.push({ arquivo: rel, itens });
+  }
+  const todos = resultado.flatMap((a) => a.itens);
+  const bloqueios = todos.filter((i) => i.nivel === 'bloqueio');
+  const alertas = todos.filter((i) => i.nivel === 'alerta').length;
+  // [PREENCHER] só o usuário resolve: não força REJECT (o redator não tem o dado), mas a
+  // aprovação final não fecha sem ele.
+  const reais = bloqueios.filter((i) => i.item !== FALTA_INFO).length;
+  const status = reais ? 'BLOQUEADA' : bloqueios.length ? 'AGUARDANDO_USUARIO' : 'OK';
+  return { arquivos: resultado, notas, bloqueios: bloqueios.length, alertas, status };
+}
+
+const ROTULO = { bloqueio: '❌ Bloqueio', alerta: '⚠️ Alerta', ok: '✅ OK' };
+const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
+
+export function formatarRelatorio(r) {
+  const linhas = ['## Verificação automática', ''];
+  for (const a of r.arquivos) {
+    linhas.push(`### ${a.arquivo}`, '');
+    const medidos = a.itens.filter((i) => i.medido != null);
+    if (medidos.length) {
+      linhas.push('| Item | Medido | Limite | Resultado |', '|---|---|---|---|');
+      for (const i of medidos) {
+        const op = i.nivel === 'alerta' || /links/i.test(i.item) ? '≥' : '≤';
+        linhas.push(`| ${i.item} | ${i.medido} | ${op} ${i.limite} | ${ROTULO[i.nivel]} |`);
+      }
+      linhas.push('');
+    }
+    for (const i of a.itens.filter((x) => x.medido == null)) {
+      linhas.push(`- ${ROTULO[i.nivel]} — ${i.item}: "${i.detalhe}"`);
+    }
+    if (!a.itens.length) linhas.push('- ✅ Nada a apontar.');
+    linhas.push('');
+  }
+  if (r.notas.length) linhas.push('**Notas:**', ...r.notas.map((n) => `- ${n}`), '');
+  linhas.push(`**Resumo: ${plural(r.bloqueios, 'bloqueio', 'bloqueios')}, ${plural(r.alertas, 'alerta', 'alertas')}**`, '');
+  linhas.push(`VERIFICACAO:${r.status}`);
+  return linhas.join('\n');
+}
+
+function lerArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const m = argv[i].match(/^--(crew|arquivo|formato)$/);
+    if (m && i + 1 < argv.length) args[m[1]] = argv[++i];
+  }
+  return args;
+}
+
+const USO = 'Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo <a.md>[,<b.md>] [--formato blog-post|blog-seo]';
+
+/** @returns {Promise<number>} 0 = verificou (OK ou BLOQUEADA) · 1 = erro de uso */
+export async function main(argv, { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = {}) {
+  const args = lerArgs(argv);
+  if (!args.crew || !args.arquivo) {
+    escrever(USO);
+    return 1;
+  }
+  const arquivos = args.arquivo.split(',').map((s) => s.trim()).filter(Boolean);
+  for (const rel of [args.crew, ...arquivos]) {
+    const abs = path.resolve(cwd, rel);
+    if (path.relative(cwd, abs).startsWith('..') || path.isAbsolute(path.relative(cwd, abs))) {
+      escrever(`Caminho fora do projeto: ${rel}`);
+      return 1;
+    }
+  }
+  const faltando = arquivos.find((rel) => !existsSync(path.join(cwd, rel)));
+  if (faltando) {
+    escrever(`Arquivo não encontrado: ${faltando}`);
+    return 1;
+  }
+  const r = await verificar({ raiz: cwd, crew: args.crew, arquivos, formato: args.formato || 'blog-post' });
+  escrever(formatarRelatorio(r));
+  return 0;
+}
+
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; });
+}

package/templates/gitignore

@@ -2,8 +2,10 @@ node_modules/
 .env
 *.log
 crews/*/output/
+crews/*/state.json
+crews/*/_investigations/
 _opencrew/_memory/company.md
 _opencrew/_memory/preferences.md
 _opencrew/_browser_profile/
 _opencrew/logs/
-STATUS.md
+.claude/settings.local.json