@shirayner/ace 0.1.7 → 0.1.8-SNAPSHOT.1

package/src/commands/list.js

@@ -67,6 +67,11 @@ async function getComponentStatus(component) {
     } catch { /* ignore */ }
   }
 
+  if (component.recursiveDir) {
+    const collected = await collectMdFiles(path.join(TEMPLATES_DIR, component.recursiveDir), component.recursiveDir);
+    allPaths.push(...collected.map(f => path.join(CLAUDE_DIR, f)));
+  }
+
   if (component.files) {
     allPaths.push(...component.files.map(f => path.join(CLAUDE_DIR, f.dest)));
   }
@@ -101,6 +106,11 @@ async function getComponentDetails(component) {
     } catch { /* ignore */ }
   }
 
+  if (component.recursiveDir) {
+    const collected = await collectMdFiles(path.join(TEMPLATES_DIR, component.recursiveDir), component.recursiveDir);
+    allFiles.push(...collected);
+  }
+
   allFiles.push(
     ...(component.files || []).map(f => f.dest),
     ...(component.directories || []),
@@ -115,3 +125,19 @@ async function getComponentDetails(component) {
 
   return { missing, installed };
 }
+
+async function collectMdFiles(dir, relBase) {
+  const results = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const rel = path.join(relBase, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await collectMdFiles(path.join(dir, entry.name), rel));
+      } else if (entry.name.endsWith('.md')) {
+        results.push(rel);
+      }
+    }
+  } catch { /* ignore */ }
+  return results;
+}

package/src/commands/spec.js

@@ -1,7 +1,9 @@
 import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
+import * as p from '@clack/prompts';
 import { SpecInstaller } from '../core/spec-installer.js';
+import { TeamInstaller } from '../core/team-installer.js';
 
 export async function specInitCommand(targetPath, options) {
   const targetDir = targetPath ? path.resolve(targetPath) : process.cwd();
@@ -31,6 +33,61 @@ export async function specInitCommand(targetPath, options) {
     spinner.fail(`Unexpected error: ${err.message}`);
     process.exit(1);
   }
+
+  // ─── Team conventions initialization ───────────────
+  await initTeamConventions(targetDir, options);
+}
+
+async function initTeamConventions(targetDir, options) {
+  let repoUrl = options.teamRepo;
+
+  if (!repoUrl) {
+    const shouldInit = await p.confirm({
+      message: 'Initialize team conventions from a Git repository?',
+      initialValue: false,
+    });
+
+    if (p.isCancel(shouldInit) || !shouldInit) return;
+
+    const urlInput = await p.text({
+      message: 'Enter the Git repository URL for team conventions:',
+      placeholder: 'https://gitlab.example.com/team/conventions.git',
+      validate: (value) => {
+        if (!value || value.trim().length === 0) return 'URL is required';
+        if (!value.match(/^(https?:\/\/|git@)/)) return 'Must be a valid git URL (https:// or git@)';
+      },
+    });
+
+    if (p.isCancel(urlInput)) return;
+    repoUrl = urlInput.trim();
+  }
+
+  const spinner = ora('Cloning team conventions...').start();
+
+  try {
+    const teamInstaller = new TeamInstaller({
+      targetDir,
+      repoUrl,
+      force: options.force,
+      dryRun: options.dryRun,
+    });
+
+    const results = await teamInstaller.run();
+    spinner.stop();
+
+    if (results.errors.length > 0) {
+      console.log(chalk.red('\n  Team conventions errors:'));
+      results.errors.forEach(e => console.log(chalk.red(`    ! ${e.error}`)));
+    } else if (results.skipped.length > 0) {
+      console.log(chalk.yellow('\n  Team conventions:'));
+      results.skipped.forEach(s => console.log(chalk.yellow(`    - ${s}`)));
+    } else if (results.installed.length > 0) {
+      console.log(chalk.green('\n  Team conventions installed:'));
+      results.installed.forEach(f => console.log(chalk.green(`    + ${f}`)));
+    }
+  } catch (err) {
+    spinner.fail(`Failed to initialize team conventions: ${err.message}`);
+  }
 }
 
 export async function specDoctorCommand(targetPath) {

package/src/commands/uninstall.js

@@ -17,7 +17,7 @@ export async function uninstallCommand(options) {
     const { confirm } = await inquirer.prompt([{
       type: 'confirm',
       name: 'confirm',
-      message: 'This will remove all ace-managed files (rules, plugin, hooks, hookify rules). Continue?',
+      message: 'This will remove all ace-managed files (rules, plugin, hooks). Continue?',
       default: false,
     }]);
     if (!confirm) {
@@ -30,16 +30,30 @@ export async function uninstallCommand(options) {
   const skipped = [];
   const errors = [];
 
-  // 1. Remove rules/ace/ directory
+  // 1. Remove ace/rules/ directory (and legacy rules/ace/ if still present)
   const spinner1 = ora('Removing rules...').start();
   try {
-    const rulesDir = path.join(CLAUDE_DIR, 'rules', 'ace');
-    if (await fs.pathExists(rulesDir)) {
-      await fs.remove(rulesDir);
-      removed.push('rules/ace/');
-    } else {
-      skipped.push('rules/ace/ (not found)');
+    const newRulesDir = path.join(CLAUDE_DIR, 'ace', 'rules');
+    const aceDir = path.join(CLAUDE_DIR, 'ace');
+    const legacyRulesDir = path.join(CLAUDE_DIR, 'rules', 'ace');
+
+    if (await fs.pathExists(newRulesDir)) {
+      await fs.remove(newRulesDir);
+      removed.push('ace/rules/');
+    }
+    // Remove ace/ parent if empty
+    if (await fs.pathExists(aceDir)) {
+      const remaining = await fs.readdir(aceDir);
+      if (remaining.length === 0) {
+        await fs.remove(aceDir);
+      }
+    }
+    // Also clean legacy directory if still exists
+    if (await fs.pathExists(legacyRulesDir)) {
+      await fs.remove(legacyRulesDir);
+      removed.push('rules/ace/ (legacy)');
     }
+
     spinner1.succeed('rules removed');
   } catch (err) {
     spinner1.fail('rules removal failed');
@@ -82,38 +96,44 @@ export async function uninstallCommand(options) {
     errors.push({ component: 'plugin', error: err.message });
   }
 
-  // 3. Remove hookify rules
-  const spinner3 = ora('Removing hookify rules...').start();
+  // 3. Remove hook scripts
+  const spinner3 = ora('Removing hooks...').start();
   try {
-    const hookifyFiles = COMPONENTS.hookify.files;
-    for (const file of hookifyFiles) {
+    const hookFiles = [...(COMPONENTS.hooks.files || []), ...(COMPONENTS.hooks.conditional || [])];
+    for (const file of hookFiles) {
       const destPath = path.join(CLAUDE_DIR, file.dest);
       if (await fs.pathExists(destPath)) {
         await fs.remove(destPath);
         removed.push(file.dest);
       }
     }
-    spinner3.succeed('hookify rules removed');
+    spinner3.succeed('hooks removed');
   } catch (err) {
-    spinner3.fail('hookify rules removal failed');
-    errors.push({ component: 'hookify', error: err.message });
+    spinner3.fail('hooks removal failed');
+    errors.push({ component: 'hooks', error: err.message });
   }
 
-  // 4. Remove hook scripts
-  const spinner4 = ora('Removing hooks...').start();
+  // 4. Remove legacy hookify rules (cleanup from older versions)
+  const spinner4 = ora('Removing legacy hookify rules...').start();
   try {
-    const hookFiles = COMPONENTS.hooks.conditional;
-    for (const file of hookFiles) {
-      const destPath = path.join(CLAUDE_DIR, file.dest);
-      if (await fs.pathExists(destPath)) {
-        await fs.remove(destPath);
-        removed.push(file.dest);
+    const hookifyPattern = /^hookify\.ace\..+\.local\.md$/;
+    const claudeFiles = await fs.readdir(CLAUDE_DIR);
+    let hookifyRemoved = 0;
+    for (const file of claudeFiles) {
+      if (hookifyPattern.test(file)) {
+        await fs.remove(path.join(CLAUDE_DIR, file));
+        removed.push(file);
+        hookifyRemoved++;
       }
     }
-    spinner4.succeed('hooks removed');
+    if (hookifyRemoved > 0) {
+      spinner4.succeed(`legacy hookify rules removed (${hookifyRemoved})`);
+    } else {
+      spinner4.succeed('no legacy hookify rules found');
+    }
   } catch (err) {
-    spinner4.fail('hooks removal failed');
-    errors.push({ component: 'hooks', error: err.message });
+    spinner4.fail('legacy hookify removal failed');
+    errors.push({ component: 'hookify-legacy', error: err.message });
   }
 
   // 5. Restore CLAUDE.md and settings.json from pre-install backups
@@ -126,17 +146,31 @@ export async function uninstallCommand(options) {
       await fs.remove(claudeBackup);
       removed.push('CLAUDE.md (restored pre-ace backup)');
     } else if (await fs.pathExists(claudeMdPath)) {
-      // Fallback: surgically remove ace @references
+      // Fallback: surgically remove ace @references and managed section
       const content = await fs.readFile(claudeMdPath, 'utf-8');
-      const lines = content.split('\n');
-      const filtered = lines.filter(line => !line.includes('@~/.claude/rules/ace/'));
-      const cleaned = filtered.join('\n')
+      let cleaned = content;
+      // Remove the entire managed section if present
+      const managedStart = '<!-- ace:managed:start -->';
+      const managedEnd = '<!-- ace:managed:end -->';
+      const startIdx = cleaned.indexOf(managedStart);
+      const endIdx = cleaned.indexOf(managedEnd);
+      if (startIdx !== -1 && endIdx !== -1) {
+        cleaned = cleaned.slice(0, startIdx) + cleaned.slice(endIdx + managedEnd.length);
+      }
+      // Remove any remaining ace @references (legacy or new format)
+      const lines = cleaned.split('\n');
+      const filtered = lines.filter(line =>
+        !line.includes('@~/.claude/rules/ace/') &&
+        !line.includes('@~/.claude/ace/') &&
+        !line.includes('hookify.ace.')
+      );
+      cleaned = filtered.join('\n')
         .replace(/\n## Added by ace\n*/g, '\n')
         .replace(/\n{3,}/g, '\n\n')
         .trim() + '\n';
       if (cleaned !== content) {
         await fs.writeFile(claudeMdPath, cleaned, 'utf-8');
-        removed.push('CLAUDE.md ace @references (surgical)');
+        removed.push('CLAUDE.md ace content (surgical)');
       }
     }
 

package/src/core/constants.js

@@ -17,9 +17,9 @@ export const MARKETPLACE_DIR = path.join(CLAUDE_DIR, 'plugins', 'marketplaces',
 export const PLUGIN_KEY = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
 
 export const PRESETS = {
-  full: ['core', 'rules', 'plugin', 'hooks', 'hookify', 'memory'],
+  full: ['core', 'rules', 'plugin', 'hooks', 'scripts', 'memory'],
   minimal: ['core', 'rules', 'plugin'],
-  safe: ['core', 'rules', 'plugin', 'hookify', 'memory'],
+  safe: ['core', 'rules', 'plugin', 'memory'],
 };
 
 export const ROLES = {
@@ -58,12 +58,13 @@ export const SPEC_TEMPLATE_FILES = [
 
 /**
  * Patterns for files owned by ACE - these are overwritten directly on init without prompting.
- * Used to identify ACE-owned content in rules/, hooks/, and hookify/.
+ * Used to identify ACE-owned content in ace/ and hooks/.
  */
 export const ACE_OWNED_PATTERNS = [
-  /^rules\/ace\//,          // rules/ace/*.md
+  /^ace\/rules\//,          // ace/rules/*.md (v2.0+)
+  /^rules\/ace\//,          // rules/ace/*.md (legacy, for migration detection)
   /^hooks\/ace\./,          // hooks/ace.*.sh
-  /^hookify\.ace\./,        // hookify.ace.*.local.md
+  /^scripts\/statusline/,   // scripts/statusline*
 ];
 
 /**
@@ -72,17 +73,18 @@ export const ACE_OWNED_PATTERNS = [
  * @returns {boolean}
  */
 export function isAceOwnedFile(relativePath) {
-  return ACE_OWNED_PATTERNS.some(pattern => pattern.test(relativePath));
+  const normalized = relativePath.replace(/\\/g, '/');
+  return ACE_OWNED_PATTERNS.some(pattern => pattern.test(normalized));
 }
 
 /**
  * Check if an @reference path is owned by ACE.
- * @param {string} refPath - Reference path like '~/.claude/rules/ace/thinking.md' or '~/.claude/hooks/ace.java-compile-check.sh'
+ * @param {string} refPath - Reference path like '@~/.claude/rules/ace/thinking.md' or '~/.claude/hooks/ace.java-compile-check.sh'
  * @returns {boolean}
  */
 export function isAceOwnedRef(refPath) {
-  // Remove the ~/.claude/ prefix if present
-  const relativePath = refPath.replace(/^~\/\.claude\//, '');
+  // Remove the @~/.claude/ or ~/.claude/ prefix if present
+  const relativePath = refPath.replace(/^@?~\/\.claude\//, '');
   return isAceOwnedFile(relativePath);
 }
 
@@ -98,7 +100,7 @@ export const COMPONENTS = {
   rules: {
     description: 'Cognitive & code quality rules',
     required: true,
-    rulesDir: 'rules/ace',
+    rulesDir: 'ace/rules',
   },
   plugin: {
     description: 'Ace plugin (skills: auto-goal, coding, skill-creator, skill-optimize; commands: report)',
@@ -106,23 +108,24 @@ export const COMPONENTS = {
     isPlugin: true,
   },
   hooks: {
-    description: 'Hook scripts (optional, role-dependent)',
+    description: 'Hook scripts (safety guards + compile checks)',
     required: false,
+    files: [
+      { src: 'hooks/ace.bash-guard.sh', dest: 'hooks/ace.bash-guard.sh' },
+      { src: 'hooks/ace.content-guard.sh', dest: 'hooks/ace.content-guard.sh' },
+      { src: 'hooks/ace.file-guard.sh', dest: 'hooks/ace.file-guard.sh' },
+      { src: 'hooks/ace.stop-verify.sh', dest: 'hooks/ace.stop-verify.sh' },
+    ],
     conditional: [
       { src: 'hooks/ace.java-compile-check.sh', dest: 'hooks/ace.java-compile-check.sh', roles: ['backend', 'fullstack'] },
     ],
   },
-  hookify: {
-    description: 'Safety guard rules (block dangerous ops, protect secrets, safe git, code quality, require verification)',
+  scripts: {
+    description: 'Utility scripts (status line)',
     required: false,
     files: [
-      { src: 'hookify/hookify.ace.block-dangerous-ops.local.md', dest: 'hookify.ace.block-dangerous-ops.local.md' },
-      { src: 'hookify/hookify.ace.protect-secrets.local.md', dest: 'hookify.ace.protect-secrets.local.md' },
-      { src: 'hookify/hookify.ace.safe-git-commands.local.md', dest: 'hookify.ace.safe-git-commands.local.md' },
-      { src: 'hookify/hookify.ace.code-quality-gate.local.md', dest: 'hookify.ace.code-quality-gate.local.md' },
-      { src: 'hookify/hookify.ace.require-verification.local.md', dest: 'hookify.ace.require-verification.local.md' },
-      { src: 'hookify/hookify.ace.dangerous-commands.local.md', dest: 'hookify.ace.dangerous-commands.local.md' },
-      { src: 'hookify/hookify.ace.sensitive-data.local.md', dest: 'hookify.ace.sensitive-data.local.md' },
+      { src: 'scripts/statusline-command.sh', dest: 'scripts/statusline-command.sh' },
+      { src: 'scripts/statusline.py', dest: 'scripts/statusline.py' },
     ],
   },
   memory: {

package/src/core/installer.js

@@ -57,6 +57,9 @@ export class Installer {
         }
       }
 
+      // Check recursiveDir files (ACE-owned, no conflict prompt)
+      // Skip conflict detection — these are always overwritten via ACE_OWNED_PATTERNS
+
       // Check regular files
       if (component.files) {
         for (const file of component.files) {
@@ -94,6 +97,7 @@ export class Installer {
   async run() {
     if (!this.dryRun) {
       await fs.ensureDir(this.targetDir);
+      await this.prepare();
     }
 
     for (const componentName of this.components) {
@@ -114,6 +118,56 @@ export class Installer {
     return this.results;
   }
 
+  /**
+   * Prepare the target directory: migrate legacy structure and ensure new layout.
+   * Call this before installComponent() if not using run().
+   */
+  async prepare() {
+    await fs.ensureDir(this.targetDir);
+    await this.migrateFromLegacy();
+    await this.ensureAceStructure();
+  }
+
+  /**
+   * Migrate from legacy directory structure (rules/ace/) to new (ace/rules/).
+   * Only runs if old directory exists.
+   */
+  async migrateFromLegacy() {
+    const legacyDir = path.join(this.targetDir, 'rules', 'ace');
+    const newDir = path.join(this.targetDir, 'ace', 'rules');
+
+    if (!await fs.pathExists(legacyDir)) return;
+
+    // Move contents from legacy to new location
+    await fs.ensureDir(newDir);
+    const files = await fs.readdir(legacyDir);
+    for (const file of files) {
+      const src = path.join(legacyDir, file);
+      const dest = path.join(newDir, file);
+      await fs.move(src, dest, { overwrite: true });
+    }
+
+    // Remove empty legacy directory
+    await fs.remove(legacyDir);
+    // Clean up parent if empty
+    const rulesParent = path.join(this.targetDir, 'rules');
+    if (await fs.pathExists(rulesParent)) {
+      const remaining = await fs.readdir(rulesParent);
+      if (remaining.length === 0) {
+        await fs.remove(rulesParent);
+      }
+    }
+
+    this.results.merged.push({ file: 'ace/rules/ (migrated from rules/ace/)' });
+  }
+
+  /**
+   * Ensure the ace/ namespace directory structure exists.
+   */
+  async ensureAceStructure() {
+    await fs.ensureDir(path.join(this.targetDir, 'ace', 'rules'));
+  }
+
   async installComponent(name, component) {
     if (component.isPlugin) {
       await this.installPlugin();
@@ -124,6 +178,10 @@ export class Installer {
       await this.installRulesDir(component.rulesDir, name);
     }
 
+    if (component.recursiveDir) {
+      await this.installRecursiveDir(component.recursiveDir, name);
+    }
+
     if (component.files) {
       for (const file of component.files) {
         await this.installFile(file, name);
@@ -247,6 +305,27 @@ export class Installer {
     }
   }
 
+  async installRecursiveDir(dir, componentName) {
+    const srcDir = path.join(this.templatesDir, dir);
+    if (!await fs.pathExists(srcDir)) {
+      this.results.errors.push({ file: dir, error: 'Directory not found in templates' });
+      return;
+    }
+    await this._walkAndInstall(srcDir, dir, componentName);
+  }
+
+  async _walkAndInstall(baseDir, relativeBase, componentName) {
+    const entries = await fs.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcRel = path.join(relativeBase, entry.name);
+      if (entry.isDirectory()) {
+        await this._walkAndInstall(path.join(baseDir, entry.name), srcRel, componentName);
+      } else if (entry.name.endsWith('.md')) {
+        await this.installFile({ src: srcRel, dest: srcRel }, componentName);
+      }
+    }
+  }
+
   async installFile(fileSpec, componentName) {
     const srcPath = path.join(this.templatesDir, fileSpec.src);
     const destPath = path.join(this.targetDir, fileSpec.dest);
@@ -330,15 +409,16 @@ export class Installer {
   async mergeClaudeMdFile(srcPath, destPath, fileSpec) {
     const existing = await fs.readFile(destPath, 'utf-8');
     const template = await fs.readFile(srcPath, 'utf-8');
-    const { content, added } = mergeClaudeMd(existing, template);
+    const { content, added, removed } = mergeClaudeMd(existing, template);
 
-    if (added.length === 0) {
+    // Skip if content is unchanged (no refs added/removed, managed section identical)
+    if (content === existing) {
       this.results.skipped.push(fileSpec.dest);
       return;
     }
 
     if (this.dryRun) {
-      !this.quiet && console.log(chalk.cyan(`  [dry-run] Would merge CLAUDE.md, adding ${added.length} references`));
+      !this.quiet && console.log(chalk.cyan(`  [dry-run] Would merge CLAUDE.md`));
       this.results.merged.push({ file: fileSpec.dest, added });
       return;
     }
@@ -346,7 +426,7 @@ export class Installer {
     await backupPreInstall(destPath);
     await backupFile(destPath);
     await fs.writeFile(destPath, content, 'utf-8');
-    this.results.merged.push({ file: fileSpec.dest, added });
+    this.results.merged.push({ file: fileSpec.dest, added, removed });
   }
 
   async mergeSettingsJsonFile(srcPath, destPath, fileSpec) {

package/src/core/merger.js

@@ -60,28 +60,40 @@ function mergeWithMarkers(existingContent, templateContent) {
   let result = replaceManagedSection(existingContent, templateManaged);
 
   // Clean up any obsolete ACE refs outside the managed section
+  // This includes old @~/.claude/rules/ace/ refs AND hookify @refs
   const removed = [];
   const lines = result.split('\n');
   const cleanedLines = lines.map(line => {
     const refs = extractRefs(line);
     const hasObsoleteAceRef = refs.some(ref => {
-      // Check if this is an ACE-owned ref that's NOT in the new template
       if (isAceOwnedRef(ref)) {
         const refWithAt = `@${ref}`;
         if (!templateRefs.includes(refWithAt)) {
           removed.push(ref);
-          return true; // This line has an obsolete ref
+          return true;
         }
       }
       return false;
     });
 
-    // Return null to mark for removal, otherwise keep line
+    // Also remove lines with hookify @ references (these should not be in CLAUDE.md)
+    const hasHookifyRef = refs.some(ref => /hookify\.ace\./.test(ref));
+    if (hasHookifyRef) {
+      const refBare = refs.find(ref => /hookify\.ace\./.test(ref));
+      if (refBare) removed.push(refBare);
+      return null;
+    }
+
     return hasObsoleteAceRef ? null : line;
   }).filter(line => line !== null);
 
   result = cleanedLines.join('\n');
 
+  // Clean up empty "## Added by ace" section if all its refs were removed
+  result = result.replace(/\n## Added by ace\n*(?=\n|$)/g, '\n');
+  // Normalize multiple blank lines
+  result = result.replace(/\n{3,}/g, '\n\n');
+
   // Get the new refs that were added (in the managed section)
   const existingRefs = extractRefs(existingContent);
   const added = templateRefs

package/src/core/team-installer.js

@@ -0,0 +1,96 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+export class TeamInstaller {
+  constructor(options = {}) {
+    this.targetDir = options.targetDir || process.cwd();
+    this.repoUrl = options.repoUrl;
+    this.force = options.force || false;
+    this.dryRun = options.dryRun || false;
+    this.results = { installed: [], skipped: [], errors: [] };
+  }
+
+  get teamDir() {
+    return path.join(this.targetDir, '.claude', 'rules', 'team');
+  }
+
+  async run() {
+    if (!this.repoUrl) return this.results;
+
+    const tempDir = path.join(os.tmpdir(), `ace-team-${Date.now()}`);
+
+    try {
+      await this.cloneRepo(tempDir);
+      await this.copyFiles(tempDir);
+    } finally {
+      await fs.remove(tempDir);
+    }
+
+    return this.results;
+  }
+
+  async cloneRepo(tempDir) {
+    if (this.dryRun) {
+      this.results.installed.push(`git clone ${this.repoUrl} (dry-run)`);
+      return;
+    }
+
+    try {
+      execSync(`git clone --depth 1 "${this.repoUrl}" "${tempDir}"`, {
+        stdio: 'pipe',
+        timeout: 60000,
+      });
+    } catch (err) {
+      const msg = err.stderr ? err.stderr.toString().trim() : err.message;
+      this.results.errors.push({
+        component: 'team-clone',
+        error: `Failed to clone ${this.repoUrl}: ${msg}`,
+      });
+      throw err;
+    }
+  }
+
+  async copyFiles(tempDir) {
+    if (this.dryRun) {
+      this.results.installed.push(`.claude/rules/team/ (from ${this.repoUrl})`);
+      return;
+    }
+
+    if (!await fs.pathExists(tempDir)) return;
+
+    const exists = await fs.pathExists(this.teamDir);
+    if (exists && !this.force) {
+      this.results.skipped.push('.claude/rules/team/ (already exists, use --force to overwrite)');
+      return;
+    }
+
+    if (exists) {
+      await fs.remove(this.teamDir);
+    }
+
+    await fs.ensureDir(this.teamDir);
+    await this._copyRecursive(tempDir, this.teamDir);
+  }
+
+  async _copyRecursive(srcDir, destDir) {
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name === '.git') continue;
+
+      const srcPath = path.join(srcDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await fs.ensureDir(destPath);
+        await this._copyRecursive(srcPath, destPath);
+      } else {
+        await fs.copy(srcPath, destPath);
+        const relative = path.relative(this.teamDir, destPath).replace(/\\/g, '/');
+        this.results.installed.push(`.claude/rules/team/${relative}`);
+      }
+    }
+  }
+}

package/src/core/ui.js

@@ -92,6 +92,5 @@ export const componentLabels = {
   rules:   'Rules',
   plugin:  'Plugin',
   hooks:   'Hooks',
-  hookify: 'Safety Guards',
   memory:  'Memory',
 };