@polymorphism-tech/morph-spec 8.42.0 → 8.43.0

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

@@ -30,16 +30,48 @@ import {
   isGitRepo,
   resolvePrimaryRoot,
   parseWorktreeList,
-  WORKTREE_DIR_NAMES,
   clearDanglingWorktreeRegistration,
 } from '../../commands/project/worktree.js';
+import { containerDirs, isUnder } from '../../../framework/hooks/shared/worktree-root.js';
 import { detectDefaultBranch } from '../git/default-branch.js';
 import { buildPrIndex } from '../git/pr-index.js';
 import { classifyBranch, commitsAhead, resolveBaseRef } from '../git/branch-classifier.js';
 import { auditDockerStacks } from './docker-audit.js';
 import { auditFinishBackups } from './finish-backup.js';
+import { planAgentReap } from './agent-reaper.js';
 
 const norm = (p) => resolve(p).replace(/\\/g, '/');
+const AGENT_TASK = /^agent-[0-9a-f]+$/;
+
+const AGENT_FIX = {
+  'stopped-clean': 'morph-spec worktree reap  (ou `morph-spec doctor --worktrees --prune`)',
+  'orphan-branch': 'morph-spec worktree reap  (ou `morph-spec doctor --worktrees --prune`)',
+  'directory-missing': 'morph-spec doctor --worktrees --prune',
+  locked: 'a árvore está com `git worktree lock`; `git worktree unlock <path>` libera, se o lock já não vale',
+  unknown: 'não foi possível provar que é seguro remover — deixe como está',
+};
+
+function agentLeftoverIssue(item) {
+  const where = item.path ?? item.branch;
+  const reapable = item.state === 'reapable';
+  const fix = AGENT_FIX[item.reason]
+    ?? (item.reason === 'exclusive-commits'
+      ? `integre a branch (\`git merge --no-ff ${item.branch}\` no orquestrador) antes de remover — ela é o único exemplar`
+      : item.reason === 'dirty'
+        ? `confira o trabalho na árvore (commite ou descarte) e rode \`morph-spec worktree remove --target "${item.path}"\``
+        : `o harness não registrou o fim do agente; se ele já terminou, \`morph-spec worktree remove --target "${item.path}"\``);
+  return {
+    type: 'agent-worktree-leftover',
+    severity: 'info',
+    ...(item.path ? { path: item.path } : {}),
+    branch: item.branch,
+    reapable,
+    detail: reapable
+      ? `${where} é sobra de sub-agent que já parou, sem trabalho pendente`
+      : `${where} é sobra de sub-agent com trabalho a preservar (${item.reason}${item.detail ? `: ${item.detail}` : ''})`,
+    fix,
+  };
+}
 
 /** Feature names morph knows about in the primary root. */
 function knownFeatures(root) {
@@ -170,15 +202,16 @@ function isEmptyDir(path) {
 /** Directories physically present under either worktree root. */
 function dirsOnDisk(root) {
   const found = [];
-  for (const dirName of WORKTREE_DIR_NAMES) {
-    const base = join(root, dirName);
+  const rootNorm = norm(root);
+  for (const base of containerDirs(root)) {
     if (!existsSync(base)) continue;
+    const label = base.startsWith(`${rootNorm}/`) ? base.slice(rootNorm.length + 1) : base;
     try {
       for (const name of readdirSync(base)) {
         const full = join(base, name);
         try {
           if (statSync(full).isDirectory()) {
-            found.push({ name, path: norm(full), container: dirName, empty: isEmptyDir(full) });
+            found.push({ name, path: norm(full), container: label, empty: isEmptyDir(full) });
           }
         } catch { /* unreadable entry — skip */ }
       }
@@ -214,6 +247,11 @@ function dirsOnDisk(root) {
  *                                 directory that exists but git's own
  *                                 registry does not know as a worktree
  *
+ *   • agent-worktree-leftover (info) — a sub-agent's `agent-<hex>` tree or
+ *                                 `morph-task/agent-<hex>` branch left behind:
+ *                                 `reapable` when the agent stopped and nothing
+ *                                 is lost, otherwise the reason it is kept
+ *
  *   • docker-stack-orphan (warn) — a `morph-*` docker stack of this repository
  *                                 still running for a feature this tree does
  *                                 not know, and
@@ -242,6 +280,7 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
   // two differently on purpose.
   const prIndex = buildPrIndex(root);
 
+  const containers = containerDirs(root);
   const registered = parseWorktreeList(root);
   const registeredPaths = new Set();
   const features = knownFeatures(root);
@@ -263,7 +302,7 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
 
     const feature = entry.branch?.match(/^refs\/heads\/morph\/(.+)$/)?.[1] || null;
     if (!feature) {
-      const inContainer = WORKTREE_DIR_NAMES.some((d) => path.startsWith(`${rootNorm}/${d}/`));
+      const inContainer = isUnder(containers, path);
       const task = entry.branch?.match(/^refs\/heads\/morph-task\/(.+)$/)?.[1] || null;
 
       if (!inContainer) {
@@ -287,6 +326,7 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
       }
 
       if (task) {
+        if (AGENT_TASK.test(task)) continue; // reported once, by the agent plan below
         // `morph-task/*`: a task-isolation tree provisioned by the WorktreeCreate
         // hook. Clean → nothing to say (the orchestrator removes it after the
         // merge). With commits the default does not have → report, never
@@ -367,6 +407,10 @@ export function auditWorktrees(cwd = process.cwd(), { exec } = {}) {
     }
   }
 
+  for (const item of planAgentReap(root, { cwd }).items) {
+    if (item.state === 'reapable' || item.state === 'preserved') issues.push(agentLeftoverIssue(item));
+  }
+
   for (const d of dirsOnDisk(root)) {
     if (registeredPaths.has(d.path)) continue;
     issues.push({

package/src/lib/worktree/worktree-include.js

@@ -0,0 +1,46 @@
+import { execFileSync } from 'node:child_process';
+import { copyFileSync, existsSync, lstatSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { isDisposableBuildArtifact } from './ignored-triage.js';
+
+const INCLUDE_FILE = '.worktreeinclude';
+const NESTED_GIT = /(^|\/)\.git(\/|$)/;
+
+const gitOut = (cwd, args, input) => execFileSync('git', args, { cwd, stdio: ['pipe', 'pipe', 'ignore'], encoding: 'utf8', input });
+
+/**
+ * Claude Code's `.worktreeinclude` for a worktree morph-spec creates (a WorktreeCreate hook replaces
+ * the native creation, so the native copy never runs): files matching a pattern AND gitignored in the
+ * tree are copied when the tree lacks them. Real files only; build artifacts and `node_modules` never.
+ *
+ * @returns {string[]} relative paths copied
+ */
+export function copyWorktreeIncludes(worktreePath, root) {
+  const file = join(root, INCLUDE_FILE);
+  if (!existsSync(file)) return [];
+  try {
+    // No --exclude-standard: with --ignored it would list every gitignored file, not just the pattern matches.
+    const matched = gitOut(root, ['ls-files', '--others', '--ignored', '--exclude-from', file, '-z'])
+      .split('\0').filter(Boolean).map((p) => p.replace(/\\/g, '/'))
+      .filter((p) => !NESTED_GIT.test(p) && !isDisposableBuildArtifact(p));
+    if (!matched.length) return [];
+
+    const ignoredThere = new Set(gitOut(worktreePath, ['check-ignore', '--stdin', '-z'], `${matched.join('\0')}\0`).split('\0').filter(Boolean));
+    const copied = [];
+    for (const rel of matched) {
+      if (!ignoredThere.has(rel)) continue;
+      const src = join(root, rel);
+      const dst = join(worktreePath, rel);
+      try {
+        if (!lstatSync(src).isFile()) continue;
+        try { lstatSync(dst); continue; } catch { /* absent, and not a dangling link either */ }
+        mkdirSync(dirname(dst), { recursive: true });
+        copyFileSync(src, dst);
+        copied.push(rel);
+      } catch { /* unreadable or unwritable — leave it out */ }
+    }
+    return copied;
+  } catch {
+    return [];
+  }
+}

package/src/scripts/setup-infra.js

@@ -25,6 +25,7 @@ import {
   ensureGitattributes
 } from '../utils/file-copier.js';
 import { parseStacks, getProjectTags, shouldInstall } from '../lib/stack-filter.js';
+import { applyEditorSettings } from '../lib/worktree/vscode-settings.js';
 import { injectMorphImport } from '../utils/claude-md-injector.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion, getProjectMorphVersion } from '../utils/version-checker.js';
 import { installClaudeHooks, installGlobalStatusline } from '../utils/claude-settings-manager.js';
@@ -440,6 +441,9 @@ export async function setupInfra(targetPath, {
   await updateGitignore(targetPath);
   await ensureGitattributes(targetPath);
 
+  log('Step 18a: Editor excludes for worktrees...');
+  try { applyEditorSettings(targetPath); } catch { /* fail-open */ }
+
   // --- 18b. Codebase graph (graphify) ---
   // Fail-open por inteiro (ADR-002): sem Python, sem uv e sem pipx, o step
   // registra e segue. O wrapper de CLI mata o processo em qualquer throw

package/src/utils/hooks-installer.js

@@ -52,8 +52,11 @@ import { realEffects } from '../lib/installers/effects.js';
  * 3.11.0 writes every `timeout` in seconds, the unit Claude Code reads: the
  * values were milliseconds, so a hung hook held the session for hours (120000
  * on WorktreeCreate is 33 h) instead of the seconds they meant.
+ *
+ * 3.12.0 adds heavy-gate to the Bash PreToolUse chain and heavy-release to the
+ * PostToolUse and PostToolUseFailure chains: the opt-in `heavy.gateBash`.
  */
-const HOOKS_VERSION = '3.11.0';
+const HOOKS_VERSION = '3.12.0';
 
 /** Marker for old dispatch.js (v1) */
 const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
@@ -165,6 +168,8 @@ const MORPH_HOOKS = [
   // on someone having read MORPH.md. block-raw-worktree-add is its way-IN
   // counterpart (a raw `git worktree add` builds a tree with no junctions, no
   // ports, no identity) — static, so it costs nothing after the first two.
+  // heavy-gate comes after every guard — it takes a slot, and a command a guard
+  // blocks must not hold one — and before the rewriter.
   // worktree-env-inject is LAST: it rewrites launcher commands (updatedInput)
   // with the worktree's port block, and a command a previous link blocked must
   // never be rewritten. Block-first-wins guarantees it never sees one.
@@ -174,7 +179,7 @@ const MORPH_HOOKS = [
     hooks: [{
       type: 'command',
       command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['pre-bash-denylist', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'worktree-env-inject']
+      args: ['pre-bash-denylist', 'block-destructive-worktree-removal', 'block-raw-worktree-add', 'heavy-gate', 'worktree-env-inject']
     }]
   },
 
@@ -264,19 +269,21 @@ const MORPH_HOOKS = [
     hooks: [{
       type: 'command',
       command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['telemetry-log', 'loop-detect', 'graph-refresh-kick'],
+      args: ['telemetry-log', 'loop-detect', 'graph-refresh-kick', 'heavy-release'],
       timeout: 10
     }]
   },
 
   // === PostToolUseFailure: All — telemetry of the failed call (exit code,
   // duration). loop-detect stays out: its warning is shaped for PostToolUse.
+  // heavy-release gives back the slot of a heavy Bash call that failed.
   {
     event: 'PostToolUseFailure',
     matcher: null,
     hooks: [{
       type: 'command',
-      command: 'node framework/hooks/claude-code/core/telemetry-log.js',
+      command: 'node framework/hooks/claude-code/core/chain.js',
+      args: ['telemetry-log', 'heavy-release'],
       timeout: 5,
       async: true
     }]