@aksp/opencrew 1.5.0 → 1.6.1

package/src/lib/manifest.js

@@ -0,0 +1,89 @@
+// Manifest of the files OpenCrew delivered (path → sha256). It lets `update` tell a file the
+// user edited (copy it to .opencrew-backup/ before replacing) from one that is just older.
+// Workspaces without a manifest (≤ 1.5.0): any file that differs from the new package is copied.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { exists } from './fsx.js';
+
+export const MANIFEST = path.join('_opencrew', 'manifest.json');
+
+// Text files are hashed with LF line endings: an editor, git or a sync tool switching CRLF/LF
+// must not make a file look "edited by the user". Binary files (with NUL bytes) are hashed as is.
+const normalize = (buf) => {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+  return b.includes(0) ? b : Buffer.from(b.toString('utf8').replace(/\r\n/g, '\n'));
+};
+const sha = (buf) => createHash('sha256').update(normalize(buf)).digest('hex');
+const rel = (target, abs) => path.relative(target, abs).split(path.sep).join('/');
+
+/** @returns {Promise<{files: Record<string,string>} | null>} null = no (or unreadable) manifest */
+export async function readManifest(target) {
+  try {
+    const data = JSON.parse(await fs.readFile(path.join(target, MANIFEST), 'utf8'));
+    return data && typeof data.files === 'object' ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeManifest(target, version, files) {
+  const sorted = Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)));
+  await fs.writeFile(path.join(target, MANIFEST), JSON.stringify({ version, files: sorted }, null, 2) + '\n');
+}
+
+/**
+ * Delivery context shared by one init/update run.
+ * @param {string} target project root
+ * @param {{files:Record<string,string>}|null} manifest previous manifest (null = none)
+ */
+export function newDelivery(target, manifest) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return { target, manifest, backupDir: path.join(target, '.opencrew-backup', stamp), files: {}, copied: [], written: 0 };
+}
+
+/**
+ * Put `content` at `dest`. Missing → write. Equal → nothing. Different → only if `overwrite`,
+ * copying the current file to the backup dir first when the user edited it.
+ */
+export async function deliverFile(ctx, dest, content, { overwrite }) {
+  const key = rel(ctx.target, dest);
+  const fresh = sha(content);
+  if (!(await exists(dest))) {
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    await fs.writeFile(dest, content);
+    ctx.files[key] = fresh;
+    ctx.written += 1;
+    return;
+  }
+  const current = sha(await fs.readFile(dest));
+  if (current === fresh) {
+    ctx.files[key] = fresh;
+    return;
+  }
+  if (!overwrite) return; // the user's version stays (and is not tracked)
+  const edited = ctx.manifest ? ctx.manifest.files[key] !== current : true;
+  if (edited) {
+    const copy = path.join(ctx.backupDir, key);
+    await fs.mkdir(path.dirname(copy), { recursive: true });
+    await fs.copyFile(dest, copy);
+    ctx.copied.push(key);
+  }
+  await fs.writeFile(dest, content);
+  ctx.files[key] = fresh;
+  ctx.written += 1;
+}
+
+/** deliverFile for every file under `src`, mirrored into `dest`. */
+export async function deliverTree(ctx, src, dest, { overwrite, skip = () => false }) {
+  async function walk(dir) {
+    for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+      const from = path.join(dir, entry.name);
+      const relPath = path.relative(src, from).split(path.sep).join('/');
+      if (skip(relPath)) continue;
+      if (entry.isDirectory()) await walk(from);
+      else await deliverFile(ctx, path.join(dest, relPath), await fs.readFile(from), { overwrite });
+    }
+  }
+  await walk(src);
+}

package/src/lib/migrations.js

@@ -0,0 +1,147 @@
+// What `update` does beyond refreshing _opencrew/core and the catalog skills, so that every
+// improvement reaches people who already use OpenCrew (AGENTS.md rule 14). The IDE detection
+// is shared with `init --repair-bridges`, whose helpers live here too.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { exists, writeBridgeFile } from './fsx.js';
+import { IDES, allIdeIds } from './ides.js';
+import { deliverFile, writeManifest } from './manifest.js';
+
+/** Semver compare (no pre-release tags): >0 if a > b, <0 if a < b, 0 if equal. */
+export function compareVersions(a, b) {
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d;
+  }
+  return 0;
+}
+
+const sharedPaths = (() => {
+  const count = new Map();
+  for (const ide of IDES) for (const f of ide.files) count.set(f.path, (count.get(f.path) ?? 0) + 1);
+  return new Set([...count].filter(([, n]) => n > 1).map(([p]) => p));
+})();
+
+async function hasOpencrew(file) {
+  return (await exists(file)) && /opencrew/i.test(await fs.readFile(file, 'utf8'));
+}
+
+/**
+ * IDEs installed in `target`, detected by their own bridge files (a path shared by several
+ * IDEs only counts for an IDE that has no file of its own — e.g. Codex).
+ */
+export async function detectInstalledIdes(target) {
+  const found = [];
+  for (const ide of IDES) {
+    const own = ide.files.filter((f) => !sharedPaths.has(f.path));
+    const probes = own.length ? own : ide.files;
+    for (const f of probes) {
+      if (await hasOpencrew(path.join(target, f.path))) {
+        found.push(ide);
+        break;
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * IDE ids `init --repair-bridges` rewrites when --ide is not given: every IDE with --all,
+ * otherwise the ones `update` would detect. --yes chooses nothing here.
+ */
+export async function repairIdeIds(target, { all } = {}) {
+  if (all) return allIdeIds();
+  return (await detectInstalledIdes(target)).map((ide) => ide.id);
+}
+
+/** `init --repair-bridges` found no bridge and got neither --ide nor --all. */
+export const NO_BRIDGES_FOUND =
+  `Não encontrei pontes de IDE aqui. Use \`--ide=<id>\` para escolher. Ids válidos: ${allIdeIds().join(', ')}.`;
+
+/** `init --repair-bridges` in a folder that is not a workspace: the repair never installs. */
+export const NO_WORKSPACE =
+  'Não encontrei um workspace do OpenCrew nesta pasta. O reparo não instala: para instalar, rode `npx @aksp/opencrew@latest init`.';
+
+/**
+ * Add the bridges a repair rewrote to the manifest — only when the workspace has one. Without
+ * it (installed up to 1.5.0) none is created: a bridges-only manifest would make the next
+ * `update` call every older file "edited by you" and hide its first-protected-update notice.
+ */
+export async function recordRepair(ctx, version) {
+  if (ctx.manifest) await writeManifest(ctx.target, version, { ...ctx.manifest.files, ...ctx.files });
+}
+
+/** Summary lines of a delivery's backup copies, each with its path in .opencrew-backup/<date>/. */
+export function backupSummary(ctx) {
+  if (!ctx.copied.length) return [];
+  const dir = path.relative(ctx.target, ctx.backupDir).split(path.sep).join('/');
+  return [
+    `${ctx.copied.length} cópia(s) de segurança feita(s) antes de regravar:`,
+    ...ctx.copied.map((file) => `    ${dir}/${file}`),
+  ];
+}
+
+/** Rewrite the bridges of the installed IDEs only (frontmatter files whole, others by block). */
+export async function refreshBridges(ctx, ides) {
+  const done = new Set();
+  for (const ide of ides) {
+    for (const f of ide.files) {
+      if (done.has(f.path)) continue;
+      done.add(f.path);
+      const file = path.join(ctx.target, f.path);
+      if (f.content.startsWith('---')) await deliverFile(ctx, file, f.content, { overwrite: true });
+      else await writeBridgeFile(file, f.content);
+    }
+  }
+}
+
+const OUTPUT_DIR = ['--output-dir', '_opencrew/logs/playwright'];
+
+/**
+ * Merge the Playwright server of the template into the project's .mcp.json without touching
+ * other servers. @returns 'created' | 'updated' | 'unchanged' | 'invalid'
+ */
+export async function mergeMcp(target, templateFile) {
+  const file = path.join(target, '.mcp.json');
+  const template = JSON.parse(await fs.readFile(templateFile, 'utf8'));
+  if (!(await exists(file))) {
+    await fs.writeFile(file, JSON.stringify(template, null, 2) + '\n');
+    return 'created';
+  }
+  let current;
+  try {
+    current = JSON.parse(await fs.readFile(file, 'utf8'));
+  } catch {
+    return 'invalid';
+  }
+  current.mcpServers ??= {};
+  const pw = current.mcpServers.playwright;
+  if (!pw) current.mcpServers.playwright = template.mcpServers.playwright;
+  else if (Array.isArray(pw.args) && !pw.args.includes('--output-dir')) pw.args.push(...OUTPUT_DIR);
+  else return 'unchanged';
+  await fs.writeFile(file, JSON.stringify(current, null, 2) + '\n');
+  return 'updated';
+}
+
+const LEGACY_ROOTS = ['.gemini/skills', '.claude/skills', '.agents/skills', '.agent/workflows', '.agent/rules'];
+
+/** Old bridges that point to a system no longer installed (e.g. `_opensquad/`). Never deleted. */
+export async function findLegacyBridges(target) {
+  if (await exists(path.join(target, '_opensquad'))) return [];
+  const found = [];
+  async function walk(dir, depth) {
+    let entries;
+    try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory() && depth < 2) await walk(p, depth + 1);
+      else if (e.isFile() && e.name.endsWith('.md') && /_opensquad\//.test(await fs.readFile(p, 'utf8'))) {
+        found.push(path.relative(target, p).split(path.sep).join('/'));
+      }
+    }
+  }
+  for (const root of LEGACY_ROOTS) await walk(path.join(target, root), 0);
+  return found;
+}

package/templates/.mcp.json

@@ -3,7 +3,7 @@
   "mcpServers": {
     "playwright": {
       "command": "npx",
-      "args": ["@playwright/mcp@0.0.78", "--config", "_opencrew/config/playwright.config.json"]
+      "args": ["@playwright/mcp@0.0.78", "--config", "_opencrew/config/playwright.config.json", "--output-dir", "_opencrew/logs/playwright"]
     }
   }
 }

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.5.0
+1.6.1

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
@@ -398,6 +410,8 @@ side_effects: irreversible  # REQUIRED for any step that publishes, posts, sends
                             # 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.
+max_review_cycles: {N}  # ONLY for the review step: write it next to its `on_reject`.
+                        # By crew tier (`crew.tier` in design.yaml): Express 1, Standard 2, Full 3.
 ---
 ```
 

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,35 @@ 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. **Source check** — before loading the project sources (1d), 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`, show the new result and re-read `crew.yaml` and
+    any agent file already loaded (it may have changed them); 1d then loads the sources from the
+    corrected paths. If the new result still ends in `FONTES:PENDENTE`, ask again with options 2 and
+    3 only. Not-portable alerts (absolute paths) are mentioned once, without stopping. If the script
+    did not run (no Node, an error, or no `FONTES:` status line), tell the user "⚠️ A conferência de
+    fontes não rodou: {motivo}" and continue; the final approval repeats the warning.
+
+1d. **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.
 
 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 +293,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:
@@ -319,6 +353,16 @@ Before executing any step that references an agent:
       - 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.
       ```
+   g. **Reviewer rules (always)** — for every step with `on_reject:`, inject at the same point:
+      ```
+      --- REGRAS DO REVISOR ---
+      - Copie os valores medidos do relatório; nunca estime contagens.
+      - Bloqueio no relatório é REJECT, seja qual for a nota — menos [PREENCHER], que o usuário
+        resolve na aprovação final.
+      - Alerta não resolvido nem justificado limita a nota a 7/10.
+      - O checklist só marca o que o relatório confirma; item "não medido" ou "não verificado" é
+        dito assim, nunca como aprovado.
+      ```
 
 ### Context Compression (Summary-Based Handoff)
 
@@ -530,6 +574,15 @@ 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), in the canonical form — `- Nunca usar "termo"` or, with a replacement,
+  `- Nunca usar "termo" → usar "outro"` — 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:
@@ -640,36 +693,48 @@ catching obvious issues early and reducing review cycle waste.
 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):
+   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). Each item is `caminho=formato`, with
+   the `format:` of the step that generated that file; a step with no `format:`, with an export
+   format (`pdf`, `csv`, `formatted-post`) or with one outside `[a-z0-9-]+` goes without `=formato`:
    ```bash
-   node _opencrew/core/scripts/verificar.mjs --crew crews/{name} --arquivo "{path1},{path2},…" --formato {blog format id of those steps, if any}
+   node _opencrew/core/scripts/verificar.mjs --crew "crews/{name}" --arquivo "{path1}={format1},{path2},…"
    ```
    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.
+   measured values from it (see best-practices `review.md`). If the checker did not run (no Node,
+   an error, or no `VERIFICACAO:` status line), tell the user, continue with the normal review and
+   repeat it at the final approval: "⚠️ A verificação automática não rodou: {motivo}".
 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:
+3. Track the review cycle count: a **cycle** is one pass of the reviewer. The maximum is
+   `max_review_cycles`, an integer from 1 declared where the step declares `on_reject` (the step
+   frontmatter or its `pipeline.yaml` entry); absent or invalid: 3. On every rejection, with or
+   without a block, send the reviewer's feedback to the writer and go back to the referenced step.
+4. If the last allowed pass also rejects, stop; the status of the last report picks the message, as
+   in item 2 — `VERIFICACAO:BLOQUEADA`: the blocks; any other status: the reviewer's feedback, also
+   with `VERIFICACAO:AGUARDANDO_USUARIO` (its only blocks are `[PREENCHER: …]`). Same three options:
    ```
-   ⚠️ A revisão ainda encontra bloqueios depois de {N} ciclos:
+   {if VERIFICACAO:BLOQUEADA} ⚠️ A revisão ainda encontra bloqueios depois de {N} ciclos:
    {lista de bloqueios do relatório}
+   {any other status} A revisão não aprovou o texto depois de {N} ciclos. Motivo: {parecer resumido}
 
    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)
+   2. Aceitar assim mesmo
    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.
+   report — `Verificação automática: {N} bloqueios, {M} alertas, {Z} não medidos` — plus the list
+   of alerts and the {Z} items not measured or not verified (the `Não medido` and `Não verificado`
+   lines under each file, not the "não é texto" line of **Notas**), one per line as
+   `{arquivo} — {motivo}`, then the lines under `**Notas:**` in that report, as they are written,
+   and repeat every "não rodou" warning of this run (checker and source check). 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)
 
@@ -758,7 +823,8 @@ This archives the run state for the `runs` command while keeping crew history av
      - Writing style choices → `## Estilo de Escrita`
      - Visual/design preferences → `## Design Visual`
      - Content structure choices → `## Estrutura de Conteúdo`
-     - Explicit rejections or prohibitions → `## Proibições Explícitas`
+     - Explicit rejections or prohibitions → `## Proibições Explícitas`, in the canonical form
+       (`- Nunca usar "termo"` or `- Nunca usar "termo" → usar "outro"`)
      - Crew-specific technical patterns → `## Técnico (específico do crew)`
 
    **Never write to `memories.md`:**
@@ -766,7 +832,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/comum.mjs

@@ -0,0 +1,48 @@
+// Validações e mensagens de erro de uso comuns aos scripts do runtime (verificar,
+// conferir-fontes…). Node puro, sem dependências.
+// Spec: specs/fase-r1-reparos-1-6-1.md, regra 13 (repositório do OpenCrew).
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const MSG = {
+  faltaOpcao: (opcao) => `Falta a opção obrigatória ${opcao}.`,
+  semRaiz: 'Não encontrei `_opencrew/` nesta pasta. Rode o comando a partir da pasta do projeto.',
+  foraDoProjeto: (caminho) => `Caminho fora do projeto: ${caminho}`,
+  crewNaoEncontrada: (crew) => `Crew não encontrada: ${crew}`,
+};
+
+/** O caminho (relativo à raiz ou absoluto) fica dentro da raiz do projeto? */
+export function dentroDoProjeto(raiz, caminho) {
+  const rel = path.relative(raiz, path.resolve(raiz, caminho));
+  return !(rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel));
+}
+
+/**
+ * O script foi chamado direto (`node …/script.mjs`)? Compara os caminhos reais: com o projeto
+ * aberto por uma junção ou um link de pasta, o Node resolve o link em `import.meta.url` e não em
+ * `process.argv[1]`, e a comparação dos textos daria falso — o script sairia sem imprimir nada.
+ */
+export function ehPrincipal(metaUrl) {
+  try {
+    return Boolean(process.argv[1]) && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(metaUrl));
+  } catch {
+    return false;
+  }
+}
+
+const ehPasta = (p) => existsSync(p) && statSync(p).isDirectory();
+
+/**
+ * Erro de uso, na ordem da regra 13: opção obrigatória faltando → pasta atual sem `_opencrew/`
+ * → crew ou caminho fora do projeto (antes de testar se existe) → crew inexistente.
+ * @returns {string|null} a mensagem em PT-BR, ou null quando está tudo certo
+ */
+export function erroDeUso({ raiz, faltando = [], crew, caminhos = [] }) {
+  if (faltando.length) return MSG.faltaOpcao(faltando[0]);
+  if (!ehPasta(path.join(raiz, '_opencrew'))) return MSG.semRaiz;
+  const fora = [crew, ...caminhos].find((c) => !dentroDoProjeto(raiz, c));
+  if (fora) return MSG.foraDoProjeto(fora);
+  if (!ehPasta(path.resolve(raiz, crew))) return MSG.crewNaoEncontrada(crew);
+  return null;
+}

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

@@ -0,0 +1,82 @@
+// Busca da conferência de fontes: onde está cada caminho citado (crew → raiz do projeto →
+// absoluto → ao lado do agente ou da task que cita) e, quando ele sumiu, o que existe no projeto
+// com o mesmo nome. Só testa existência e lista nomes; nunca lê conteúdo.
+// Spec: specs/fase-r1-reparos-1-6-1.md, regra 17 (repositório do OpenCrew).
+import { readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+export const LIMITE_DA_BUSCA = 20000;
+const IGNORAR = new Set(['node_modules', 'output', '_opencrew', '_build']);
+
+export const barra = (p) => p.split(path.sep).join('/');
+export const ehAbsoluto = (p) => /^[A-Za-z]:[\\/]/.test(p) || p.startsWith('/');
+export const temBarraFinal = (ref) => /[\\/]$/.test(ref);
+const semBarraFinal = (ref) => ref.replace(/[\\/]+$/, '');
+
+const SUFIXO_DE_AGENTE = '.agent.md';
+
+/**
+ * Pastas ao lado de quem cita, só para arquivo de agente ou de task (dentro de `agents/`): a do
+ * próprio arquivo e, para `agents/X.agent.md`, também `agents/X/` — é lá que fica a task que o
+ * frontmatter do agente escreve como `tasks/x.md`.
+ */
+function pastasDeQuemCita(raiz, crew, citadoEm) {
+  const agentes = path.resolve(raiz, crew, 'agents') + path.sep;
+  return citadoEm.filter((arquivo) => arquivo.startsWith(agentes)).flatMap((arquivo) => {
+    const pasta = path.dirname(arquivo);
+    const nome = path.basename(arquivo);
+    return nome.endsWith(SUFIXO_DE_AGENTE) ? [pasta, path.join(pasta, nome.slice(0, -SUFIXO_DE_AGENTE.length))] : [pasta];
+  });
+}
+
+/**
+ * Caminho real do que foi citado, ou null quando não existe. Ordem: pasta da crew → raiz do
+ * projeto → absoluto → pastas ao lado dos arquivos de agente ou de task que citam (`citadoEm`).
+ */
+export function resolver(raiz, crew, ref, citadoEm = []) {
+  if (ehAbsoluto(ref)) return existsSync(ref) ? path.resolve(ref) : null;
+  for (const base of [path.resolve(raiz, crew), raiz, ...pastasDeQuemCita(raiz, crew, citadoEm)]) {
+    const p = path.resolve(base, ref);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+/**
+ * Índice nome → caminhos relativos à raiz (pasta termina em `/`), sem saídas, dependências e
+ * pastas ocultas. Para ao passar de `limite` itens: aí `parcial` é true.
+ */
+export async function indexar(raiz, limite) {
+  const porNome = new Map();
+  let vistos = 0;
+  let parcial = false;
+  async function percorrer(dir) {
+    let entradas;
+    try { entradas = await readdir(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entradas) {
+      if (++vistos > limite) { parcial = true; 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 percorrer(abs);
+    }
+  }
+  await percorrer(raiz);
+  return { porNome, parcial };
+}
+
+/** Candidatos com o mesmo nome. Citado com barra final só casa com pasta; sem ela, com os dois. */
+export function candidatosPorNome(indice, ref) {
+  const todos = indice.porNome.get(path.basename(semBarraFinal(ref)).toLowerCase()) ?? [];
+  return temBarraFinal(ref) ? todos.filter((c) => c.endsWith('/')) : todos;
+}
+
+/** Nomes do que existe na pasta em que o caminho deveria estar. */
+export async function nomesDaPastaEsperada(raiz, crew, ref) {
+  const pai = resolver(raiz, crew, path.dirname(semBarraFinal(ref)));
+  if (!pai) return [];
+  try { return (await readdir(pai)).filter((f) => !f.startsWith('.')); } catch { return []; }
+}