@aksp/opencrew 1.6.2 → 1.7.0

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

@@ -5,6 +5,23 @@
 
 You are the Pipeline Runner. Your job is to execute a crew's pipeline step by step.
 
+## Safe names in commands (nome seguro)
+
+Applies to EVERY command below and in any prompt or skill. A path of the crew or of the user's
+project goes into a command only between double quotes and only if it is made of letters (accents
+included), digits, space and `. _ - / \ : ( )`. With any other character (`$`, backtick, quote,
+`%`, `!`, `,`, `;`, `&`, `|`, `<`, `>`, line break) do NOT build the command:
+- **Crew folder** → stop: "⚠️ A pasta da crew (`crews/{name}`) tem um caractere que não posso usar
+  em comandos ({caractere}). Renomeie a pasta e rode de novo."
+- **Output file** (`inputFile`, `outputFile`, any file passed to a script) → ask and wait:
+  ```
+  ⚠️ O nome `{caminho}` tem um caractere que não posso usar em comandos ({caractere}). Use só letras, números, espaço, ponto, hífen, sublinhado e parênteses.
+  1. Parar para você renomear (ajuste também o `outputFile` do passo)
+  2. Seguir sem conferir este arquivo
+  ```
+  On 2, run no command with that file (no validation gate, not sent to the checker) and list it at
+  the final approval: `{arquivo} — não verificado: nome com caractere que não vai em comando`.
+
 ## Initialization
 
 Before starting execution:
@@ -16,18 +33,7 @@ Before starting execution:
    - Crew memory from `crews/{name}/_memory/memories.md`
    - User preferences from `_opencrew/_memory/preferences.md`
 
-1a. **Check the Dashboard toggle** — the visual dashboard (`state.json` writes) is an
-    optional, opt-in feature that most installs never use (it requires running the
-    separate dashboard app from source — see README). Scan the already-loaded
-    `preferences.md` for a `Dashboard:` field:
-    - If its value is `enabled` (as written by onboarding: `- **Dashboard:** enabled`, or the
-      plain form `Dashboard: enabled`) → set `dashboard_enabled = true` for this run.
-    - Otherwise (`disabled`, missing, or preferences.md not configured yet) →
-      set `dashboard_enabled = false`. This is the default.
-    Store `dashboard_enabled` in working memory for the rest of this run. Every
-    `state.json` read/write instruction in this document is conditional on it —
-    when `false`, skip ALL of them; never create, update, or delete
-    `crews/{name}/state.json`.
+1a. **Escritório toggle** — the optional live view is off unless `preferences.md` turns it on (see "Escritório" below).
 
 > **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 →
@@ -49,7 +55,7 @@ Before starting execution:
 
 1b. **Memory format migration** — After loading `memories.md`, check whether it uses the new format by scanning for the `## Estilo de Escrita` section header:
    ```bash
-   [ -f crews/{name}/_memory/memories.md ] && grep -q "## Estilo de Escrita" crews/{name}/_memory/memories.md && echo "NEW_FORMAT" || echo "OLD_FORMAT"
+   [ -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) → migrate before proceeding:
@@ -74,7 +80,7 @@ Before starting execution:
         (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:
         ```bash
-        test -f crews/{name}/_memory/runs.md && echo "EXISTS" || echo "MISSING"
+        test -f "crews/{name}/_memory/runs.md" && echo "EXISTS" || echo "MISSING"
         ```
         If `MISSING`, create it with:
         ```markdown
@@ -102,9 +108,10 @@ Before starting execution:
     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.
+    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.
 
 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
@@ -224,43 +231,45 @@ Before starting execution:
    - Format: `YYYY-MM-DD-HHmmss` using the current timestamp (e.g. `2026-03-03-143022`)
    - Check if `crews/{name}/output/{run_id}/` already exists
      - If it does (sub-second collision), append `-2`, `-3`, etc. until the folder does not exist
-   - Create the folder using Bash: `mkdir -p crews/{name}/output/{run_id}`
+   - Create the folder using Bash: `mkdir -p "crews/{name}/output/{run_id}"`
    - Store `run_id` in working memory for this run — it will be used for ALL output paths
-6. **Initialize state.json** (only if `dashboard_enabled` — see step 1a; otherwise skip this entire step, including all sub-steps below):
-   - **IMPORTANT**: When enabled, write to `crews/{name}/state.json` before every step and after every handoff, as described throughout this document. When `dashboard_enabled` is false, never create, write, or delete this file.
-   - Create `state.json` from scratch:
-     a. Read `crews/{name}/crew-party.csv` — for each agent row (skip header), extract:
-        - `id`: take the `path` column, strip `./agents/` prefix and `.agent.md` suffix
-          (e.g. `./agents/researcher.agent.md` → `researcher`)
-        - `name`: use the `displayName` column
-        - `icon`: use the `icon` column
-     b. Assign desk positions by agent order (0-based index):
-        - `col = (index % 3) + 1`
-        - `row = floor(index / 3) + 1`
-        (index 0 → col:1 row:1, index 1 → col:2 row:1, index 2 → col:3 row:1, index 3 → col:1 row:2, etc.)
-     c. Read `crews/{name}/crew.yaml` — count items in `pipeline.steps` for `total`
-     d. Write `crews/{name}/state.json` with the Write tool:
-        ```json
-        {
-          "crew": "{crew code from crew.yaml}",
-          "status": "idle",
-          "step": { "current": 0, "total": {step count from c}, "label": "" },
-          "agents": [
-            {
-              "id": "{agent id}",
-              "name": "{agent displayName}",
-              "icon": "{agent icon}",
-              "status": "idle",
-              "desk": { "col": {col from b}, "row": {row from b} }
-            }
-          ],
-          "handoff": null,
-          "startedAt": null,
-          "updatedAt": "{ISO timestamp now}"
-        }
-        ```
-        Include one entry per agent, in crew-party.csv order. For each agent, set
-        `"status"` to `"skipped"` if it is in `skipped_agents`, otherwise `"idle"`.
+6. **Escritório** — if it is on, run `iniciar`, then one `pular` per deselected agent, one after the other (see "Escritório" below).
+
+## Escritório (optional live view)
+
+A local page that shows the crew at work, off by default. Follow this section 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 via Bash, 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.
 
 ## Execution Rules
 
@@ -307,13 +316,14 @@ Before executing any step that references an agent:
       ```
    If the step has no `format:` field, skip this step entirely (backward compatible).
 6. **Inject skill context (Two-Tier)**:
-    a. Build a Tier 1 skill index from each declared skill's frontmatter `name` and `description` (~30 tokens per skill)
-    b. Append the index after format injection:
+    a. Build a Tier 1 skill index from each declared skill's frontmatter `name`, `description` and `side_effects` (~30 tokens per skill)
+    b. Append the index after format injection (the second form is for every skill with `side_effects: irreversible`):
        ```
        --- AVAILABLE SKILLS ---
        - {skill-id}: {description} (type: {type})
+       - {skill-id}: {description} (type: {type}) — irreversível: carregue as instruções desta skill e peça a confirmação antes de usar
        ```
-    c. If the step's frontmatter contains `skills_needed: [...]`, load Tier 2 (full SKILL.md body) for those skills immediately
+    c. If the step's frontmatter contains `skills_needed: [...]`, load Tier 2 (full SKILL.md body) for those skills immediately; for a skill with `side_effects: irreversible`, always load Tier 2 before its first use
     d. Otherwise, Tier 2 is loaded on-demand when the agent invokes a skill during execution
     e. See `_opencrew/core/skills.engine.md` Operation 6 for full details
 
@@ -464,7 +474,7 @@ Apply to every path that was transformed in Step 1:
 
 2. Detect existing versions for this group using Bash:
    ```bash
-   ls -1 crews/{name}/output/{run_id}/{relative-group}/ 2>/dev/null | grep -E '^v[0-9]+$' | sort -V | tail -1
+   ls -1 "crews/{name}/output/{run_id}/{relative-group}/" 2>/dev/null | grep -E '^v[0-9]+$' | sort -V | tail -1
    ```
    - If the command returns a version (e.g. `v2`) → use `v3`
    (Always increment the highest version found, even if lower versions have gaps — e.g. if `v1` and `v3` exist, use `v4`)
@@ -485,38 +495,15 @@ Apply this transformation consistently for every write in this step.
 0. **Agent deselection check** — Read the step's `agent:` frontmatter field.
    - If the step has an `agent:` value present AND it is in `skipped_agents` →
      announce `⏭️ Skipping {Agent Name} (deselected for this run)` and skip this
-     step ENTIRELY: no dashboard update, no input validation, no execution, no output
-     validation, no veto, no output file, no handoff. Advance to the next step in
+     step ENTIRELY: no Escritório command, no input validation, no execution, no output
+     validation, no veto, no output file. Advance to the next step in
      `filtered_steps`.
    - Checkpoints that declare `agent:` and whose agent was deselected are skipped the
      same way. Checkpoints with no `agent:` field always run (backward compatible).
    - When the selection step was skipped (no `agent_dependencies:`), `skipped_agents`
      is empty → this check never fires (legacy behavior).
 
-0b. **Update dashboard** (only if `dashboard_enabled`; otherwise skip to step 1). Write `crews/{name}/state.json` using the Write tool. Use this content:
-   ```json
-   {
-     "crew": "{crew code from crew.yaml}",
-     "status": "running",
-     "step": {
-       "current": {1-based index of this step},
-       "total": {total steps in pipeline},
-       "label": "{step id or label}"
-     },
-     "agents": [
-       {
-         "id": "{agent id}",
-         "name": "{agent displayName}",
-         "icon": "{agent icon}",
-          "status": "{working if this is the current step's agent, done if already completed, skipped if in skipped_agents, idle otherwise}",
-         "desk": {preserve existing desk positions from state.json — do not change col/row}
-       }
-     ],
-     "handoff": {preserve existing handoff object, or null if this is the first step},
-     "startedAt": "{ISO timestamp — set on the first step only, then preserve from existing state.json on subsequent steps}",
-     "updatedAt": "{ISO timestamp now}"
-   }
-   ```
+0b. **Escritório** — if it is on, run `passo`, or `checkpoint` when the step is a checkpoint (see "Escritório" above).
 
 1. **Pre-Step Input Validation** — MANDATORY. If the step's frontmatter declares an `inputFile`, validate that the input exists before executing the step. Run via Bash tool:
    ```bash
@@ -732,52 +719,23 @@ When a step has `on_reject: {step-id}` (a review step):
    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
+   and repeat every "não rodou" warning of this run (checker and source check) and the line of
+   every file left unchecked by the safe-name rule. 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)
-
-Only if `dashboard_enabled` (otherwise skip this entire section). After a step
-completes output and there IS a next step:
-
-1. **Write delivering state** — Write `crews/{name}/state.json` with:
-   - Current step's agent: `"status": "delivering"`
-   - Next step's agent: `"status": "idle"`
-   - All other agents unchanged
-   - Pipeline `"status": "running"`
-   - Add or update `"handoff"`:
-     ```json
-     "handoff": {
-       "from": "{current agent id}",
-       "to": "{next agent id}",
-       "message": "{one-sentence summary of what was produced, written in the user's language}",
-       "completedAt": "{ISO timestamp now}"
-     }
-     ```
-   - `"updatedAt"`: now
-
-2. _(No delay — proceed immediately to working state)_
-
-2. **Write working state** — Write `crews/{name}/state.json` again with:
-   - Current agent: `"status": "done"`
-   - Next agent: `"status": "working"`
-   - Keep the `"handoff"` object from step 1 unchanged
-   - `"updatedAt"`: now
-
 ### Step Execution Order (Summary)
 
 For reference, the complete execution order for each pipeline step is:
 
 ```
 0. Agent deselection check (skip step if its agent was deselected)
-0b. Dashboard update (state.json) — only if dashboard_enabled
+0b. Escritório command (passo or checkpoint) — only if it is on
 1. Pre-Step Input Validation (bash gate)
 2. Read step file
 3. Check execution mode and execute (subagent / inline / checkpoint)
 4. Post-Step Output Validation (bash gate)
 5. Veto Condition Enforcement
-6. Dashboard Handoff (to next step) — only if dashboard_enabled
 ```
 
 Steps 1 and 4 are binary bash gates. If either fails, the pipeline does NOT advance — the user is consulted.
@@ -786,31 +744,9 @@ Steps 1 and 4 are binary bash gates. If either fails, the pipeline does NOT adva
 
 1. Save final output to `crews/{name}/output/{run_id}/{filename}.md`
    (The run folder was created during initialization — no separate date subfolder needed)
-1b. **Update dashboard** (only if `dashboard_enabled`; otherwise skip to step 2 below). Write `crews/{name}/state.json` with:
-    - `"status": "completed"`
-    - All agents: `"status": "done"`
-    - `"updatedAt"`: now
-    - `"completedAt"`: now
-    - `"startedAt"`: preserve from existing `state.json`
-    - Keep existing `"handoff"` object
-
-### Post-Completion Cleanup (only if `dashboard_enabled`)
-
-After writing the final "completed" state to `crews/{name}/state.json`:
-
-1. Add the `completedAt` field (or `failedAt` if status is `failed`) with the current ISO timestamp
-2. Copy `state.json` to the run output folder for permanent history:
-   ```bash
-   cp crews/{name}/state.json crews/{name}/output/{run_id}/state.json
-   ```
-3. Leave the working copy of `crews/{name}/state.json` in place — do not delete it and
-   do not add an artificial delay. A dashboard watching the file already sees the
-   "completed" status the moment it's written; the next run's initialization (step 6)
-   overwrites this file from scratch. There is nothing to clean up.
-
-This archives the run state for the `runs` command while keeping crew history available.
+1b. **Escritório** — if it is on, run `concluir` (see "Escritório" above).
 
-2. **Update crew memory** — write to BOTH files (runs after Post-Completion Cleanup above):
+2. **Update crew memory** — write to BOTH files:
 
    ### 2a. Update `memories.md` (living preferences)
 
@@ -927,6 +863,7 @@ This archives the run state for the `runs` command while keeping crew history av
 - If a step file is missing, inform the user and suggest running `/opencrew edit {crew}` to fix.
 - If company.md is empty, stop and redirect to onboarding.
 - Never continue past a checkpoint without user input.
+- When the run is aborted: if the Escritório is on, run `falhar` (see "Escritório" above).
 
 ## Pipeline State
 

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

@@ -1,6 +1,7 @@
 // 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).
+// Specs: specs/fase-r1-reparos-1-6-1.md, regra 13, e specs/fase-r2-update-e-envio-seguros.md,
+// regra 23 (repositório do OpenCrew).
 import { existsSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -12,12 +13,56 @@ export const MSG = {
   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));
+/** Caminho de rede: começa por duas barras (`\\` ou `//`), em qualquer sistema. Nunca vai ao disco. */
+export const ehDeRede = (caminho) => /^[\\/]{2}/.test(caminho);
+
+/** Pelo texto: `alvo` é a `pasta` ou fica dentro dela? */
+function contem(pasta, alvo) {
+  const rel = path.relative(pasta, alvo);
   return !(rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel));
 }
 
+/**
+ * Lugar real de um caminho: link, junção e nome curto resolvidos. O trecho que ainda não existe é
+ * juntado, como foi escrito, à pasta mais funda que existe. Caminho de rede não é consultado: vale
+ * o texto.
+ */
+export function lugarReal(caminho) {
+  const abs = path.resolve(caminho);
+  if (ehDeRede(caminho) || ehDeRede(abs)) return abs;
+  try {
+    return realpathSync.native(abs);
+  } catch {
+    const pai = path.dirname(abs);
+    return pai === abs ? abs : path.join(lugarReal(pai), path.basename(abs));
+  }
+}
+
+/** Pelo lugar real: `caminho` é a `pasta` ou fica dentro dela? */
+export const realDentroDe = (pasta, caminho) => contem(lugarReal(pasta), lugarReal(caminho));
+
+/**
+ * O caminho (relativo à raiz ou absoluto) fica dentro do projeto? Sim quando o texto ou o lugar
+ * real diz "dentro"; não, só quando os dois dizem "fora" (regra 23). Raiz e caminho são resolvidos
+ * pela mesma função, e o lugar real só é consultado quando o texto diz "fora". Caminho de rede só
+ * vale pelo texto, com o projeto também na rede: o disco não é tocado, em nenhum sistema.
+ */
+export function dentroDoProjeto(raiz, caminho) {
+  const alvo = path.resolve(raiz, caminho);
+  if (ehDeRede(caminho)) return ehDeRede(raiz) && contem(raiz, alvo);
+  return contem(raiz, alvo) || realDentroDe(raiz, alvo);
+}
+
+/**
+ * Caminho de dentro do projeto, relativo à raiz e com `/`: pelo texto quando o texto já fica
+ * dentro; senão, pelo lugar real (link, junção ou nome curto que leva ao projeto).
+ */
+export function relativoAoProjeto(raiz, caminho) {
+  const alvo = path.resolve(raiz, caminho);
+  const [de, para] = contem(raiz, alvo) ? [raiz, alvo] : [lugarReal(raiz), lugarReal(alvo)];
+  return path.relative(de, para).split(path.sep).join('/');
+}
+
 /**
  * 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

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

@@ -1,10 +1,12 @@
 // 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).
+// com o mesmo nome. Só testa existência e lista nomes; nunca lê conteúdo nem acessa a rede.
+// Specs: specs/fase-r1-reparos-1-6-1.md, regra 17, e specs/fase-r2-update-e-envio-seguros.md,
+// regra 25 (repositório do OpenCrew).
 import { readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { ehDeRede } from '../comum.mjs';
 
 export const LIMITE_DA_BUSCA = 20000;
 const IGNORAR = new Set(['node_modules', 'output', '_opencrew', '_build']);
@@ -13,6 +15,7 @@ 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 ehPasta = (p) => Boolean(p) && Boolean(statSync(p, { throwIfNoEntry: false })?.isDirectory());
 
 const SUFIXO_DE_AGENTE = '.agent.md';
 
@@ -33,8 +36,10 @@ function pastasDeQuemCita(raiz, crew, citadoEm) {
 /**
  * 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`).
+ * Citação de duas barras (caminho de rede) nunca chega ao disco: sai como "não existe".
  */
 export function resolver(raiz, crew, ref, citadoEm = []) {
+  if (ehDeRede(ref)) return null;
   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);
@@ -43,6 +48,40 @@ export function resolver(raiz, crew, ref, citadoEm = []) {
   return null;
 }
 
+/**
+ * O primeiro segmento de `exemplo.com/blog/`, quando tem cara de domínio: um ponto que não é o
+ * início e, depois do último ponto, 2 a 24 letras. Nome sem barra (`briefing.md`) é arquivo: null.
+ */
+function dominioNoInicio(ref) {
+  const corte = ref.search(/[\\/]/);
+  const primeiro = ref.slice(0, Math.max(corte, 0));
+  const ponto = primeiro.lastIndexOf('.');
+  return ponto > 0 && /^[A-Za-z]{2,24}$/.test(primeiro.slice(ponto + 1)) ? primeiro : null;
+}
+
+/**
+ * Citação que a conferência não testa (regra 25 da fase R2): caminho de rede (começa por duas
+ * barras) ou endereço de site — tem `://` (menos `http(s)://`, que fica como sempre foi), começa
+ * por `mailto:` ou `www.`. Caminho de disco (letra de unidade ou uma barra no início) nunca é
+ * endereço. Não consulta o disco nem a rede.
+ */
+export function ehRedeOuSite(ref) {
+  if (ehDeRede(ref)) return true;
+  if (ehAbsoluto(ref) || /^https?:\/\//i.test(ref)) return false;
+  return ref.includes('://') || /^(?:mailto:|www\.)/i.test(ref);
+}
+
+/**
+ * Citação que só parece endereço de site pela forma: o primeiro segmento tem cara de domínio e
+ * não há pasta com esse nome no projeto. Quem chama confere antes se o projeto tem arquivo com o
+ * mesmo nome: pasta com ponto que foi movida continua pendência, com sugestão.
+ */
+export function pareceSite({ raiz, crew }, { ref, citadoEm }) {
+  if (ehAbsoluto(ref) || /^https?:\/\//i.test(ref)) return false;
+  const dominio = dominioNoInicio(ref);
+  return dominio != null && !ehPasta(resolver(raiz, crew, dominio, citadoEm));
+}
+
 /**
  * Í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.

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

@@ -1,7 +1,7 @@
 // Relatório da conferência de fontes e as mensagens ao usuário (PT-BR).
-// Spec: specs/fase-r1-reparos-1-6-1.md, regra 17 e seção 6 (repositório do OpenCrew).
-import path from 'node:path';
-import { barra } from './busca.mjs';
+// Specs: specs/fase-r1-reparos-1-6-1.md, regra 17 e seção 6, e
+// specs/fase-r2-update-e-envio-seguros.md, regras 24 a 26 e seção 6 (repositório do OpenCrew).
+import { relativoAoProjeto } from '../comum.mjs';
 
 const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
 
@@ -10,6 +10,9 @@ export const MSG = {
   corrigidos: (n) => `${plural(n, 'caminho corrigido', 'caminhos corrigidos')} (cópia .bak ao lado de cada arquivo alterado).\n`,
   semCorrecaoAutomatica: (n) => `Não há correção automática para ${n} pendência(s): escolha um candidato ou corrija o caminho na crew.`,
   buscaParcial: (limite) => `Procurei só nos primeiros ${limite} itens do projeto; pode existir um arquivo com esse nome que eu não vi.`,
+  linkParaFora: (arquivo) => `Não corrigi \`${arquivo}\`: é um link que aponta para fora da crew. O caminho citado nele continua como estava.`,
+  crewLigadaParaFora: (crew) => `Não corrigi nada: a pasta \`${crew}\` é um link que aponta para fora do projeto.`,
+  naoConferi: (motivo) => `Não consegui conferir: ${motivo}`,
 };
 
 const MAX_NOMES = 20;
@@ -37,16 +40,25 @@ function linhaDoAlerta(i, onde) {
   return `- ⚠️ \`${i.ref}\` é um caminho absoluto (não é portátil — quebra em outro computador).${sugestao} (${onde})`;
 }
 
+/** Caminho de rede ou endereço de site: a citação aparece, e o relatório diz que não foi testada. */
+function linhaDoNaoConferido(i, onde) {
+  return `- ⚠️ \`${i.ref}\` é um caminho de rede ou um endereço de site: não conferi se existe (a conferência não acessa a rede). (${onde})`;
+}
+
+// Os dois estados de alerta (não mudam o status); qualquer outro estado apontado é pendência.
+const LINHA_DO_ALERTA = { 'nao-portatil': linhaDoAlerta, 'nao-conferido': linhaDoNaoConferido };
+
 export function formatar(r) {
   const aviso = r.buscaParcial ? MSG.buscaParcial(r.limite) : '';
   const contar = (estado) => r.refs.filter((i) => i.estado === estado).length;
   const apontados = r.refs.filter((x) => x.estado !== 'ok');
   const linhas = [`## Conferência de fontes — ${r.crew}`, ''];
   for (const i of apontados) {
-    const onde = `citado em ${i.citadoEm.map((a) => barra(path.relative(r.raiz, a))).join(', ')}`;
-    linhas.push(i.estado === 'nao-portatil' ? linhaDoAlerta(i, onde) : linhaDaPendencia(i, onde, aviso));
+    const onde = `citado em ${i.citadoEm.map((a) => relativoAoProjeto(r.raiz, a)).join(', ')}`;
+    linhas.push((LINHA_DO_ALERTA[i.estado] ?? linhaDaPendencia)(i, onde, aviso));
   }
   if (apontados.length) linhas.push(''); // sem pendência nem alerta, uma linha em branco só
-  linhas.push(`**Resumo: ${r.refs.length} fontes — ${contar('ok')} ok, ${contar('faltando')} pendentes, ${contar('nao-portatil')} alertas**`, '');
+  const alertas = contar('nao-portatil') + contar('nao-conferido');
+  linhas.push(`**Resumo: ${r.refs.length} fontes — ${contar('ok')} ok, ${contar('faltando')} pendentes, ${alertas} alertas**`, '');
   return linhas.join('\n');
 }