@polymorphism-tech/morph-spec 8.32.0 → 8.34.2

package/framework/hooks/git/pre-commit/orchestrator.sh

@@ -1,64 +1,64 @@
-#!/usr/bin/env bash
-# Scope: universal | Orchestrates framework + stack-specific pre-commit hooks
-# MORPH-SPEC Master Pre-Commit Hook
-# Runs universal framework hooks + stack-specific hooks in sequence
-
-echo "╔════════════════════════════════════════════════╗"
-echo "║     MORPH-SPEC PRE-COMMIT VALIDATION           ║"
-echo "╚════════════════════════════════════════════════╝"
-echo ""
-
-FRAMEWORK_HOOKS_DIR="$(dirname "$0")"
-STACK_HOOKS_DIR=".morph/hooks/pre-commit"
-
-HAS_FAILURES=false
-
-# Run framework hooks (universal - all stacks)
-echo "📦 Running framework hooks (universal)..."
-for hook in "$FRAMEWORK_HOOKS_DIR"/*.sh; do
-  # Skip orchestrator itself
-  if [[ "$hook" == */orchestrator.sh ]]; then
-    continue
-  fi
-
-  if [[ -f "$hook" ]]; then
-    hook_name=$(basename "$hook")
-    echo "─────────────────────────────────────────────────"
-    if ! bash "$hook"; then
-      HAS_FAILURES=true
-      echo "❌ Framework hook failed: $hook_name"
-    fi
-    echo ""
-  fi
-done
-
-# Run stack-specific hooks (if exist)
-if [[ -d "$STACK_HOOKS_DIR" ]]; then
-  echo "🎯 Running stack-specific hooks..."
-  for hook in "$STACK_HOOKS_DIR"/*.sh; do
-    if [[ -f "$hook" ]]; then
-      hook_name=$(basename "$hook")
-      echo "─────────────────────────────────────────────────"
-      if ! bash "$hook"; then
-        HAS_FAILURES=true
-        echo "❌ Stack hook failed: $hook_name"
-      fi
-      echo ""
-    fi
-  done
-else
-  echo "ℹ️  No stack-specific hooks found (optional)"
-  echo ""
-fi
-
-echo "═════════════════════════════════════════════════"
-
-if [[ "$HAS_FAILURES" == "true" ]]; then
-  echo "❌ PRE-COMMIT VALIDATION FAILED"
-  echo "   Fix errors above before committing"
-  echo "   Or use: git commit --no-verify to skip"
-  exit 1
-fi
-
-echo "✅ ALL PRE-COMMIT VALIDATIONS PASSED"
-exit 0
+#!/usr/bin/env bash
+# Scope: universal | Orchestrates framework + stack-specific pre-commit hooks
+# MORPH-SPEC Master Pre-Commit Hook
+# Runs universal framework hooks + stack-specific hooks in sequence
+
+echo "╔════════════════════════════════════════════════╗"
+echo "║     MORPH-SPEC PRE-COMMIT VALIDATION           ║"
+echo "╚════════════════════════════════════════════════╝"
+echo ""
+
+FRAMEWORK_HOOKS_DIR="$(dirname "$0")"
+STACK_HOOKS_DIR=".morph/hooks/pre-commit"
+
+HAS_FAILURES=false
+
+# Run framework hooks (universal - all stacks)
+echo "📦 Running framework hooks (universal)..."
+for hook in "$FRAMEWORK_HOOKS_DIR"/*.sh; do
+  # Skip orchestrator itself
+  if [[ "$hook" == */orchestrator.sh ]]; then
+    continue
+  fi
+
+  if [[ -f "$hook" ]]; then
+    hook_name=$(basename "$hook")
+    echo "─────────────────────────────────────────────────"
+    if ! bash "$hook"; then
+      HAS_FAILURES=true
+      echo "❌ Framework hook failed: $hook_name"
+    fi
+    echo ""
+  fi
+done
+
+# Run stack-specific hooks (if exist)
+if [[ -d "$STACK_HOOKS_DIR" ]]; then
+  echo "🎯 Running stack-specific hooks..."
+  for hook in "$STACK_HOOKS_DIR"/*.sh; do
+    if [[ -f "$hook" ]]; then
+      hook_name=$(basename "$hook")
+      echo "─────────────────────────────────────────────────"
+      if ! bash "$hook"; then
+        HAS_FAILURES=true
+        echo "❌ Stack hook failed: $hook_name"
+      fi
+      echo ""
+    fi
+  done
+else
+  echo "ℹ️  No stack-specific hooks found (optional)"
+  echo ""
+fi
+
+echo "═════════════════════════════════════════════════"
+
+if [[ "$HAS_FAILURES" == "true" ]]; then
+  echo "❌ PRE-COMMIT VALIDATION FAILED"
+  echo "   Fix errors above before committing"
+  echo "   Or use: git commit --no-verify to skip"
+  exit 1
+fi
+
+echo "✅ ALL PRE-COMMIT VALIDATIONS PASSED"
+exit 0

package/framework/hooks/git/pre-commit/specs.sh

@@ -1,50 +1,50 @@
-#!/bin/bash
-# Scope: universal | Validates spec.md required sections
-# MORPH-SPEC Pre-Commit Hook: Spec Validation
-# Validates that spec.md files have required sections
-
-echo "🔍 Validating spec files..."
-
-# Find modified spec.md files
-SPEC_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep 'spec\.md$')
-
-if [ -z "$SPEC_FILES" ]; then
-  echo "✓ No spec files modified"
-  exit 0
-fi
-
-HAS_ERRORS=false
-
-for spec_file in $SPEC_FILES; do
-  echo "Checking: $spec_file"
-
-  # Required sections
-  REQUIRED_SECTIONS=(
-    "## 📋 Metadata"
-    "## 🎯 Overview"
-    "## 🏗️ Technical Design"
-    "## ✅ Acceptance Criteria"
-  )
-
-  for section in "${REQUIRED_SECTIONS[@]}"; do
-    if ! grep -q "$section" "$spec_file"; then
-      echo "  ❌ Missing section: $section"
-      HAS_ERRORS=true
-    fi
-  done
-
-  # Check if has at least one user story or requirement
-  if ! grep -qi "user story\|requirement\|acceptance criteria" "$spec_file"; then
-    echo "  ⚠️  Warning: No user stories or requirements found"
-  fi
-done
-
-if [ "$HAS_ERRORS" = true ]; then
-  echo ""
-  echo "❌ COMMIT BLOCKED: spec.md files are incomplete"
-  echo "   Add missing sections before committing"
-  exit 1
-fi
-
-echo "✓ All spec files are valid"
-exit 0
+#!/bin/bash
+# Scope: universal | Validates spec.md required sections
+# MORPH-SPEC Pre-Commit Hook: Spec Validation
+# Validates that spec.md files have required sections
+
+echo "🔍 Validating spec files..."
+
+# Find modified spec.md files
+SPEC_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep 'spec\.md$')
+
+if [ -z "$SPEC_FILES" ]; then
+  echo "✓ No spec files modified"
+  exit 0
+fi
+
+HAS_ERRORS=false
+
+for spec_file in $SPEC_FILES; do
+  echo "Checking: $spec_file"
+
+  # Required sections
+  REQUIRED_SECTIONS=(
+    "## 📋 Metadata"
+    "## 🎯 Overview"
+    "## 🏗️ Technical Design"
+    "## ✅ Acceptance Criteria"
+  )
+
+  for section in "${REQUIRED_SECTIONS[@]}"; do
+    if ! grep -q "$section" "$spec_file"; then
+      echo "  ❌ Missing section: $section"
+      HAS_ERRORS=true
+    fi
+  done
+
+  # Check if has at least one user story or requirement
+  if ! grep -qi "user story\|requirement\|acceptance criteria" "$spec_file"; then
+    echo "  ⚠️  Warning: No user stories or requirements found"
+  fi
+done
+
+if [ "$HAS_ERRORS" = true ]; then
+  echo ""
+  echo "❌ COMMIT BLOCKED: spec.md files are incomplete"
+  echo "   Add missing sections before committing"
+  exit 1
+fi
+
+echo "✓ All spec files are valid"
+exit 0

package/framework/hooks/git/pre-push/run-tests.sh

@@ -1,44 +1,44 @@
-#!/usr/bin/env bash
-# Scope: universal | Runs test suite before push
-# MORPH-SPEC Pre-Push Hook
-# Ensures all tests pass before pushing to remote
-
-echo "🧪 Running test suite before push..."
-echo ""
-
-# Detect project type and run appropriate tests
-if [[ -f *.csproj ]] || find . -maxdepth 2 -name "*.csproj" 2>/dev/null | grep -q .; then
-  # .NET project detected
-  echo "📦 Detected .NET project"
-
-  if ! dotnet test --verbosity minimal --no-build --no-restore 2>/dev/null; then
-    echo ""
-    echo "❌ .NET tests failed!"
-    echo ""
-    echo "Fix failing tests before pushing."
-    echo "Override with: git push --no-verify"
-    exit 1
-  fi
-
-elif [[ -f package.json ]]; then
-  # Node.js project detected
-  echo "📦 Detected Node.js project"
-
-  if ! npm test 2>/dev/null; then
-    echo ""
-    echo "❌ Node.js tests failed!"
-    echo ""
-    echo "Fix failing tests before pushing."
-    echo "Override with: git push --no-verify"
-    exit 1
-  fi
-
-else
-  echo "⚠️  No recognized test framework found"
-  echo "   Skipping test execution"
-  exit 0
-fi
-
-echo ""
-echo "✅ All tests passed - safe to push"
-exit 0
+#!/usr/bin/env bash
+# Scope: universal | Runs test suite before push
+# MORPH-SPEC Pre-Push Hook
+# Ensures all tests pass before pushing to remote
+
+echo "🧪 Running test suite before push..."
+echo ""
+
+# Detect project type and run appropriate tests
+if [[ -f *.csproj ]] || find . -maxdepth 2 -name "*.csproj" 2>/dev/null | grep -q .; then
+  # .NET project detected
+  echo "📦 Detected .NET project"
+
+  if ! dotnet test --verbosity minimal --no-build --no-restore 2>/dev/null; then
+    echo ""
+    echo "❌ .NET tests failed!"
+    echo ""
+    echo "Fix failing tests before pushing."
+    echo "Override with: git push --no-verify"
+    exit 1
+  fi
+
+elif [[ -f package.json ]]; then
+  # Node.js project detected
+  echo "📦 Detected Node.js project"
+
+  if ! npm test 2>/dev/null; then
+    echo ""
+    echo "❌ Node.js tests failed!"
+    echo ""
+    echo "Fix failing tests before pushing."
+    echo "Override with: git push --no-verify"
+    exit 1
+  fi
+
+else
+  echo "⚠️  No recognized test framework found"
+  echo "   Skipping test execution"
+  exit 0
+fi
+
+echo ""
+echo "✅ All tests passed - safe to push"
+exit 0

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

@@ -0,0 +1,23 @@
+/**
+ * command-tokens.js — shell-ish tokenizer shared by the PreToolUse Bash guards.
+ *
+ * Lives in shared/ (not inside a hook) on purpose: every core hook ends in a
+ * standalone tail that reads stdin and exits, so a hook importing a sibling
+ * hook for a helper would fire THAT tail in its own process — consuming the
+ * payload and exiting before the importer ever ran. block-raw-worktree-add
+ * and block-destructive-worktree-removal both read paths off these tokens,
+ * so they agree on what a quoted path is.
+ */
+
+/**
+ * Split a shell-ish command into tokens, honoring single and double quotes.
+ * @param {string} command
+ * @returns {string[]}
+ */
+export function tokenize(command) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(String(command || ''))) !== null) tokens.push(m[1] ?? m[2] ?? m[3]);
+  return tokens;
+}

package/framework/hooks/shared/git-paths.js

@@ -58,6 +58,31 @@ function findDotGit(startDir) {
   }
 }
 
+/**
+ * Is `startDir` inside a LINKED (secondary) worktree?
+ *
+ * Same on-disk fact `resolveGitCommonDir` reads: git represents a linked
+ * worktree's `.git` as a FILE holding a `gitdir:` pointer, and a primary
+ * checkout's `.git` as a DIRECTORY. The e2e isolation rule keys on this —
+ * a compose that cannot be isolated is a hard failure only where a second
+ * stack could actually collide with the primary's (see e2e-check.js
+ * `decideIsolation`).
+ *
+ * Fail-open: outside any repo, or on an unreadable path, answers `false` —
+ * the lenient direction (warn instead of fail).
+ *
+ * @param {string} startDir
+ * @returns {boolean}
+ */
+export function isSecondaryWorktree(startDir) {
+  try {
+    const found = findDotGit(startDir);
+    return Boolean(found && !found.isDirectory);
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Resolve the git COMMON dir for `startDir` — pure filesystem, no subprocess.
  * Always returns an absolute path (unlike `git rev-parse --git-common-dir`,

package/framework/hooks/shared/hook-response.js

@@ -122,3 +122,20 @@ export async function runStandalone(run) {
   }
   process.exit(0);
 }
+
+/**
+ * Pure builder for a PreToolUse rewrite: Claude Code runs the tool with
+ * `updatedInput` in place of the original `tool_input`, and the decision is
+ * an explicit `allow` (a rewrite without a decision is ignored). Use it ONLY
+ * when the hook actually changed something — an unconditional `allow` would
+ * skip the permission prompt for every call it touches.
+ *
+ * @param {object} updatedInput - the full replacement tool_input
+ * @param {string} eventName - 'PreToolUse'
+ * @param {string} [context] - optional additionalContext (what was changed)
+ */
+export function updatedInputResult(updatedInput, eventName, context) {
+  const out = { hookEventName: eventName, permissionDecision: 'allow', updatedInput };
+  if (context) out.additionalContext = context;
+  return { hookSpecificOutput: out };
+}

package/framework/hooks/shared/morph-cli.js

@@ -0,0 +1,134 @@
+/**
+ * morph-cli.js — run the morph-spec CLI from inside a hook.
+ *
+ * Hooks are installed STANDALONE into `.morph/framework/hooks/` and may never
+ * import from `src/`; the only way for a hook to reuse a CLI command (the
+ * WorktreeCreate hook needs `worktree setup`/`provision`, WorktreeRemove needs
+ * `worktree remove --if-clean`) is to spawn the CLI as a subprocess. This
+ * module is the ONE place that knows how to find it.
+ *
+ * Resolution order:
+ *   1. `MORPH_SPEC_BIN` — an explicit command, possibly with leading args and
+ *      quoted paths (`node "R:/my repo/bin/morph-spec.js"`). What tests and a
+ *      framework checkout use.
+ *   2. `morph-spec` on PATH — the npm-installed bin. On win32 the shim is
+ *      `morph-spec.cmd`, which Node refuses to spawn without a shell, so it is
+ *      located by scanning PATH ourselves and then run through the shell with
+ *      each arg quoted; on POSIX a plain `shell:false` spawn.
+ *   3. `npx --no-install morph-spec` — a project-local dependency.
+ *
+ * ENOENT (or the shell's "not recognized"/"could not determine executable")
+ * everywhere → `{ unavailable: true }`, never a throw: the caller decides what
+ * degraded behavior looks like.
+ *
+ * `json` is the LAST line of stdout that parses as a JSON object (the CLI's
+ * commands print exactly one JSON line; anything a stray console.log adds
+ * before it is skipped), or null.
+ */
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { delimiter, join } from 'path';
+
+/** Split a command string into argv, honoring single and double quotes. */
+function splitCommand(command) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(command)) !== null) tokens.push(m[1] ?? m[2] ?? m[3]);
+  return tokens;
+}
+
+/** Quote one argument for cmd.exe (the only shell path this module uses). */
+function quoteForCmd(arg) {
+  if (arg === '') return '""';
+  if (!/[\s"&|<>^()]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+/** First PATH entry holding `file`, or null. */
+function findOnPath(file, env) {
+  const raw = env.PATH || env.Path || env.path || '';
+  for (const dir of raw.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, file);
+    try { if (existsSync(candidate)) return candidate; } catch { /* unreadable entry */ }
+  }
+  return null;
+}
+
+/** Last stdout line that parses as a JSON object, or null. */
+export function lastJsonLine(stdout) {
+  const lines = String(stdout || '').split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (!lines[i].startsWith('{')) continue;
+    try {
+      const parsed = JSON.parse(lines[i]);
+      if (parsed && typeof parsed === 'object') return parsed;
+    } catch { /* not this line */ }
+  }
+  return null;
+}
+
+/**
+ * The candidates to try, in order. Each is `{ file, args, shell }`.
+ * @param {NodeJS.ProcessEnv} env
+ */
+function candidates(env) {
+  const list = [];
+  const explicit = env.MORPH_SPEC_BIN && splitCommand(env.MORPH_SPEC_BIN);
+  if (explicit && explicit.length) {
+    list.push({ file: explicit[0], args: explicit.slice(1), shell: false, kind: 'env' });
+  }
+  if (process.platform === 'win32') {
+    const cmd = findOnPath('morph-spec.cmd', env);
+    if (cmd) list.push({ file: cmd, args: [], shell: true, kind: 'path' });
+    const npx = findOnPath('npx.cmd', env);
+    if (npx) list.push({ file: npx, args: ['--no-install', 'morph-spec'], shell: true, kind: 'npx' });
+  } else {
+    list.push({ file: 'morph-spec', args: [], shell: false, kind: 'path' });
+    list.push({ file: 'npx', args: ['--no-install', 'morph-spec'], shell: false, kind: 'npx' });
+  }
+  return list;
+}
+
+const NOT_FOUND_RE = /not recognized as an internal or external command|could not determine executable to run|command not found|ENOENT/i;
+
+/**
+ * Run `morph-spec <args>` and return its result.
+ *
+ * @param {string[]} args - CLI argv after the program name
+ * @param {{ cwd?: string, timeoutMs?: number, env?: NodeJS.ProcessEnv }} [opts]
+ * @returns {{ ok: boolean, code: number|null, stdout: string, stderr: string, json: object|null, unavailable: boolean }}
+ */
+export function runMorphSpec(args, { cwd, timeoutMs = 120000, env } = {}) {
+  const runEnv = env || process.env;
+  const argv = Array.isArray(args) ? args.map(String) : [];
+
+  for (const cand of candidates(runEnv)) {
+    let r;
+    try {
+      const full = [...cand.args, ...argv];
+      r = cand.shell
+        ? spawnSync(quoteForCmd(cand.file), full.map(quoteForCmd), { cwd, env: runEnv, encoding: 'utf8', timeout: timeoutMs, shell: true, stdio: ['ignore', 'pipe', 'pipe'] })
+        : spawnSync(cand.file, full, { cwd, env: runEnv, encoding: 'utf8', timeout: timeoutMs, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (err) {
+      if (err?.code === 'ENOENT') continue;
+      return { ok: false, code: null, stdout: '', stderr: String(err?.message || err), json: null, unavailable: false };
+    }
+    if (r.error) {
+      if (r.error.code === 'ENOENT') continue;
+      return { ok: false, code: null, stdout: r.stdout || '', stderr: String(r.error.message || r.error), json: null, unavailable: false };
+    }
+    const stdout = r.stdout || '';
+    const stderr = r.stderr || '';
+    // The npx/shell paths cannot surface ENOENT: the shell (or npx itself)
+    // reports "not found" as a non-zero exit with a message. Only those two
+    // kinds are read that way — a real morph-spec failure is never mistaken
+    // for absence.
+    if (cand.kind !== 'env' && r.status !== 0 && !stdout.trim() && NOT_FOUND_RE.test(stderr)) continue;
+    return { ok: r.status === 0, code: r.status, stdout, stderr, json: lastJsonLine(stdout), unavailable: false };
+  }
+
+  return { ok: false, code: null, stdout: '', stderr: 'morph-spec CLI not found (MORPH_SPEC_BIN, PATH, npx)', json: null, unavailable: true };
+}

package/framework/hooks/shared/stdin-reader.js

@@ -1,26 +1,26 @@
-/**
- * Shared stdin reader for Claude Code hooks.
- *
- * Reads JSON payload from stdin (provided by Claude Code to hooks).
- * Returns parsed object or null on failure.
- */
-
-/**
- * Read and parse JSON from stdin
- * @returns {Promise<Object|null>} Parsed JSON or null
- */
-export function readStdin() {
-  return new Promise((resolve) => {
-    let input = '';
-    process.stdin.setEncoding('utf-8');
-    process.stdin.on('data', (chunk) => { input += chunk; });
-    process.stdin.on('end', () => {
-      try {
-        resolve(JSON.parse(input || '{}'));
-      } catch {
-        resolve(null);
-      }
-    });
-    process.stdin.on('error', () => resolve(null));
-  });
-}
+/**
+ * Shared stdin reader for Claude Code hooks.
+ *
+ * Reads JSON payload from stdin (provided by Claude Code to hooks).
+ * Returns parsed object or null on failure.
+ */
+
+/**
+ * Read and parse JSON from stdin
+ * @returns {Promise<Object|null>} Parsed JSON or null
+ */
+export function readStdin() {
+  return new Promise((resolve) => {
+    let input = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(input || '{}'));
+      } catch {
+        resolve(null);
+      }
+    });
+    process.stdin.on('error', () => resolve(null));
+  });
+}

package/framework/rules/infrastructure-standards.md

@@ -11,6 +11,8 @@ stacks:
 # Infrastructure Standards
 
 @.morph/framework/standards/infrastructure/docker/coolify-deploy.md
+@.morph/framework/standards/infrastructure/docker/local-compose-isolation.md
+@.morph/framework/standards/infrastructure/docker/local-compose-isolation.md
 
 ## Infrastructure Templates
 
@@ -18,7 +20,7 @@ stacks:
 |----------|------|---------|
 | .NET API Dockerfile | `.morph/framework/templates/infrastructure/docker/dockerfile-api.dockerfile` | Multi-stage .NET |
 | Next.js Dockerfile | `.morph/framework/templates/infrastructure/docker/dockerfile-web.dockerfile` | Multi-stage Next.js |
-| Docker Compose | `.morph/framework/templates/infrastructure/docker/docker-compose.template.yml` | Local dev env |
+| Docker Compose | `.morph/framework/templates/infrastructure/docker/docker-compose.template.yml` | Local dev env — one isolated stack per worktree (ports from the block, no `container_name`) |
 | Coolify Config | `.morph/framework/templates/infrastructure/docker/coolify.template.json` | Deployment config |
 | .NET Build CI | `.morph/framework/templates/infrastructure/github/workflows/dotnet-build.yml.hbs` | CI workflow |
 | Docker Push CI | `.morph/framework/templates/infrastructure/github/workflows/docker-build-push.yml.hbs` | Build & push |

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-invoke: ao iniciar um novo projeto de LP com o template Umbraco genérico
 user-invokable: true
-cliVersion: "8.32.0"
+cliVersion: "8.34.2"
 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-invoke: ao receber instrução "use /migrate-lp-to-umbraco {projeto}" do usuário, ou quando o usuário descrever necessidade de migrar uma LP para Umbraco
 user-invokable: true
-cliVersion: "8.32.0"
+cliVersion: "8.34.2"
 stacks:
   - umbraco
 ---

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

@@ -4,7 +4,7 @@ description: Orquestra a execução autônoma de tasks de uma feature morph-spec
 version: core
 when-to-invoke: após Gate 2 aprovado, ao receber instrução "use /morph-apply" ou "implementar feature"
 user-invokable: true
-cliVersion: "8.32.0"
+cliVersion: "8.34.2"
 ---
 
 # morph-apply
@@ -202,10 +202,10 @@ Depois do batch paralelo, executar o restante em modo sequencial (passo 3a).
 
 Quando o `morph-spec dag {feature}` reporta `isolation.recommended: "worktree"` (dois fluxos paralelos planejam escrever no mesmo path — colisão de `outputs`), despache cada fluxo com o parâmetro `isolation: "worktree"` do tool Agent. Cada agente trabalha numa working tree própria; build/test rodam lá dentro sem colidir.
 
-1. **Dispatch:** mesmo `subagent_type: "morph-{id}"` e standards de §3b, mais `isolation: "worktree"`. Se a stack for Node e faltar `node_modules` no worktree, o agente roda `morph-spec worktree link` (fail-open) antes de testar; se ainda impossível, reporta "verificação: não executada" (o verify pós-merge cobre). Se o agente precisar subir um dev server e existir `.morph/worktree.env` no seu cwd, usa as portas de lá (nunca as padrão — MORPH.md §2.2). O agente commita na branch do worktree e reporta a branch.
+1. **Dispatch:** mesmo `subagent_type: "morph-{id}"` e standards de §3b, mais `isolation: "worktree"`. O worktree vem do hook `WorktreeCreate` do morph: nasce em `worktrees/<n>` na branch `morph-task/<n>`, com junctions (`node_modules`, `.claude`, `.morph/framework`) e `.morph/worktree.env` já prontos — se faltar infra mesmo assim, o agente roda `morph-spec worktree link --all` (fail-open); se ainda impossível, reporta "verificação: não executada" (o verify pós-merge cobre). Dev server/compose dentro do worktree já sai nas portas do bloco (o hook `worktree-env-inject` prefixa o comando; fora do Claude, `eval "$(morph-spec env)"`). O agente commita na branch do worktree como último ato e reporta a branch.
 2. **Integração (orquestrador, após todos os relatórios):** faça o merge de cada branch reportada, uma por vez, na ordem de chegada — `git merge --no-ff <branch>`. Conflito → `git merge --abort`, marque a task de volta a `pending` com nota "merge conflict — reexecutar sequencial", siga para a próxima branch. Os paths em conflito são exatamente os de `isolation.collisions` do dag.
 3. **Pós-merge:** rode `morph-spec verify {feature} --json` UMA vez (o merge é o novo ponto de integração — verificação compartilhada obrigatória), depois `morph-eval` + `morph-spec score` por relatório, como em §3b.
-4. **Cleanup:** `morph-spec worktree remove --target <path>` por worktree (NUNCA `git worktree remove` cru — o passo 1 pode ter criado junction de `node_modules`, e a remoção crua a atravessa e apaga o `node_modules` da raiz) + `git branch -d` das branches integradas + `git worktree prune` (fail-open). Branches não integradas ficam e são registradas no recap com o motivo.
+4. **Cleanup:** o hook `WorktreeRemove` remove o worktree **limpo** ao fim do subagent (branch sobrevive) — mas não conte com ele: rode `morph-spec worktree remove --target <path>` por worktree que sobrou (NUNCA `git worktree remove` cru — as junctions do passo 1 seriam atravessadas e o `node_modules`/`.claude` da raiz apagados) + `git branch -d morph-task/<n>` das branches integradas + `git worktree prune` (fail-open). Worktree sujo (subagent não commitou) fica, vira `unintegrated-work` no `doctor --worktrees`, e a task volta a `pending`. Branches não integradas ficam e são registradas no recap com o motivo.
 5. **Agente morto no meio:** se commitou, a branch sobrevive (retomável); senão, a task volta a `pending` na lane sequencial. Registre a falha de protocolo no recap.
 
 > Anti-padrões: não misture unidades isoladas e não-isoladas no mesmo batch; o subagent nunca faz merge (integração é exclusiva do orquestrador).