@aksp/opencrew 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -3,6 +3,63 @@
 All notable changes to opencrew are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## [1.14.0] — 2026-10-08
+
+Fase U5, fatia 3: "Execução registrada" (`specs/fase-u5c-execucao-registrada.md`). Chega a quem já
+usa com um `npx @aksp/opencrew@latest update`; as crews e as execuções antigas ficam como estão.
+
+Ainda não nesta versão: o pedido avulso à crew (1.15.0).
+
+### Added
+- **`/opencrew retomar <nome>`.** A execução que parou no meio — a conversa caiu, o contexto
+  acabou — continua de onde parou, em qualquer conversa nova. A IA mostra o tema, o que já está
+  pronto e de que passo vai seguir, e espera o seu sim. O que foi gravado e conferido não é
+  refeito; o passo que estava no meio é refeito inteiro.
+- **Registro da execução.** Cada execução deixa na pasta dela um `execucao.json`, gravado por
+  script a cada passo: o tema, os passos conferidos, as suas respostas nas aprovações e os
+  vereditos da revisão. A IA não escreve nesse arquivo. Não há comando a mais por passo: o
+  registro pega carona no que a execução já rodava.
+- **`/opencrew repair` olha o histórico.** Pasta de execução sem linha no `runs.md` vira um ponto
+  do conserto: ele pergunta o tema e grava a linha como `Registrada depois`, com cópia
+  `runs.md.bak`. Linha sem pasta e pasta vazia são só apontadas: nada é apagado.
+
+### Changed
+- **O histórico (`runs.md`) é gravado pelo script, não pela IA** — também quando a execução é
+  abortada ou rejeitada, que antes ficavam de fora. As colunas são as mesmas, e as linhas que já
+  existem não mudam.
+- **O Score tem uma definição só:** aprovações suas sem pedido de correção, sobre as aprovações
+  que você respondeu (`2/3`). Quem conta é o script. Antes o texto dava duas contas diferentes, e
+  numa crew real saiu uma nota.
+- **Regra de Ouro contada de verdade.** As correções ficam no registro de cada execução; no fim, o
+  script mostra as das 10 últimas e a IA procura ali o que se repetiu em 3 ou mais. Antes ela
+  procurava na memória da crew, que não guarda dado de execução. A seção se chama
+  `## Regras de Ouro`, um nome só.
+- O `LEIA-ME.md` da entrega abre com o tema da execução, quando o registro tem um.
+
+### Limites
+- O registro só sabe o que os comandos contam: se a IA pular o aviso de uma aprovação, o score
+  sai errado para menos.
+- Execução feita antes desta versão não tem registro: não dá para retomar, e só entra no
+  histórico pelo conserto.
+- Ao retomar, o que foi combinado só na conversa anterior, sem ter sido gravado, não volta.
+
+## [1.13.0] — 2026-10-07
+
+Fase U5, fatia 2: "Runner dividido" (`specs/fase-u5b-runner-dividido.md`). Chega a quem já usa
+com um `npx @aksp/opencrew@latest update`. Nenhuma regra mudou de texto: mudou de lugar.
+
+### Changed
+- **O executor de pipeline ficou menor.** O `runner.pipeline.md`, lido no começo de toda execução,
+  foi de 872 para 543 linhas. Sete blocos que só valem em alguma condição passaram para arquivos
+  próprios em `_opencrew/core/runner/`, lidos só quando é o caso: seleção de agentes, migração do
+  formato da memória, Escritório, tarefas do agente, contrato de saída, fontes pendentes e o fim
+  da execução (memória, histórico, reflexão e menu final). No lugar de cada um ficou um trecho
+  curto que diz quando ler o arquivo. Numa execução comum a IA lê 654 linhas em vez de 872, e as
+  regras do fim da execução são lidas no fim, quando valem.
+- O painel (Escritório) só custa leitura para quem o ligou.
+
+### Removed
+- O resumo "Step Execution Order", que repetia a ordem dos passos já descrita logo acima dele.
 ## [1.12.0] — 2026-10-07
 
 Fase U5, fatia 1: "Polimento do uso" (`specs/fase-u5a-polimento-do-uso.md`). A U5 é a fase de

package/README.md

@@ -181,12 +181,13 @@ meu-projeto/
 ├── _opencrew/
 │   ├── core/
 │   │   ├── system.md             ← 🧠 sistema completo do OpenCrew
-│   │   ├── runner.pipeline.md    ← executor de pipeline
+│   │   ├── runner.pipeline.md    ← executor de pipeline (o que toda execução usa)
+│   │   ├── runner/               ← 8 partes do executor, lidas só quando é o caso (painel, fim da execução, retomar…)
 │   │   ├── skills.engine.md      ← gerenciador de skills
 │   │   ├── architect.agent.yaml  ← definição do Arquiteto
 │   │   ├── formato-da-crew.md    ← o formato dos arquivos de uma crew (crew.yaml, pipeline.yaml, passos)
 │   │   ├── best-practices/       ← 24 guias de melhores práticas + _catalog.yaml
-│   │   ├── scripts/              ← verificador, conferência de fontes, caminhos, entrega, documento Word, conserto de crews e os scripts do Escritório
+│   │   ├── scripts/              ← verificador, conferência de fontes, caminhos, registro da execução, entrega, documento Word, conserto de crews e os scripts do Escritório
 │   │   ├── modelos/              ← modelo do perfil de documento oficial (papel timbrado)
 │   │   ├── escritorio/           ← página do Escritório ao vivo (abre com /opencrew dashboard)
 │   │   └── prompts/              ← 15 prompts de fase (discovery, design, build, entrega, documento, etc.)
@@ -205,6 +206,7 @@ meu-projeto/
 ├── crews/                        ← suas crews vivem aqui
 │   ├── blog-semanal/             ← template: blog semanal
 │   │   └── output/<execução>/    ← criada a cada execução
+│   │       ├── execucao.json     ← registro da execução, gravado por script (é o que o `/opencrew retomar` lê)
 │   │       ├── v1/  v2/  …       ← o que cada passo gravou
 │   │       └── entrega/          ← o que você usa: LEIA-ME.md + uma pasta por canal (copiada para a pasta do projeto que você escolher)
 │   ├── instagram-carrossel/      ← template: Instagram carrossel
@@ -293,6 +295,25 @@ são sempre em português.
 
 ---
 
+## Histórico e execução interrompida
+
+Cada execução deixa um registro na pasta dela (`crews/<crew>/output/<execução>/execucao.json`):
+o tema, os passos já gravados e conferidos, o que você respondeu em cada aprovação. Quem grava é
+um script, a cada passo — a IA não escreve nesse arquivo.
+
+- **O histórico da crew** (`crews/<crew>/_memory/runs.md`) ganha uma linha por execução, também
+  gravada pelo script: a que terminou, a que você abortou e a que a revisão rejeitou. A coluna
+  Score tem um significado só: aprovações suas sem pedido de correção, sobre as aprovações que você
+  respondeu (`2/3`).
+- **A conversa caiu no meio?** Em qualquer conversa nova, peça `/opencrew retomar <nome>`. A IA
+  mostra o tema, o que já está pronto e de que passo vai continuar, e espera o seu sim. O que já
+  foi gravado e conferido não é refeito; o passo que estava no meio é refeito inteiro. O que foi
+  combinado só na conversa anterior, sem ter sido gravado, não volta.
+- **Execução antiga fora do histórico?** O `/opencrew repair <nome>` mostra as pastas de execução
+  sem linha no histórico, pergunta o tema de cada uma e grava a linha como `Registrada depois`,
+  com cópia `runs.md.bak`. Linha sem pasta e pasta vazia são só apontadas: nada é apagado.
+- Execução feita antes da 1.14.0 não tem registro: não dá para retomar.
+
 ## Documento Word
 
 Ata, ofício, declaração, contrato: quando o resultado é um documento para imprimir, assinar ou
@@ -498,9 +519,10 @@ npx @aksp/opencrew update --check
 | `/opencrew` | Abre o menu principal |
 | `/opencrew create <descrição>` | Cria uma nova crew a partir da sua descrição |
 | `/opencrew run <nome>` | Executa o pipeline de uma crew |
+| `/opencrew retomar <nome>` | Continua a execução que parou no meio (a conversa caiu, o contexto acabou): mostra o que já está pronto e segue do passo seguinte, sem refazer o que foi gravado |
 | `/opencrew list` | Lista todas as suas crews |
 | `/opencrew edit <nome>` | Modifica uma crew existente |
-| `/opencrew repair <nome>` | Mostra o que falta numa crew que você já tem (formato de cada texto, arquivos do projeto que ela deve ler, proibições que o verificador consegue barrar, nomes dos agentes) e conserta um ponto por vez, com o seu sim e uma cópia `.bak` |
+| `/opencrew repair <nome>` | Mostra o que falta numa crew que você já tem (formato de cada texto, arquivos do projeto que ela deve ler, proibições que o verificador consegue barrar, nomes dos agentes, execuções que ficaram fora do histórico) e conserta um ponto por vez, com o seu sim e uma cópia `.bak` |
 | `/opencrew delete <nome>` | Remove uma crew |
 | `/opencrew skills` | Navega, instala ou remove skills |
 | `/opencrew install <skill>` | Instala uma skill do catálogo |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aksp/opencrew",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "publishConfig": {
     "access": "public"
   },

package/templates/AGENTS.md

@@ -59,6 +59,7 @@ Route input to the matching action:
 | `/opencrew create <description>` | Load the Architect (`_opencrew/core/architect.agent.yaml`) → Create Crew flow: one prompt per phase, listed there |
 | `/opencrew list` | List all crews in `crews/` (a folder without `crew.yaml` is not a crew) |
 | `/opencrew run <name>` | Load Pipeline Runner → Execute crew |
+| `/opencrew retomar <name>` | Load Pipeline Runner → resume the run of that crew that stopped in the middle (`_opencrew/core/runner/retomar.md`) |
 | `/opencrew edit <name> <changes>` | Load the Architect → Edit Crew flow |
 | `/opencrew repair <name>` | Load `_opencrew/core/prompts/repair.prompt.md` → show what an existing crew is missing and fix one point at a time, each with a `.bak` copy |
 | `/opencrew skills` | Load Skills Engine → Show skills menu |
@@ -97,11 +98,8 @@ When running a crew:
    from `_opencrew/_memory/preferences.md` (used to check the Dashboard toggle)
 5. Load crew memory from `crews/{name}/_memory/memories.md`
 6. Read the pipeline runner instructions from `_opencrew/core/runner.pipeline.md`
-7. **Pre-Execution Agent Selection** — only when `crew.yaml` declares
-   `agent_dependencies:`. Analyze the user's request against the decision matrix,
-   present the agents as a numbered multi-select (IDE-neutral), let the user
-   confirm/adjust, warn about broken dependencies, and build the filtered step
-   list. Crews without the field skip this and run all agents.
+7. **Pre-Execution Agent Selection** — the runner says when it applies (only when `crew.yaml`
+   declares `agent_dependencies:`) and which of its parts to read
 8. Execute the pipeline step by step following the runner instructions
 
 ## Dashboard (Optional)

package/templates/_opencrew/.opencrew-version

@@ -1 +1 @@
-1.12.0
+1.14.0

package/templates/_opencrew/core/formato-da-crew.md

@@ -9,6 +9,7 @@ crews/{code}/
 ├── crew.yaml               the crew: identity, sources, limits
 ├── crew-party.csv          one row per agent (the names shown to the user)
 ├── agents/{agent-id}.agent.md
+├── agents/{agent-id}/tasks/   the task files of an agent that declares `tasks:` (optional)
 ├── pipeline/
 │   ├── pipeline.yaml       the order of the steps
 │   ├── steps/step-NN-{name}.md

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

@@ -36,6 +36,8 @@ Generate these files directly — they are compilations of data already gathered
 
    ## Proibições Explícitas
 
+   ## Regras de Ouro
+
    ## Técnico (específico do crew)
    ```
    - `crews/{code}/_memory/runs.md` — empty run history log:

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

@@ -2,7 +2,7 @@
 
 You are the opencrew Repair agent. A crew built by an older version misses what later versions
 added: the format of each text, the project sources, bans the checker can enforce, the persona
-names. Your job is to show the user what is missing in **one crew that already exists** and fix
+names, the runs that never reached the history. Your job is to show the user what is missing in **one crew that already exists** and fix
 one point at a time, each with the user's yes.
 
 **You never write inside `crews/` yourself.** Every change is one command of the script below,
@@ -33,6 +33,8 @@ It only reads. Its last line is the status:
 
 - `CONSERTO:OK` — say "A crew {nome} está em dia: não há o que consertar." and stop.
 - `CONSERTO:PENDENTE` — one block per finding, each starting with `[código]`. Go to Step 3.
+- A line starting with `Nota:` (with any status) is information, not a finding: show it to the
+  user once, in plain words; there is nothing to fix and nothing is deleted.
 - `CONSERTO:ERRO`, or the script did not run (no Node, an error) — show the user the message as
   it came and stop. Do not repair by hand.
 
@@ -60,6 +62,7 @@ codes between brackets, the `--aplicar` lines or the `CONSERTO:` status line.
 | `sem-aprovacao-final` | "Depois da revisão não há um ponto de aprovação seu. Isso se resolve editando a crew: /opencrew edit {nome}." | none |
 | `publica-antes` | "O passo {n} publica ou envia antes da revisão e da sua aprovação final. Enquanto estiver assim, o que sai não passou pela revisão. Isso se resolve editando a crew: /opencrew edit {nome}." | none |
 | `passo-faltando` | Show the lines the script printed and say that it is solved by editing the crew: `/opencrew edit {nome}` | none |
+| `historico` | For each listed run folder: "A pasta {run} tem arquivos de uma execução que não está no histórico: {arquivos}. Qual foi o tema dela? (Se não lembrar, responda 'não sei'.)" With 'não sei', the theme is `não informado`. A folder the script marks as `interrompida` can still be resumed: say so (`/opencrew retomar {nome}`) and register it only if the user prefers. An empty folder (`execução abandonada`) and a row with no folder are only shown: nothing is deleted | `--aplicar "historico:{run}={tema}"` — the theme on one line, with only letters, digits, spaces and `. , : ; - ( ) / ?` |
 
 The command is always the same line, with the item between double quotes:
 

package/templates/_opencrew/core/runner/contrato-de-saida.md

@@ -0,0 +1,33 @@
+# Output Contract Validation
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when the step's frontmatter declares an `output_contract:` field.
+
+If the step's frontmatter declares an `output_contract:` field, apply structured validation
+in the same call as the basic file existence check (Post-Step Output Validation):
+
+1. **Required sections check**: If `output_contract.required_sections` is defined, add
+   `--secoes {min_sections}` to the same `conferir` command: the file needs at least that many
+   lines starting with `## `.
+
+2. **TL;DR check**: If the output contract requires a TL;DR section, add `--tldr` to the same
+   `conferir` command.
+
+3. **If a check fails** (the last line is `CAMINHO:REPROVADO {motivo}`, with a motivo other than
+   `arquivo ausente ou vazio`; the script reports the first one):
+   - Present to user: "⚠️ Output from {Agent Name} is incomplete: {motivo}"
+   - Options as numbered list:
+     1. Accept anyway and continue
+     2. Retry step (re-execute the agent)
+     3. Abort pipeline
+
+4. **If no `output_contract` is defined**, skip this validation entirely (backward compatible).
+
+Example `output_contract` in step frontmatter:
+```yaml
+output_contract:
+  required_sections:
+    - "Fontes Pesquisadas"
+    - "Principais Descobertas"
+    - "TL;DR"
+  min_sections: 3
+```

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

@@ -0,0 +1,37 @@
+# Escritório (optional live view)
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when `preferences.md` has `Dashboard: enabled`.
+
+A local page that shows the crew at work, off by default. Follow this part only when the
+already-loaded `preferences.md` has `Dashboard: enabled` (written `- **Dashboard:** enabled` or
+plain `Dashboard: enabled`, any letter case); otherwise run none of these commands. When it is on,
+run, from the project root, the one-line command of each moment:
+
+| Moment | Command |
+|---|---|
+| Start of the run (Initialization, step 6) | `node _opencrew/core/scripts/estado.mjs "{name}" iniciar --passos {N}` |
+| Right after `iniciar`, once per deselected agent | `node _opencrew/core/scripts/estado.mjs "{name}" pular --agente {id}` |
+| Before each step, each time it starts | `node _opencrew/core/scripts/estado.mjs "{name}" passo --n {K} --agente {id} --rotulo "{rótulo}" --mensagem "{frase}"` |
+| Before asking the question of a checkpoint (instead of `passo`) | `node _opencrew/core/scripts/estado.mjs "{name}" checkpoint --n {K} --agente {id} --rotulo "{rótulo}"` |
+| End of the run (After Pipeline Completion) | `node _opencrew/core/scripts/estado.mjs "{name}" concluir` |
+| Run aborted after `iniciar`, by the user or by an error | `node _opencrew/core/scripts/estado.mjs "{name}" falhar --motivo "{motivo}"` |
+
+- **One at a time** — Run these commands one at a time, waiting for the `ESTADO:` line of each
+  before the next — never in parallel or in the background (each one reads and rewrites the same file).
+- **Values** — `{name}`: the crew code. `{N}`: how many steps will run, checkpoints included (a
+  deselected agent's steps do not count). `{K}`: the step's position among them, from 1. `{id}`: the agent's `id` column in
+  `crew-party.csv`; a step or checkpoint with no `agent:` goes without `--agente`
+  (the table shows the full form). `{rótulo}`: the step's name, in
+  a few words. `--mensagem` goes only when the agent changed since the last `passo` (so never on the first
+  one): one sentence on what the previous agent delivered — never look at the next step. `{motivo}`: why the run stopped.
+- **Text on the command line** — `--rotulo`, `--mensagem` and `--motivo` go between double quotes,
+  on one line, starting with a letter or a digit, with only letters (accents included), digits,
+  spaces and `. , : ; - ( ) / ?`. Drop every other sign (quotes of any kind, `$`, backtick, `\`,
+  `%`, `!`, emoji). If no text is left, omit the option. Write them in the user's language.
+- **After `iniciar`**, when it answers `ESTADO:OK`, show the user once:
+  `Escritório ligado. Se a página não estiver aberta, rode em outro terminal: node _opencrew/core/scripts/escritorio.mjs`
+- **The Escritório never stops the run.** A command that fails, does not run or answers
+  `ESTADO:IGNORADO`: go on, do not repeat that event, ask nothing, and tell the user once per run,
+  in one line: `O escritório não foi atualizado nesta execução; o trabalho segue normalmente.` With
+  the reason "escritório desligado", say nothing and stop calling the script for the rest of this run.
+- The script is the only writer: never read, write or describe `crews/{name}/state.json` yourself.

package/templates/_opencrew/core/runner/fim-da-execucao.md

@@ -0,0 +1,99 @@
+# End of the run
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it when the pipeline has completed. It continues the list of "After Pipeline Completion" in the runner: items 2 and 3 below are the items 2 and 3 of that list; follow them in order.
+
+2. **Update crew memory** — write to BOTH files:
+
+### 2a. Update `memories.md` (living preferences)
+
+Read `crews/{name}/_memory/memories.md` in full. Then identify candidates from this run: **only explicit user feedback** — approvals with comments, rejections with reasons, direct requests ("prefiro X", "não quero Y"). Never infer preferences.
+
+For each candidate:
+- If an equivalent memory already exists and is compatible → skip (no duplicate)
+- If an equivalent memory exists but contradicts the new item → replace with the newer version
+- If no equivalent exists → add to the correct semantic section:
+  - 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`, 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`:**
+- Runner inferences ("usuário parece preferir X")
+- 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 `_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`.
+
+If no candidates are found (the run had no explicit user feedback), skip writing `memories.md` entirely — do not write an unmodified copy. Always proceed to step 2b regardless.
+
+### 2b. Prepend to `runs.md` — the script writes the row
+
+Never write `crews/{name}/_memory/runs.md` yourself. Close the run with the `fechar` command of the runner ("Run record"): `--resultado` is `aprovado` (the final approval was given), `publicado` (an irreversible step published or sent) or `rejeitado` (the review rejected at the last cycle and the user aborted); `--saida` is a brief description of what was generated (e.g. "Carrossel 9 slides", "Thread 7 posts"); add `--tema "{tema}"` (1 sentence max) if no command of this run carried the topic yet.
+
+The script writes the row of this run right below the header — `Data | Run ID | Tema | Output | Score | Resultado`, newest run first; a row this run already had is replaced — and prints it. No other data.
+
+`Score` has one definition, and the script counts it from the recorded checkpoints: the checkpoints the user approved without corrections ÷ the checkpoints the user answered (approved + corrected; a skipped one does not count), e.g. `2/3`; `—` when none was answered. Never compute it yourself.
+
+- Last line `EXECUCAO:FECHADA {resultado} {score}` → go on to 2c. A line `Não consegui gravar o histórico desta execução: {motivo}` before it → show it to the user as it came.
+- The script did not run (no Node, an error, no `EXECUCAO:` line) → tell the user `⚠️ Não consegui gravar o histórico desta execução: {motivo}` and go on. Do not write the row by hand.
+
+### 2c. Post-Run Reflection (pattern detection)
+
+After updating `memories.md` and closing the run, run a reflection pass. This is a lightweight analysis — not a full agent execution, just pattern matching on the corrections of this run and of the last runs.
+
+1. **Collect this run's corrections**: From checkpoint responses, gather every user rejection or correction. A correction is:
+   - A rejected output with a reason ("tom muito informal", "cor não combina", "fonte sem data")
+   - A modification request during checkpoint ("muda o título para X", "usa azul em vez de verde")
+
+2. **Look for recurrence**: use the list the `fechar` command printed under `Correções das últimas execuções:` — one line per correction recorded in the last 10 closed runs of this crew, this one included (`- {run_id} · passo {N} · {nota}`).
+   - Do not search `memories.md` for past runs: by rule it keeps no run data.
+   - Count: in how many different runs of that list does the same pattern appear?
+   - A "match" means the same step (so the same agent) + the same type of error (e.g. "redator + tom informal", "designer + cores saturadas")
+   - No list was printed → there is nothing to compare: skip items 3 and 4.
+
+3. **Promote to Regra de Ouro**: If the SAME pattern appears in **3 or more runs** (including this one):
+   a. Add a new entry under `## Regras de Ouro` in `memories.md` (the header is exactly this, fixed PT-BR; create the section if the file does not have it):
+      ```markdown
+      ## Regras de Ouro
+
+      - **{Agent role}**: SEMPRE {correct behavior}. {Why — grounded in user feedback}.
+        (Runs: #{run1}, #{run2}, #{run3})
+      ```
+      Example:
+      ```markdown
+      - **Redator**: SEMPRE verificar se o CTA contém link rastreável antes de finalizar.
+        (Runs: #2026-08-01-143022, #2026-08-05-091530, #2026-08-10-160845)
+      ```
+   b. Remove the individual entries from their original sections (`## Estilo de Escrita`, `## Design Visual`, etc.) — the Regra de Ouro replaces them.
+   c. Display to the user:
+      ```
+      💡 Regra de Ouro detectada:
+      "{correct behavior}" aconteceu 3 vezes.
+      Vou aplicar automaticamente a partir de agora.
+      ```
+
+4. **Mark improvement**: If a previously recurring error did NOT happen this run:
+   - Add a `✅` marker to the Regra de Ouro entry: `✅ **Redator**: SEMPRE ...`
+   - This tracks that the crew is improving — the rule is working.
+
+5. **Bail out early**: If this run had zero corrections (all checkpoints approved), skip the entire reflection — nothing to learn.
+
+6. **Reflection budget**: Maximum 30 seconds of analysis: the list of the script is all the history you read. This is a quick scan, not an exhaustive audit.
+
+3. Present completion summary:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Pipeline complete!
+📁 Delivery: crews/{name}/output/{run_id}/entrega/ — start with LEIA-ME.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+What would you like to do?
+● Run again (new topic)
+○ Edit this content
+○ Back to menu
+```

package/templates/_opencrew/core/runner/fontes-pendentes.md

@@ -0,0 +1,21 @@
+# Source check that did not end in FONTES:OK
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when the source check of the Initialization (1c) ended in `FONTES:PENDENTE` or did not run.
+
+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. Alerts — not portable (absolute paths) or "não conferido" (a network path or a site
+address: the script never accesses the network) — 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.

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

@@ -0,0 +1,58 @@
+# Memory format
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when `memories.md` has no `## Estilo de Escrita` section header, is empty or does not exist.
+
+**Note on language**: The structural labels listed below are **fixed PT-BR** and must
+never be translated — opencrew's primary supported audience is PT-BR (see AGENTS.md →
+Language Handling). Only the *content* written under these headers follows the user's
+preferred language.
+
+| Fixed PT-BR header | Location | Purpose |
+|---|---|---|
+| `## Estilo de Escrita` | `memories.md` | Writing style rules accumulated per crew |
+| `## Design Visual` | `memories.md` | Visual design preferences per crew |
+| `## Estrutura de Conteúdo` | `memories.md` | Content structure rules per crew |
+| `## Proibições Explícitas` | `memories.md` | User bans and hard blocks per crew |
+| `## Regras de Ouro` | `memories.md` | Corrections repeated in 3 or more runs, promoted at the end of a run |
+| `## Técnico (específico do crew)` | `memories.md` | Technical crew-specific settings |
+| `Data \| Run ID \| Tema \| Output \| Score \| Resultado` | `runs.md` | Run history table columns |
+
+When adding new structural sections to `memories.md` or `runs.md`, keep headers in PT-BR
+unless the user base expands beyond PT-BR — at that point, discuss a migration strategy
+(e.g. i18n key mapping) rather than mixing languages in a single file.
+
+## Migration
+
+**Memory format migration** — After loading `memories.md`, check whether it uses the new format: it does when it has the `## Estilo de Escrita` section header (read the file with the read tool — no command).
+   - If it has the header → proceed normally.
+   - If it does not (or the 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}
+
+        ## Estilo de Escrita
+
+        ## Design Visual
+
+        ## Estrutura de Conteúdo
+
+        ## Proibições Explícitas
+
+        ## Regras de Ouro
+
+        ## Técnico (específico do crew)
+        ```
+        (Use the crew's display name for `{crew-name}`, and the crew code for `{name}` in file paths — they refer to the same crew.)
+     b. Check if `crews/{name}/_memory/runs.md` exists (read tool — no command).
+        If it does not exist, create it with:
+        ```markdown
+        # Run History: {crew-name}
+
+        | Data | Run ID | Tema | Output | Score | Resultado |
+        |------|--------|------|--------|-------|-----------|
+        ```
+   - Do not pause execution for this migration (the one-line notice above is enough).

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

@@ -0,0 +1,51 @@
+# Resuming a run (retomar)
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only on `/opencrew retomar {name}`.
+
+A run that stopped in the middle — the conversation ended, the context ran out — left its record on
+disk. Resuming is going on from the step after the last one that was done, with the same `run_id`:
+what was written and checked is not redone; the step that was in the middle is done again, whole.
+
+1. From the project root, with the crew code between double quotes (safe-name rule of the runner):
+   ```
+   node _opencrew/core/scripts/execucao.mjs "{name}" retomar
+   ```
+2. Read the last line:
+   - `EXECUCAO:NADA` → say `Não há execução interrompida da crew {nome}.` and stop (to start a new
+     run: `/opencrew run {name}`).
+   - `EXECUCAO:RETOMAR {run_id} {N}` → the lines before it are the theme, the steps already checked
+     (each with its file), the checkpoints already answered and the verdicts of the review. Go to 3.
+   - The output starts with `Execuções abertas` → more than one run is open: show the list and ask
+     which one. For one that is not the newest, run the command again with `--run "{run_id}"`.
+   - A line `Não consegui ler na crew para qual passo a revisão … volta` → show it and confirm the
+     step with the user before going on.
+   - No `EXECUCAO:` line (no Node, an error) → show the message as it came and stop. Never rebuild
+     the state of a run by looking at its folder, and never read `execucao.json` yourself.
+3. Ask, and wait for the answer:
+   `A execução {run} ({tema}) parou depois do passo {k}. Já estão prontos: {lista}. Continuo do passo {N}?`
+   (`{run}`: the `run_id`; `{k}`: the step of the line `Parou depois do passo`; `{lista}`: the files
+   under `Passos conferidos` — not the ones under `Já gravados, mas serão feitos de novo`; a run
+   with no theme goes without the parentheses.)
+   - No → change nothing. Ask `Quer que eu encerre essa execução como abortada?`; after a yes, run
+     the `fechar` command of the runner ("Run record") with `--resultado abortado`, so it is no
+     longer offered. Then stop.
+4. Only now, after the yes (nothing of the runner's Initialization runs before the question): do the Initialization of the runner in full (memory format, source check, project
+   sources, pipeline, skills, tiers, agent selection, the header) **except step 5b**: do not run
+   `pasta` — the `run_id` is the one of the `EXECUCAO:RETOMAR` line.
+   Step 6 (the Escritório) happens as in a new run.
+5. Go on at step `{N}` of "For each pipeline step", with that `run_id`:
+   - Every input comes from the `entrada` command, as always: it finds what the earlier steps wrote.
+   - The paths under `Passos conferidos` are the stored paths of those steps: use them to show a
+     file at a checkpoint and to build the list of the delivery.
+   - Do not ask again a checkpoint the script listed as answered: its answer is in the file the
+     checkpoint saved (the `inputFile` of the step after it), or in the note the script printed.
+   - Step `{N}` is done whole, even when a file of it is already there (`saida` opens a new version).
+   - A review cycle the script listed counts: the cycles left are `max_review_cycles` minus the
+     verdicts under `Revisões:` for that review step (no such section: none), and the next
+     `verificacao-ciclo-{N}.md` is that number plus 1.
+   - The `Tema:` line says whether the record has a topic: `(sem tema)` → send `--tema` with the
+     next `marcar` or with `fechar`.
+   - `{N}` is after the last step of the pipeline (the script says `Todos os passos já foram feitos`)
+     → go straight to "After Pipeline Completion".
+6. Say once, before the first step: `Retomei pelo que está gravado. O que foi combinado só na conversa anterior não veio junto.`
+   A resumed run is recorded and closed like any other (`conferir --passo`, `marcar`, `fechar`).

package/templates/_opencrew/core/runner/selecao-de-agentes.md

@@ -0,0 +1,79 @@
+# Pre-Execution Agent Selection
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when `crew.yaml` declares an `agent_dependencies:` field. It decides which agents actually run for this task.
+
+Run this step ONLY if `crew.yaml` declares an `agent_dependencies:` field (even an
+empty map `{}`). If the field is absent → skip this entire step and run ALL agents
+exactly as before (legacy behavior).
+
+When active, in this order:
+
+a. **Capture the task** — Determine the user's request for this run:
+   - If the run was invoked with a description (e.g. `/opencrew run {name} {description}`),
+     use that text as the task.
+   - Otherwise ask: `📝 What is the task for this run? Reply in one line.`
+     Wait for the user's reply before continuing.
+
+b. **Analyze against the decision matrix** — Scan the task text (case-insensitive,
+   PT-BR and EN keywords) for the signals below. Start with ALL agents suggested as
+   SELECTED (`required`). For each matching signal, find the affected agent(s) in
+   `crew-party.csv` by matching the role terms against the agent's `id` and `title`
+   (and `displayName` if ambiguous), then apply the suggested status:
+
+   | Signal in the task | Role terms to match (id / title) | Suggested status |
+   |--------------------|----------------------------------|------------------|
+   | "já pesquisei", "com base em", "fontes que tenho", "material pronto", "baseado nas fontes", "research already done" | researcher, pesquisad, research | optional |
+   | "revise", "melhore", "corrija", "refine", "edite" (sem criar do zero), "improve this draft" | copywriter, redator, writer, criador | optional |
+   | "só texto", "sem imagem", "sem visual", "sem arte", "no image" | designer, design, visual | skip |
+   | "já revisei", "já foi aprovado", "aprovado por terceiros", "revisão feita", "already reviewed" | reviewer, revisor | optional |
+   | "quero só revisar este texto", "apenas revisar", "review only" | researcher AND copywriter | skip |
+   | "tenho o conteúdo pronto", "forneço o documento", "docs em anexo", "segue o material", "here is the content" | copywriter, writer, creator | optional |
+
+   Resolution rules:
+   - `optional` = agent stays selected but may be unchecked.
+   - `skip` = agent is suggested deselected.
+   - Conflicting signals on the same agent → the more restrictive wins (`skip` > `optional`).
+   - Never suggest skipping an agent whose output is the run's final deliverable unless the
+     signal is explicit.
+   - No signal matches → suggest keeping all agents (no change).
+
+c. **Present the selection** — IDE-neutral numbered multi-select. List every agent from
+   `crew-party.csv` in party order:
+   ```
+   🧑‍🤝‍🧑 Which agents should work on this task?
+
+   Suggested selection:
+   1. [x] {icon} {displayName} ({id}) — {title}
+   2. [x] {icon} {displayName} ({id}) — {title}
+   3. [ ] {icon} {displayName} ({id}) — {title}
+   ...
+   [x] = suggested selected · [ ] = suggested deselected
+
+   Reply with the numbers of the agents you want to INCLUDE, separated by commas.
+   Example: "1, 2"   ·   Reply "all" to run everyone.
+   ```
+   Wait for the user's reply. Parse it into `selected_agents`. At least one agent must
+   be selected — if the user replies with none, repeat the prompt once.
+
+d. **Dependency warnings** — Using `crew.yaml → agent_dependencies`
+   (e.g. `copywriter: [researcher]` = copywriter consumes researcher's output):
+   for every dependency `dependent → required_agent`, if `dependent` is selected but
+   `required_agent` is NOT, warn:
+   ```
+   ⚠️ {dependent} normally depends on {required_agent}'s output, which you deselected.
+
+   1. Re-select {required_agent} (recommended)
+   2. Keep going without it — I will supply the input myself
+   3. Deselect {dependent} too
+   ```
+   Wait for the user's choice and apply it. If they pick option 2, set
+   `missing_dependency = true` in working memory (the existing Pre-Step Input
+   Validation recovery — "Skip step and continue / Abort" — then handles any
+   downstream gap).
+
+e. **Build the filtered step list** — Set `skipped_agents = all party agents − selected_agents`.
+   Build `filtered_steps` by walking `pipeline.yaml` in order, keeping a step when:
+   - its frontmatter has NO `agent:` field (checkpoints / generic steps), OR
+   - its `agent:` value is in `selected_agents`.
+   Store `selected_agents`, `skipped_agents`, and `filtered_steps` in working memory for
+   the per-step loop (steps 5 and 6 of the Initialization reflect them).

package/templates/_opencrew/core/runner/tarefas-do-agente.md

@@ -0,0 +1,34 @@
+# Task-Based Agent Execution
+
+> Part of the Pipeline Runner (`_opencrew/core/runner.pipeline.md`). Read it only when the agent of the step has a `tasks:` field in its frontmatter.
+
+When an agent's `.agent.md` frontmatter contains a `tasks:` field:
+
+1. **Load task list**: Read the `tasks:` array from the agent's frontmatter
+   - Each entry is a relative path to a task file (e.g., `tasks/analyze-source.md`)
+   - Tasks execute in the order listed
+
+2. **For each task in sequence**:
+   a. Read the task file from the agent's directory (`crews/{crew-name}/agents/{agent-id}/tasks/{task}.md`: a folder with the agent id, next to the agent file)
+   b. Construct the execution prompt:
+      - Agent persona + principles (from agent.md — fixed across all tasks)
+      - Task description and process (from task file)
+      - Task output format (from task file)
+      - Task quality criteria and veto conditions (from task file)
+      - Input: For the first task, use the step's input. For subsequent tasks, use the previous task's output.
+   c. Execute the task (inline or subagent, matching the step's execution mode)
+   d. Collect the task output
+   e. Check task veto conditions (same enforcement as the step veto conditions: "Veto Condition Enforcement", in the runner)
+
+3. **Final output**: The output of the LAST task in the chain becomes the step's output
+   - Resolve the `outputFile` path with the `saida` command (Output Path Transformation) before saving — this applies regardless of whether the step runs as `execution: inline` or `execution: subagent`
+   - Save to the **transformed** outputFile path
+   - This is what the next step (or checkpoint) receives
+
+4. **Progress reporting**: For inline execution, announce each task:
+   ```
+   {icon} {Agent Name} — Task {N}/{total}: {task name}...
+   ```
+
+5. **Backward compatibility**: If the agent's frontmatter does NOT contain a `tasks:` field,
+   execute the agent monolithically as before (current behavior unchanged).