@aksp/opencrew 1.4.2 → 1.6.0

package/templates/AGENTS.md

@@ -115,4 +115,5 @@ enabled, it writes `crews/{name}/state.json` before each step and at every hando
 - ALWAYS save outputs to the crew's output directory
 - When switching personas (inline execution), clearly indicate which agent is speaking
 - When using subagents, inform the user that background work is happening
-- After each pipeline run, update the crew's memories.md with key learnings
+- Crew memory (memories.md) records only the user's explicit feedback and corrections —
+  written at the checkpoint where they happen (see the Pipeline Runner), never invented learnings

package/templates/_opencrew/.opencrew-version

@@ -1 +1 @@
-1.4.2
+1.6.0

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

@@ -17,7 +17,10 @@ version: "1.0.0"
 5. Present 3 distinct hook options before drafting the body.
 6. Align completely with brand voice and audience-specific vocabulary.
 7. Write concise, one-idea sentences and short paragraphs.
-8. Use specific numbers and concrete details instead of vague claims.
+8. Use specific numbers and concrete details instead of vague claims — but only REAL ones
+   (briefing, research with source, company profile). Never invent cases, testimonials, clients,
+   numbers or first-person stories: nunca invente; write `[PREENCHER: o que falta]` instead and
+   the user fills it in at final approval.
 9. Select one dominant psychological driver and anchor the piece to it.
 10. Deploy the appropriate framework (AIDA, PAS, BAB) based on the funnel stage.
 11. Inject an objection neutralizer immediately before the CTA.

package/templates/_opencrew/core/best-practices/image-design.md

@@ -88,7 +88,7 @@ Present all rendered images to the user or downstream agent. Include the design
 ## Platform Specifications
 
 ### Instagram Post / Carousel
-- **Viewport**: 1080 x 1440 (3:4 portrait)
+- **Viewport**: 1080 x 1350 (4:5 portrait)
 - **Min font sizes**: Hero 58px, Heading 43px, Body 34px, Caption 24px
 - **Optimal slide count**: 5-10 slides. Under 5 feels incomplete, over 10 causes drop-off.
 - **Structure**: Hook on slide 1, CTA on last slide, value in between.
@@ -135,7 +135,7 @@ Present all rendered images to the user or downstream agent. Include the design
 DESIGN SYSTEM
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 Platform: Instagram Carousel
-Viewport: 1080 x 1440
+Viewport: 1080 x 1350
 Slides: 7 (hook + 5 content + CTA)
 
 Colors:
@@ -181,7 +181,7 @@ File: slide-01.html
     @import url('https://fonts.googleapis.com/css2?family=Inter:wght@500;700&display=swap');
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body {
-      width: 1080px; height: 1440px; overflow: hidden;
+      width: 1080px; height: 1350px; overflow: hidden;
       background: #1A1A2E;
       font-family: 'Inter', sans-serif;
       display: flex; flex-direction: column;
@@ -342,7 +342,7 @@ Design rationale: Clean white background matches LinkedIn's professional aesthet
 
 3. **Document design rationale.** After each completed design, briefly explain why you made the key visual choices: color rationale, font selection, layout strategy. This helps the user understand the design thinking and makes iteration faster.
 
-4. **Match viewport exactly.** Body width and height in CSS must match the browser viewport resize dimensions exactly. A 1080x1440 carousel slide means body { width: 1080px; height: 1440px; }.
+4. **Match viewport exactly.** Body width and height in CSS must match the browser viewport resize dimensions exactly. A 1080x1350 carousel slide means body { width: 1080px; height: 1350px; }.
 
 ## Vocabulary Guidance
 
@@ -350,7 +350,7 @@ Design rationale: Clean white background matches LinkedIn's professional aesthet
 
 - **"Design system"**: The foundational term for consistent visual identity across pieces. Always define it before creating individual assets.
 - **"Visual hierarchy"**: How the eye moves through the design. Use this when explaining font size, weight, and positioning choices.
-- **"Viewport: WxH"**: Always state the target dimensions explicitly. "Instagram carousel at 1080x1440" not "standard Instagram size."
+- **"Viewport: WxH"**: Always state the target dimensions explicitly. "Instagram carousel at 1080x1350" not "standard Instagram size."
 - **"Contrast ratio"**: Reference WCAG contrast standards when justifying color combinations. "4.5:1 minimum for body text."
 - **"Self-contained HTML"**: The non-negotiable constraint. Reinforce that every file must render independently without external dependencies.
 - **"Rendering verification"**: The step where you visually confirm the screenshot matches the intended design before proceeding.

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

@@ -90,6 +90,18 @@ Generate these files. Use the Write tool for all file creation — never use Bas
        - pipeline/data/anti-patterns.md
        - pipeline/data/tone-of-voice.md  # for content crews
       ```
+    - Include a `fontes:` section with the project sources from `discovery.yaml →
+      project_sources` (omit it only if that list is empty). The Pipeline Runner reads them at the
+      start of every run and checks they still exist:
+      ```yaml
+      fontes:
+        - caminho: Memoria/01_Decisoes.md      # relative to the project root
+          para_que: decisões de público e posicionamento
+      ```
+    - **Paths to the user's project files** — in `crew.yaml`, step files and tasks — are always
+      written as a caminho relativo à raiz do projeto (relative to the project root), between
+      backticks, e.g. `` `Ativos/Identidade Visual/logo.png` ``. NEVER write absolute paths
+      (`C:/…`, `J:/…`, `/Users/…`): they break as soon as the user moves or syncs the folder.
     - Include an `agent_dependencies:` section (OPTIONAL — enables runtime
       Pre-Execution Agent Selection):
       ```yaml
@@ -271,6 +283,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]

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

@@ -117,6 +117,14 @@ Based on the detected domain, ask the most relevant contextual question first. W
 **If domain = `mixed`:**
 Ask the most pressing question from each relevant domain, starting with the primary one. Cap at 3 questions total in this step.
 
+**Always (any domain) — project sources (fontes):** ask ONE question:
+"Tem arquivos ou pastas deste projeto que a crew deve consultar sempre? (por exemplo: decisões,
+calendário de eventos, manual de marca, pasta de logos). Pode citar o caminho ou o nome."
+If the user names files/folders, confirm each one exists (search the project if only a name was
+given) and store them in `project_sources` with paths **relative to the project root** (never
+absolute — absolute paths break when the folder is moved or synced to another computer).
+If the user says no, store an empty list.
+
 ---
 
 ### Step 4 — Tools and Integrations (automatic)
@@ -234,12 +242,17 @@ Wait for confirmation before writing the output file.
 
 ---
 
-## Output: `_build/discovery.yaml`
+## Output: `crews/{code}/_build/discovery.yaml`
 
-After the user confirms in Step 7, write the following file:
+After the user confirms in Step 7, write the following file **inside the crew folder** —
+`crews/{code}/_build/discovery.yaml` (never at the project root; `{code}` = the unique
+`crew_code` below):
 
 ```yaml
 crew_code: "{slugified crew name from purpose}"
+project_sources:                     # relative to the project root; becomes `fontes:` in crew.yaml
+  - path: "{e.g. Memoria/01_Decisoes.md}"
+    purpose: "{what the crew uses it for}"
 purpose: "{user's description from Step 1}"
 domain: "{content | research | automation | analysis | mixed}"
 # When a template was used (Step 0), these fields are populated from discovery.template.yaml:

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

@@ -52,8 +52,12 @@ Before starting execution:
    [ -f crews/{name}/_memory/memories.md ] && grep -q "## Estilo de Escrita" crews/{name}/_memory/memories.md && echo "NEW_FORMAT" || echo "OLD_FORMAT"
    ```
    - If `NEW_FORMAT` → proceed normally.
-   - If `OLD_FORMAT` (or file is empty / does not exist) → silently migrate before proceeding:
-     a. Write `crews/{name}/_memory/memories.md` with the new empty-sections format (do NOT attempt to salvage content from the old file — reset unconditionally):
+   - If `OLD_FORMAT` (or file is empty / does not exist) → migrate before proceeding:
+     a0. If the file exists and is not empty, FIRST copy it to `crews/{name}/_memory/memories.md.bak`
+        (never lose what the crew learned), then tell the user in one line:
+        "Atualizei o formato da memória da crew; a versão anterior está em `memories.md.bak`."
+        Move every rule you can recognize from the old file into the matching new section.
+     a. Write `crews/{name}/_memory/memories.md` with the new sections format:
         ```markdown
         # Crew Memory: {crew-name}
 
@@ -79,7 +83,31 @@ Before starting execution:
         | Data | Run ID | Tema | Output | Score | Resultado |
         |------|--------|------|--------|-------|-----------|
         ```
-   - Do NOT inform the user or pause execution for this migration — it is transparent.
+   - Do not pause execution for this migration (the one-line notice above is enough).
+
+1c. **Project sources (`fontes:`)** — if `crew.yaml` has a `fontes:` list (files or folders of
+    the user's project, paths relative to the project root), read them now: a file in full up to
+    ~300 lines, otherwise its headings plus the passages relevant to this run's task; a folder as
+    its file list. Treat them as the **truth of the project**: when they disagree with the
+    briefing, the research or your own assumptions, the sources take precedence over them
+    (as fontes valem sobre o briefing e a pesquisa) — and say so when it matters.
+
+1d. **Source check** — before the first step, run:
+    ```bash
+    node _opencrew/core/scripts/conferir-fontes.mjs --crew crews/{name}
+    ```
+    If the last line is `FONTES:PENDENTE` (a cited file was moved, renamed or deleted), show the
+    report and ask — never continue silently with a missing source:
+    ```
+    Alguns arquivos que a crew usa não estão mais onde ela espera:
+    {resumo do relatório}
+
+    1. Corrigir os caminhos sugeridos (troco nos arquivos da crew e guardo .bak)
+    2. Seguir assim mesmo
+    3. Parar
+    ```
+    On 1, run the same command with `--corrigir` and show the new result. Not-portable alerts
+    (absolute paths) are mentioned once, without stopping.
 
 2. Read `crews/{name}/pipeline/pipeline.yaml` for the pipeline definition
 3. **Resolve skills**: Read `crew.yaml` → `skills` section. For each non-native skill (anything other than web_search, web_fetch):
@@ -261,8 +289,10 @@ Before executing any step that references an agent:
       - The agent must follow the export process for the specified format — read the input file,
         transform the content, and write the output file in the target format.
       - Skip the best-practices lookup below for export formats.
-   b. **Content formats** — otherwise, read `_opencrew/core/best-practices/{format}.md` (e.g., `_opencrew/core/best-practices/instagram-feed.md`)
-      - If the file does not exist → **WARNING**: "Format '{format}' not found in _opencrew/core/best-practices/. Skipping format injection." Continue without format.
+   b. **Content formats** — otherwise, read `_opencrew/best-practices.local/{format}.md` (the user's
+      own version, never touched by `update`) if it exists, else `_opencrew/core/best-practices/{format}.md`
+      (e.g., `_opencrew/core/best-practices/instagram-feed.md`)
+      - If neither exists → **WARNING**: "Format '{format}' not found in _opencrew/best-practices.local/ or _opencrew/core/best-practices/. Skipping format injection." Continue without format.
    c. Parse the YAML frontmatter to extract the `name` field
    d. Extract the Markdown body (everything after the YAML frontmatter closing `---`)
    e. Append to the agent's context, before skill instructions:
@@ -310,6 +340,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)
 
@@ -521,6 +560,14 @@ Apply this transformation consistently for every write in this step.
 - **Always include the file path** of any generated content the user needs to review. Example: "Review the content at `crews/{name}/output/{run_id}/v1/content.md` and let me know if it looks good."
 - Wait for user input before proceeding
 - Save the user's choice/response for the next step
+- **Correction → memory, right away**: if the answer corrects something (tone, audience, a term,
+  a fact, a format), write it to `crews/{name}/_memory/memories.md` in the matching section
+  **before the next step** (antes do próximo passo) — not only at the end of the run, which may
+  never come. A term the user asked to remove goes to `## Proibições Explícitas` **between
+  quotes** (entre aspas: `- Nunca usar "termo"`), so the automatic checker blocks it next time.
+- **Correction vs. company profile**: if the correction contradicts `_opencrew/_memory/company.md`
+  (e.g. the organization's name, the main audience), ask: "Isso vale para todas as crews?
+  Atualizo o perfil da empresa?" — change `company.md` only after a yes.
 - **If the step frontmatter contains `outputFile`**: after collecting the user's full response,
   apply the Output Path Transformation **Step 1 only** (run_id injection — skip Step 2, version folder) to the `outputFile` path, then write the response to the transformed path using the Write tool before moving to the next step. Checkpoint files are user input captures, not versioned output — Step 2 does not apply here, regardless of the general "every write" rule in the Output Path Transformation section above.
   Use this format:
@@ -628,11 +675,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)
 
@@ -729,7 +804,7 @@ This archives the run state for the `runs` command while keeping crew history av
    - Run scores, review grades, output file paths, topics from past runs
 
    **Technical routing:** For any technical learning (bugs, workarounds, API behavior):
-   - If it affects any crew (Playwright bugs, OS rendering quirks, API limits) → write to the appropriate `_opencrew/core/best-practices/` file instead of `memories.md`
+   - If it affects any crew (Playwright bugs, OS rendering quirks, API limits) → write to `_opencrew/best-practices.local/{format}.md` instead of `memories.md` (copy the core file there first if the local one does not exist yet — the core folder is replaced by every `update`; the local one is never touched)
    - If it is specific to this crew's output type or toolchain → add to `## Técnico (específico do crew)` following the dedup rules above
 
    After applying all candidates, write the updated `memories.md`.

package/templates/_opencrew/core/scripts/conferir-fontes.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// Conferência de fontes do OpenCrew — no início do run, confere se os arquivos que a crew cita
+// existem. Se foram movidos, sugere o novo caminho (relativo à raiz do projeto); se o nome mudou,
+// lista o que existe na pasta esperada. Nunca apaga nada; só corrige com --corrigir (e .bak).
+// Uso: node _opencrew/core/scripts/conferir-fontes.mjs --crew crews/<nome> [--corrigir]
+// Última linha da saída: FONTES:OK ou FONTES:PENDENTE (o runner lê esta linha).
+// Spec: specs/fase-u2-crew-que-conhece-o-projeto.md (repositório do OpenCrew).
+import { readFile, writeFile, readdir, copyFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const IGNORAR = new Set(['node_modules', 'output', '_opencrew', '_build']);
+const LIMITE_ENTRADAS = 20000;
+
+const barra = (p) => p.split(path.sep).join('/');
+const ehAbsoluto = (p) => /^[A-Za-z]:[\\/]/.test(p) || p.startsWith('/');
+
+function pareceCaminho(t) {
+  if (/[{}<>*$|]/.test(t) || /^https?:/i.test(t) || !/[\\/]/.test(t)) return false;
+  return /\.[A-Za-z0-9]{1,5}$/.test(t) || /[\\/]$/.test(t);
+}
+const saidaDeRun = (t) => /(^|[\\/])(output|_build)[\\/]/.test(t);
+
+/** Caminhos citados entre crases no crew.yaml e nos passos, mais as `fontes:` do crew.yaml. */
+async function coletar(raiz, crew) {
+  const refs = new Map();
+  const add = (ref, arquivo) => {
+    if (!refs.has(ref)) refs.set(ref, new Set());
+    refs.get(ref).add(arquivo);
+  };
+  const crewYaml = path.join(raiz, crew, 'crew.yaml');
+  const passos = path.join(raiz, crew, 'pipeline', 'steps');
+  const arquivos = existsSync(crewYaml) ? [crewYaml] : [];
+  if (existsSync(passos)) {
+    for (const f of await readdir(passos)) if (f.endsWith('.md')) arquivos.push(path.join(passos, f));
+  }
+  for (const arquivo of arquivos) {
+    const texto = await readFile(arquivo, 'utf8');
+    for (const m of texto.matchAll(/`([^`\n]+)`/g)) {
+      const t = m[1].trim();
+      if (pareceCaminho(t) && !saidaDeRun(t)) add(t, arquivo);
+    }
+    if (arquivo === crewYaml) {
+      for (const m of texto.matchAll(/^\s*-?\s*caminho:\s*["']?([^"'\n#]+?)["']?\s*$/gm)) add(m[1].trim(), arquivo);
+    }
+  }
+  return refs;
+}
+
+function resolver(raiz, crew, ref) {
+  if (ehAbsoluto(ref)) return existsSync(ref) ? path.resolve(ref) : null;
+  for (const base of [path.join(raiz, crew), raiz]) {
+    const p = path.resolve(base, ref);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+/** Índice nome-do-arquivo → caminhos relativos, ignorando saídas, dependências e pastas ocultas. */
+async function indexar(raiz) {
+  const porNome = new Map();
+  let n = 0;
+  async function walk(dir) {
+    let entradas;
+    try { entradas = await readdir(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entradas) {
+      if (++n > LIMITE_ENTRADAS) return;
+      if (e.name.startsWith('.') || (e.isDirectory() && IGNORAR.has(e.name))) continue;
+      const abs = path.join(dir, e.name);
+      const chave = e.name.toLowerCase();
+      if (!porNome.has(chave)) porNome.set(chave, []);
+      porNome.get(chave).push(barra(path.relative(raiz, abs)) + (e.isDirectory() ? '/' : ''));
+      if (e.isDirectory()) await walk(abs);
+    }
+  }
+  await walk(raiz);
+  return porNome;
+}
+
+export async function conferir({ raiz, crew }) {
+  const refs = await coletar(raiz, crew);
+  let indice = null;
+  const lista = [];
+  for (const [ref, citado] of refs) {
+    const item = { ref, citadoEm: [...citado], estado: 'ok', sugestao: null, candidatos: [], pasta: [] };
+    const achado = resolver(raiz, crew, ref);
+    if (achado) {
+      if (ehAbsoluto(ref)) {
+        item.estado = 'nao-portatil';
+        const rel = path.relative(raiz, achado);
+        if (!rel.startsWith('..') && !path.isAbsolute(rel)) item.sugestao = barra(rel) + (/[\\/]$/.test(ref) ? '/' : '');
+      }
+    } else {
+      item.estado = 'faltando';
+      indice ??= await indexar(raiz);
+      const nome = path.basename(ref.replace(/[\\/]+$/, '')).toLowerCase();
+      item.candidatos = (indice.get(nome) ?? []).filter((c) => /[\\/]$/.test(ref) === c.endsWith('/'));
+      if (item.candidatos.length === 1) item.sugestao = item.candidatos[0];
+      if (!item.candidatos.length) {
+        const pai = resolver(raiz, crew, path.dirname(ref.replace(/[\\/]+$/, '')));
+        if (pai) {
+          try { item.pasta = (await readdir(pai)).filter((f) => !f.startsWith('.')); } catch { /* não é pasta */ }
+        }
+      }
+    }
+    lista.push(item);
+  }
+  const status = lista.some((i) => i.estado === 'faltando') ? 'PENDENTE' : 'OK';
+  return { crew, raiz, refs: lista, status };
+}
+
+async function copiaDeSeguranca(arquivo) {
+  const bak = existsSync(`${arquivo}.bak`) ? `${arquivo}.bak-${new Date().toISOString().replace(/[:.]/g, '-')}` : `${arquivo}.bak`;
+  await copyFile(arquivo, bak);
+}
+
+/** Troca, nos arquivos da crew, cada caminho com sugestão única. @returns quantos caminhos */
+export async function corrigir({ resultado }) {
+  const comSugestao = resultado.refs.filter((i) => i.sugestao && i.estado !== 'ok');
+  const tocados = new Set();
+  for (const item of comSugestao) {
+    for (const arquivo of item.citadoEm) {
+      const texto = await readFile(arquivo, 'utf8');
+      if (!tocados.has(arquivo)) {
+        await copiaDeSeguranca(arquivo);
+        tocados.add(arquivo);
+      }
+      await writeFile(arquivo, texto.split(item.ref).join(item.sugestao));
+    }
+  }
+  return comSugestao.length;
+}
+
+export function formatar(r) {
+  const rel = (a) => barra(path.relative(r.raiz, a));
+  const linhas = [`## Conferência de fontes — ${r.crew}`, ''];
+  for (const i of r.refs.filter((x) => x.estado !== 'ok')) {
+    const onde = `citado em ${i.citadoEm.map(rel).join(', ')}`;
+    if (i.estado === 'nao-portatil') {
+      linhas.push(`- ⚠️ \`${i.ref}\` é um caminho absoluto (não é portátil — quebra em outro computador).${i.sugestao ? ` Sugestão: \`${i.sugestao}\`` : ''} (${onde})`);
+    } else if (i.sugestao) {
+      linhas.push(`- ❌ Não encontrei \`${i.ref}\` (${onde}). Novo caminho sugerido: \`${i.sugestao}\``);
+    } else if (i.candidatos.length) {
+      linhas.push(`- ❌ Não encontrei \`${i.ref}\` (${onde}). Encontrei ${i.candidatos.length} candidatos: ${i.candidatos.map((c) => `\`${c}\``).join(', ')}`);
+    } else if (i.pasta.length) {
+      linhas.push(`- ❌ Não encontrei \`${i.ref}\` (${onde}). Na pasta esperada existem: ${i.pasta.join(', ')}`);
+    } else {
+      linhas.push(`- ❌ Não encontrei \`${i.ref}\` (${onde}) nem nada com esse nome no projeto.`);
+    }
+  }
+  const ok = r.refs.filter((i) => i.estado === 'ok').length;
+  const pend = r.refs.filter((i) => i.estado === 'faltando').length;
+  const alertas = r.refs.filter((i) => i.estado === 'nao-portatil').length;
+  linhas.push('', `**Resumo: ${r.refs.length} fontes — ${ok} ok, ${pend} pendentes, ${alertas} alertas**`, '');
+  return linhas.join('\n');
+}
+
+/** @returns {Promise<number>} 0 = conferiu · 1 = erro de uso */
+export async function main(argv, { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = {}) {
+  const i = argv.indexOf('--crew');
+  const crew = i > -1 ? argv[i + 1] : null;
+  if (!crew) {
+    escrever('Uso: node _opencrew/core/scripts/conferir-fontes.mjs --crew crews/<nome> [--corrigir]');
+    return 1;
+  }
+  if (!existsSync(path.join(cwd, crew))) {
+    escrever(`Crew não encontrada: ${crew}`);
+    return 1;
+  }
+  let r = await conferir({ raiz: cwd, crew });
+  escrever(formatar(r));
+  if (argv.includes('--corrigir')) {
+    const n = await corrigir({ resultado: r });
+    if (!n) escrever('Nada a corrigir.');
+    else {
+      escrever(`${n} ${n === 1 ? 'caminho corrigido' : 'caminhos corrigidos'} (cópia .bak ao lado de cada arquivo alterado).\n`);
+      r = await conferir({ raiz: cwd, crew });
+      escrever(formatar(r));
+    }
+  }
+  escrever(`FONTES:${r.status}`);
+  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/_opencrew/core/scripts/verificar/leitura.mjs

@@ -0,0 +1,104 @@
+// 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:` do best-practice — primeiro o do usuário
+ * (`_opencrew/best-practices.local/<id>.md`, nunca tocado pelo update), depois o do core.
+ */
+export async function lerLimites(raiz, formatoId) {
+  for (const pasta of [['best-practices.local'], ['core', 'best-practices']]) {
+    const arquivo = path.join(raiz, '_opencrew', ...pasta, `${formatoId}.md`);
+    if (existsSync(arquivo)) return lerFrontmatter(await readFile(arquivo, 'utf8'))?.constraints ?? {};
+  }
+  return null;
+}
+
+/**
+ * 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;
+}