@polymorphism-tech/morph-spec 9.6.0 → 9.8.0

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.6.0"
+cliVersion: "9.8.0"
 ---
 
 # morph-plan
@@ -105,8 +105,8 @@ O `create` já escreveu o esqueleto em `2-plan/plan.md` (leia e preencha; `chore
 - Cenário que se observa por um artefato de outra fatia (rota, endpoint, componente que ela cria) faz da fatia que o cobre um `depende:` daquela — senão as duas caem na mesma onda e o teste do cenário não tem por onde provar. O `plan-check` não vê de quem é a rota: a regra é sua.
 
 **Contrato de implementação**: o que quem implementa precisa e o código não diz.
-- **Verificação de runtime:** o stack sobe por `morph-spec e2e up {feature}` (compose do projeto; sem compose, isso é uma fatia); os fluxos que o verificador navega, nos verbos dos cenários; base URL `process.env.PLAYWRIGHT_BASE_URL ?? \`http://localhost:${process.env.PORT ?? 3000}\``, compose com `"${PORT:-3000}:3000"` e sem `container_name` (standard `infrastructure/docker/local-compose-isolation`). App com login: `e2e.auth` em `config.json` (`mode: seed|storageState|bypass|none`, `seedCommand`, `storageStatePath`, `envFile`), credenciais num `.env.e2e` gitignored — **`mode` é obrigatório sempre que houver `seedCommand`**, sem ele o seed fica inerte. Biblioteca pura: registre a dispensa e o porquê.
-- **Baseline é um COMANDO, nunca um número.** O plano congela e é lido por dias: um número cravado está errado na primeira fatia, e quem confia nele "conserta" o que não quebrou. Registre como medir (`npm test`, `dotnet test`); o `expectedCount` sai de `morph-spec verify {feature} --record-baseline`, nunca digitado. Sem `project.stack`/`project.tests` no `config.json`, a `morph-apply` os declara a partir destes comandos antes do primeiro verify.
+- **Verificação de runtime:** o stack sobe por `morph-spec e2e up {feature}` (compose do projeto; sem compose, isso é uma fatia); os fluxos que o verificador navega, nos verbos dos cenários; base URL `process.env.PLAYWRIGHT_BASE_URL ?? \`http://localhost:${process.env.PORT ?? 3000}\``, compose com `"${PORT:-3000}:3000"` e sem `container_name` (standard `infrastructure/docker/local-compose-isolation`). App cujo build é caro dentro do Docker sobe como processo do host por `e2e.hostServices` (compose só com as dependências; campos em `morph-spec e2e --help`). App com login: `e2e.auth` em `config.json` (`mode: seed|storageState|bypass|none`, `seedCommand`, `storageStatePath`, `envFile`), credenciais num `.env.e2e` gitignored — **`mode` é obrigatório sempre que houver `seedCommand`**, sem ele o seed fica inerte. Biblioteca pura: registre a dispensa e o porquê.
+- **Baseline é um COMANDO, nunca um número.** O plano congela e é lido por dias: um número cravado está errado na primeira fatia, e quem confia nele "conserta" o que não quebrou. Registre como medir (`npm test`, `dotnet test`); o `expectedCount` (só `node-test`/`evals`; nos outros runners vale o piso zero) sai de `morph-spec verify {feature} --record-baseline`, nunca digitado. Sem `project.stack`/`project.tests` no `config.json`, a `morph-apply` os declara a partir destes comandos antes do primeiro verify.
 - **Pré-requisito é um PREDICADO, nunca um SHA literal:** "`git merge-base --is-ancestor origin/main HEAD` sai 0" — o SHA muda no primeiro squash.
 
 Plano bom cabe em duas páginas; crescendo além, corte escopo. Feche com `morph-spec plan-check {feature}` até zero erro. Ele também recusa veredito de reuso fora do enum, id `C`/`F`/`ADR` duplicado, `## Errata` fora do fim, `## Cenários` vazio e fatia sem `persona:`; avisa chave de fatia desconhecida, superfície fora da `ui-designer`, ADR sem **Alcance**, fatia sem `cobre:` e mais de 12 fatias.

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.6.0"
+cliVersion: "9.8.0"
 ---
 
 # morph-review
@@ -51,7 +51,8 @@ símbolo público do diff, `morph-spec graph affected <símbolo> --prod --json`;
 (`no-graph`/`not-found`/`ambiguous`), siga sem o blast radius — o revisor cai para `git grep` — e
 registre a ausência no recado a ele. Cada agente nasce com contexto fresco e **nunca recebe relatório anterior** (ancoragem).
 `chore` tem review leve: só o revisor (∥ segurança, quando exigida) — sem verificador, sem cobertura de
-`Cn`, sem mutação. Despache todos na mesma resposta:
+`Cn`, sem mutação. Despache todos na mesma resposta, **sem nome no dispatch**: com nome, o `agent_type` que o hook
+`test-budget` lê vira o nome, e o guard de review não reconhece o papel.
 ```
 dispatch Agent (subagent_type: "morph-verifier", model: {reviewModels.verifier.model}) with prompt:
   feature, base, sha, JSON do verify (nós, e2e, URL) se já terminou, 1-design/mockups.md e

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.6.0"
+cliVersion: "9.8.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.6.0"
+cliVersion: "9.8.0"
 ---
 
 # morph-uiux

package/framework/standards/STANDARDS.json

@@ -1629,9 +1629,10 @@
         "portNames": "#project-named-port-variables",
         "rules": "#core-rules",
         "enforcement": "#what-the-harness-enforces",
+        "hostServices": "#services-on-the-host",
         "skeleton": "#minimal-compose-skeleton"
       },
-      "digest": "Every worktree runs its OWN compose stack (project morph-{feature}, own postgres, own volumes). Ports come from the worktree block: PORT +0, API_PORT +1 (ASPNETCORE_URLS on .NET), POSTGRES_PORT +2, REDIS_PORT +3 — publish via ${VAR:-default}:container, never a fixed host port, never container_name (not prefixed by the project → collides). Stable POSTGRES_DB, healthcheck on every service, DATABASE_URL with an in-network default, playwright.config reads PLAYWRIGHT_BASE_URL. A non-isolable compose fails the verify e2e node inside a worktree. finish tears down with volumes (--keep-volumes opts out). Cloud DB credentials go in e2e.auth.envFile, never in .morph/worktree.env. A compose that reads a port by ANOTHER name (PG_PORT) is not fed by the block: declare it in config.json e2e.portEnvNames ({\"postgres\": \"PG_PORT\"}) and the harness exports it with the same value in worktree.env, the compose env and the hook."
+      "digest": "Every worktree runs its OWN compose stack (project morph-{feature}, own postgres, own volumes). Ports come from the worktree block: PORT +0, API_PORT +1 (ASPNETCORE_URLS on .NET), POSTGRES_PORT +2, REDIS_PORT +3 — publish via ${VAR:-default}:container, never a fixed host port, never container_name (not prefixed by the project → collides). Stable POSTGRES_DB, healthcheck on every service, DATABASE_URL with an in-network default, playwright.config reads PLAYWRIGHT_BASE_URL. A non-isolable compose fails the verify e2e node inside a worktree. finish/delete tear down with --rmi local -v (--keep-volumes drops -v on finish); worktree remove of a morph-task/* branch with -v, of morph/{f} without. An app whose build is expensive in the Docker VM runs as a host process via e2e.hostServices (compose keeps only the dependencies; ports from the block). Cloud DB credentials go in e2e.auth.envFile, never in .morph/worktree.env. A compose that reads a port by ANOTHER name (PG_PORT) is not fed by the block: declare it in config.json e2e.portEnvNames ({\"postgres\": \"PG_PORT\"}) and the harness exports it with the same value in worktree.env, the compose env and the hook."
     },
     {
       "id": "infrastructure-neon-pgrag",

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

@@ -51,10 +51,23 @@ Keys are `web`, `api`, `postgres` and `redis`. Each declared name carries the **
 ## What the harness enforces
 
 - Inside a secondary worktree, a compose with a fixed host port or a `container_name` **fails the `verify` e2e node** (`compose-not-isolable`) — Gate 3 cannot pass on a stack that cannot run beside its siblings. At the primary root the same finding is a warning.
-- `morph-spec finish` tears the stack down **with volumes** (`--keep-volumes` opts out) and deletes the freshness stamp; `morph-spec worktree remove` tears it down without volumes (the feature is still open).
+- `morph-spec finish` and `morph-spec delete` tear the stack down with `down --remove-orphans --rmi local -v` (`--keep-volumes` on `finish` drops the `-v`) and delete the freshness stamp. `--rmi local` removes only the images compose built, never a pulled one (`postgres`) that the next feature would download again; `docker builder prune` never runs, because the build cache is global to the machine. `morph-spec worktree remove` (and `worktree reap`, which goes through it) tears down a `morph/{f}` branch without volumes (the feature is still open) and a `morph-task/*` branch with `-v` (the task is disposable). Every one of these also stops the `e2e.hostServices` processes.
 - Two worktrees never share `POSTGRES_PORT`: the block is allocated first-free-index per feature and released only when the worktree is removed.
 - The credentials env file is read **after** the block but cannot outrank it. All four surfaces (`e2e up`, the `verify` e2e node, the teardown, `morph-spec env`) build their environment through the same `buildComposeEnv`, which drops the layout keys coming from that file and names them on **stderr** — stdout stays eval-safe for `eval "$(morph-spec env)"`. With no block allocated (outside a worktree) nothing is filtered: there the file is the only port source.
 
+## Services on the host
+
+When building an app inside the Docker VM is expensive (a `dotnet publish` or `next build` repeating the build the `verify` already did on the host), run it as a host process through `config.json → e2e.hostServices` and keep only the dependencies (postgres, redis) in compose. The app listens on the ports of the worktree block — `${API_PORT}` / `${PORT}` in its `env` and `health` — so two worktrees still never collide.
+
+```json
+"e2e": { "hostServices": [
+  { "name": "web", "build": "npm run build", "start": "node .next/standalone/server.js",
+    "env": { "PORT": "${PORT}" }, "health": "http://localhost:${PORT}/" }
+] }
+```
+
+`e2e up` and the `verify` e2e node run `compose up --wait`, then each host service in array order (build → start → health), then the auth seed. They stay up until `e2e down`, `finish`, `delete` or `worktree remove`. Fields, reuse and failure rules: `morph-spec e2e --help` and the `e2e` section of `.morph/framework/CLI.md`.
+
 ## Minimal compose skeleton
 
 ```yaml

package/package.json

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

package/src/commands/e2e/e2e.js

@@ -8,7 +8,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 
 import {
-  bringUpStack,
+  bringUpE2e,
   composeProjectName,
   computeSourceStamp,
   decideIsolation,
@@ -17,13 +17,13 @@ import {
   getStackStatus,
   isDockerAvailable,
   lintComposeIsolation,
-  prepareAuth,
   readStamp,
   resolveComposeFile,
   resolveSpecCommand,
   tearDownStack,
 } from '../../../framework/hooks/shared/e2e-check.js';
 import { isSecondaryWorktree } from '../../../framework/hooks/shared/git-paths.js';
+import { hostServicesStatus, stopHostServices } from '../../../framework/hooks/shared/host-services.js';
 import { buildComposeEnv } from '../../lib/e2e/compose-env.js';
 import { findWorktreeForFeature, resolvePrimaryRoot } from '../project/worktree.js';
 import { createHeavyGate, HeavyBusyError } from '../../lib/heavy/gate.js';
@@ -105,7 +105,8 @@ export async function e2eUpCommand(featureName, options = {}) {
     console.log(chalk.yellow(`⚠️  ${isolation.reason}`));
   }
 
-  if (!isDockerAvailable(ctx.cwd)) {
+  const exec = options._exec ?? defaultExec;
+  if (!isDockerAvailable(ctx.cwd, exec)) {
     console.error(chalk.red('\n❌ Docker is not available in this environment.\n'));
     process.exit(EXIT_USAGE);
   }
@@ -114,13 +115,14 @@ export async function e2eUpCommand(featureName, options = {}) {
   let result;
   try {
     gate.enter('e2e');
-    result = bringUpStack(ctx.cwd, {
+    result = bringUpE2e(ctx.cwd, {
+      config: ctx.config,
       composeFile: ctx.composeFile,
       projectName: ctx.projectName,
       gitCommonDir: ctx.gitCommonDir,
       env: ctx.env,
       forceFresh: Boolean(options.fresh),
-    });
+    }, exec);
   } catch (err) {
     if (!(err instanceof HeavyBusyError)) throw err;
     if (options.json) {
@@ -134,40 +136,42 @@ export async function e2eUpCommand(featureName, options = {}) {
     gate.release();
   }
 
-  const auth =
-    result.status === 'pass'
-      ? prepareAuth(ctx.cwd, { config: ctx.config, env: ctx.env, forceSeed: Boolean(options.fresh) })
-      : { status: 'skip', reason: null };
-
+  const { auth, hostServices } = result;
   // A seedCommand that `mode` switches off is reported, never swallowed.
   const warnings = [];
   if (isolation.status === 'warn') warnings.push(isolation.reason);
-  if (auth.warning) warnings.push(auth.warning);
+  warnings.push(...result.warnings);
 
-  const failed = result.status === 'fail' || auth.status === 'fail';
+  const failed = result.status === 'fail';
   const payload = {
     feature: featureName,
     project: ctx.projectName,
     tree: ctx.tree,
     composeFile: ctx.composeFile,
     status: failed ? 'fail' : 'pass',
-    reused: result.reused,
+    reused: result.stack.reused,
     reason: result.reason,
     auth: { status: auth.status, reason: auth.reason },
+    ...(hostServices.status === 'skip' ? {} : { hostServices: hostServices.services }),
     ...(warnings.length ? { warnings } : {}),
+    ...(failed && result.output ? { output: result.output } : {}),
   };
 
   if (options.json) {
     console.log(JSON.stringify(payload, null, 2));
   } else if (failed) {
-    console.error(chalk.red(`\n✗ ${result.reason || auth.reason}\n`));
+    console.error(chalk.red(`\n✗ ${result.reason}\n`));
     if (result.output) console.error(result.output);
+    for (const w of result.warnings) console.error(chalk.yellow(`⚠️  ${w}`));
   } else {
-    const how = result.reused ? chalk.gray(`(${result.reason})`) : chalk.gray('(built)');
+    const how = result.stack.reused ? chalk.gray(`(${result.stack.reason})`) : chalk.gray('(built)');
     console.log(chalk.green(`\n✓ Stack up — ${ctx.projectName} ${how}`));
     console.log(chalk.gray(`  tree: ${ctx.tree}`));
+    for (const s of hostServices.services) {
+      console.log(chalk.gray(`  host: ${s.name} pid ${s.pid} (${s.reused ? 'reused' : 'started'}) — log ${s.log}`));
+    }
     if (auth.reason) console.log(chalk.gray(`  auth: ${auth.reason}`));
-    if (auth.warning) console.log(chalk.yellow(`⚠️  ${auth.warning}`));
+    for (const w of result.warnings) console.log(chalk.yellow(`⚠️  ${w}`));
     console.log('');
   }
 
@@ -185,17 +189,19 @@ export async function e2eStatusCommand(featureName, options = {}) {
   const ctx = resolveContext(featureName, options);
   if (!ctx) process.exit(EXIT_USAGE);
 
+  const exec = options._exec ?? defaultExec;
   const status = getStackStatus(ctx.cwd, {
     composeFile: ctx.composeFile,
     projectName: ctx.projectName,
     env: ctx.env,
-  });
+  }, exec);
 
-  const stamp = computeSourceStamp(ctx.cwd);
+  const stamp = computeSourceStamp(ctx.cwd, exec);
   const previous = ctx.gitCommonDir ? readStamp(ctx.gitCommonDir, ctx.projectName) : null;
   const fresh = Boolean(stamp && previous?.stamp === stamp);
 
   const spec = resolveSpecCommand(ctx.cwd, ctx.config, ctx.config?.project?.frontendPath);
+  const hostServices = ctx.gitCommonDir ? hostServicesStatus(ctx.gitCommonDir, ctx.projectName) : [];
 
   const payload = {
     feature: featureName,
@@ -213,6 +219,7 @@ export async function e2eStatusCommand(featureName, options = {}) {
       state: s.State ?? null,
       health: s.Health || null,
     })),
+    ...(hostServices.length ? { hostServices } : {}),
   };
 
   if (options.json) {
@@ -233,6 +240,10 @@ export async function e2eStatusCommand(featureName, options = {}) {
     for (const s of payload.services) {
       console.log(chalk.gray(`    · ${s.name}: ${s.state}${s.health ? ` / ${s.health}` : ''}`));
     }
+    for (const h of hostServices) {
+      const health = h.health === null ? 'no health check' : h.health ? 'healthy' : 'unhealthy';
+      console.log(chalk.gray(`    · host ${h.name}: pid ${h.pid} ${h.alive ? 'alive' : 'dead'} / ${health}`));
+    }
     console.log('');
   }
 
@@ -245,30 +256,42 @@ export async function e2eDownCommand(featureName, options = {}) {
   const ctx = resolveContext(featureName, options);
   if (!ctx) process.exit(EXIT_USAGE);
 
+  const hostServices = stopHostServices(ctx.gitCommonDir, ctx.projectName);
   const result = tearDownStack(ctx.cwd, {
     composeFile: ctx.composeFile,
     projectName: ctx.projectName,
     env: ctx.env,
     volumes: Boolean(options.volumes),
-  });
+  }, options._exec ?? defaultExec);
   const stampDeleted = deleteStamp(ctx.gitCommonDir, ctx.projectName);
   const cleanup = afterHeavyRun({ projectPath: ctx.cwd, config: readHeavyConfig(ctx.cwd) });
 
   if (options.json) {
     console.log(JSON.stringify(
-      { feature: featureName, project: ctx.projectName, tree: ctx.tree, status: result.status, stampDeleted, cleanup },
+      {
+        feature: featureName, project: ctx.projectName, tree: ctx.tree, status: result.status, stampDeleted, cleanup,
+        ...(stoppedAnything(hostServices) ? { hostServices } : {}),
+      },
       null, 2,
     ));
-  } else if (result.status === 'pass') {
-    console.log(chalk.green(`\n✓ Stack down — ${ctx.projectName}`));
-    console.log(chalk.gray(`  tree: ${ctx.tree}\n`));
   } else {
-    console.log(chalk.yellow(`\n⚠️  Teardown reported a problem (not fatal):\n${result.output}\n`));
+    if (result.status === 'pass') {
+      console.log(chalk.green(`\n✓ Stack down — ${ctx.projectName}`));
+      console.log(chalk.gray(`  tree: ${ctx.tree}\n`));
+    } else {
+      console.log(chalk.yellow(`\n⚠️  Teardown reported a problem (not fatal):\n${result.output}\n`));
+    }
+    if (hostServices.killed.length) console.log(chalk.gray(`  host services stopped: ${hostServices.killed.join(', ')}`));
+    for (const w of hostServices.warnings) console.log(chalk.yellow(`⚠️  ${w}`));
   }
 
   process.exit(0);
 }
 
+function stoppedAnything({ killed, skipped, warnings }) {
+  return killed.length + skipped.length + warnings.length > 0;
+}
+
 function readConfig(cwd) {
   try {
     const path = join(cwd, '.morph', 'config', 'config.json');

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/worktree.js

@@ -85,8 +85,27 @@ function getDateSuffix() {
   return new Date().toISOString().slice(0, 10).replace(/-/g, '');
 }
 
-// The ONLY links `finish` may auto-remove (never widened to any reparse point found), plus
-// `{project.frontendPath}/node_modules`: a monorepo frontend has its own install.
+function trackedPackageNodeModules(mainCwd) {
+  let out;
+  try {
+    out = execFileSync('git', ['ls-files', '-z', '--', '*package.json'], { cwd: mainCwd, stdio: 'pipe' }).toString();
+  } catch {
+    return [];
+  }
+  const dirs = [];
+  for (const file of out.split('\0')) {
+    const parts = file.split('/');
+    if (parts.length < 2 || parts.at(-1) !== 'package.json') continue;
+    const dirParts = parts.slice(0, -1);
+    if (dirParts.includes('node_modules') || WORKTREE_DIR_NAMES.includes(dirParts[0])) continue;
+    const rel = join(...dirParts, 'node_modules');
+    if (existsSync(join(mainCwd, rel))) dirs.push(rel);
+  }
+  return dirs;
+}
+
+// The ONLY links `finish` may auto-remove (never widened to any reparse point found), plus the
+// `node_modules` of each tracked nested package: a monorepo package has its own install.
 function resolveInfraLinkDirs(mainCwd) {
   const dirs = ['node_modules', '.claude'];
   if (existsSync(join(mainCwd, '.morph', 'framework'))) {
@@ -100,6 +119,9 @@ function resolveInfraLinkDirs(mainCwd) {
       if (frontendPath) dirs.push(join(frontendPath, 'node_modules'));
     }
   } catch {}
+  for (const rel of trackedPackageNodeModules(mainCwd)) {
+    if (!dirs.includes(rel)) dirs.push(rel);
+  }
   return dirs;
 }
 
@@ -1013,11 +1035,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
@@ -1044,7 +1068,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

@@ -292,7 +292,8 @@ export async function finishCommand(feature, options = {}) {
   }
   const dirtLines = withoutLeftoverIgnore(cleanCwd, dirty.split(/\r?\n/).filter((l) => l.trim()));
   const testArtifacts = untrackedTestArtifacts(dirtLines);
-  if (dirtLines.length > testArtifacts.length) {
+  const commitState = dirtLines.length > testArtifacts.length && onlyFeatureStateDirty(cleanCwd, feature);
+  if (dirtLines.length > testArtifacts.length && !commitState) {
     emit({ finished: false, error: isWorktreeFlow ? 'worktree-dirty' : 'working-dir-dirty', hint: 'commit seu trabalho na branch antes do finish', feature });
     process.exit(1);
   }
@@ -341,6 +342,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);
+  if (commitState && !commitFeatureState(cleanCwd, feature)) {
+    emit({ finished: false, error: 'state-commit-failed', hint: `não foi possível commitar .morph/features/${feature} (identidade git ausente?) — commite o estado na branch e rode o finish de novo`, feature });
+    process.exit(1);
+  }
   if (isWorktreeFlow) {
     for (const p of testArtifacts) rmSync(join(cleanCwd, p), { recursive: true, force: true });
   }
@@ -409,6 +414,15 @@ export function finishPreflight({ feature, root, worktreePath, cwd, mode, branch
 
   if (defaultBranch) out.defaultBranch = defaultBranch;
 
+  try {
+    const tree = worktreePath || root;
+    const dirt = gitStatusPorcelain(tree);
+    const work = dirt === null ? [] : withoutLeftoverIgnore(tree, dirt.split(/\r?\n/).filter((l) => l.trim()));
+    if (work.length > untrackedTestArtifacts(work).length && onlyFeatureStateDirty(tree, feature)) {
+      out.wouldDo.unshift(`commitar o estado sujo de .morph/features/${feature} (${stateCommitMessage(feature)}) na branch ${branch}`);
+    }
+  } catch { /* o pré-voo nunca lança */ }
+
   // A retenção automática também é mutação do finish real; a contagem é a de AGORA, antes do
   // backup que este finish gravar.
   try {
@@ -808,6 +822,34 @@ function untrackedTestArtifacts(lines) {
     .filter((p) => isTestArtifact(p));
 }
 
+const stateCommitMessage = (feature) => `chore(morph): estado da feature ${feature}`;
+
+// `--untracked-files=all`: o porcelain padrão colapsa `?? .morph/` e esconderia sujeira fora do escopo.
+function onlyFeatureStateDirty(cwd, feature) {
+  let out;
+  try {
+    out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd, stdio: 'pipe' }).toString();
+  } catch {
+    return false;
+  }
+  const scope = `.morph/features/${feature}/`;
+  const paths = out.split(/\r?\n/).filter((l) => l.trim())
+    .flatMap((l) => l.slice(3).split(' -> '))
+    .map((p) => p.replace(/^"|"$/g, ''));
+  return paths.length > 0 && paths.every((p) => p.startsWith(scope));
+}
+
+function commitFeatureState(cwd, feature) {
+  const scope = `.morph/features/${feature}`;
+  try {
+    execFileSync('git', ['add', '-A', '--', scope], { cwd, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-q', '-m', stateCommitMessage(feature), '--', scope], { cwd, stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function gitStatusPorcelain(cwd) {
   try {
     return execFileSync('git', ['status', '--porcelain'], { cwd, stdio: 'pipe' }).toString();
@@ -901,7 +943,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/state/report-check.js

@@ -15,6 +15,7 @@ import { verifierModelFor } from '../../lib/risk-detector.js';
 import { changedPathsAgainst, detectDefaultBranch } from '../../lib/git/default-branch.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
 import { readPlanChecks } from '../../lib/plan/checks.js';
+import { isTestPath } from '../../lib/graph/sanitize.js';
 import { featureGeneratesMedia, collectReviewRequirement } from './gate-check.js';
 
 export { inspectReport, REPORT_MARKERS };
@@ -139,12 +140,45 @@ function decide(report, observed, stale) {
     : { verdict: 'no-work-no-report', action: 'redispatch' };
 }
 
+const isTestRef = (p) => isTestPath(p) || /\.(test|spec)\.[a-z]+$|Tests?\.cs$/i.test(p);
+
+/** Cn whose `**Checks:**` entry cites tests in more than one file, as `{ id, files }`. */
+export function checksSpread(body) {
+  const lines = String(body ?? '').split(/\r?\n/);
+  const start = lines.findIndex((l) => /^\s*(?:[-*]\s*)?\*\*checks\s*:?\*\*/i.test(l));
+  if (start < 0) return [];
+  const block = [lines[start].replace(/^.*?\*\*checks\s*:?\*\*\s*:?/i, '')];
+  for (const l of lines.slice(start + 1)) {
+    if (/^\s*(\*\*|#)/.test(l)) break;
+    block.push(l);
+  }
+  const filesByCn = new Map();
+  let current = null;
+  for (const piece of block.join('\n').split(/[;\n]/)) {
+    const lead = /^\s*(?:[-*]\s*)?\(?(C\d+)\b/.exec(piece);
+    if (lead) current = lead[1];
+    if (!current) continue;
+    const refs = (piece.match(/[\w@.\/\\-]+\.[A-Za-z]+/g) ?? []).map(slash).filter(isTestRef);
+    if (!filesByCn.has(current)) filesByCn.set(current, new Set());
+    for (const f of refs) filesByCn.get(current).add(f);
+  }
+  return [...filesByCn].filter(([, files]) => files.size > 1).map(([id, files]) => ({ id, files: [...files] }));
+}
+
+function spreadWarnings(fsPath) {
+  let body = '';
+  try { body = readFileSync(fsPath, 'utf8'); } catch { return []; }
+  return checksSpread(body).map(({ id, files }) =>
+    `${id} cita testes em ${files.length} arquivos (${files.join(', ')}): um teste por Cn, na camada mais baixa que o prova`);
+}
+
 function checkSlice(cwd, feature, slice, telemetry) {
   const fsPath = sliceReportPath(join(cwd, '.morph', 'features', feature), slice.id);
   const report = inspectReport(fsPath, { covers: slice.covers ?? [] });
   const observed = observedEvidence(telemetry, feature, slice);
   const stale = report.exists && isReportStale(fsPath, observed);
-  return { slice: slice.id, report, observed, ...decide(report, observed, stale) };
+  const warnings = report.exists ? spreadWarnings(fsPath) : [];
+  return { slice: slice.id, report, observed, warnings, ...decide(report, observed, stale) };
 }
 
 const ACTION_HINT = {
@@ -220,6 +254,7 @@ function printHuman(obj) {
       }
       console.log(chalk.gray(`      → ${r.hint}`));
     }
+    for (const w of r.warnings ?? []) console.log(chalk.yellow(`      ⚠ ${w}`));
   }
   for (const [role, r] of Object.entries(obj.reviews ?? {})) {
     if (!r.exists && role === 'security') continue;

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

@@ -309,6 +309,9 @@ export async function verifyCommand(featureName, options = {}) {
       for (const u of result.baseline.updates) {
         console.log(chalk.green(`  baseline ${u.id}: ${u.from ?? '—'} → ${u.to}`));
       }
+      for (const id of result.baseline.removed ?? []) {
+        console.log(chalk.gray(`  baseline ${id}: removida (runner sem baseline, só o piso zero)`));
+      }
       console.log(chalk.gray(`Gravada em ${result.baseline.path}
 `));
     }