@polymorphism-tech/morph-spec 8.46.0 → 9.0.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/comment-guard.js

@@ -23,7 +23,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`,

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"
+    }
   ]
 }

package/framework/hooks/claude-code/core/enforce-phase-writes.js

@@ -6,9 +6,9 @@
  * Event: PreToolUse | Matcher: Write|Edit
  *
  * Ensures writes to .morph/features/{feature}/ go to the current phase's subfolder:
- *   proposal → only 0-proposal/
+ *   plan → only 2-plan/ (and 2-plan/ is writable in every phase: the errata
+ *          and plan-check live there)
  *   uiux → only 1-design/
- *   plan → only 2-plan/
  *   implement → 3-implement/ + any source code (unrestricted)
  *   review → only 4-review/
  *
@@ -30,15 +30,16 @@ import {
  * The gate that authorizes writing a phase folder's FIRST artifact. Once that
  * gate is approved, the next phase's canonical file may be created even though
  * the phase only advances (via derivation) once that file exists — this is the
- * fix for the forward-transition chicken-and-egg. proposal-approval unlocks both
- * the optional `1-design/` and `2-plan/` (the uiux fork).
+ * fix for the forward-transition chicken-and-egg. The plan gate unlocks both
+ * the optional `1-design/` and `3-implement/` (the uiux fork).
  */
 const PHASE_DIR_ENTRY_GATE = {
-  '1-design': 'proposal',
-  '2-plan': 'proposal',
+  '1-design': 'plan',
   '3-implement': 'plan',
   '4-review': 'plan',
 };
+
+const ALWAYS_WRITABLE_DIR = '2-plan';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
 import { logHookActivity } from '../../shared/activity-logger.js';
 import { getFilePath, resolveMorphRoot, resolveTargetPath } from '../../shared/payload-utils.js';
@@ -67,9 +68,8 @@ export async function run(payload) {
     // Resolve the tree that OWNS this file, NOT the tree the session sits in.
     // A session rooted in the primary repo may legitimately write to a feature
     // living in a secondary worktree; reading the session's `.morph/` there
-    // reported the ROOT's phase for the WORKTREE's file, and blocked a legal
-    // `2-plan/` write with "not allowed during PROPOSAL phase". `stateExists`
-    // must be asked of that same tree — a worktree carries its own state.
+    // reported the ROOT's phase for the WORKTREE's file and blocked a legal write.
+    // `stateExists` must be asked of that same tree — a worktree carries its own state.
     const root = resolveMorphRoot(filePath, process.cwd());
     if (!stateExists(root)) return null;
 
@@ -84,6 +84,7 @@ export async function run(payload) {
 
     const targetDir = extractPhaseDir(filePath);
     if (!targetDir) return null; // File directly in feature root — allow
+    if (targetDir === ALWAYS_WRITABLE_DIR) return null;
 
     const allowedDir = PHASE_DIRS[phase];
     if (!allowedDir) return null; // Unknown phase — allow
@@ -102,14 +103,9 @@ export async function run(payload) {
       // advances once that file exists) — the deadlock this hook used to create.
       const entryGate = PHASE_DIR_ENTRY_GATE[targetDir];
       if (entryGate && isGateApproved(featureName, entryGate, root)) {
-        // uiux is OPTIONAL — proposal approval alone is enough to enter
-        // 2-plan/ for a feature that never took the design branch (no
-        // 1-design/ dir), exactly as before this check. But once a feature
-        // HAS opted into uiux (1-design/ exists), that gate is not
-        // decorative: 2-plan/ must wait for it too, or a feature can skip
-        // straight from an approved proposal into planning with its design
-        // gate silently left pending.
-        const tookDesignBranch = targetDir === '2-plan'
+        // uiux is optional, but once 1-design/ exists its gate is not
+        // decorative: implementation waits for it too.
+        const tookDesignBranch = targetDir !== '1-design'
           && existsSync(resolveTargetPath(`.morph/features/${featureName}/1-design`, root));
 
         if (!tookDesignBranch || isGateApproved(featureName, 'uiux', root)) {
@@ -119,9 +115,9 @@ export async function run(payload) {
 
         logHookActivity('enforce-phase-writes', 'PreToolUse', 'blocked');
         return blockResult(
-          `MORPH-SPEC: Writing to '2-plan/' is not allowed yet.\n` +
+          `MORPH-SPEC: Writing to '${targetDir}/' is not allowed yet.\n` +
           `This feature entered the uiux branch (1-design/ exists) and the 'uiux' gate is still pending.\n\n` +
-          `Approve the design gate first, then re-enter plan:\n` +
+          `Approve the design gate first, then move on to implementation:\n` +
           `  morph-spec approve ${featureName} uiux\n` +
           `  morph-spec advance ${featureName}`
         );
@@ -129,7 +125,7 @@ export async function run(payload) {
 
       const phaseLabel = phase.toUpperCase();
       // Name the tree the verdict came from whenever it is NOT the session's own.
-      // The phase read is per-tree, so "which .morph/ said proposal?" is the first
+      // The phase read is per-tree, so "which .morph/ said plan?" is the first
       // question anyone debugging this asks.
       const treeNote = root !== process.cwd().replace(/\\/g, '/')
         ? `\n(phase read from the tree that owns the file: ${root})`

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

@@ -26,6 +26,7 @@
 
 import { loadState, stateExists, getActiveFeature } from '../../shared/state-reader.js';
 import { contextResult, runStandalone } from '../../shared/hook-response.js';
+import { gateFromQuestion } from '../../shared/gate-question.js';
 import { logHookActivity } from '../../shared/activity-logger.js';
 import { resolveMorphRoot, resolveTargetPath } from '../../shared/payload-utils.js';
 import { locateFeatureForQuestion } from '../../shared/feature-locator.js';
@@ -68,16 +69,6 @@ function askedTexts(input) {
   return texts;
 }
 
-/** Map a gate question's text to a gate id. Mirrors state-sync.js. */
-function gateFromQuestion(question) {
-  if (typeof question !== 'string') return null;
-  const lower = question.toLowerCase();
-  if (lower.includes('gate 1') || lower.includes('proposta')) return 'proposal';
-  if (lower.includes('gate 2') || lower.includes('plano') || lower.includes('plan')) return 'plan';
-  if (lower.includes('gate 3') || lower.includes('review')) return 'review';
-  return null;
-}
-
 function getDecision(state, feature, gate) {
   const d = state.features?.[feature]?.gateDecisions?.[gate];
   if (!d || typeof d.pause !== 'boolean') return null;
@@ -154,7 +145,7 @@ function checkStateEdit(input, sessionRoot) {
 
   let checked = false;
   const gates = state.features?.[feature]?.approvalGates ?? {};
-  for (const gate of ['proposal', 'plan', 'review']) {
+  for (const gate of ['plan', 'uiux', 'review']) {
     const g = gates[gate];
     const autoApproved = g?.approved === true && g?.approvedBy === 'auto';
     if (!autoApproved) continue;

package/framework/hooks/claude-code/core/pre-bash-denylist.js

@@ -4,8 +4,39 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
 import { stateExists } from '../../shared/state-reader.js';
+import { tokenize } from '../../shared/command-tokens.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const SEPARATOR = /^[;&|]+$/;
+const executableName = (token) => token.replace(/\\/g, '/').split('/').pop().toLowerCase().replace(/\.exe$/, '');
+
+const hasFlag = (token, flag) => (flag.startsWith('--') || token.startsWith('--')
+  ? token === flag
+  : /^-[A-Za-z]+$/.test(token) && token.includes(flag.slice(1)));
+
+/**
+ * A quoted argument is one token, never the executable: mentioning the command in a message is not calling it.
+ * `args` match a whole token; each group in `flags` (case-sensitive, clusters like `-rf` count) must appear in the same command.
+ */
+export function matchesExecutableRule(command, rule) {
+  const exe = rule.executable.toLowerCase();
+  const args = new Set(rule.args.map((a) => a.toLowerCase()));
+  const flagGroups = rule.flags || [];
+  const tokens = tokenize(command);
+  for (let i = 0; i < tokens.length; i++) {
+    if (executableName(tokens[i].replace(/^[;&|(]+/, '')) !== exe) continue;
+    const seen = [];
+    let argHit = false;
+    for (let j = i + 1; j < tokens.length && !SEPARATOR.test(tokens[j]); j++) {
+      const raw = tokens[j].replace(/[;&|)]+$/, '');
+      if (args.has(raw.toLowerCase())) argHit = true;
+      seen.push(raw);
+      if (tokens[j] !== raw) break;
+    }
+    if (argHit && flagGroups.every((group) => seen.some((t) => group.some((flag) => hasFlag(t, flag))))) return true;
+  }
+  return false;
+}
 
 /**
  * @param {object} payload - parsed PreToolUse stdin payload (Bash matcher)
@@ -26,6 +57,13 @@ export async function run(payload) {
       }
     }
 
+    for (const rule of denylist.executableArgs || []) {
+      if (matchesExecutableRule(command, rule)) {
+        const shown = [rule.executable, ...(rule.flags || []).map((group) => group[0]), rule.args[0]].join(' ');
+        return blockResult(`Comando bloqueado pela denylist: \`${shown}\` ${rule.reason}.`);
+      }
+    }
+
     return null;
   } catch {
     return null;