@polymorphism-tech/morph-spec 9.5.0 → 9.6.0

package/README.md

@@ -3,7 +3,7 @@
 > Spec-driven development framework for multi-stack projects. Turns feature requests into implementation-ready code through structured, AI-orchestrated phases.
 
 **Package:** `@polymorphism-tech/morph-spec`
-**Version:** 9.5.0  
+**Version:** 9.6.0  
 **Requires:** Node.js 22+, Claude Code
 
 ---
@@ -380,4 +380,4 @@ Code generated by morph-spec (contracts, templates, implementation output) belon
 
 ---
 
-*morph-spec v9.5.0 by [Polymorphism Tech](https://polymorphism.tech)*
+*morph-spec v9.6.0 by [Polymorphism Tech](https://polymorphism.tech)*

package/bin/morph-spec.js

@@ -520,6 +520,7 @@ program
   .description('Print the worktree\'s dedicated environment (port block + COMPOSE_PROJECT_NAME), shell-loadable: eval "$(morph-spec env)" outside Claude Code; feature defaults to the morph/{f} or morph-task/{n} branch of cwd')
   .option('--json', 'Output as JSON')
   .option('--powershell', 'Emit $env:K="V" lines instead of POSIX exports')
+  .option('--with-secrets', 'Also emit the e2e.auth.envFile credentials (omitted by default: stdout lands in transcripts); use inside eval "$(…)"')
   .action((feature, options) => envCommand(feature, options));
 
 program

package/claude-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "morph-spec",
-  "version": "9.5.0",
+  "version": "9.6.0",
   "displayName": "MORPH-SPEC Framework",
   "description": "Spec-driven development with 38 agents and 8-phase workflow for .NET/Blazor/Next.js/Azure",
   "publisher": "polymorphism-tech",

package/docs/CHEATSHEET.md

@@ -185,4 +185,4 @@ Never edited directly — go through CLI commands or `morph-spec update` instead
 
 ---
 
-*morph-spec v9.5.0 by Polymorphism Tech*
+*morph-spec v9.6.0 by Polymorphism Tech*

package/docs/QUICKSTART.md

@@ -249,4 +249,4 @@ morph-spec doctor
 
 ---
 
-*morph-spec v9.5.0 by Polymorphism Tech*
+*morph-spec v9.6.0 by Polymorphism Tech*

package/framework/docs/CLI.md

@@ -10,7 +10,7 @@
 
 **`morph-spec approve <feature> <gate> --mode auto`** — aprova um gate (`plan`/`uiux`/`review`) em `trust: auto`.
 
-**O Gate 3 exige os relatórios de review**: `4-review/verifier.md` e `reviewer.md`, mais `security.md` quando o diff toca caminho sensível (`securityReviewFor`) — ausente, PARCIAL ou sem `**Verdict:**`, o comando recusa (exit 1) nomeando o arquivo. A assinatura humana (`--approver`) aprova mesmo com `FIX` ou cenário não provado; a `auto` recalcula a pausa do `gate-check`, cobertura dos `Cn` incluída. `**Reviewed-SHA:**` é lido de todo relatório presente e o pior vence: o código andou depois dele → recusa; sem carimbo → aviso. Se o dispatch for impossível nesta sessão, aprove com `--self-assessed` — a degradação é gravada em `approvalGates.review.selfAssessed` e aparece marcada no `morph-spec list`. `--force` **não** dispensa esta regra (é só para ordem de gate).
+**O Gate 3 exige os relatórios de review**: `4-review/verifier.md` e `reviewer.md`, mais `security.md` quando o diff toca caminho sensível fora de teste (`securityReviewFor`; spec, `e2e/` e `test-results/` não contam) — ausente, PARCIAL ou sem `**Verdict:**`, o comando recusa (exit 1) nomeando o arquivo. A assinatura humana (`--approver`) aprova mesmo com `FIX` ou cenário não provado; a `auto` recalcula a pausa do `gate-check`, cobertura dos `Cn` incluída. `**Reviewed-SHA:**` é lido de todo relatório presente e o pior vence: o código andou depois dele → recusa; sem carimbo → aviso. Se o dispatch for impossível nesta sessão, aprove com `--self-assessed` — a degradação é gravada em `approvalGates.review.selfAssessed` e aparece marcada no `morph-spec list`. `--force` **não** dispensa esta regra (é só para ordem de gate).
 
 **O plano semeia `bin/`/`obj/`** (`plan-check` que grava o `checks.json`, `approve <f> plan`, `advance` saindo do plano e `advance --design` com o plano já aprovado — o `plan-check` cobre também o gate gravado pelo hook state-sync): num projeto .NET — `project.stack` com `dotnet`, fatia de `dotnet-senior`/`ef-modeler`/`maf-expert` no `checks.json` ou `.csproj`/`.sln`/`.slnx` na árvore (fora de `worktrees/`, `node_modules/`, `bin/`, `obj/`) — as duas linhas entram no `.gitignore` da árvore dona antes do primeiro código, e a saída as nomeia para irem no mesmo commit. O `create` aplica a mesma regra (`src/lib/stack/dotnet-build-ignores.js`); no greenfield só a fatia do plano existe para decidir.
 
@@ -124,7 +124,7 @@ Feature sem `workType` (pré-v8) é tratada como `feature`.
 
 **Índice de ADRs:** no mesmo commit do archive, o `finish` lê o `2-plan/plan.md` da feature: os ADRs de `## Decisões` com `**Alcance:** projeto` entram em `.morph/specs/adrs/` (um arquivo por ADR, `{feature}--ADR-{nnn}.md` — features paralelas nunca tocam o mesmo arquivo), e a tabela `ADR | Mudança | Escopo` de `### Conflitos com o acervo` retira (total, o arquivo sai) ou estreita (parcial, `scope:` no arquivo) os ADRs revogados — forma em `morph-spec plan-check --help`; o `plan-check` avisa, enquanto o plano ainda muda, a linha que o `finish` não aplicaria. O payload traz `adrIndex: {added, revoked, narrowed}` e `revocationProblems: [{id, reason, message}]` (linha malformada ou ambígua, ADR fora do índice) — cada chave só aparece com conteúdo, e nenhum problema recusa o `finish`.
 
-`--merge` faz merge `--no-ff` **local** na default (sem push); `--pr` faz `push` + `gh pr create` (exige `origin` + `gh`, checados **antes** de arquivar — um `--pr` recusado não deixa meio-estado). Desmonta o worktree (PROVE-or-DECLINE) e libera o bloco de portas; no `--pr` **preserva** a branch (o PR precisa dela) e fica em `morph/{f}`.
+`--merge` faz merge `--no-ff` **local** na default (sem push); `--pr` faz `push` + `gh pr create` (exige `origin` + `gh`, checados **antes** de arquivar — um `--pr` recusado não deixa meio-estado). Saída de teste não rastreada (`test-results/`, `TestResults/`, `playwright-report/`, `blob-report/`) não conta como árvore suja: na raiz só é tolerada, na worktree sai junto com o desmonte; qualquer outro arquivo não commitado recusa. Desmonta o worktree (PROVE-or-DECLINE) e libera o bloco de portas; no `--pr` **preserva** a branch (o PR precisa dela) e fica em `morph/{f}`.
 
 **Sessão ancorada no worktree → o desmonte é ADIADO** (`--merge` e `--pr`): quando a sessão do Claude Code que rodou o `finish` tem o próprio worktree como projeto (`CLAUDE_PROJECT_DIR` — exportado ao CLI como `MORPH_SESSION_PROJECT_DIR` pelo hook `worktree-env-inject`, porque o Bash tool não o exporta e `cd <raiz> && morph-spec finish` apaga o cwd), a integração acontece normalmente, mas o worktree fica: saída com `worktreeRemoved: false`, `teardownDeferred: "session-anchored"`, `worktree: {path, branch}` e um `hint` com `morph-spec worktree remove <f>` para rodar depois, de uma sessão aberta na raiz. O `--dry-run` já avisa (`teardownDeferred` no pré-voo).
 
@@ -158,7 +158,7 @@ O `.morph/state.json` do worktree é índice derivável: ele se refaz sozinho a
 
 ### env
 
-**`morph-spec env [feature] [--json|--powershell]`** — imprime o bloco do worktree em forma shell-loadable (`eval "$(morph-spec env)"`; PowerShell: `morph-spec env --powershell | Invoke-Expression`). Feature vem do argumento ou da branch `morph/{f}`/`morph-task/{n}` do cwd. Deriva de `buildComposeEnv`, a mesma função do nó e2e — um shell e o stack nunca discordam. É o caminho para quem roda **fora** do Claude Code (terminal humano, CI, sub-agent sem hooks). As credenciais do arquivo apontado por `e2e.auth.envFile` entram no ambiente, mas **chave de layout de portas vinda de lá é ignorada** — o bloco alocado a esta worktree prevalece (um `.env.e2e` copiado de outra árvore carrega o bloco DELA). A chave ignorada é nomeada em **stderr**, nunca em stdout, para o `eval` do shell seguir limpo.
+**`morph-spec env [feature] [--json|--powershell] [--with-secrets]`** — imprime o bloco do worktree em forma shell-loadable (`eval "$(morph-spec env)"`; PowerShell: `morph-spec env --powershell | Invoke-Expression`). Feature vem do argumento ou da branch `morph/{f}`/`morph-task/{n}` do cwd. Deriva de `buildComposeEnv`, a mesma função do nó e2e — um shell e o stack nunca discordam. É o caminho para quem roda **fora** do Claude Code (terminal humano, CI, sub-agent sem hooks). As credenciais do arquivo apontado por `e2e.auth.envFile` **só saem com `--with-secrets`** (o stdout vai parar no transcript; use a flag dentro de `eval "$(…)"`), e sem ela os nomes omitidos vão para stderr. Uma chave `*_PORT` desse arquivo que não bate com nenhuma porta do bloco é avisada em stderr com a sugestão de declará-la em `e2e.portEnvNames`. E **chave de layout de portas vinda de lá é ignorada** — o bloco alocado a esta worktree prevalece (um `.env.e2e` copiado de outra árvore carrega o bloco DELA). A chave ignorada é nomeada em **stderr**, nunca em stdout, para o `eval` do shell seguir limpo.
 
 ### worktree remove
 
@@ -382,13 +382,17 @@ Isolamento entre worktrees: `COMPOSE_PROJECT_NAME=morph-{feature}` separa os con
 
 `heavy status` é **somente leitura**: quem segura cada slot (pid, label, feature, nó, idade), a limpeza exclusiva do build-server se houver e a RAM livre.
 
-**Espera:** slot cheio, ou RAM livre (`os.freemem()`) abaixo de `heavy.minFreeMemGb` (4), espera até `heavy.waitTimeoutSec` (600) avisando em **stderr** a cada 30 s e nomeando quem segura (o `--json` mantém o stdout limpo).
+**Espera:** slot cheio, ou RAM livre (`os.freemem()`) abaixo do piso do tipo do comando, espera até `heavy.waitTimeoutSec` (600) avisando em **stderr** a cada 30 s e nomeando quem segura (o `--json` mantém o stdout limpo).
+
+**Piso de RAM por tipo** (`heavy.minFreeMemGbByKind`, padrão `unit` 1,5 · `build` 4 · `e2e` 4 GB): `unit` = vitest/jest, `npm|pnpm|yarn test`, `npm run test[:x]` e o nó `tests` do verify; `e2e` = playwright, `docker compose up`, script com `e2e` no nome, o nó `e2e` e o `e2e up`; `build` = o resto (`dotnet build|test|publish` — o `dotnet test` compila —, `next build`, `docker build`, `mutate` e comando desconhecido). O `heavy run` e o hook do `gateBash` classificam pelo comando; o `verify` toma o slot com o piso do primeiro nó e, antes de um nó mais pesado (tests → e2e), espera de novo só pela RAM segurando o slot — estourar ali também é exit 3, sem stamp. `heavy.minFreeMemGb` (4) virou o fallback: **definido explicitamente**, vale para todo tipo que `minFreeMemGbByKind` não lista (`0` continua desligando a checagem em tudo); sem ele, cada tipo usa o seu padrão.
+
+**Ocupado por RAM** (`verify`, `e2e up`, `heavy run`): a mensagem nomeia o piso e a chave (`heavy.minFreeMemGbByKind.<tipo>`) e lista as stacks e2e de pé deste repo (`docker compose ls`, prefixo `morph-`, compose sob a raiz principal — de todas as worktrees). Feature já arquivada (`.morph/archive/<f>` sem `.morph/features/<f>`) vem com `morph-spec e2e down <f>`; stack sem feature, com `docker compose -p <nome> down`. Docker fora ou lento (10 s) = lista vazia, nunca erro.
 
 **Estouro = exit 3 (`busy`), nunca vermelho:** `verify --json` sai `{ status: "busy", persisted: false, busy: { reason, holders, freeGb, waitedMs } }`, **sem stamp e sem evento `Verify`** (nada foi verificado, e fila não é gate verde nem vermelho); `e2e up` e `heavy run` também saem 3. Quem orquestra repete a chamada — nas skills, exit 3 não conta como tentativa e não dispara o loop de correção.
 
 **Slot vago:** pid morto, ou idade acima de `heavy.maxHoldMinutes` (90, contra reuso de PID); Ctrl-C deixa o arquivo, que o pid morto cobre. Um filho herda o slot por `MORPH_HEAVY_LEASE` e nunca pede um segundo.
 
-**Config** (`.morph/config/config.json`, bloco `heavy`, schema em `config.schema.json`): `enabled`, `slots`, `minFreeMemGb`, `waitTimeoutSec`, `maxHoldMinutes`, `shutdownBuildServer`, `disableNodeReuse`, `gateBash`; valor ilegível cai no default **com aviso** — o bloco nunca bloqueia trabalho por estar errado.
+**Config** (`.morph/config/config.json`, bloco `heavy`, schema em `config.schema.json`): `enabled`, `slots`, `minFreeMemGb`, `minFreeMemGbByKind`, `waitTimeoutSec`, `maxHoldMinutes`, `shutdownBuildServer`, `disableNodeReuse`, `gateBash`; valor ilegível cai no default **com aviso** — o bloco nunca bloqueia trabalho por estar errado.
 
 Env: `MORPH_HEAVY=off` desliga o semáforo (a suíte do próprio framework roda assim, para não enfileirar nos slots reais de quem a executa), `MORPH_HEAVY_SLOTS`, `MORPH_HEAVY_DIR`.
 

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

@@ -5,7 +5,7 @@
 
 import { stateExists } from '../../shared/state-reader.js';
 import { blockResult, runStandalone } from '../../shared/hook-response.js';
-import { heavyKind, leaseTtlMs } from '../../shared/heavy-command.js';
+import { heavyClass, heavyKind, leaseTtlMs } from '../../shared/heavy-command.js';
 
 const HOOK_BUDGET_SEC = 540;
 
@@ -18,7 +18,7 @@ export async function run(payload, deps = {}) {
     if (!kind || !payload?.tool_use_id) return null;
 
     // Loaded only here: this link runs on every Bash call and almost none is heavy.
-    const { readHeavyConfig } = await import('../../shared/heavy-config.js');
+    const { minFreeMemFor, readHeavyConfig } = await import('../../shared/heavy-config.js');
     const { acquireHeavy, describeBusy, heavyDir } = await import('../../shared/heavy-slots.js');
     const env = deps.env ?? process.env;
     const dir = env.CLAUDE_PROJECT_DIR || payload?.cwd || process.cwd();
@@ -26,6 +26,7 @@ export async function run(payload, deps = {}) {
     const config = readHeavyConfig(dir, env);
     if (!config.enabled || !config.gateBash) return null;
 
+    const memClass = heavyClass(kind);
     const result = (deps.acquire ?? acquireHeavy)({
       dir: heavyDir(env),
       slots: config.slots,
@@ -33,7 +34,8 @@ export async function run(payload, deps = {}) {
       feature: null,
       node: null,
       cwd: dir,
-      minFreeMemGb: config.minFreeMemGb,
+      kind: memClass,
+      minFreeMemGb: minFreeMemFor(config, memClass),
       waitTimeoutMs: Math.min(config.waitTimeoutSec, HOOK_BUDGET_SEC) * 1000,
       maxHoldMs: config.maxHoldMinutes * 60_000,
       lease: { id: payload.tool_use_id, ttlMs: leaseTtlMs(input, env) },

package/framework/hooks/shared/feature-locator.js

@@ -4,6 +4,7 @@
 
 import { execSync } from 'child_process';
 import { loadState } from './state-reader.js';
+import { morphBranchFeature } from './git-paths.js';
 
 // `loadState`, not a directory listing: it also sees features only the index carries.
 export function featureNamesIn(root) {
@@ -55,26 +56,27 @@ export function unrecognizedSlugLike(text, names) {
   return tokens.find((t) => !known.has(t)) ?? null;
 }
 
-// The session root wins a feature present in both trees: it is where
-// `morph-spec approve` would write from that cwd.
+// The tree on `morph/<f>` owns the feature and wins: the primary root only carries its index
+// entry, and `morph-spec approve` refuses any other tree. Without an owner, the session root wins.
 export function locateFeatureForQuestion(text, sessionRoot) {
   const trees = allWorkTrees(sessionRoot);
   const localNames = featureNamesIn(sessionRoot);
+  const ownerOr = (name, root) => trees.find((t) => morphBranchFeature(t) === name) ?? root;
 
   const local = featureNamedIn(text, localNames);
-  if (local) return { name: local, root: sessionRoot };
+  if (local) return { name: local, root: ownerOr(local, sessionRoot) };
 
   for (const root of trees) {
     if (root === sessionRoot) continue;
     const found = featureNamedIn(text, featureNamesIn(root));
-    if (found) return { name: found, root };
+    if (found) return { name: found, root: ownerOr(found, root) };
   }
 
   const allNames = trees.flatMap(featureNamesIn);
   if (unrecognizedSlugLike(text, allNames)) return null;
 
   // With exactly ONE feature in the tree there is nothing else the answer could be about.
-  if (localNames.length === 1) return { name: localNames[0], root: sessionRoot };
+  if (localNames.length === 1) return { name: localNames[0], root: ownerOr(localNames[0], sessionRoot) };
 
   return null;
 }

package/framework/hooks/shared/heavy-command.js

@@ -106,6 +106,18 @@ export function heavyKind(command) {
   return null;
 }
 
+const E2E_CLASS = /\be2e\b|playwright|compose up/;
+const UNIT_CLASS = /^(tests|(npx )?(vitest|jest)|(npm|pnpm|yarn|bun) (test|run test(:\S+)?))$/;
+
+// Maps a `heavyKind` label or a verify node to the RAM class it pays. `dotnet test` and anything
+// unknown stay `build`: they compile before running, and the fallback must never lower a floor.
+export function heavyClass(label) {
+  const s = String(label ?? '').toLowerCase().trim();
+  if (E2E_CLASS.test(s)) return 'e2e';
+  if (UNIT_CLASS.test(s)) return 'unit';
+  return 'build';
+}
+
 // The lease has no live process to watch: this TTL is the only thing that frees it after a
 // denied or interrupted call.
 const BASH_DEFAULT_TIMEOUT_MS = 2 * 60_000;

package/framework/hooks/shared/heavy-config.js

@@ -7,6 +7,7 @@ export const HEAVY_DEFAULTS = Object.freeze({
   enabled: true,
   slots: 2,
   minFreeMemGb: 4,
+  minFreeMemGbByKind: Object.freeze({ unit: 1.5, build: 4, e2e: 4 }),
   waitTimeoutSec: 600,
   maxHoldMinutes: 90,
   shutdownBuildServer: true,
@@ -14,11 +15,16 @@ export const HEAVY_DEFAULTS = Object.freeze({
   gateBash: false,
 });
 
+export const HEAVY_KINDS = Object.freeze(['unit', 'build', 'e2e']);
+
 const isBool = (v) => typeof v === 'boolean';
+const isGb = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const VALID = {
   enabled: isBool,
   slots: (v) => Number.isInteger(v) && v >= 1,
-  minFreeMemGb: (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0,
+  minFreeMemGb: isGb,
+  minFreeMemGbByKind: isPlainObject,
   waitTimeoutSec: (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0,
   maxHoldMinutes: (v) => typeof v === 'number' && Number.isFinite(v) && v > 0,
   shutdownBuildServer: isBool,
@@ -40,6 +46,7 @@ export function resolveHeavyConfig(config, env = process.env) {
   const out = { ...HEAVY_DEFAULTS };
   const warnings = [];
   const raw = config?.heavy;
+  let byKind = {};
 
   if (raw !== undefined) {
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
@@ -47,12 +54,15 @@ export function resolveHeavyConfig(config, env = process.env) {
     } else {
       for (const [key, value] of Object.entries(raw)) {
         if (!(key in VALID)) warnings.push(`heavy.${key} não existe; ignorada`);
+        else if (key === 'minFreeMemGbByKind' && VALID[key](value)) byKind = value;
         else if (VALID[key](value)) out[key] = value;
         else warnings.push(`heavy.${key} inválida (${JSON.stringify(value)}); usando ${JSON.stringify(HEAVY_DEFAULTS[key])}`);
       }
     }
   }
 
+  out.minFreeMemGbByKind = resolveByKind(byKind, isGb(raw?.minFreeMemGb) ? raw.minFreeMemGb : null, warnings);
+
   if (/^(off|0|false)$/i.test(env.MORPH_HEAVY ?? '')) out.enabled = false;
   const envSlots = Number(env.MORPH_HEAVY_SLOTS);
   if (env.MORPH_HEAVY_SLOTS !== undefined && VALID.slots(envSlots)) out.slots = envSlots;
@@ -60,6 +70,23 @@ export function resolveHeavyConfig(config, env = process.env) {
   return { ...out, warnings };
 }
 
+// An explicit `minFreeMemGb` without a per-kind entry still governs that kind:
+// a project that set 0 (RAM check off) or a stricter floor keeps it after the split.
+function resolveByKind(byKind, explicitFloor, warnings) {
+  const out = {};
+  for (const kind of HEAVY_KINDS) out[kind] = explicitFloor ?? HEAVY_DEFAULTS.minFreeMemGbByKind[kind];
+  for (const [kind, value] of Object.entries(byKind)) {
+    if (!HEAVY_KINDS.includes(kind)) warnings.push(`heavy.minFreeMemGbByKind.${kind} não existe; use ${HEAVY_KINDS.join(', ')}`);
+    else if (isGb(value)) out[kind] = value;
+    else warnings.push(`heavy.minFreeMemGbByKind.${kind} inválida (${JSON.stringify(value)}); usando ${out[kind]}`);
+  }
+  return out;
+}
+
+export function minFreeMemFor(config, kind) {
+  return config.minFreeMemGbByKind?.[kind] ?? config.minFreeMemGb;
+}
+
 export function readHeavyConfig(projectPath, env = process.env) {
   return resolveHeavyConfig(readProjectConfig(projectPath), env);
 }

package/framework/hooks/shared/heavy-slots.js

@@ -49,6 +49,8 @@ function liveHoldersPruningStale(dir, ctx) {
   return live;
 }
 
+const kindSuffix = (kind) => (kind ? ` (${kind})` : '');
+
 function blockedText(blocked, slots, now) {
   const holders = blocked.holders.map((h) => describeHolder(h, now)).join('; ');
   if (blocked.reason === 'exclusive') return `aguardando limpeza do servidor de build (${describeHolder(blocked.exclusive, now)})`;
@@ -56,14 +58,14 @@ function blockedText(blocked, slots, now) {
     const cause = blocked.holders.length
       ? `slots em uso: ${holders}`
       : 'nenhum slot em uso: a pressão vem de fora do semáforo (vmmem do WSL, IDE, outros processos)';
-    return `aguardando RAM livre: ${blocked.freeGb.toFixed(1)} GB < ${blocked.minFreeMemGb} GB mínimos — ${cause}`;
+    return `aguardando RAM livre${kindSuffix(blocked.kind)}: ${blocked.freeGb.toFixed(1)} GB < ${blocked.minFreeMemGb} GB mínimos — ${cause}`;
   }
   return `aguardando slot pesado (${blocked.holders.length}/${slots}): ${holders}`;
 }
 
 function tryClaim(dir, opts, ctx) {
   const {
-    slots, label, feature, node, cwd, minFreeMemGb, freeMem, lease: leaseSpec,
+    slots, label, feature, node, cwd, minFreeMemGb, freeMem, kind, lease: leaseSpec,
   } = opts;
   const guarded = withClaimMutex(dir, () => {
     const holders = liveHoldersPruningStale(dir, ctx);
@@ -71,7 +73,7 @@ function tryClaim(dir, opts, ctx) {
     if (exclusive) return { blocked: { reason: 'exclusive', holders, exclusive } };
     if (holders.length >= slots) return { blocked: { reason: 'slots', holders } };
     const freeGb = freeMem() / GB;
-    if (minFreeMemGb > 0 && freeGb < minFreeMemGb) return { blocked: { reason: 'memory', holders, freeGb, minFreeMemGb } };
+    if (minFreeMemGb > 0 && freeGb < minFreeMemGb) return { blocked: { reason: 'memory', holders, freeGb, minFreeMemGb, kind } };
 
     for (let i = 0; i < slots + holders.length + 1; i++) {
       const path = join(dir, `slot-${i}.lock`);
@@ -124,7 +126,13 @@ export function acquireHeavy(opts) {
     const { blocked } = attempt;
     if (waited >= waitTimeoutMs) {
       return {
-        status: 'busy', reason: blocked.reason, holders: blocked.holders, freeGb: blocked.freeGb ?? null, waitedMs: waited,
+        status: 'busy',
+        reason: blocked.reason,
+        holders: blocked.holders,
+        freeGb: blocked.freeGb ?? null,
+        minFreeMemGb: claimOpts.minFreeMemGb,
+        kind: opts.kind ?? null,
+        waitedMs: waited,
       };
     }
     if (blocked.reason !== 'contended' && now() - lastReport >= REPORT_EVERY_MS) {
@@ -135,6 +143,32 @@ export function acquireHeavy(opts) {
   }
 }
 
+// For a holder whose next node needs more RAM than it was admitted with: it keeps its slot and
+// waits only on memory, since re-claiming would hit the re-entrant path and skip the check.
+export function awaitFreeMemory(opts) {
+  const {
+    minFreeMemGb, waitTimeoutMs, kind = null,
+    now = Date.now, sleep = sleepSync, freeMem = freemem, log = (m) => process.stderr.write(`${m}\n`),
+  } = opts;
+  const start = now();
+  let lastReport = -Infinity;
+  for (;;) {
+    const freeGb = freeMem() / GB;
+    const waited = now() - start;
+    if (!(minFreeMemGb > 0) || freeGb >= minFreeMemGb) return { status: 'acquired', waitedMs: waited };
+    if (waited >= waitTimeoutMs) {
+      return {
+        status: 'busy', reason: 'memory', holders: [], freeGb, minFreeMemGb, kind, waitedMs: waited,
+      };
+    }
+    if (now() - lastReport >= REPORT_EVERY_MS) {
+      log(`aguardando RAM livre${kindSuffix(kind)}: ${freeGb.toFixed(1)} GB < ${minFreeMemGb} GB mínimos, segurando o slot já tomado`);
+      lastReport = now();
+    }
+    sleep(Math.min(POLL_MS, Math.max(1, waitTimeoutMs - waited)));
+  }
+}
+
 export function updateLease(lease, patch) {
   if (!lease) return;
   try {
@@ -168,7 +202,9 @@ export function releaseLeaseById(dir, id) {
 export function describeBusy(result, config) {
   const waited = Math.round(result.waitedMs / 1000);
   if (result.reason === 'memory') {
-    return `sem RAM livre há ${waited}s (${result.freeGb?.toFixed(1)} GB < ${config.minFreeMemGb} GB mínimos, heavy.minFreeMemGb)`;
+    const floor = result.minFreeMemGb ?? config.minFreeMemGb;
+    const key = result.kind ? `heavy.minFreeMemGbByKind.${result.kind}` : 'heavy.minFreeMemGb';
+    return `sem RAM livre há ${waited}s (${result.freeGb?.toFixed(1)} GB < ${floor} GB mínimos${kindSuffix(result.kind)}, ${key})`;
   }
   if (result.reason === 'exclusive') return `limpeza do servidor de build ainda em curso após ${waited}s`;
   return `${result.holders.length}/${config.slots} slots pesados ocupados por ${waited}s (heavy.waitTimeoutSec)`;

package/framework/schemas/config.schema.json

@@ -179,7 +179,18 @@
           "type": "number",
           "minimum": 0,
           "default": 4,
-          "description": "Free RAM (os.freemem) below which a heavy node WAITS instead of starting and dying 'killed' for memory. It waits with or without a slot holder - the pressure often comes from outside (WSL vmmem, the IDE). 0 disables the check."
+          "description": "Free RAM (os.freemem) below which a heavy node WAITS instead of starting and dying 'killed' for memory. It waits with or without a slot holder - the pressure often comes from outside (WSL vmmem, the IDE). 0 disables the check. Since the per-kind floors exist it is the fallback: set explicitly, it applies to every kind not listed in minFreeMemGbByKind (so 0 still turns the check off everywhere)."
+        },
+        "minFreeMemGbByKind": {
+          "type": "object",
+          "additionalProperties": false,
+          "default": { "unit": 1.5, "build": 4, "e2e": 4 },
+          "description": "Free-RAM floor per kind of heavy command. unit = vitest/jest, npm|pnpm|yarn test, the verify tests node; e2e = playwright, docker compose up, the verify e2e node, e2e up; build = everything else (dotnet build|test|publish, next build, docker build, mutate, unknown commands). A verify admitted at a lighter node waits again, holding its slot, before a heavier one. A kind left out takes an explicit heavy.minFreeMemGb, else its default.",
+          "properties": {
+            "unit": { "type": "number", "minimum": 0 },
+            "build": { "type": "number", "minimum": 0 },
+            "e2e": { "type": "number", "minimum": 0 }
+          }
         },
         "waitTimeoutSec": {
           "type": "number",

package/framework/skills/core/create-umbraco-lp/SKILL.md

@@ -4,7 +4,7 @@ description: Guia a criação de uma landing page nova ponta-a-ponta a partir do
 version: core
 when_to_use: Use quando for iniciar um novo projeto de LP com o template Umbraco genérico
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 stacks:
   - umbraco
 ---

package/framework/skills/core/migrate-lp-to-umbraco/SKILL.md

@@ -4,7 +4,7 @@ description: Migra uma landing page existente (React/Vite, Next.js estático ou
 version: core
 when_to_use: Use quando o usuário pedir "use /migrate-lp-to-umbraco {projeto}" ou descrever a necessidade de migrar uma LP para Umbraco
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 stacks:
   - umbraco
 ---

package/framework/skills/core/morph-apply/SKILL.md

@@ -4,7 +4,7 @@ description: Executa as fatias do plano de uma feature morph-spec — dispatch p
 version: core
 when_to_use: Use com o gate do plano aprovado, em "use /morph-apply {feature}" ou "implementar feature"
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-apply

package/framework/skills/core/morph-hotfix/SKILL.md

@@ -4,7 +4,7 @@ description: ADW cirúrgico de hotfix — resolve uma queda/bug crítico de prod
 version: core
 when_to_use: Use quando chegar "/morph-hotfix {feature}", quando a morph-plan rotear o pedido como workType hotfix, ou quando o usuário disser "produção caiu / hotfix / urgente" a respeito de um incidente
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-hotfix

package/framework/skills/core/morph-machine/SKILL.md

@@ -4,7 +4,7 @@ description: Cuida da RAM e da CPU da máquina enquanto o morph-spec trabalha
 version: core
 when_to_use: Use quando a máquina estiver lenta ou sem RAM, um comando pesado esperou ou foi recusado pela fila, sobrou worktree de sub-agent, ou vários sub-agents pesados vão rodar em paralelo
 user-invocable: false
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-machine

package/framework/skills/core/morph-media/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a AUTORIA de mídia gerada por IA — escolher o modelo pelo
 version: core
 when_to_use: Use quando a tarefa for PRODUZIR imagem ou vídeo por IA (catálogo, marketing, asset de LP) e alguém precisar decidir modelo, prompt e aprovação
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 stacks:
   - dotnet
   - nextjs

package/framework/skills/core/morph-plan/SKILL.md

@@ -4,7 +4,7 @@ description: Leva uma feature do pedido ao plano aprovado — roteia o tipo de t
 version: core
 when_to_use: Use quando uma feature, bug ou chore começar ("/morph-plan {feature}", "vamos planejar X"), ou ao retomar uma feature cujo gate plan ainda não foi aprovado
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-plan
@@ -71,7 +71,7 @@ O `create` já escreveu o esqueleto em `2-plan/plan.md` (leia e preencha; `chore
 - **Observável**: que asserção (ou que linha de código) prova? Sem resposta, reescreva ou descarte.
 - **Artefato não é comportamento.** Cenário que cita `grep`, "contém a string", "o binário", "nenhum arquivo", "arquivo/pasta/diretório em" ou glob `**/` descreve o repositório. Tente o efeito em runtime; se o artefato É o entregável, justifique em `> Por que artefato:` logo abaixo (nunca na mesma linha, nunca `> [!note]`).
 - **Saída de LLM** (o que o modelo responde) prova-se por `eval` de runtime, nunca pelo texto do prompt: evidência em `3-implement/evidencias/{Cn}.md`, path listado em `arquivos:` da fatia; com nó `runner: "evals"` (standard `ai-agents-evals-with-cache`) o cenário mora no dataset. No máximo 1 teste de estrutura da fonte do prompt.
-- **"O comando de teste da raiz roda de ponta a ponta"** prova-se pelo `verify {feature}` (o nó `e2e` e o nó de teste `e2e: true` já percorrem a cadeia): nomeie essa rodada como a prova, nunca uma execução avulsa. Precisando mesmo rodar fora dele, numa linha só (o Bash não guarda o env entre chamadas): `eval "$(morph-spec env {feature})" && morph-spec heavy run -- <comando>` — o `COMPOSE_PROJECT_NAME` da feature é o que o `finish` derruba com os volumes. `prova: manual` registra passo e resultado em `3-implement/evidencias/{Cn}.md`.
+- **"O comando de teste da raiz roda de ponta a ponta"** prova-se pelo `verify {feature}` (o nó `e2e` e o nó de teste `e2e: true` já percorrem a cadeia): nomeie essa rodada como a prova, nunca uma execução avulsa. Precisando mesmo rodar fora dele, numa linha só (o Bash não guarda o env entre chamadas): `eval "$(morph-spec env {feature} --with-secrets)" && morph-spec heavy run -- <comando>` — o `COMPOSE_PROJECT_NAME` da feature é o que o `finish` derruba com os volumes. `prova: manual` registra passo e resultado em `3-implement/evidencias/{Cn}.md`.
 - **Orçamento de teste**: um teste por cenário de risco — o cenário é a unidade, nunca a pós-condição nem o componente; variantes são linhas de tabela (`[Theory]`/`it.each`); acima disso, o porquê na linha do cenário. Nenhum teste que só fixa texto, prompt ou constante, nenhum de DTO/mapping, e o mesmo comportamento numa camada só (handler **ou** endpoint). Teste além do orçamento é escopo para o revisor. O `verify` avisa quando o teste passa da produção.
 
 ```markdown

package/framework/skills/core/morph-review/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz o Gate 3 — despacha verificador ∥ revisor (∥ seguranç
 version: core
 when_to_use: Use quando a fase review começar, com todas as fatias com relatório final e o verify da feature verde
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-review

package/framework/skills/core/morph-standards/SKILL.md

@@ -4,7 +4,7 @@ description: Localiza um standard específico via busca server-side (morph-spec
 version: core
 when_to_use: Use quando precisar consultar um standard específico durante a implementação
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-standards

package/framework/skills/core/morph-uiux/SKILL.md

@@ -4,7 +4,7 @@ description: Conduz a fase opcional de UI/UX de uma feature com plano aprovado
 version: core
 when_to_use: Use quando o ramo de design for tomado (morph-spec advance {feature} --design, depois do gate do plano) e antes de /morph-apply
 user-invocable: true
-cliVersion: "9.5.0"
+cliVersion: "9.6.0"
 ---
 
 # morph-uiux

package/framework/standards/infrastructure/docker/local-compose-isolation.md

@@ -96,5 +96,6 @@ volumes:
 ```bash
 # inside the worktree, outside Claude Code
 eval "$(morph-spec env)"        # PowerShell: morph-spec env --powershell | Invoke-Expression
+                                # --with-secrets also loads the e2e.auth.envFile credentials
 docker compose up -d --wait     # lands in project morph-{feature}, on the block's ports
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "9.5.0",
+  "version": "9.6.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/e2e/e2e.js

@@ -28,6 +28,7 @@ import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
 import { findWorktreeForFeature, resolvePrimaryRoot } from '../project/worktree.js';
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 
 const EXIT_USAGE = 2;
@@ -126,6 +127,8 @@ export async function e2eUpCommand(featureName, options = {}) {
       console.log(JSON.stringify({ status: 'busy', feature: featureName, busy: { reason: err.reason, waitedMs: err.waitedMs } }, null, 2));
     }
     console.error(chalk.yellow(`\n⏳ e2e up não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\`).\n`));
+    const hint = memoryBusyHint(err, ctx.cwd);
+    if (hint) console.error(chalk.yellow(`${hint}\n`));
     process.exit(EXIT_BUSY);
   } finally {
     gate.release();

package/src/commands/project/env.js

@@ -35,7 +35,7 @@ function gitCommonDir(cwd) {
 const shq = (v) => `'${String(v).replace(/'/g, "'\\''")}'`;
 
 /** The env map for a key, or `{ error }`. */
-export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
+export function resolveWorktreeEnv(featureArg, cwd = process.cwd(), { withCredentials = true } = {}) {
   const key = featureArg || envKeyFromBranch(currentBranch(cwd));
   if (!key) {
     return { error: 'no-feature', message: 'Nenhuma feature: passe o nome ou rode de uma branch morph/{f} / morph-task/{n}.' };
@@ -45,7 +45,7 @@ export function resolveWorktreeEnv(featureArg, cwd = process.cwd()) {
     return { error: 'not-a-git-repo', message: 'Fora de um repositório git não há bloco de portas.' };
   }
   const root = resolvePrimaryRoot(cwd);
-  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common });
+  const env = buildComposeEnv({ cwd: root, config: readConfig(root), featureName: key, gitCommonDir: common, withCredentials });
   return { key, env };
 }
 
@@ -57,7 +57,7 @@ export function render(env, format) {
 }
 
 export function envCommand(featureArg, options = {}) {
-  const result = resolveWorktreeEnv(featureArg || null, process.cwd());
+  const result = resolveWorktreeEnv(featureArg || null, process.cwd(), { withCredentials: Boolean(options.withSecrets) });
   if (result.error) {
     if (options.json) console.log(JSON.stringify({ error: result.error, message: result.message }));
     else console.error(chalk.red(`✗ ${result.message}`));

package/src/commands/project/heavy.js

@@ -5,6 +5,8 @@ import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
 import { describeHolder, heavyDir, heavyStatus } from '../../../framework/hooks/shared/heavy-slots.js';
 import { resolveSpawn } from '../../../framework/hooks/shared/spawn-command.js';
+import { heavyClass, heavyKind } from '../../../framework/hooks/shared/heavy-command.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 
 const EXIT_BUSY = 3;
 
@@ -15,6 +17,7 @@ export function heavyStatusCommand(options = {}) {
     enabled: config.enabled,
     slots: config.slots,
     minFreeMemGb: config.minFreeMemGb,
+    minFreeMemGbByKind: config.minFreeMemGbByKind,
     dir: status.dir,
     freeGb: Number(status.freeGb.toFixed(2)),
     holders: status.holders.map(({ pid, label, feature, node, cwd, since, leaseId }) => ({ pid, label, feature, node, cwd, since, ...(leaseId ? { leaseId } : {}) })),
@@ -29,8 +32,10 @@ export function heavyStatusCommand(options = {}) {
   logger.header('Slots de nós pesados (build, testes, e2e)');
   if (!config.enabled) console.log(chalk.yellow('  ⚠ semáforo desligado (heavy.enabled: false ou MORPH_HEAVY=off)'));
   console.log(chalk.gray(`  diretório: ${report.dir}`));
-  const memMark = report.freeGb < config.minFreeMemGb ? chalk.yellow('⚠') : chalk.green('✓');
-  console.log(`  ${memMark} RAM livre: ${report.freeGb.toFixed(1)} GB (mínimo ${config.minFreeMemGb} GB)`);
+  const floors = config.minFreeMemGbByKind;
+  const memMark = report.freeGb < Math.max(...Object.values(floors)) ? chalk.yellow('⚠') : chalk.green('✓');
+  const floorText = Object.entries(floors).map(([kind, gb]) => `${kind} ${gb}`).join(' · ');
+  console.log(`  ${memMark} RAM livre: ${report.freeGb.toFixed(1)} GB (mínimo em GB: ${floorText})`);
   console.log(`  slots em uso: ${status.holders.length}/${config.slots}`);
   for (const h of status.holders) console.log(chalk.gray(`    • ${describeHolder(h)}${h.cwd ? ` — ${h.cwd}` : ''}`));
   if (status.exclusive) console.log(chalk.yellow(`  ⚠ limpeza do servidor de build em curso (${describeHolder(status.exclusive)})`));
@@ -42,10 +47,12 @@ export function heavyRunCommand(command, options = {}) {
   const [file, ...args] = command;
   const gate = createHeavyGate({ projectPath: process.cwd(), label: options.label ?? 'run' });
   try {
-    gate.enter(file);
+    gate.enter(file, heavyClass(heavyKind(command.join(' '))));
   } catch (err) {
     if (!(err instanceof HeavyBusyError)) throw err;
     console.error(chalk.yellow(`\n⏳ ${file} não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+    const hint = memoryBusyHint(err, process.cwd());
+    if (hint) console.error(chalk.yellow(`${hint}\n`));
     process.exit(EXIT_BUSY);
   }
 

package/src/commands/project/worktree.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, symlinkSync, readFileSync, writeFileSync, lstatS
 import { join, resolve, dirname, basename } from 'path';
 import chalk from 'chalk';
 import { detectDefaultBranch } from '../../lib/git/default-branch.js';
-import { triageIgnoredPaths } from '../../lib/worktree/ignored-triage.js';
+import { isTestArtifact, triageIgnoredPaths } from '../../lib/worktree/ignored-triage.js';
 import {
   finishBackupDir,
   writeFeatureScopeBackup,
@@ -710,6 +710,7 @@ export function primaryRootUnexplainedDirt(root, feature, opts = {}) {
     if (!record || record.length < 4) return false;
     const p = record.slice(3).replace(/\\/g, '/');
     if (opts.exemptOwnScope && p.startsWith(ownScope)) return false;
+    if (record.startsWith('?? ') && isTestArtifact(p)) return false;
     return !isLiveSiblingWorktreeRegistration(p, root, feature);
   });
   return { ok: true, dirt };

package/src/commands/state/finish.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import {
   findWorktreeForFeature,
@@ -23,6 +23,7 @@ import { findReparsePoints } from '../../../framework/hooks/shared/reparse-scan.
 import { runArchive } from './archive.js';
 import { dropLeftoverIgnore, withoutLeftoverIgnore } from '../../../framework/hooks/shared/graph-freshness.js';
 import { newBackupStamp, enforceBackupRetention, inspectFinishBackups } from '../../lib/worktree/finish-backup.js';
+import { isTestArtifact } from '../../lib/worktree/ignored-triage.js';
 
 const PR_TYPE_BY_WORK_TYPE = { feature: 'feat', bug: 'fix', hotfix: 'fix', chore: 'chore' };
 
@@ -289,7 +290,9 @@ export async function finishCommand(feature, options = {}) {
     emit({ finished: false, error: 'status-failed', feature });
     process.exit(1);
   }
-  if (withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim())).length) {
+  const dirtLines = withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim()));
+  const testArtifacts = untrackedTestArtifacts(dirtLines);
+  if (dirtLines.length > testArtifacts.length) {
     emit({ finished: false, error: isWorktreeFlow ? 'worktree-dirty' : 'working-dir-dirty', hint: 'commit seu trabalho na branch antes do finish', feature });
     process.exit(1);
   }
@@ -338,7 +341,10 @@ export async function finishCommand(feature, options = {}) {
 
   // Every refusal is behind us: the leftover of a killed `graph refresh` goes now, never before.
   dropLeftoverIgnore(cleanCwd);
-  const arch = runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
+  if (isWorktreeFlow) {
+    for (const p of testArtifacts) rmSync(join(cleanCwd, p), { recursive: true, force: true });
+  }
+  const arch =runArchive(feature, { cwd: featureCwd, force: options.force, git: true });
   if (!arch.ok) {
     emit({ finished: false, error: `archive-${arch.error}`, feature });
     process.exit(1);
@@ -794,6 +800,14 @@ function currentBranch(cwd) {
   }
 }
 
+/** Untracked Playwright/test output (`?? test-results/`): never work, so it neither blocks nor survives the teardown. */
+function untrackedTestArtifacts(lines) {
+  return lines
+    .filter((l) => l.startsWith('?? '))
+    .map((l) => l.slice(3).replace(/^"|"$/g, '').replace(/\/$/, ''))
+    .filter((p) => isTestArtifact(p));
+}
+
 function gitStatusPorcelain(cwd) {
   try {
     return execFileSync('git', ['status', '--porcelain'], { cwd, stdio: 'pipe' }).toString();

package/src/commands/validation/mutate.js

@@ -113,13 +113,13 @@ function subsetFor({ node, group, root }) {
 
 function e2eManualProtocol(feature, node) {
   const f = feature ?? '<feature>';
-  const round = `eval "$(morph-spec env ${f})" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
+  const round = `eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f} && morph-spec heavy run -- ${node.command}`;
   return 'mutate só recompila localmente, e a suíte que alcança esse código testa o container do compose: o mutante sairia sobrevivente em falso. ' +
     `Prove à mão pelo nó "${node.id}", cada passo numa linha só e encadeado por \`&&\` (nunca \`;\`: um passo que falha não pode deixar a suíte rodar sobre o código original; ` +
     'e o env da feature se perde entre chamadas de Bash): ' +
     `(1) base verde antes do 1º mutante: \`${round}\`; ` +
     `(2) por mutante: edite a linha && \`${round}\`; ` +
-    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f})" && morph-spec e2e up ${f}\`). ` +
+    `(3) restaure, confirme com \`git diff --quiet -- <arquivo>\` e suba a stack de novo (\`eval "$(morph-spec env ${f} --with-secrets)" && morph-spec e2e up ${f}\`). ` +
     'Registre cada mutante em 4-review (expect, resultado, teste que o matou).';
 }
 

package/src/commands/validation/verify.js

@@ -11,6 +11,7 @@ import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../l
 import { treeFingerprint } from '../../lib/git/tree-fingerprint.js';
 import { HeavyBusyError } from '../../lib/heavy/gate.js';
 import { afterHeavyRun } from '../../lib/heavy/cleanup.js';
+import { memoryBusyHint } from '../../lib/heavy/live-stacks.js';
 import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
 import { runCiVerify, CiUsageError, reusableLocalStamp } from '../../lib/ci/ci-verify.js';
 
@@ -146,6 +147,8 @@ async function runLocalVerify(featureName, options) {
         }, null, 2));
       }
       console.error(chalk.yellow(`\n⏳ verify não rodou: ${err.message}. Não é vermelho — a fila já esperou o prazo dela: não repita em laço — siga sem esta rodada e avise o usuário (\`morph-spec heavy status\` mostra quem segura os slots).\n`));
+      const hint = memoryBusyHint(err, process.cwd());
+      if (hint) console.error(chalk.yellow(`${hint}\n`));
       process.exit(3);
     }
     throw err;

package/src/lib/e2e/compose-env.js

@@ -11,7 +11,9 @@ import { allocateEnvBlock, portLayout, resolveFleetConfig, resolvePortAliases }
 // Ports come from `portLayout()`, the same function that renders `.morph/worktree.env`. The credentials
 // file loads after the layout but cannot outrank it: a `.env.e2e` copied from a sibling worktree carries
 // that worktree's block. Ignored keys are announced on stderr; stdout carries `morph-spec env` output.
-export function buildComposeEnv({ cwd, config, featureName, gitCommonDir }) {
+// `withCredentials: false` keeps envFile values off stdout (`morph-spec env` lands in transcripts);
+// the withheld names go to stderr.
+export function buildComposeEnv({ cwd, config, featureName, gitCommonDir, withCredentials = true }) {
   const env = {};
   let layoutKeys = null;
 
@@ -38,16 +40,37 @@ export function buildComposeEnv({ cwd, config, featureName, gitCommonDir }) {
   const envFile = config?.e2e?.auth?.envFile;
   if (envFile) {
     const ignored = [];
+    const withheld = [];
+    const foreignPorts = [];
+    const layoutPorts = layoutKeys ? new Set([...layoutKeys].map((key) => env[key])) : null;
     for (const [key, value] of Object.entries(loadEnvFile(join(cwd, envFile)))) {
-      if (layoutKeys?.has(key)) ignored.push(key);
-      else env[key] = value;
+      if (layoutKeys?.has(key)) {
+        ignored.push(key);
+        continue;
+      }
+      if (layoutPorts && /(^|_)PORT$/.test(key) && !layoutPorts.has(value)) foreignPorts.push(`${key}=${value}`);
+      if (withCredentials) env[key] = value;
+      else withheld.push(key);
     }
     if (ignored.length) reportIgnoredLayoutKeys(envFile, ignored, env);
+    if (foreignPorts.length) reportForeignPorts(envFile, foreignPorts);
+    if (withheld.length) {
+      console.warn(chalk.yellow(
+        `  ⚠ ${envFile}: ${withheld.join(', ')} omitida(s) — credenciais não vão para o stdout; use --with-secrets dentro de eval "$(…)".`,
+      ));
+    }
   }
 
   return env;
 }
 
+function reportForeignPorts(envFile, foreignPorts) {
+  console.warn(chalk.yellow(
+    `  ⚠ ${envFile}: ${foreignPorts.join(', ')} não é porta do bloco desta worktree. `
+    + 'Se nomeia uma das portas do layout, declare-a em e2e.portEnvNames (ex.: { "postgres": "PG_PORT" }) e o bloco passa a prevalecer.',
+  ));
+}
+
 function reportIgnoredLayoutKeys(envFile, ignored, env) {
   const shown = ignored.map((key) => `${key}=${env[key]}`).join(', ');
   console.warn(chalk.yellow(

package/src/lib/heavy/gate.js

@@ -1,6 +1,7 @@
-import { readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
+import { minFreeMemFor, readHeavyConfig } from '../../../framework/hooks/shared/heavy-config.js';
+import { heavyClass } from '../../../framework/hooks/shared/heavy-command.js';
 import {
-  acquireHeavy, describeBusy, heavyDir, releaseHeavy, updateLease,
+  acquireHeavy, awaitFreeMemory, describeBusy, heavyDir, releaseHeavy, updateLease,
 } from '../../../framework/hooks/shared/heavy-slots.js';
 
 export class HeavyBusyError extends Error {
@@ -11,6 +12,8 @@ export class HeavyBusyError extends Error {
     this.reason = result.reason;
     this.holders = result.holders;
     this.freeGb = result.freeGb;
+    this.minFreeMemGb = result.minFreeMemGb ?? null;
+    this.kind = result.kind ?? null;
     this.waitedMs = result.waitedMs;
   }
 
@@ -28,6 +31,7 @@ export function createHeavyGate({
 } = {}) {
   let entered = false;
   let lease = null;
+  let admittedGb = 0;
   let waitedMs = 0;
   let exitHandler = null;
   let saved = null;
@@ -50,26 +54,40 @@ export function createHeavyGate({
     entered = false;
   };
 
+  const raiseFloor = (kind) => {
+    const floor = minFreeMemFor(config, kind);
+    if (!lease || floor <= admittedGb) return;
+    const result = awaitFreeMemory({
+      minFreeMemGb: floor, waitTimeoutMs: config.waitTimeoutSec * 1000, kind, log, ...deps,
+    });
+    if (result.status === 'busy') throw new HeavyBusyError(result, config);
+    waitedMs += result.waitedMs;
+    admittedGb = floor;
+  };
+
   return {
     config,
     get waitedMs() { return waitedMs; },
 
-    enter(node) {
+    enter(node, kind = heavyClass(node)) {
       if (entered) {
+        raiseFloor(kind);
         updateLease(lease, { node });
         return;
       }
       for (const warning of config.warnings ?? []) log(`heavy: ${warning}`);
 
       if (config.enabled) {
+        const minFreeMemGb = minFreeMemFor(config, kind);
         const result = acquireHeavy({
           dir: heavyDir(env),
           slots: config.slots,
           label,
           feature,
           node,
+          kind,
           cwd: projectPath,
-          minFreeMemGb: config.minFreeMemGb,
+          minFreeMemGb,
           waitTimeoutMs: config.waitTimeoutSec * 1000,
           maxHoldMs: config.maxHoldMinutes * 60_000,
           env,
@@ -78,6 +96,7 @@ export function createHeavyGate({
         });
         if (result.status === 'busy') throw new HeavyBusyError(result, config);
         lease = result.lease;
+        admittedGb = minFreeMemGb;
         waitedMs = result.waitedMs;
       }
 

package/src/lib/heavy/live-stacks.js

@@ -0,0 +1,64 @@
+import { readdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { composeProjectName, defaultExec } from '../../../framework/hooks/shared/e2e-check.js';
+import {
+  MORPH_PROJECT_PREFIX, parseDockerJson, resolveGitCommonDir, stackBelongsTo,
+} from '../worktree/docker-audit.js';
+
+// Runs right after a full queue wait: a hung daemon must not add another one.
+const LS_TIMEOUT_MS = 10_000;
+
+// Stacks of every worktree live under the main checkout, and so does `.morph/archive`.
+export function repoMainRoot(cwd) {
+  const common = resolveGitCommonDir(cwd);
+  return common && basename(common) === '.git' ? dirname(common) : cwd;
+}
+
+function dirNames(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+
+export function liveE2eStacks(cwd, { exec = defaultExec, root = repoMainRoot(cwd) } = {}) {
+  try {
+    const ls = exec('docker', ['compose', 'ls', '--format', 'json'], { cwd: root, timeout: LS_TIMEOUT_MS });
+    if (ls.code !== 0) return [];
+    const projects = parseDockerJson(ls.output);
+    if (!projects) return [];
+
+    const active = dirNames(join(root, '.morph', 'features'));
+    const owners = new Map(active.map((f) => [composeProjectName(f), { feature: f, state: 'active' }]));
+    for (const f of dirNames(join(root, '.morph', 'archive'))) {
+      const project = composeProjectName(f);
+      if (!owners.has(project)) owners.set(project, { feature: f, state: 'archived' });
+    }
+
+    return projects
+      .filter((p) => String(p?.Name ?? '').startsWith(MORPH_PROJECT_PREFIX) && stackBelongsTo(p, root))
+      .map((p) => {
+        const project = String(p.Name);
+        return { project, status: p.Status ?? null, ...(owners.get(project) ?? { feature: null, state: 'unknown' }) };
+      });
+  } catch {
+    return [];
+  }
+}
+
+function stackLine(s) {
+  if (s.state === 'archived') return `  • ${s.project}: feature ${s.feature} já arquivada — \`morph-spec e2e down ${s.feature}\` devolve a RAM`;
+  if (s.state === 'unknown') return `  • ${s.project}: nenhuma feature deste repo responde por ela — \`docker compose -p ${s.project} down\``;
+  return `  • ${s.project}: feature ${s.feature} em andamento`;
+}
+
+export function describeLiveStacks(stacks) {
+  if (!stacks.length) return '';
+  return `stacks e2e de pé neste repo (seguram RAM):\n${stacks.map(stackLine).join('\n')}`;
+}
+
+export function memoryBusyHint(err, cwd, deps = {}) {
+  if (err?.reason !== 'memory') return '';
+  return describeLiveStacks(liveE2eStacks(cwd, deps));
+}

package/src/lib/risk-detector.js

@@ -1,5 +1,7 @@
 import { MAX_SLICES } from './plan/checks.js';
 import { BLOCKER_TYPES, reviewFileName } from './review-reports.js';
+import { isTestPath } from './graph/sanitize.js';
+import { isTestArtifact } from './worktree/ignored-triage.js';
 
 const SECURITY_PATH_RE = /(^|[/._-])(auth|login|senha|password|token|secret|crypto|permiss|rbac|acl|lgpd|pii|privacy|payment|pagamento|billing|cobranca|invoice|asaas|stripe|migrations?)([/._-]|$)/i;
 
@@ -135,8 +137,14 @@ export function verifierModelFor({ promptModelTouched = false, generatesMedia =
   return { model: reasons.length ? 'opus' : 'sonnet', reasons };
 }
 
+// Teste e artefato de teste não são superfície de ataque: `e2e/login.spec.ts` não pede a persona security.
+const E2E_DIR_RE = /(^|\/)e2e\//;
+const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
+
 export function securityReviewFor(changedFiles = []) {
-  const risky = changedFiles.filter((f) => SECURITY_PATH_RE.test(f.replaceAll('\\', '/')));
+  const risky = changedFiles
+    .map((f) => f.replaceAll('\\', '/'))
+    .filter((f) => SECURITY_PATH_RE.test(f) && !isTestOnly(f));
   return { required: risky.length > 0, reasons: risky.length ? [`caminho sensível: ${firstOf(risky)}`] : [] };
 }
 

package/src/lib/worktree/docker-audit.js

@@ -12,9 +12,9 @@ import {
 import { allocateEnvBlock, allocatedFeatures, portLayout, resolveFleetConfig } from './env-allocator.js';
 
 const PROJECT_PROBE = 'probe';
-const MORPH_PROJECT_PREFIX = composeProjectName(PROJECT_PROBE).slice(0, -PROJECT_PROBE.length);
+export const MORPH_PROJECT_PREFIX = composeProjectName(PROJECT_PROBE).slice(0, -PROJECT_PROBE.length);
 
-function resolveGitCommonDir(cwd) {
+export function resolveGitCommonDir(cwd) {
   try {
     const common = execFileSync('git', ['rev-parse', '--git-common-dir'], {
       cwd, stdio: 'pipe', encoding: 'utf-8', windowsHide: true,
@@ -57,6 +57,10 @@ function publishedPorts(entry) {
   return ports;
 }
 
+export function stackBelongsTo(entry, root) {
+  return belongsToRoot(entry, norm(root));
+}
+
 function composeProjectOf(entry) {
   const labels = String(entry?.Labels ?? '');
   for (const part of labels.split(',')) {
@@ -73,7 +77,7 @@ function containerNameOf(entry) {
 }
 
 // `null` = unreadable, distinct from `[]` = docker answered with nothing running.
-function parseDockerJson(raw) {
+export function parseDockerJson(raw) {
   const text = String(raw ?? '').trim();
   if (!text) return [];
   const parsed = parseComposePs(text);

package/src/lib/worktree/env-allocator.js

@@ -9,6 +9,22 @@ const DEFAULT_BASE_PORT = 4000;
 const DEFAULT_BLOCK_SIZE = 10;
 const MAX_PORT = 65535;
 
+// Chromium's kRestrictedPorts (net/base/port_util.cc): the browser refuses them with
+// ERR_UNSAFE_PORT, so a block holding one is a stack Playwright and the verifier cannot open.
+const BROWSER_UNSAFE_PORTS = new Set([
+  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102, 103,
+  104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465, 512, 513,
+  514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720,
+  1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6679, 6697, 10080,
+]);
+
+export function blockHasUnsafePort(base, blockSize) {
+  for (let port = base; port < base + blockSize; port += 1) {
+    if (BROWSER_UNSAFE_PORTS.has(port)) return true;
+  }
+  return false;
+}
+
 export function registryPath(gitCommonDir) {
   return join(gitCommonDir, 'morph-spec', 'env-registry.json');
 }
@@ -47,23 +63,29 @@ export function resolveFleetConfig(rootPath) {
   }
 }
 
-/** First free index wins, so released slots are reused instead of creeping toward the port ceiling. */
+/**
+ * First free index wins, so released slots are reused instead of creeping toward the port ceiling.
+ * A block with a browser-unsafe port is never handed out, and one recorded before this rule is moved.
+ */
 export function allocateEnvBlock(feature, { gitCommonDir, basePort = DEFAULT_BASE_PORT, blockSize = DEFAULT_BLOCK_SIZE }) {
   const registry = readRegistry(gitCommonDir);
 
   const existing = registry.allocations[feature];
   if (existing && Number.isInteger(existing.index)) {
     const base = basePort + existing.index * blockSize;
-    return { index: existing.index, base, range: [base, base + blockSize - 1], created: false };
+    if (!blockHasUnsafePort(base, blockSize)) {
+      return { index: existing.index, base, range: [base, base + blockSize - 1], created: false };
+    }
   }
 
   const used = new Set(
-    Object.values(registry.allocations)
-      .map((a) => a?.index)
+    Object.entries(registry.allocations)
+      .filter(([name]) => name !== feature)
+      .map(([, a]) => a?.index)
       .filter((i) => Number.isInteger(i)),
   );
   let index = 0;
-  while (used.has(index)) index += 1;
+  while (used.has(index) || blockHasUnsafePort(basePort + index * blockSize, blockSize)) index += 1;
 
   const base = basePort + index * blockSize;
   if (base + blockSize - 1 > MAX_PORT) {

package/src/lib/worktree/ignored-triage.js

@@ -18,6 +18,14 @@ const DISPOSABLE_FILE_RE = /\.tsbuildinfo$/;
 const REPLICABLE_MAX_FILES = 500;
 const REPLICABLE_MAX_BYTES = 8 * 1024 * 1024;
 
+// Narrower than the build set on purpose: an untracked `bin/` may be new code, a `test-results/` never is.
+const TEST_ARTIFACT_DIR_NAMES = new Set(['test-results', 'TestResults', 'playwright-report', 'blob-report']);
+
+/** @param {string} p - forward-slash relative path */
+export function isTestArtifact(p) {
+  return p.split('/').filter(Boolean).some((seg) => TEST_ARTIFACT_DIR_NAMES.has(seg));
+}
+
 /** @param {string} p - forward-slash relative path */
 export function isDisposableBuildArtifact(p) {
   if (DISPOSABLE_FILE_RE.test(p)) return true;