@polymorphism-tech/morph-spec 8.47.0 → 9.1.0

package/framework/evals/review-checklist.md

@@ -1,59 +1,78 @@
-# Checklist do avaliador — Gate 3
+# Checklist do Gate 3 — verificador, revisor, segurança
 
-Você não dá nota. Você responde: **esta entrega faz o que os use cases dizem, sem quebrar o que já
-funcionava?** E prova cada "não" com evidência.
-
-## Saída (`4-review/evaluator-report.md`)
+Três agentes em contexto fresco, cada um com o seu relatório em `4-review/`. Ninguém dá nota. Cada
+relatório começa igual e é append-only (vale o último `**Verdict:**`):
 
 ```markdown
 **Verdict:** SHIP            ← ou FIX
+**Reviewed-SHA:** <sha do dispatch>
 
 ## Bloqueadores
 
-| # | Tipo | Onde | Evidência |
-|---|------|------|-----------|
-| B1 | uc | src/Orders/Create.cs:42 | UC-03 P2: pedido sem itens é aceito — `POST /orders {items:[]}` → 201 |
+| id | tipo | onde | evidência |
+|----|------|------|-----------|
+| B1 | check | src/Orders/Create.cs:42 | C3: pedido sem itens é aceito — `POST /orders {items:[]}` → 201 |
 
 ## Notas
 
 - (o que melhoraria, sem bloquear)
-
-## Navegado
-
-- (fluxos exercitados na app, quando o stack estava no ar; o que viu no console/network)
 ```
 
 Sem bloqueador, escreva `Nenhum.` na seção. `SHIP` com bloqueador aberto é contradição e pausa o gate.
+Confirmação depois de uma correção: seção nova ao fim com `**Verdict:**` e o `**Reviewed-SHA:**` novo —
+julgando só os seus bloqueadores, ou, sem eles, só o delta `{sha anterior}..{sha novo}`. Bloqueador
+que a correção fechou sai de `## Bloqueadores` (escreva `Nenhum.`) e o fechamento vai em `## Notas`;
+a `## Checklist de tela` que vale é a da última seção, então repita-a inteira.
+Parcial (limite de turnos): `PARCIAL` na 1ª linha, o feito e o que falta, SEM `**Verdict:**`.
+
+**O que bloqueia — só com evidência de um destes tipos.** Todo o resto (estilo, nome, "eu faria
+diferente") é nota; nota não bloqueia e não pede rodada nova. Na dúvida, sem evidência tipada, é nota.
+
+| Tipo | Quem | Quando | Evidência mínima |
+|------|------|--------|------------------|
+| `check` | verificador | cenário `Cn` NÃO PROVADO ou FALHA | o que falta provar, ou o repro que falha |
+| `teste` | verificador | teste vermelho; teste que não morde a regra que diz proteger | saída do verify, mutante sobrevivente, assert que passa pelo motivo errado |
+| `regressao` | revisor | comportamento que funcionava e quebrou | consumidor afetado + o caminho que quebra |
+| `escopo` | revisor | o diff faz o que nenhuma fatia pediu, ou deixa de fazer o que o contrato pede | arquivo/trecho fora das fatias, ou o item do contrato ausente |
+| `arquitetura` | revisor | padrão ou abstração nova contra o stack e os standards | o trecho e o standard que ele contraria |
+| `performance` | revisor | custo que o volume real torna visível | a consulta/lista e o volume que a derruba |
+| `seguranca` | segurança | authz, segredo, injeção, PII, custo sem teto, migration destrutiva | o caminho de exploração |
+
+## Verificador (`4-review/verifier.md`)
+
+Missão: **provar cada cenário** do `2-plan/checks.json`. O default de todo `Cn` é NÃO PROVADO;
+critério que você não verificou nunca vira PROVADO por inferência.
 
-## O que bloqueia — só com evidência de um destes tipos
-
-| Tipo | Quando | Evidência mínima |
-|------|--------|------------------|
-| `uc` | pós-condição de UC ou `doneCriteria` não atendida | repro (comando, request, teste) ou o trecho que prova |
-| `teste` | teste vermelho; teste novo que não morde a regra que diz proteger | saída do verify, mutante sobrevivente, ou o assert que passa pelo motivo errado |
-| `regressao` | comportamento que funcionava e quebrou | teste ou repro contra o comportamento anterior |
-| `seguranca` | segredo exposto, authz faltando, injeção, dado pessoal vazando, custo sem teto | o caminho de exploração |
+```markdown
+## Checks
 
-Todo o resto — estilo, nome, estrutura, "eu faria diferente" — é **nota**. Nota não bloqueia e não
-pede rodada nova. Na dúvida entre bloqueador e nota, sem evidência tipada, é nota.
+| Cn | status | evidência |
+|----|--------|-----------|
+| C1 | PROVADO | `src/Orders/Create.cs:42` + `OrdersTests.RecusaSemItens` (morde: M1 morto) |
+| C2 | NÃO PROVADO | nenhum teste exercita o caminho de escrita |
+```
 
-## O que procurar, em ordem de dano
+Uma linha por cenário, status exato `PROVADO`, `NÃO PROVADO` ou `FALHA`. O gate pausa com cenário
+sem linha ou não PROVADO. Numa confirmação, uma `## Checks` nova só com os Cn que mudaram: vale a
+última linha de cada Cn. Para cada `Cn`, em ordem de dano:
 
-1. **Cada pós-condição de UC / `doneCriteria`**: onde no código ela vale, e qual teste a prova.
+1. **Onde vale**: `arquivo:linha` do código que entrega o cenário.
 2. **Fiação**: existe caminho da entrada real ao efeito observável? A camada pura testada não prova
    que o handler a chama. Inventarie quem consome o eixo novo.
-3. **Teste que não morde**: nasceu verde e afirma o que já era verdade antes da mudança; só testa
-   recusa e nunca o caminho de escrita; guard cujos dois lados passam pelo mesmo serializador;
-   asserção sobre texto que mede vocabulário, não sentido.
+3. **O teste morde?** Nasceu verde e afirma o que já era verdade; só testa a recusa e nunca o caminho
+   de escrita; guard cujos dois lados passam pelo mesmo serializador; asserção sobre texto que mede
+   vocabulário, não sentido.
 4. **Verificações mecânicas** (.NET minimal API / Next): todo serviço injetado numa lambda de endpoint
    tem registro em `Program.cs` (senão a app não sobe); prefixo de rota server-direct e de proxy são
    constantes distintas, cada uma usada só do seu lado.
-5. **Correção de rodada anterior**: o que ela abriu? Releia o comportamento vizinho.
-6. **Fora do diff**: o blast radius que o orquestrador anexou (`graph affected`).
+5. **Runtime**: com o stack no ar (URL no dispatch), navegue o fluxo do cenário e confira console e
+   network. Stack fora do ar é achado de infra, não defeito seu a provar.
 
-## Prova por mutação — opcional, no máximo 3
+A suíte inteira é do orquestrador. Você roda no máximo um filtro de testes de um cenário, em primeiro
+plano, por `morph-spec heavy run -- <comando>`.
 
-Só quando o diff tem uma linha de guarda ou regra que um UC exige e você não achou o teste que a
+**Prova por mutação — opcional, no máximo 3, só depois que revisor e segurança terminaram.** Só
+quando o diff tem uma linha de guarda ou regra que um cenário exige e você não achou o teste que a
 morde. Escreva `4-review/mutants.json` e rode `morph-spec mutate {feature}` **uma vez**:
 
 ```json
@@ -63,20 +82,15 @@ morde. Escreva `4-review/mutants.json` e rode `morph-spec mutate {feature}` **um
 
 `expect` é obrigatório: diga qual teste deve falhar e por quê **antes** de rodar — mutante cujo
 efeito você não sabe prever tende a ser equivalente. Barra invertida do código vira `{{BS}}`.
-Sobreviveu numa linha que um UC exige → bloqueador `teste`. Sobreviveu em outra → nota. Cole a seção
-`## Mutações` que a ferramenta imprime. A reversão é da ferramenta; rodada morta no meio:
+Sobreviveu numa linha que um cenário exige → bloqueador `teste`. Sobreviveu em outra → nota. Cole a
+seção `## Mutações` que a ferramenta imprime. A reversão é da ferramenta; rodada morta no meio:
 `morph-spec mutate --restore`.
 
-## Condicionais
-
-**Feature que gera mídia** (alguma task cita em `standards[]` `standards/ai-agents/modalities-image-gen.md`,
+**Feature que gera mídia** (alguma fatia cita em `standards:` `standards/ai-agents/modalities-image-gen.md`,
 `media-video.md` ou `media-pipeline.md`): grave `## Mídia gerada`, uma linha por afirmação — custo
 controlado, revisão humana, mídia marcada, hot path não bloqueado —, cada uma com o código que a prende
 e o teste que a prova. Afirmação falsa é bloqueador. Sem a seção, o gate pausa.
 
-**Feature que chama LLM**: dá para reconstruir o que foi ao provedor e o que ele respondeu neste turno?
-Não → nota, ou bloqueador quando um UC exige rastreabilidade.
-
 **Prompt ou modelo alterado**: o nó `evals` do verify é a prova; sem ele, o gate pausa sozinho.
 
 **Contrato de tela** (`1-design/mockups.md` com `## Tela:`): grave `## Checklist de tela`, uma linha por
@@ -86,5 +100,32 @@ item decidido de cada tela:
 
 Veredito `cumpre` / `diverge` / `não verificável` (com o motivo). Paginação, ordenação ou filtro que o
 checklist põe no servidor e a tela faz em memória, ou estado vazio/carregando/erro decidido e
-ausente, é bloqueador `uc`. Divergência registrada em `decisions.md` é nota. Sem a seção, havendo
-item decidido, o gate pausa.
+ausente, é bloqueador `check`. Divergência registrada em `plan.md ## Decisões` é nota. Sem a seção,
+havendo item decidido, o gate pausa.
+
+## Revisor (`4-review/reviewer.md`)
+
+Read-only, sobre o commit do dispatch: `git diff {base}..{sha}`, `git show {sha}:<caminho>`. Nunca a
+árvore de trabalho — o verificador pode estar com um mutante aplicado nela. Default SHIP.
+
+1. **Escopo**: o diff contra as fatias (`arquivos:`) e o `## Contrato de implementação` do plano.
+2. **Arquitetura**: padrão ou abstração nova contra o stack do projeto e os standards (camada que o
+   projeto não usa, repositório sobre o DbContext, dependência nova sem decisão no plano).
+3. **Regressão**: para cada símbolo público alterado, `morph-spec graph affected <símbolo> --prod --json`.
+   Sem grafo (`no-graph`, `not-found`, `ambiguous`), caia para `git grep -n <símbolo> {sha}` e siga — a
+   ausência de grafo nunca bloqueia, e ausência de consumidor nunca sai do grafo.
+4. **O que a correção abriu**: revisando a correção de uma rodada anterior, releia o comportamento
+   vizinho ao que ela mudou.
+5. **Performance só com evidência**: lista sem paginação no servidor sobre volume real, N+1 visível.
+6. **Chamada a LLM**: dá para reconstruir o que foi ao provedor e o que ele respondeu neste turno?
+   Não → nota.
+
+## Segurança (`4-review/security.md`)
+
+Despachada só quando o diff toca auth, segredo, permissão, dado pessoal, pagamento ou migration.
+Mesmo contrato de leitura do revisor (só o SHA). Procure: authz faltando ou checada do lado errado;
+segredo no código, no log ou no cliente; injeção (SQL, comando, prompt); dado pessoal vazando para log,
+resposta ou provedor; custo sem teto (chamada paga em laço, sem limite por usuário); mídia publicada
+sem revisão humana; migration destrutiva (DROP/rename de coluna com dado, branch Neon de produção).
+Bloqueador `seguranca` exige o caminho de exploração — quem, por qual entrada, chega a quê. Sem
+caminho, é nota.

package/framework/hooks/README.md

@@ -12,7 +12,8 @@ framework/hooks/
 │   │   ├── worktree-create.js       # WorktreeCreate: governed tree via `morph-spec worktree setup|provision`
 │   │   ├── worktree-remove.js       # WorktreeRemove: safe teardown via `worktree remove --if-clean`
 │   │   ├── block-destructive-worktree-removal.js  # PreToolUse(Bash): raw removal follows junctions out
-│   │   └── block-raw-worktree-add.js              # PreToolUse(Bash): raw `git worktree add` is ungoverned
+│   │   ├── block-raw-worktree-add.js              # PreToolUse(Bash): raw `git worktree add` is ungoverned
+│   │   └── warn-bash-source-write.js              # PreToolUse(Bash): source written by redirect skips the Write/Edit guards
 │   ├── user-prompt/
 │   │   └── enrich-prompt.js         # Context-aware prompt enrichment
 │   ├── pre-tool-use/
@@ -32,8 +33,7 @@ framework/hooks/
 ├── git/                             # Git hooks (Bash)
 │   ├── pre-commit/
 │   │   ├── orchestrator.sh          # Master hook dispatcher
-│   │   ├── agents.sh                # Validates agents.json schema
-│   │   └── specs.sh                 # Validates spec.md sections
+│   │   └── agents.sh                # Validates agents.json schema
 │   ├── commit-msg/
 │   │   └── conventional-commits.sh  # Enforces conventional commits
 │   └── pre-push/
@@ -45,18 +45,17 @@ framework/hooks/
 
 | Event | Hook | Type | Purpose |
 |-------|------|------|---------|
-| **SessionStart** | worktree-context.js | Context inject | Secondary worktree → feature identity (name/branch/phase) + missing-junction warning; primary root → active-feature summary (phase, task stats, pending gates), silent if none. Also seeds a worktree that has no codebase graph from the root's, and launches the background refresh of the ROOT's graph (`shared/graph-refresh.js`) |
+| **SessionStart** | worktree-context.js | Context inject | Secondary worktree → feature identity (name/branch/phase) + missing-junction warning; primary root → active-feature summary (phase, slices done/total, pending gates), silent if none. Also seeds a worktree that has no codebase graph from the root's, and launches the background refresh of the ROOT's graph (`shared/graph-refresh.js`) |
 | **PreToolUse** (Write\|Edit) | _(native permissions.deny)_ | Block | Blocks edits to state.json and .morph/framework/ |
-| **PreToolUse** (Write\|Edit) | protect-spec-files.js | Block | Blocks edits to spec files after approval; for tasks.json validates the mutable-field diff, the status enum, and requires a `notes` when `outputs` diverge from the plan |
+| **PreToolUse** (Write\|Edit) | protect-spec-files.js | Block | Blocks edits to `plan.md` (and the uiux artifacts) after their gate is approved; an append-only `## Errata` block at the end of `plan.md` passes |
 | **PreToolUse** (Write\|Edit) | enforce-phase-writes.js | Block | Ensures writes go to current phase directory |
 | **PreToolUse** (Bash) | pre-bash-denylist.js | Block | Blocks `rm -rf .morph/` and direct state edits |
 | **PreToolUse** (Bash) | block-destructive-worktree-removal.js | Block | Blocks `git worktree remove` / `rm -rf` / `Remove-Item -Recurse` on a directory holding reparse points (the infra junctions a raw removal would FOLLOW out, emptying the root's `.claude/`); names `morph-spec worktree remove` |
 | **PreToolUse** (Bash) | block-raw-worktree-add.js | Block | Blocks raw `git worktree add` (a tree with no junctions → no hooks, no port block, no identity, outside `worktrees/`); names `morph-spec worktree setup <feature>` / `worktree provision <name> --base <ref>`. `list`/`prune`/`remove`/`lock`/`move`/`repair` pass |
+| **PreToolUse** (Bash) | warn-bash-source-write.js | Warn | Heredoc/redirect/`tee` into project source (`isProjectSource`): context naming the file, the command still runs — Write/Edit is what phase, protected-file and comment guards see |
 | **WorktreeCreate** | worktree-create.js | Replaces native | Fires for `claude -w`, EnterWorktree and `Agent isolation:"worktree"`; replaces Claude Code's bare `git worktree add`. Runs `morph-spec worktree setup <n>` (known feature) or `worktree provision <n>` (task tree, branch `morph-task/<n>`), bases a task tree on the dispatcher's `morph/<f>` branch when `worktree.baseRef` is unset (`"head"` = current HEAD, `"fresh"` = default branch), prints the path as its last stdout line. CLI unreachable → plain git, still under `<root>/worktrees/` |
 | **WorktreeRemove** | worktree-remove.js | Fail-open | Routes Claude Code's own cleanup through `morph-spec worktree remove --target --if-clean` (junctions dropped first; a dirty tree is left alone). Always exit 0. Secondary net — the event was observed NOT to fire headless; the Bash guard above stays the primary defense |
-| **PostToolUse** (Write\|Edit) | tasks-json-guard.js | Advisory | Validates the written tasks.json schema (status/effort enums); warns so the LLM fixes it immediately |
-| **PostToolUse** (Write\|Edit) | trace-autogen.js | State sync | Auto-generates `.morph/traces/YYYY-MM-DD-{feature}-implement.json` from tasks.json + recap.md on every tasks.json write — the skills never write traces by hand |
-| **PostToolUse** (Write\|Edit) | comment-guard.js | Blocking | Blocks when the edit ADDED a comment the `architecture-code-comments` standard never allows: process history (UC/ADR/task/gate), banner/`#region`, a block over 3 lines, or a doc-comment outside a published package. Old comments are never reported; last link of the chain |
+| **PostToolUse** (Write\|Edit) | comment-guard.js | Blocking | Blocks when the edit ADDED a comment the `architecture-code-comments` standard never allows: process history (ADR, scenario/slice id, gate, plan.md), banner/`#region`, a block over 3 lines, or a doc-comment outside a published package. Old comments are never reported; last link of the chain |
 | **PostToolUse** (Write\|Edit\|AskUserQuestion) | state-sync.js | State sync | Autonomous state updates (feature register, output tracking, gate approval) |
 | **PostToolUse** (Write\|Edit\|AskUserQuestion) | gate-guard.js | Advisory | Warns (never blocks) when a gate action disagrees with the persisted gateDecisions; logs one `coherent`/`divergent` line per check in `.morph/logs/activity.jsonl` (issue #63) |
 | **PostToolUse** (all tools) | telemetry-log.js | Telemetry | Appends every tool call (skill, sub-agent dispatch + prompt, knowledge-base read, bash/edit) to `.morph/logs/events.jsonl`; silent, fail-open — the NLH execution-path capture read back by `morph-spec telemetry` |
@@ -66,7 +65,7 @@ framework/hooks/
 | **PostToolBatch** | telemetry-log.js | Telemetry | One `ToolBatch` event per model turn that used tools (the turn counter of `cost --metrics`) |
 | **SubagentStop** | telemetry-log.js | Telemetry | `AgentUsage`: the sub-agent's token usage read from its own transcript, as a delta per agent; never blocks the stop |
 | **UserPromptSubmit** | telemetry-log.js | Telemetry | Appends the user's prompt to the same `events.jsonl` stream; silent, fail-open |
-| **Stop** | validate-completion.js | Advisory | Warns about incomplete tasks/missing outputs/recap drift (hash-deduped, only re-injects when the warning set changes) |
+| **Stop** | validate-completion.js | Advisory | Warns about incomplete slice reports (hash-deduped, only re-injects when the warning set changes) |
 
 ## Design Principles
 
@@ -150,8 +149,8 @@ Claude Code sends JSON to stdin: { tool_input: { file_path: "..." } }
     ↓
 protect-spec-files.js
     ├── Is in .morph/features/{feature}/?
-    │   ├── Is spec.md and design gate approved? → BLOCK
-    │   ├── Is tasks.json and tasks gate approved? → BLOCK
+    │   ├── Is plan.md and plan gate approved? → BLOCK (unless append-only ## Errata)
+    │   ├── Is a 1-design/ artifact and uiux gate approved? → BLOCK
     │   └── Gate not approved → pass
     └── Not a feature file → pass
     ↓

package/framework/hooks/claude-code/core/block-destructive-worktree-removal.js

@@ -6,70 +6,31 @@ import { stateExists } from '../../shared/state-reader.js';
 import { scanForBlockers } from '../../shared/reparse-scan.js';
 import { tokenize } from '../../shared/command-tokens.js';
 
-/**
- * block-destructive-worktree-removal — the only defense that does not depend on
- * someone reading documentation.
- *
- * A morph worktree carries JUNCTIONS to the primary root's shared infra
- * (`node_modules`, `.claude`, `.morph/framework`). Every generic recursive
- * removal — `git worktree remove` (plain AND `--force`), `rm -rf`,
- * `Remove-Item -Recurse`, `rmdir /s` — FOLLOWS those links out of the worktree
- * and deletes what they point at, leaving the primary root's `.claude/` and
- * `.morph/framework/` as empty directories. That is the incident this hook
- * exists for, and it is not hypothetical: it happened, and the command was
- * copied from a message the CLI itself printed.
- *
- * `morph-spec worktree remove` is safe because it drops the junctions BEFORE
- * letting git near the directory. This hook is what stops the unsafe path from
- * being reachable by accident.
- *
- * DELIBERATELY NARROW — an inert or over-eager guardrail is worse than none:
- *   - only recursive-removal shapes, only when a target path can be extracted;
- *   - only when that path exists AND the scan finds reparse points under it
- *     (an already-unlinked worktree, or one that never had junctions, passes);
- *   - anything unparseable passes.
- * The scan is the authority, not the path shape: a worktree kept outside
- * `worktrees/` is protected just the same, and a `worktrees/` directory with
- * nothing to traverse is not blocked for looking dangerous.
- */
+// Generic recursive removals FOLLOW a worktree's junctions and empty the root's `.claude/` and `.morph/framework/`.
+// The reparse scan is the authority, not the path shape; anything unparseable passes.
 
-// The tokenizer lives in shared/command-tokens.js — block-raw-worktree-add.js
-// reads `git worktree add` off the same tokens, and a hook must never import a
-// sibling hook (its standalone tail would fire in the importer's process).
+// A hook never imports a sibling hook (its standalone tail would fire), so the tokenizer lives in shared/.
 export { tokenize };
 
-/**
- * The path a recursive-removal command would destroy, or null when this is not
- * such a command (or the target cannot be read off it).
- *
- * @param {string} command
- * @returns {string|null}
- */
 export function extractRemovalTarget(command) {
   const tokens = tokenize(command);
   if (!tokens.length) return null;
   const lower = tokens.map((t) => t.toLowerCase());
 
-  // `git worktree remove [--force] <path>` — the path is always the last
-  // non-flag token; git has no form of this command without one.
+  // The path is always the last non-flag token.
   const gi = lower.indexOf('git');
   if (gi !== -1 && lower[gi + 1] === 'worktree' && lower[gi + 2] === 'remove') {
     const rest = tokens.slice(gi + 3).filter((t) => !t.startsWith('-'));
     return rest.length ? rest[rest.length - 1] : null;
   }
 
-  // Generic recursive deletes. Each needs BOTH its command word and a recursive
-  // flag — a plain `rm file` or `Remove-Item file` cannot traverse a junction's
-  // contents and is none of this hook's business.
+  // Needs both the command word and a recursive flag: a plain `rm file` cannot traverse a junction.
   const recursive = tokens.some((t) => /^(-[a-z]*r[a-z]*|--recursive|\/s)$/i.test(t));
   const removalCmd = lower.find((t) => /^(rm|remove-item|ri|rd|rmdir|del)$/.test(t));
   if (!removalCmd || !recursive) return null;
 
   const idx = lower.indexOf(removalCmd);
-  // A cmd.exe switch is a slash plus a letter or two (`rmdir /s /q`). Anything
-  // longer that starts with `/` is a POSIX ABSOLUTE PATH — filtering on the
-  // bare `/` made every Linux target look like a flag, so `rm -rf /tmp/wt`
-  // extracted nothing and the hook passed exactly where it had to block.
+  // A cmd.exe switch is a slash plus one or two letters; anything longer is a POSIX absolute path.
   const isCmdSwitch = (t) => /^\/[a-z]{1,2}$/i.test(t);
   const operands = tokens.slice(idx + 1).filter((t) => !t.startsWith('-') && !isCmdSwitch(t));
   // Named-parameter form: `Remove-Item -Path <p> -Recurse`.
@@ -78,10 +39,6 @@ export function extractRemovalTarget(command) {
   return operands.length ? operands[0] : null;
 }
 
-/**
- * @param {object} payload - parsed PreToolUse stdin payload (Bash matcher)
- * @returns {Promise<object|null>} `{decision:'block',reason}` or null (pass).
- */
 export async function run(payload) {
   try {
     if (!stateExists()) return null;

package/framework/hooks/claude-code/core/block-raw-worktree-add.js

@@ -5,56 +5,23 @@ import { stateExists } from '../../shared/state-reader.js';
 // standalone tail (stdin read + exit) inside THIS process.
 import { tokenize } from '../../shared/command-tokens.js';
 
-/**
- * block-raw-worktree-add — PreToolUse (Bash) guard against `git worktree add`.
- *
- * A worktree created by raw git is a worktree morph cannot see: no infra
- * junctions (`.claude`, `node_modules`, `.morph/framework` — so NO hooks run
- * in there), no port block (its dev server collides with the root's), no
- * feature/task identity (invisible to `fleet`, `doctor --worktrees`,
- * `worktree list`), and a location git chose, not `<root>/worktrees/`. The
- * sibling guard (block-destructive-worktree-removal) protects the way OUT;
- * this one protects the way IN, by naming the two commands that build a
- * governed tree:
- *
- *   morph-spec worktree setup <feature>                — a feature's tree
- *   morph-spec worktree provision <name> [--base <ref>] — a task-isolation tree
- *
- * DELIBERATELY NARROW: only the `add` subcommand. `list`, `prune`, `remove`
- * (the sibling's business), `lock`, `unlock`, `move`, `repair` all pass. The
- * `git` token may be followed by global options (`-C <dir>`, `--git-dir=<d>`,
- * `-c k=v`) before `worktree`, and may sit anywhere in a chained command
- * (`cd a && git worktree add b`) — every `git` occurrence is checked.
- */
-
-/** Global `git` options that take a separate value: `git -C <dir> worktree add`. */
 const GIT_GLOBAL_WITH_VALUE = new Set(['-c', '-C', '--git-dir', '--work-tree', '--namespace', '--exec-path', '--config-env']);
 
-/**
- * Does this command line invoke `git worktree add` anywhere?
- * @param {string} command
- * @returns {boolean}
- */
 export function isRawWorktreeAdd(command) {
   const tokens = tokenize(command);
   const lower = tokens.map((t) => t.toLowerCase());
   for (let i = 0; i < lower.length; i++) {
     if (lower[i] !== 'git' && !/(^|[\\/])git(\.exe)?$/.test(lower[i])) continue;
     let j = i + 1;
-    // Skip global options between `git` and the subcommand.
     while (j < lower.length && lower[j].startsWith('-')) {
-      if (GIT_GLOBAL_WITH_VALUE.has(tokens[j])) j += 2; // `-C dir` consumes its value
-      else j += 1;                                       // `--git-dir=x`, `--no-pager`, …
+      if (GIT_GLOBAL_WITH_VALUE.has(tokens[j])) j += 2;
+      else j += 1;
     }
     if (lower[j] === 'worktree' && lower[j + 1] === 'add') return true;
   }
   return false;
 }
 
-/**
- * @param {object} payload - parsed PreToolUse stdin payload (Bash matcher)
- * @returns {Promise<object|null>} `{decision:'block',reason}` or null (pass).
- */
 export async function run(payload) {
   try {
     if (!stateExists()) return null;

package/framework/hooks/claude-code/core/chain.js

@@ -1,54 +1,6 @@
 #!/usr/bin/env node
-/**
- * chain.js — roda vários hooks core num único processo node.
- *
- * Motivação (onda de performance R2): cada hook registrado no Claude Code é
- * hoje um processo node próprio (~60ms de cold start). Um único Write/Edit
- * disparava até 9 desses processos — 2 PreToolUse + 3+2+2 PostToolUse. Este
- * script agrupa os elos de um mesmo event+matcher (a mesma entrada do
- * registry em src/utils/hooks-installer.js) num só spawn: lê stdin UMA vez,
- * importa e chama `run(payload)` de cada hook em sequência, e combina as
- * respostas — reduzindo esses 9 spawns para 4 por Write/Edit (1 PreToolUse +
- * 3 PostToolUse: Write|Edit / Write|Edit|AskUserQuestion / matcher-`*`).
- *
- * Uso: `node chain.js <hook1> <hook2> ...` — nomes de arquivo SEM `.js`,
- * resolvidos no mesmo diretório deste script (core/), na ORDEM em que devem
- * rodar. A ordem é a mesma que o registry antigo (duas entries separadas)
- * já implicava — ver o comentário de cada grupo em hooks-installer.js.
- *
- * Cada hook core exporta `run(payload)` (ver framework/hooks/shared/hook-response.js
- * `runStandalone`) — o arquivo continua executável standalone (spawnSync
- * direto, como os testes já fazem) porque a própria cauda do arquivo só lê
- * stdin/imprime/sai quando NÃO está sendo importado por esta cadeia.
- *
- * Regras de combinação:
- *  - PreToolUse (decision:'block'): o PRIMEIRO elo que retornar um bloqueio
- *    VENCE e encerra a cadeia — os elos seguintes nem chegam a rodar. Isto é
- *    uma otimização NOVA desta consolidação (antes, Claude Code podia
- *    disparar os dois processos de qualquer forma); o resultado observável
- *    pro Claude Code é idêntico (o tool call é bloqueado do mesmo jeito).
- *  - PostToolUse / outros eventos de contexto: os textos de TODOS os elos que
- *    retornarem `hookSpecificOutput.additionalContext` (ou `decision:'approve'`
- *    com additionalContext) são concatenados, na ORDEM dos argv, separados por
- *    uma linha em branco — nenhum elo é pulado por um vizinho ter respondido.
- *  - Nome do evento (hookSpecificOutput.hookEventName) no resultado final:
- *    o valor que o PRIMEIRO elo a declarar um venceu (mesma regra de
- *    "primeiro vence" do bloqueio acima — na prática todos os elos de um
- *    mesmo grupo observam o MESMO evento real do Claude Code, então isto só
- *    importa como desempate determinístico); na ausência de qualquer elo
- *    declarando, cai para `payload.hook_event_name`; por último, `'PostToolUse'`.
- *  - updatedInput (PreToolUse): um elo pode devolver
- *    `hookSpecificOutput.updatedInput` (ver `updatedInputResult` em
- *    hook-response.js) para reescrever o tool_input. O ÚLTIMO elo a devolver um
- *    vence (só um elo do grupo reescreve, por construção). `permissionDecision:
- *    'allow'` + `updatedInput` só entram no resultado final quando algum elo
- *    reescreveu — um `allow` incondicional pularia o prompt de permissão de
- *    TODO Bash, que é exatamente o contrário de um guardrail.
- *  - Fail-open POR ELO: uma exceção não tratada por um hook individual (import
- *    falhou, run() não existe, etc.) não derruba a cadeia — os elos seguintes
- *    ainda rodam. Cada hook já fail-opens sozinho dentro do seu próprio
- *    try/catch; isto é a segunda rede de segurança, para o import em si.
- */
+// Usage: node chain.js <hook> ... (names without .js, run in argv order). The first block wins and ends the chain,
+// the contexts of every link concatenate, and an exception in one link never stops the next.
 
 import { dirname, join } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -56,20 +8,12 @@ import { readStdin } from '../../shared/stdin-reader.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Marca "já estou dentro de uma cadeia" para os hooks importados abaixo: a
-// cauda de execução standalone de cada hook (runStandalone() em
-// hook-response.js) só dispara quando esta flag NÃO está setada. Setada
-// ANTES do primeiro import dinâmico — cada hook importado herda o mesmo
-// process.env deste processo.
+// Set before the first import: each hook's standalone tail runs only when this is unset.
 process.env.MORPH_HOOK_CHAINED = '1';
 
-// Override só para testes da mecânica genérica desta cadeia (fixtures fora
-// de core/, sem precisar ser hooks reais nem satisfazer as convenções que
-// hook-wiring.test.js exige de todo arquivo em core/). Produção nunca seta
-// isto — resolve sempre no próprio diretório deste script.
+// Test-only override; production always resolves next to this script.
 const coreDir = process.env.MORPH_HOOK_CORE_DIR || __dirname;
 
-/** Extrai o texto de contexto de um resultado de hook, se houver. */
 function contextOf(result) {
   if (!result) return null;
   if (result.decision === 'approve' && typeof result.additionalContext === 'string') {
@@ -93,13 +37,11 @@ async function main() {
       const mod = await import(pathToFileURL(join(coreDir, `${name}.js`)).href);
       result = await mod.run(payload);
     } catch {
-      // Fail-open POR ELO — ver doc do módulo acima.
       result = null;
     }
 
     if (!result) continue;
 
-    // PreToolUse: o primeiro bloqueio vence e encerra a cadeia.
     if (result.decision === 'block') {
       // A later link blocking must not swallow what earlier links reported (a tsc error on the same edit).
       if (contexts.length) result = { ...result, reason: [...contexts, result.reason].join('\n\n') };
@@ -116,9 +58,6 @@ async function main() {
     const ctx = contextOf(result);
     if (ctx) {
       contexts.push(ctx);
-      // First link to declare a name wins (mirrors block-first-wins above) —
-      // in practice every link in a group observes the SAME real Claude Code
-      // event, so this only matters as a deterministic tie-break.
       eventName = eventName || result?.hookSpecificOutput?.hookEventName;
     }
   }

package/framework/hooks/claude-code/core/comment-guard.js

@@ -1,17 +1,7 @@
 #!/usr/bin/env node
 
-/**
- * PostToolUse Hook: comments the edit added in a shape the
- * `architecture-code-comments` standard never allows.
- *
- * Event: PostToolUse | Matcher: Write|Edit
- *
- * `decision: block` makes the agent fix it in the same turn; the edit itself
- * already landed. Only comments absent from `tool_response.originalFile`
- * count, so editing a legacy file never reports its old comments.
- *
- * Fail-open: any error passes silently.
- */
+// `decision: block` makes the agent fix it in the same turn (the edit already landed). Only comments absent from
+// `tool_response.originalFile` count, so editing a legacy file never reports its old comments.
 
 import { readFileSync } from 'fs';
 import { isAbsolute, relative, resolve } from 'path';
@@ -23,7 +13,7 @@ import { isGenerated, isProjectSource } from '../../shared/source-files.js';
 const MAX_LISTED = 10;
 
 const RULE_LABEL = {
-  process: 'história de processo (UC/ADR/task/gate)',
+  process: 'história de processo (ADR, cenário, fatia, gate, plan.md)',
   banner: 'banner ou #region',
   'doc-comment': '///·JSDoc em código que não é pacote publicado',
   'long-block': `bloco com mais de ${MAX_BLOCK_LINES} linhas`,
@@ -78,10 +68,6 @@ function describe(file, findings) {
   ].join('\n');
 }
 
-/**
- * @param {object} payload - PostToolUse stdin payload
- * @returns {Promise<object|null>}
- */
 export async function run(payload) {
   try {
     if (!['Write', 'Edit'].includes(payload?.tool_name)) return null;

package/framework/hooks/claude-code/core/denylist.json

@@ -1,8 +1,6 @@
 {
-  "version": "1.0.0",
+  "version": "1.2.0",
   "patterns": [
-    "rm -rf /",
-    "rm -rf ~",
     "DROP TABLE",
     "DROP DATABASE",
     "format c:",
@@ -10,5 +8,37 @@
     "> /dev/sda",
     "dd if=/dev/zero",
     ":(){:|:&};:"
+  ],
+  "executableArgs": [
+    {
+      "executable": "taskkill",
+      "args": [
+        "/im",
+        "-im"
+      ],
+      "reason": "mata por nome de imagem e derruba os MCPs de todas as sessões; encerre pelo PID que você subiu (`/PID <n>`)"
+    },
+    {
+      "executable": "rm",
+      "flags": [
+        [
+          "-r",
+          "-R",
+          "--recursive"
+        ],
+        [
+          "-f",
+          "--force"
+        ]
+      ],
+      "args": [
+        "/",
+        "/*",
+        "~",
+        "~/",
+        "~/*"
+      ],
+      "reason": "apaga a raiz ou o home inteiro; remova o caminho específico"
+    }
   ]
 }