@polymorphism-tech/morph-spec 8.41.0 → 8.43.0

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']
     }]
   },
 
@@ -216,14 +221,15 @@ const MORPH_HOOKS = [
   // order as before. post-edit-typecheck declared no timeout of its own (it
   // can legitimately spend up to its internal TSC_TIMEOUT_MS=30000 running
   // `npx tsc --noEmit`), so the chain declares none rather than under-
-  // provisioning it with just the sum of the other two links' 3000ms each. ===
+  // provisioning it with just the sum of the other two links' 3000ms each.
+  // comment-guard is LAST: it blocks, and a block ends the chain. ===
   {
     event: 'PostToolUse',
     matcher: 'Write|Edit',
     hooks: [{
       type: 'command',
       command: 'node framework/hooks/claude-code/core/chain.js',
-      args: ['post-edit-typecheck', 'tasks-json-guard', 'trace-autogen']
+      args: ['post-edit-typecheck', 'tasks-json-guard', 'trace-autogen', 'comment-guard']
     }]
   },
 
@@ -263,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
     }]