@aksp/opencrew 1.6.3 → 1.7.0

package/templates/_opencrew/core/escritorio/sprites.js

@@ -0,0 +1,187 @@
+// Os desenhos do escritório são matrizes de pixels escritas como texto: uma string por linha, uma
+// letra por pixel e uma paleta (letra → cor). Nenhuma imagem entra no pacote.
+// Este módulo traz as cores fixas de toda a cena, o molde do boneco de 16×16 com as trocas de
+// linha de cada pose, e a conta que transforma uma matriz nos retângulos que a cena preenche.
+// Os irmãos `sprites-sala.js` e `sprites-mesa.js` trazem a sala e os móveis.
+// Spec: fase-e1-escritorio-ao-vivo.md, regra 16 (repositório do OpenCrew).
+
+/** As cores fixas da cena. A camisa, o cabelo e a pele de cada boneco vêm do modelo. */
+export const CORES = Object.freeze({
+  tinta: '#1a1c2c',
+  branco: '#f4f4ee',
+  cinzaClaro: '#c3c8d4',
+  cinzaEscuro: '#4a5266',
+  pisoClaro: '#9aa5b8',
+  pisoEscuro: '#8d98ad',
+  junta: '#808ba1',
+  parede: '#ead9b5',
+  paredeSombra: '#d6c196',
+  madeiraLuz: '#dba76a',
+  madeira: '#c58a52',
+  madeiraMedia: '#a0683f',
+  madeiraEscura: '#6f4630',
+  ceu: '#7ec4e0',
+  ceuClaro: '#bfe6f0',
+  folha: '#4c9a52',
+  folhaEscura: '#2f6b40',
+  telaApagada: '#232838',
+  telaAcesa: '#123f4a',
+  verde: '#5fd47a',
+  ambar: '#f4a73b',
+  vermelho: '#e0564c',
+});
+
+/**
+ * Uma matriz de pixels: `linhas` do mesmo tamanho e a `paleta` com a cor de cada letra. O ponto
+ * é sempre o pixel vazio.
+ */
+export function matriz(paleta, linhas) {
+  return Object.freeze({ paleta: Object.freeze({ '.': null, ...paleta }), linhas: Object.freeze(linhas) });
+}
+
+/**
+ * O molde do boneco: 16×16, de frente, parado. Na paleta, `cabelo`, `pele`, `camisa` e as duas
+ * sombras são fendas que `coresDoBoneco` troca pelas cores de cada agente.
+ */
+export const MOLDE = matriz({
+  o: CORES.tinta, h: 'cabelo', s: 'pele', S: 'pele-sombra', c: 'camisa', C: 'camisa-sombra',
+  p: CORES.cinzaEscuro, P: CORES.telaApagada, b: CORES.madeiraEscura, w: CORES.branco, g: CORES.cinzaClaro,
+}, [
+  '....oooooooo....',
+  '...ohhhhhhhho...',
+  '..ohhhhhhhhhho..',
+  '..ohhhhhhhhhho..',
+  '..ohhsssssshho..',
+  '..ohsssssssSho..',
+  '..ossossssosSo..',
+  '..osssssssssSo..',
+  '...oSSSSSSSSo...',
+  '..oCccccccccCo..',
+  '..oCccccccccCo..',
+  '..osccccccccso..',
+  '...oCCCCCCCCo...',
+  '....oppppppo....',
+  '....oppoopPo....',
+  '...obbboobbbo...',
+]);
+
+/**
+ * As poses são o molde com linhas trocadas: cada troca diz o número da linha e o texto novo.
+ * `digitar` e `andar` têm dois quadros; `mao` é o braço levantado de quem espera; `festa`, os
+ * dois braços para cima de quem comemora; `papel` é o braço com o papel, que se soma às pernas
+ * de quem anda.
+ */
+export const TROCAS = Object.freeze({
+  'digitar-a': { 11: '..oCccccccccso..', 12: '...ossCCCCCCo...' },
+  'digitar-b': { 11: '..osccccccccCo..', 12: '...oCCCCCCsso...' },
+  'andar-a': { 14: '....oppoobbo....', 15: '...obbbo.oo.....' },
+  'andar-b': { 14: '....obboopPo....', 15: '.....oo.obbbo...' },
+  mao: {
+    0: '....oooooooo.oo.',
+    1: '...ohhhhhhhhosso',
+    2: '..ohhhhhhhhhhoso',
+    3: '..ohhhhhhhhhhoso',
+    4: '..ohhsssssshhoCo',
+    5: '..ohsssssssShoCo',
+    6: '..ossossssosSoCo',
+    7: '..osssssssssSoCo',
+    8: '...oSSSSSSSSoCCo',
+    9: '..oCcccccccccCo.',
+    11: '..osccccccccCo..',
+  },
+  festa: {
+    0: '.oo.oooooooo.oo.',
+    1: 'ossohhhhhhhhosso',
+    2: 'osohhhhhhhhhhoso',
+    3: 'osohhhhhhhhhhoso',
+    4: 'oCohhsssssshhoCo',
+    5: 'oCohsssssssShoCo',
+    6: 'oCossossssosSoCo',
+    7: 'oCosssssssssSoCo',
+    8: 'oCCoSSSSSSSSoCCo',
+    9: '.oCccccccccccCo.',
+    11: '..oCccccccccCo..',
+  },
+  papel: {
+    8: '...oSSSSSSSSooo.',
+    9: '..oCccccccccCwwo',
+    10: '..oCccccccccCwgo',
+    11: '..osccccccccswwo',
+    12: '...oCCCCCCCCoooo',
+  },
+});
+
+const virar = (linha) => [...linha].reverse().join('');
+const POSTAS = new Map();
+
+/**
+ * As 16 linhas do boneco numa pose. A mesma pose devolve sempre a mesma lista.
+ * @param {string} pose uma das poses de `quadro` (`parado` é o molde)
+ * @param {{ papel?: boolean, festa?: boolean, espelhado?: boolean }} [o] `papel`: leva o papel ·
+ *   `festa`: os dois braços para cima, no lugar da pose · `espelhado`: virado para a esquerda
+ */
+export function linhasDoBoneco(pose, { papel = false, festa = false, espelhado = false } = {}) {
+  const chave = `${pose}|${papel}|${festa}|${espelhado}`;
+  if (!POSTAS.has(chave)) {
+    const trocas = { ...(festa ? TROCAS.festa : TROCAS[pose]), ...(papel ? TROCAS.papel : null) };
+    const linhas = MOLDE.linhas.map((linha, i) => trocas[i] ?? linha);
+    POSTAS.set(chave, espelhado ? linhas.map(virar) : linhas);
+  }
+  return POSTAS.get(chave);
+}
+
+/** A cor um quarto mais escura: a sombra que dá volume à pele e à camisa. */
+export function sombra(cor) {
+  const canal = (inicio) => Math.round(parseInt(cor.slice(inicio, inicio + 2), 16) * 0.75).toString(16).padStart(2, '0');
+  return `#${canal(1)}${canal(3)}${canal(5)}`;
+}
+
+const PALETAS = new Map();
+
+/** A paleta do molde com as cores de um agente (`{ camisa, cabelo, pele }`, em `#rrggbb`). */
+export function coresDoBoneco({ camisa, cabelo, pele }) {
+  const chave = `${camisa}|${cabelo}|${pele}`;
+  if (!PALETAS.has(chave)) {
+    const fendas = { cabelo, pele, 'pele-sombra': sombra(pele), camisa, 'camisa-sombra': sombra(camisa) };
+    PALETAS.set(chave, Object.fromEntries(Object.entries(MOLDE.paleta).map(([letra, cor]) => [letra, fendas[cor] ?? cor])));
+  }
+  return PALETAS.get(chave);
+}
+
+/** Os trechos de uma linha: `[x, largura, letra]` de cada sequência da mesma letra, sem os vazios. */
+function trechos(linha) {
+  return [...linha.matchAll(/([^.])\1*/g)].map((achado) => [achado.index, achado[0].length, achado[1]]);
+}
+
+const guardar = (lista, item) => {
+  lista.push(item);
+  return item;
+};
+
+/** Trechos iguais em linhas seguidas viram um retângulo só: a cena preenche menos vezes. */
+function juntar(linhas) {
+  const todos = [];
+  let acima = new Map();
+  linhas.forEach((linha, y) => {
+    const nesta = new Map();
+    for (const [x, largura, letra] of trechos(linha)) {
+      const chave = `${x}:${largura}:${letra}`;
+      const retangulo = acima.get(chave) ?? guardar(todos, [x, y, largura, 0, letra]);
+      retangulo[3] += 1;
+      nesta.set(chave, retangulo);
+    }
+    acima = nesta;
+  });
+  return todos;
+}
+
+const RETANGULOS = new WeakMap();
+
+/**
+ * Os retângulos que desenham uma matriz: `[x, y, largura, altura, letra]`, a partir do canto
+ * superior esquerdo dela. A conta é feita uma vez por lista de linhas.
+ */
+export function retangulos(linhas) {
+  if (!RETANGULOS.has(linhas)) RETANGULOS.set(linhas, juntar(linhas));
+  return RETANGULOS.get(linhas);
+}

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

@@ -131,9 +131,9 @@ Generate these files. Use the Write tool for all file creation — never use Bas
    - **`displayName` is REQUIRED and MUST be byte-for-byte identical to the agent's
      `name:` frontmatter field in its `.agent.md`** (the mandatory two-word "FirstName
      LastName" persona name). The Pipeline Runner reads `displayName` — NOT `title` — to
-     render the agent's name in `state.json`, in "🤖 {name} is working…" announcements, and
-     in the dashboard. If `displayName` is missing, empty, or set to the role/title instead
-     of the persona name, the crew renders with functions but no names.
+     render the agent's name in "🤖 {name} is working…" announcements, and the Escritório
+     (the optional live view) shows the same column. If `displayName` is missing, empty, or set
+     to the role/title instead of the persona name, the crew renders with functions but no names.
    - `id` = the `path` basename with `./agents/` and `.agent.md` stripped
      (e.g. `./agents/researcher.agent.md` → `researcher`).
    - `title` = the agent's `title:` frontmatter (the role/function label). This is a

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

@@ -1,8 +1,8 @@
 # Repair — Fix Crew Agent Names / Manifest
 
 You are the opencrew Repair agent. Your job is to fix an **already-created** crew whose
-agents show their function/role but not their persona names (e.g. the dashboard and the
-Pipeline Runner announce "Pesquisador" instead of "Pedro Pesquisa").
+agents show their function/role but not their persona names (e.g. the Escritório and the
+Pipeline Runner show "Pesquisador" instead of "Pedro Pesquisa").
 
 This is a known defect in crews built by older versions: the `crew-party.csv` manifest was
 generated without a `displayName` column (or with the role/title in it instead of the
@@ -13,10 +13,9 @@ re-run the Build phase.
 
 ## Scope
 
-You may ONLY touch files under `crews/{code}/`:
+You may ONLY touch these files under `crews/{code}/`:
 - `crews/{code}/crew-party.csv`
 - `crews/{code}/agents/*.agent.md` (only in the fallback case — see Step 4)
-- `crews/{code}/state.json` (only if it exists)
 
 Never modify `_opencrew/`, `templates/`, or any other crew. Use the Write tool for all file
 writes (never Bash `mkdir`).
@@ -77,13 +76,7 @@ existed and must be generated now, following the **Agent Naming Convention** fro
 Only do this for agents that are actually broken. Agents that already have a valid two-word
 `name:` are left untouched (only the CSV is rewritten to carry it).
 
-## Step 5: Refresh `state.json` (only if it exists)
-
-If `crews/{code}/state.json` exists, update each agent entry's `name` field to the repaired
-`displayName`. Do not change any other field. If the file does not exist, skip — the
-Pipeline Runner recreates it from the CSV on the next run.
-
-## Step 6: Report
+## Step 5: Report
 
 Present a summary table of what changed:
 
@@ -96,11 +89,13 @@ Crew "{name}" repaired.
 | copywriter  | Guilherme     | ✍️ Guilherme Gancho | generated   |
 
 crew-party.csv: rewritten with displayName column
-state.json: {updated | not present}
 
 Run it: /opencrew run {code}
 ```
 
+The Escritório (the optional live view) takes the names from the CSV when the next run starts:
+there is nothing else to refresh.
+
 If nothing was broken (CSV already had a valid `displayName` for every agent), say so
 plainly instead of inventing changes: "This crew's manifest is already correct — no repair
 needed."

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

@@ -33,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 →
@@ -244,41 +233,43 @@ Before starting execution:
      - 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}"`
    - 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
 
@@ -504,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
@@ -756,48 +724,18 @@ When a step has `on_reject: {step-id}` (a review step):
    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.
@@ -806,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)
 
@@ -947,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/escritorio/leitura.mjs

@@ -0,0 +1,31 @@
+// O que o `/estado` do escritório devolve: o estado de cada crew, lido do disco a cada pedido.
+// Só lê; quem grava `crews/<crew>/state.json` é o `estado.mjs`.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const MARCA_DE_ORDEM = 0xfeff; // alguns editores e terminais gravam essa marca no início do arquivo
+
+/** O estado de uma crew, ou null: arquivo ausente, pela metade, inválido ou sem `agents` em lista. */
+async function lerCrew(raiz, crew) {
+  try {
+    const texto = await fs.readFile(path.join(raiz, 'crews', crew, 'state.json'), 'utf8');
+    const estado = JSON.parse(texto.charCodeAt(0) === MARCA_DE_ORDEM ? texto.slice(1) : texto);
+    return Array.isArray(estado?.agents) ? { crew, estado } : null;
+  } catch {
+    return null;
+  }
+}
+
+/** `updatedAt` em milissegundos; ausente ou ilegível vale 0 (a crew vai para o fim). */
+const atualizadaEm = ({ estado }) => Date.parse(estado.updatedAt) || 0;
+
+/**
+ * As crews de `crews/` que têm estado legível, a de `updatedAt` mais recente primeiro. Os nomes
+ * vêm da pasta, nunca do pedido. Sem a pasta `crews/`, ou sem nenhum estado: lista vazia.
+ * @returns {Promise<Array<{ crew: string, estado: object }>>}
+ */
+export async function lerCrews(raiz) {
+  const nomes = await fs.readdir(path.join(raiz, 'crews')).catch(() => []);
+  const lidas = await Promise.all(nomes.sort().map((nome) => lerCrew(raiz, nome)));
+  return lidas.filter(Boolean).sort((a, b) => atualizadaEm(b) - atualizadaEm(a));
+}

package/templates/_opencrew/core/scripts/escritorio/porta.mjs

@@ -0,0 +1,98 @@
+// A porta do escritório: abrir, perguntar quem está numa porta ocupada e procurar a que serve.
+// Spec: fase-e1-escritorio-ao-vivo.md, regra 15 (repositório do OpenCrew).
+import http from 'node:http';
+import net from 'node:net';
+
+const LOCAL = '127.0.0.1';
+const ULTIMA_PORTA = 65535;
+// Quem responde na porta pode ser qualquer serviço: a resposta não é guardada sem limite.
+const TETO_DA_SONDA = 1_000_000;
+
+/**
+ * Alguém aceita conexão em 127.0.0.1:porta? No Windows, o `listen` em 127.0.0.1 abre por cima de
+ * quem escuta a mesma porta em 0.0.0.0 ou `::` e toma o tráfego local dele: só a conexão mostra
+ * que a porta tem dono. Porta livre recusa na hora; sem resposta dentro da espera, conta como livre.
+ */
+function alguemEscuta(porta, esperaMs = 1000) {
+  return new Promise((resolve) => {
+    const conexao = net.connect({ host: LOCAL, port: porta });
+    const fim = (escuta) => { conexao.destroy(); resolve(escuta); };
+    conexao.setTimeout(esperaMs, () => fim(false));
+    conexao.once('connect', () => fim(true)).once('error', () => fim(false));
+  });
+}
+
+/**
+ * Abre o servidor na porta, preso em 127.0.0.1.
+ * @returns {Promise<boolean>} true se subiu; false se a porta não pôde ser aberta (ocupada, por
+ *   quem quer que seja e em qualquer endereço, ou reservada pelo sistema). O mesmo servidor pode
+ *   tentar outra porta em seguida.
+ */
+export async function abrir(servidor, porta) {
+  if (porta !== 0 && await alguemEscuta(porta)) return false;
+  return new Promise((resolve) => {
+    const subiu = () => { servidor.off('error', falhou); resolve(true); };
+    const falhou = () => { servidor.off('listening', subiu); resolve(false); };
+    servidor.once('listening', subiu).once('error', falhou).listen(porta, LOCAL);
+  });
+}
+
+/** O `projeto` de uma resposta do `/estado`, ou null quando a resposta não é a de um escritório. */
+function projetoDaResposta(corpo) {
+  try {
+    const { projeto } = JSON.parse(corpo) ?? {};
+    return typeof projeto === 'string' ? projeto : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Junta o corpo da resposta e o entrega inteiro; cortada no meio ou acima do teto, entrega null. */
+function juntar(res, entregar) {
+  let corpo = '';
+  res.setEncoding('utf8');
+  res.on('data', (parte) => {
+    corpo += parte;
+    if (corpo.length > TETO_DA_SONDA) entregar(null);
+  });
+  res.on('end', () => entregar(corpo));
+  res.on('error', () => entregar(null));
+}
+
+/**
+ * Pergunta quem está na porta: `GET /estado`, com espera de até 1 s.
+ * @returns {Promise<string|null>} o `projeto` do escritório que respondeu; null para qualquer
+ *   outra resposta (outro serviço, erro, resposta grande demais) ou nenhuma dentro da espera
+ */
+export function sondar(porta, esperaMs = 1000) {
+  return new Promise((resolve) => {
+    const pedido = http.get({ host: LOCAL, port: porta, path: '/estado', agent: false }, (res) => juntar(res, fim));
+    const relogio = setTimeout(() => fim(null), esperaMs);
+    pedido.on('error', () => fim(null));
+    function fim(corpo) {
+      clearTimeout(relogio);
+      pedido.destroy();
+      resolve(corpo === null ? null : projetoDaResposta(corpo));
+    }
+  });
+}
+
+/**
+ * Procura a porta do escritório, de `inicial` em diante, em até `tentativas` portas. Porta que
+ * não abre é sondada: se quem responde é o escritório deste projeto, não sobe outro.
+ * @param {object} o
+ * @param {number} o.inicial primeira porta
+ * @param {string} o.projeto id deste projeto
+ * @param {(porta: number) => Promise<boolean>} o.abrir tenta abrir o servidor na porta
+ * @param {(porta: number) => Promise<string|null>} o.sondar o `projeto` de quem está na porta
+ * @returns {Promise<{ tipo: 'aberto'|'ja-aberto'|'sem-porta', porta?: number, ultima: number }>}
+ *   `ultima` é a última porta do intervalo (a que entra na mensagem "sem porta")
+ */
+export async function procurar({ inicial, projeto, abrir: tentar, sondar: perguntar, tentativas = 10 }) {
+  const ultima = Math.min(inicial + tentativas - 1, ULTIMA_PORTA);
+  for (let porta = inicial; porta <= ultima; porta++) {
+    if (await tentar(porta)) return { tipo: 'aberto', porta, ultima };
+    if ((await perguntar(porta)) === projeto) return { tipo: 'ja-aberto', porta, ultima };
+  }
+  return { tipo: 'sem-porta', ultima };
+}

package/templates/_opencrew/core/scripts/escritorio/projeto.mjs

@@ -0,0 +1,29 @@
+// Identidade do projeto para o escritório: diz se o servidor que responde numa porta é o deste
+// projeto, sem expor o caminho da pasta.
+import { createHash } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * 12 caracteres hexadecimais do SHA-256 do caminho real da raiz. No Windows o caminho vai para
+ * minúsculas antes: lá `D:\Projeto` e `d:\projeto` são a mesma pasta. Função pura.
+ */
+export function idDoProjeto(caminhoReal, plataforma = process.platform) {
+  const texto = plataforma === 'win32' ? caminhoReal.toLowerCase() : caminhoReal;
+  return createHash('sha256').update(texto).digest('hex').slice(0, 12);
+}
+
+/**
+ * Caminho real: o mesmo projeto aberto por um link de pasta dá o mesmo resultado. Onde o sistema
+ * não resolve (alguns discos virtuais), vale o caminho absoluto.
+ */
+function caminhoReal(raiz) {
+  try {
+    return realpathSync.native(raiz);
+  } catch {
+    return path.resolve(raiz);
+  }
+}
+
+/** O id do projeto que mora em `raiz`. */
+export const projetoDe = (raiz) => idDoProjeto(caminhoReal(raiz));