@polymorphism-tech/morph-spec 9.5.0 → 9.7.0

package/src/commands/observability/cost.js

@@ -108,6 +108,18 @@ function printMetricsBody(m) {
     console.log(`  ${klass.padEnd(12)} ${fmtDuration(t.measuredMs / 1000).padStart(8)}  ${t.runs} execução(ões)${unmeasured}`);
   }
 
+  const tov = m.testOutsideVerify;
+  const timed = (t) => `${String(t.runs).padStart(4)}×  ${fmtDuration(t.measuredMs / 1000).padStart(8)}`
+    + (t.unmeasured ? chalk.gray(` (${t.unmeasured} sem duração)`) : '');
+  console.log('\n' + chalk.white.bold('Teste fora do verify (sub-agentes)')
+    + chalk.gray(` · de ${tov.total.runs} testes+verifies, ${fmtDuration(tov.total.measuredMs / 1000)} cronometrados`
+      + (tov.total.unmeasured ? `, ${tov.total.unmeasured} sem duração` : '')));
+  console.log(`  sub-agente rodando verify cheio      ${timed(tov.subagentVerify)}`);
+  console.log(`  implementador, 3ª rodada em diante   ${timed(tov.implementerRound3Plus)}`);
+  console.log(`  agente de review rodando teste       ${timed(tov.reviewTests)}`);
+  console.log(chalk.gray(`    ${tov.reviewTests.byPersona.runs}× pela persona morph-* (o que o hook test-budget reconhece);`
+    + ' o resto veio de um nome de dispatch (ver-, rev-, gate3-…)'));
+
   console.log('\n' + chalk.white.bold('Rerun do mesmo comando em ≤10 min (mesma feature; o filtro de saída não conta)'));
   console.log(`  total: ${pct(m.reruns.rate)} repetidas (${m.reruns.reruns}/${m.reruns.runs}) · ${pct(m.reruns.burstRate)} em rajada — testes, builds e verifies`);
   for (const [kind, r] of Object.entries(m.rerunsByKind).sort((a, b) => b[1].runs - a[1].runs)) {

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 };
@@ -1012,11 +1013,13 @@ export async function runWorktreeRemove(featureArg, options = {}) {
   // Read BEFORE the teardown: the entry is gone from `git worktree list` afterwards.
   const envKey = envKeyForWorktree(worktreePath, root);
 
-  // Compose stack down BEFORE the tree: a bind-mounted container holds the dir on Windows. Volumes survive.
+  // Compose stack down BEFORE the tree: a bind-mounted container holds the dir on Windows.
+  // A `morph/{f}` volume survives for the finish that reclaims it; a `morph-task/*` one has no later owner.
+  const volumes = /^morph-task\//.test(branch ?? '');
   let e2e = null;
   try {
     const { tearDownFeatureStack } = await import('../../lib/e2e/stack-teardown.js');
-    e2e = tearDownFeatureStack(envKey || feature || basename(worktreePath), { root, worktreePath, volumes: false });
+    e2e = tearDownFeatureStack(envKey || feature || basename(worktreePath), { root, worktreePath, volumes, _exec: options._exec });
   } catch { e2e = null; }
 
   // The stamp this removal's backup is written under — protected from the
@@ -1043,7 +1046,9 @@ export async function runWorktreeRemove(featureArg, options = {}) {
     ...(feature ? { feature } : {}),
   };
   if (teardown.unlinked.length) out.unlinked = teardown.unlinked;
-  if (e2e?.attempted) out.e2e = { status: e2e.status, cwd: e2e.cwd, volumes: false };
+  if (e2e?.attempted || e2e?.hostServices) {
+    out.e2e = { status: e2e.status, cwd: e2e.cwd, volumes, ...(e2e.hostServices ? { hostServices: e2e.hostServices } : {}) };
+  }
   if (teardown.worktreeRemoved) {
     if (teardown.discarded.length) out.discardedIgnored = teardown.discarded;
     if (teardown.replicable.length) out.replicatedInRoot = teardown.replicable;

package/src/commands/state/advance.js

@@ -76,6 +76,9 @@ function resolveApprovedBy(options) {
 
 export function reportDotnetIgnores(added) {
   if (added.length) console.log(chalk.gray(`   .gitignore: ${added.join(' ')} adicionados (projeto .NET) — commite antes do primeiro build.`));
+  for (const { entry, file } of added.skipped || []) {
+    console.log(chalk.yellow(`   .gitignore: ${entry} não adicionado — esconderia fonte versionada (${file}); ignore a saída de build pelo caminho do projeto.`));
+  }
 }
 
 function reportDesignSeed({ mockups, designSystem }) {

package/src/commands/state/create.js

@@ -9,6 +9,7 @@ import { runWorktreeSetup, materializeState, isGitRepo, branchExists, buildBranc
 import { detectDefaultBranch } from '../../lib/git/default-branch.js';
 import { writePlanSkeleton } from '../../lib/plan/plan-template.js';
 import { seedDotnetBuildIgnores } from '../../lib/stack/dotnet-build-ignores.js';
+import { reportDotnetIgnores } from './advance.js';
 
 // Branches from the DEFAULT branch, never HEAD, so it never inherits another feature's commits.
 // `checkout: false` still CREATES the branch, which `finish` depends on. Fail-open: any git error
@@ -221,6 +222,7 @@ export async function createCommand(featureName, options = {}) {
       if (branchResult) out.branch = branchResult;
       if (planSkeleton) out.planSkeleton = planSkeleton;
       if (gitignoreAdded.length) out.gitignoreAdded = gitignoreAdded;
+      if (gitignoreAdded.skipped) out.gitignoreSkipped = gitignoreAdded.skipped;
       // Under --json the move goes to stderr, so it survives `... --json > out.json`.
       if (branchResult?.movedFrom) {
         console.error(chalk.yellow(branchMoveWarning(branchResult).join('\n')));
@@ -234,9 +236,7 @@ export async function createCommand(featureName, options = {}) {
       console.log(chalk.gray(`   .morph/features/${featureName}/feature.json (canonical shape)`));
       console.log(chalk.gray(`   status: ${finalFeature.status} | createdAt: ${finalFeature.createdAt}`));
       console.log(chalk.gray(`   scaffolded: ${wt.scaffold.join(', ')}`));
-      if (gitignoreAdded.length) {
-        console.log(chalk.gray(`   .gitignore: ${gitignoreAdded.join(' ')} adicionados (projeto .NET)`));
-      }
+      reportDotnetIgnores(gitignoreAdded);
       if (planSkeleton?.written) {
         console.log(chalk.gray(`   2-plan/plan.md: esqueleto escrito (gramática: morph-spec plan-check --help)`));
       }

package/src/commands/state/delete.js

@@ -109,7 +109,7 @@ export async function deleteCommand(featureName, options = {}) {
       const root = resolvePrimaryRoot(cwd);
       // The stack comes down BEFORE the worktree, where its compose file and bind mount live. Fail-open.
       try {
-        tearDownFeatureStack(featureName, { root, worktreePath: owner.tree, volumes: true });
+        tearDownFeatureStack(featureName, { root, worktreePath: owner.tree, volumes: true, images: 'local', _exec: options._exec });
       } catch { /* fail-open */ }
       const teardown = await teardownWorktree(owner.tree, {
         root,

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();
@@ -887,7 +901,9 @@ function openPrFor(branch, cwd) {
 // Never throws: a stack that refuses to come down must not fail a finish that already merged.
 function reclaimStack(feature, { root, worktreePath, options }) {
   try {
-    return tearDownFeatureStack(feature, { root, worktreePath, volumes: !options.keepVolumes });
+    return tearDownFeatureStack(feature, {
+      root, worktreePath, volumes: !options.keepVolumes, images: 'local', _exec: options._exec,
+    });
   } catch {
     return { attempted: false, cwd: worktreePath || root, status: 'fail', stampDeleted: false };
   }

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/plan-check.js

@@ -57,6 +57,7 @@ export function planCheckCommand(featureName, options = {}) {
   const gitignoreAdded = result.written ? seedDotnetBuildIgnores(process.cwd(), { featureName }) : [];
   if (options.json) {
     if (gitignoreAdded.length) result.gitignoreAdded = gitignoreAdded;
+    if (gitignoreAdded.skipped) result.gitignoreSkipped = gitignoreAdded.skipped;
     console.log(JSON.stringify(result, null, 2));
     process.exit(result.exit);
   }

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/dashboard/app/main.jsx

@@ -1,13 +1,13 @@
-import { StrictMode } from 'react';
-import { createRoot } from 'react-dom/client';
-import { BrowserRouter } from 'react-router-dom';
-import App from './App.jsx';
-import './styles/index.css';
-
-createRoot(document.getElementById('root')).render(
-  <StrictMode>
-    <BrowserRouter>
-      <App />
-    </BrowserRouter>
-  </StrictMode>
-);
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+import App from './App.jsx';
+import './styles/index.css';
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </StrictMode>
+);

package/src/dashboard/vite.config.js

@@ -1,24 +1,24 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-import tailwindcss from '@tailwindcss/vite';
-import morphDataPlugin from './vite-plugin-morph-data.js';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const frameworkDir = resolve(__dirname, '..', '..', 'framework');
-const projectDir = process.env.MORPH_PROJECT_DIR || process.cwd();
-
-export default defineConfig({
-  root: __dirname,
-  plugins: [
-    react(),
-    tailwindcss(),
-    morphDataPlugin(frameworkDir, projectDir),
-  ],
-  server: {
-    port: 3200,
-  },
-});
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import morphDataPlugin from './vite-plugin-morph-data.js';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const frameworkDir = resolve(__dirname, '..', '..', 'framework');
+const projectDir = process.env.MORPH_PROJECT_DIR || process.cwd();
+
+export default defineConfig({
+  root: __dirname,
+  plugins: [
+    react(),
+    tailwindcss(),
+    morphDataPlugin(frameworkDir, projectDir),
+  ],
+  server: {
+    port: 3200,
+  },
+});

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/e2e/stack-teardown.js

@@ -13,12 +13,18 @@ import {
   resolveComposeFile,
   tearDownStack,
 } from '../../../framework/hooks/shared/e2e-check.js';
+import { stopHostServices } from '../../../framework/hooks/shared/host-services.js';
 import { buildComposeEnv } from './compose-env.js';
 
-export function tearDownFeatureStack(feature, { root, worktreePath = null, volumes = true, _exec = defaultExec } = {}) {
+export function tearDownFeatureStack(feature, { root, worktreePath = null, volumes = true, images, _exec = defaultExec } = {}) {
   const cwd = worktreePath && existsSync(worktreePath) ? worktreePath : root;
   const projectName = composeProjectName(feature);
   const gitCommonDir = resolveGitCommonDir(root);
+  // Before the compose lookup: a worktree already gone still leaves its host processes running.
+  const stopped = stopHostServicesSafely(gitCommonDir, projectName);
+  const hostServices = stopped.killed.length + stopped.skipped.length + stopped.warnings.length > 0
+    ? { hostServices: stopped }
+    : {};
 
   try {
     const config = readConfig(cwd) ?? readConfig(root);
@@ -33,25 +39,34 @@ export function tearDownFeatureStack(feature, { root, worktreePath = null, volum
 
     if (!composeFile) {
       // Nothing to bring down, but a stamp left behind would tell the next `up` a stack it cannot see is fresh.
-      return { attempted: false, cwd, status: 'skip', stampDeleted: deleteStamp(gitCommonDir, projectName) };
+      return { attempted: false, cwd, status: 'skip', stampDeleted: deleteStamp(gitCommonDir, projectName), ...hostServices };
     }
 
     const env = {
       COMPOSE_PROJECT_NAME: projectName,
       ...buildComposeEnv({ cwd: composeCwd, config, featureName: feature, gitCommonDir }),
     };
-    const result = tearDownStack(composeCwd, { composeFile, projectName, env, volumes }, _exec);
+    const result = tearDownStack(composeCwd, { composeFile, projectName, env, volumes, images }, _exec);
 
     return {
       attempted: true,
       cwd: composeCwd,
       status: result.status,
       stampDeleted: deleteStamp(gitCommonDir, projectName),
+      ...hostServices,
       ...(result.status === 'fail' && result.output ? { output: result.output } : {}),
     };
   } catch {
     // The stamp must not outlive the stack it described, even when the teardown itself blew up.
-    return { attempted: false, cwd, status: 'fail', stampDeleted: deleteStamp(gitCommonDir, projectName) };
+    return { attempted: false, cwd, status: 'fail', stampDeleted: deleteStamp(gitCommonDir, projectName), ...hostServices };
+  }
+}
+
+function stopHostServicesSafely(gitCommonDir, projectName) {
+  try {
+    return stopHostServices(gitCommonDir, projectName);
+  } catch (err) {
+    return { killed: [], skipped: [], warnings: [`host services not stopped: ${err?.message ?? err}`] };
   }
 }
 

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));
+}