@ghl-ai/aw 0.1.8 → 0.1.11

package/cli.mjs

@@ -16,6 +16,7 @@ const COMMANDS = {
   drop:    () => import('./commands/drop.mjs').then(m => m.dropCommand),
   status:  () => import('./commands/status.mjs').then(m => m.statusCommand),
   search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
+  link:    () => import('./commands/link-project.mjs').then(m => m.linkProjectCommand),
   nuke:    () => import('./commands/nuke.mjs').then(m => m.nukeCommand),
   daemon:  () => import('./commands/daemon.mjs').then(m => m.daemonCommand),
 };

package/commands/init.mjs

@@ -1,98 +1,110 @@
-// commands/init.mjs — True omnipresent init: one install, works everywhere
+// commands/init.mjs — Clean init: clone registry, link IDEs, git hooks for omnipresence.
 //
-// How it works:
-//   1. Installs the source of truth at ~/.aw_registry/
-//   2. Links IDE config to ~/.claude/, ~/.cursor/, ~/.codex/
-//   3. Adds a chpwd hook to ~/.zshrc so every `cd` into a project
-//      auto-symlinks .aw_registry → ~/.aw_registry (omnipresence)
-//   4. Starts a background daemon for hourly silent pulls
-//   5. Writes a manifest of everything touched so `aw nuke` can do perfect cleanup
-
-import { mkdirSync, existsSync, writeFileSync, readFileSync, chmodSync, symlinkSync, lstatSync } from 'node:fs';
+// No shell profile modifications. No daemons. No background processes.
+// Uses git's built-in template hooks for automatic linking on clone/checkout.
+// Uses IDE tasks for auto-pull on workspace open.
+
+import { mkdirSync, existsSync, writeFileSync, symlinkSync, chmodSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join, resolve, relative } from 'node:path';
-import { homedir, platform } from 'node:os';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { pullCommand } from './pull.mjs';
 import { linkWorkspace } from '../link.mjs';
-import { daemonCommand } from './daemon.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
-import { readFileSync as readFileSyncPkg } from 'node:fs';
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const VERSION = JSON.parse(readFileSyncPkg(join(__dirname, '..', 'package.json'), 'utf8')).version;
+const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
+const GIT_TEMPLATE_DIR = join(HOME, '.git-templates', 'aw');
 
-// Shell hook that auto-symlinks .aw_registry into every directory you cd into
-const CHPWD_MARKER = '# aw-omnipresence';
-const CHPWD_HOOK = `
-${CHPWD_MARKER}
-_aw_chpwd() {
-  # Only act inside git repos (has .git/) and skip home dir
-  [ "$PWD" = "$HOME" ] && return
-  [ ! -d ".git" ] && return
-  # Skip if .aw_registry already exists (real dir or symlink)
-  [ -e ".aw_registry" ] && return
-  # Create symlink to global source of truth
-  ln -s "$HOME/.aw_registry" ".aw_registry" 2>/dev/null
-}
-# Fire on every directory change (zsh)
-if [ -n "$ZSH_VERSION" ]; then
-  autoload -U add-zsh-hook
-  add-zsh-hook chpwd _aw_chpwd
+// ── Git template hook for omnipresence ──────────────────────────────────
+// Git's init.templateDir copies hooks into every new clone/init.
+// post-checkout fires on clone and branch switch — perfect for auto-linking.
+
+const POST_CHECKOUT_HOOK = `#!/bin/sh
+# aw: auto-link registry on clone/checkout (installed by aw init)
+AW_REGISTRY="$HOME/.aw_registry"
+if [ -d "$AW_REGISTRY" ] && [ ! -e ".aw_registry" ] && [ -d ".git" ]; then
+  ln -s "$AW_REGISTRY" ".aw_registry" 2>/dev/null
 fi
-# Also fire on shell startup for the initial directory
-_aw_chpwd
 `;
 
-function installOmnipresenceHook() {
-  const profiles = [];
-  if (platform() === 'darwin') {
-    profiles.push(join(HOME, '.zshrc'));
-    profiles.push(join(HOME, '.zprofile'));
-  }
-  profiles.push(join(HOME, '.bashrc'));
-  profiles.push(join(HOME, '.bash_profile'));
-
-  const target = profiles.find(p => existsSync(p)) || join(HOME, '.zshrc');
-  const current = existsSync(target) ? readFileSync(target, 'utf8') : '';
+function installGitTemplate() {
+  const hooksDir = join(GIT_TEMPLATE_DIR, 'hooks');
+  mkdirSync(hooksDir, { recursive: true });
 
-  if (current.includes(CHPWD_MARKER)) {
-    fmt.logStep(`Omnipresence hook already in ${target.replace(HOME, '~')}`);
-    return target;
-  }
+  const hookPath = join(hooksDir, 'post-checkout');
+  writeFileSync(hookPath, POST_CHECKOUT_HOOK);
+  chmodSync(hookPath, '755');
 
-  writeFileSync(target, current + CHPWD_HOOK);
-  fmt.logStep(`Omnipresence hook added to ${target.replace(HOME, '~')}`);
-  fmt.logStep(chalk.dim('  Every cd into a git repo auto-links .aw_registry'));
-  return target;
+  // Set git global template dir (merges with existing hooks)
+  try {
+    const current = execSync('git config --global init.templateDir', {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    if (current && current !== GIT_TEMPLATE_DIR) {
+      // Another template dir is set — don't override, just inform
+      fmt.logWarn(`Git template dir already set to ${current}`);
+      fmt.logStep(chalk.dim('  Skipping git template — run: git config --global init.templateDir ~/.git-templates/aw'));
+      return false;
+    }
+  } catch { /* not set yet — good */ }
+
+  execSync(`git config --global init.templateDir "${GIT_TEMPLATE_DIR}"`, { stdio: 'pipe' });
+  fmt.logStep('Git template hook installed (auto-links on clone)');
+  return true;
 }
 
-function installAutoSync() {
-  const profiles = [];
-  if (platform() === 'darwin') {
-    profiles.push(join(HOME, '.zshrc'));
-  }
-  profiles.push(join(HOME, '.bashrc'));
-
-  const marker = '# aw-auto-sync';
-  const snippet = `\n${marker}\n[ -f "$HOME/.aw_registry/.sync-config.json" ] && command -v aw >/dev/null 2>&1 && (cd "$HOME" && aw pull --silent) &\n`;
-
-  const target = profiles.find(p => existsSync(p)) || join(HOME, '.zshrc');
-  const current = existsSync(target) ? readFileSync(target, 'utf8') : '';
-
-  if (current.includes(marker)) return;
+// ── IDE tasks for auto-pull ─────────────────────────────────────────────
+
+function installIdeTasks() {
+  // VS Code / Cursor task — runs aw pull on folder open
+  const vscodeTask = {
+    version: '2.0.0',
+    tasks: [
+      {
+        label: 'aw: sync registry',
+        type: 'shell',
+        command: 'aw init --silent',
+        presentation: { reveal: 'silent', panel: 'shared', close: true },
+        runOptions: { runOn: 'folderOpen' },
+        problemMatcher: [],
+      },
+    ],
+  };
 
-  writeFileSync(target, current + snippet);
-  fmt.logStep('Auto-sync on new terminal (background, zero delay)');
+  // Install globally for VS Code and Cursor
+  for (const ide of ['Code', 'Cursor']) {
+    const userDir = join(HOME, 'Library', 'Application Support', ide, 'User');
+    if (!existsSync(userDir)) continue;
+
+    const tasksPath = join(userDir, 'tasks.json');
+    if (existsSync(tasksPath)) {
+      // Don't override existing tasks — check if aw task already there
+      try {
+        const existing = JSON.parse(readFileSync(tasksPath, 'utf8'));
+        if (existing.tasks?.some(t => t.label === 'aw: sync registry' || t.label === 'aw: pull registry')) continue;
+        // Add our task to existing
+        existing.tasks = existing.tasks || [];
+        existing.tasks.push(vscodeTask.tasks[0]);
+        writeFileSync(tasksPath, JSON.stringify(existing, null, 2) + '\n');
+        fmt.logStep(`Added auto-pull task to ${ide}`);
+      } catch { /* corrupted tasks.json, skip */ }
+    } else {
+      writeFileSync(tasksPath, JSON.stringify(vscodeTask, null, 2) + '\n');
+      fmt.logStep(`Added auto-pull task to ${ide}`);
+    }
+  }
 }
 
 function saveManifest(data) {
@@ -115,79 +127,95 @@ export async function initCommand(args) {
     fmt.cancel("'ghl' is a reserved namespace — it is the shared platform layer");
   }
 
-  // ── Check existing install ────────────────────────────────────────────
+  const isExisting = config.exists(GLOBAL_AW_DIR);
+  const silent = args['--silent'] === true;
+  const cwd = process.cwd();
 
-  if (config.exists(GLOBAL_AW_DIR)) {
-    fmt.logStep('Existing install found — re-initializing...');
+  // ── Fast path: already initialized → just pull + link ─────────────────
+
+  if (isExisting) {
+    if (!silent) fmt.logStep('Already initialized — syncing...');
+
+    // Pull latest
+    pullCommand({ ...args, _positional: [], _workspaceDir: GLOBAL_AW_DIR, '--silent': silent });
+
+    // Re-link IDE dirs (idempotent)
+    linkWorkspace(HOME);
+    generateCommands(HOME);
+    copyInstructions(HOME, null, namespace) || [];
+    initAwDocs(HOME);
+    setupMcp(HOME, namespace) || [];
+
+    // Link current project if needed
+    if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
+      try {
+        symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
+        if (!silent) fmt.logStep('Linked .aw_registry in current project');
+      } catch { /* best effort */ }
+    }
+
+    if (!silent) {
+      fmt.outro([
+        'Sync complete',
+        '',
+        `  ${chalk.green('✓')} Registry updated`,
+        `  ${chalk.green('✓')} IDE integration refreshed`,
+        cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Current project linked` : null,
+      ].filter(Boolean).join('\n'));
+    }
+    return;
   }
 
-  // ── Auto-detect user ──────────────────────────────────────────────────
+  // ── Full init: first time setup ───────────────────────────────────────
 
+  // Auto-detect user
   if (!user) {
     try {
-      user = execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    } catch { /* gh not available */ }
+      user = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch { /* git not configured */ }
   }
 
-  // ── Step 1: Create global source of truth ─────────────────────────────
-
-  if (!existsSync(GLOBAL_AW_DIR)) {
-    mkdirSync(GLOBAL_AW_DIR, { recursive: true });
-  }
+  // Step 1: Create global source of truth
+  mkdirSync(GLOBAL_AW_DIR, { recursive: true });
 
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace, user, scope: 'omnipresent' });
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace, user });
 
   fmt.note([
     `${chalk.dim('source:')}     ~/.aw_registry/`,
     namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
     user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
-    `${chalk.dim('mode:')}       omnipresent — works in every project`,
+    `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
-  // ── Step 2: Pull registry content ─────────────────────────────────────
-
+  // Step 2: Pull registry content
   pullCommand({ ...args, _positional: ['ghl'], _workspaceDir: GLOBAL_AW_DIR });
 
   if (namespace) {
     pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR });
   }
 
-  // ── Step 3: Link to global IDE dirs ───────────────────────────────────
-
+  // Step 3: Link to global IDE dirs
   linkWorkspace(HOME);
   generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, namespace) || [];
   initAwDocs(HOME);
   const mcpFiles = setupMcp(HOME, namespace) || [];
 
-  // ── Step 4: Install omnipresence hook (chpwd) ─────────────────────────
-
-  const hookTarget = installOmnipresenceHook();
-
-  // ── Step 5: Install auto-sync on new terminal ─────────────────────────
+  // Step 4: Git template hook (omnipresence)
+  const gitTemplateInstalled = installGitTemplate();
 
-  installAutoSync();
+  // Step 5: IDE auto-init tasks
+  installIdeTasks();
 
-  // ── Step 6: Start background daemon ───────────────────────────────────
-
-  let daemonInstalled = false;
-  try {
-    daemonCommand({ _positional: ['install'], '--interval': '1h' });
-    daemonInstalled = true;
-  } catch { /* non-fatal */ }
-
-  // ── Step 7: Symlink in current directory if it's a git repo ───────────
-
-  const cwd = process.cwd();
-  if (cwd !== HOME && existsSync(join(cwd, '.git')) && !existsSync(join(cwd, '.aw_registry'))) {
+  // Step 6: Symlink in current directory if it's a git repo
+  if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
     try {
       symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
-      fmt.logStep(`Linked .aw_registry in current project`);
+      fmt.logStep('Linked .aw_registry in current project');
     } catch { /* best effort */ }
   }
 
-  // ── Step 8: Write manifest for perfect nuke cleanup ───────────────────
-
+  // Step 7: Write manifest for nuke cleanup
   const manifest = {
     version: 1,
     installedAt: new Date().toISOString(),
@@ -196,23 +224,23 @@ export async function initCommand(args) {
       ...instructionFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
       ...mcpFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
     ],
-    shellProfile: hookTarget,
-    shellMarkers: [CHPWD_MARKER, '# aw-auto-sync'],
-    daemon: daemonInstalled ? 'launchd' : null,
+    gitTemplate: gitTemplateInstalled ? GIT_TEMPLATE_DIR : null,
   };
   saveManifest(manifest);
 
-  // ── Done ──────────────────────────────────────────────────────────────
-
+  // Done
   fmt.outro([
-    `Omnipresent install complete`,
-    ``,
+    'Install complete',
+    '',
     `  ${chalk.green('✓')} Source of truth: ~/.aw_registry/`,
     `  ${chalk.green('✓')} IDE integration: ~/.claude/, ~/.cursor/, ~/.codex/`,
-    `  ${chalk.green('✓')} Auto-symlink: every git repo you cd into gets .aw_registry`,
-    `  ${chalk.green('✓')} Auto-sync: background daemon + new terminal pull`,
-    ``,
-    `  ${chalk.dim('Open any project in any IDE — AW is already there.')}`,
-    `  ${chalk.dim('To undo everything:')} ${chalk.bold('aw nuke')}`,
-  ].join('\n'));
+    gitTemplateInstalled ? `  ${chalk.green('✓')} Git hook: new clones auto-link .aw_registry` : null,
+    `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,
+    cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Linked in current project` : null,
+    '',
+    `  ${chalk.dim('Existing repos:')} ${chalk.bold('cd <project> && aw link')}`,
+    `  ${chalk.dim('New clones:')}     auto-linked via git hook`,
+    `  ${chalk.dim('Update:')}         ${chalk.bold('aw init')} ${chalk.dim('(or auto on IDE open)')}`,
+    `  ${chalk.dim('Uninstall:')}      ${chalk.bold('aw nuke')}`,
+  ].filter(Boolean).join('\n'));
 }

package/commands/link-project.mjs

@@ -0,0 +1,26 @@
+// commands/link-project.mjs — Symlink ~/.aw_registry into current project
+
+import { existsSync, symlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+
+const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
+
+export function linkProjectCommand(args) {
+  const cwd = process.cwd();
+  const target = join(cwd, '.aw_registry');
+
+  if (!existsSync(GLOBAL_AW_DIR)) {
+    fmt.cancel('No global install found. Run: aw init');
+  }
+
+  if (existsSync(target)) {
+    fmt.logSuccess('.aw_registry already linked in this project');
+    return;
+  }
+
+  symlinkSync(GLOBAL_AW_DIR, target);
+  fmt.logSuccess(`Linked .aw_registry → ~/.aw_registry/`);
+}

package/commands/nuke.mjs

@@ -1,20 +1,17 @@
-// commands/nuke.mjs — Safe omnipresent cleanup: reads manifest, removes only what AW created
+// commands/nuke.mjs — Safe cleanup: reads manifest, removes only what AW created
 //
 // Safety guarantee: NEVER deletes files that AW didn't create.
-// Uses .aw-manifest.json (written by init) to know exactly what to remove.
 
 import { join } from 'node:path';
-import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync, readFileSync, writeFileSync, readlinkSync } from 'node:fs';
+import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync, readFileSync, readlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
-import { homedir, platform } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
-const DAEMON_LABEL = 'ai.ghl.aw.pull';
-const PLIST_PATH = join(HOME, 'Library', 'LaunchAgents', `${DAEMON_LABEL}.plist`);
 
 // IDE dirs where AW creates symlinks
 const IDE_DIRS = ['.claude', '.cursor', '.codex'];
@@ -27,242 +24,82 @@ function loadManifest() {
   } catch { return null; }
 }
 
-// ── Step 1: Stop and remove daemon ──────────────────────────────────────────
-
-function removeDaemon(manifest) {
-  const isMac = platform() === 'darwin';
-
-  if (isMac) {
-    if (existsSync(PLIST_PATH)) {
-      try { execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
-      unlinkSync(PLIST_PATH);
-      fmt.logStep('Removed launchd daemon');
-    }
-  } else {
-    // Linux: remove cron line with # aw-daemon marker
-    try {
-      const current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
-      if (current.includes('# aw-daemon')) {
-        const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
-        execSync(`echo ${JSON.stringify(cleaned)} | crontab -`);
-        fmt.logStep('Removed cron job');
-      }
-    } catch { /* no crontab */ }
-  }
-}
-
-// ── Step 2: Remove shell hooks (by marker, surgically) ──────────────────────
-
-function removeShellHooks(manifest) {
-  const markers = manifest?.shellMarkers || ['# aw-omnipresence', '# aw-auto-sync'];
-  const profilePath = manifest?.shellProfile;
-
-  // Find all shell profiles that might have our hooks
-  const profiles = new Set();
-  if (profilePath && existsSync(profilePath)) profiles.add(profilePath);
-  for (const p of ['.zshrc', '.zprofile', '.bashrc', '.bash_profile']) {
-    const full = join(HOME, p);
-    if (existsSync(full)) profiles.add(full);
-  }
-
-  for (const profile of profiles) {
-    let content;
-    try { content = readFileSync(profile, 'utf8'); } catch { continue; }
-
-    let modified = false;
-    for (const marker of markers) {
-      if (!content.includes(marker)) continue;
-
-      // Remove the block: from marker line to next blank line or end
-      const lines = content.split('\n');
-      const result = [];
-      let skipping = false;
-
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes(marker)) {
-          skipping = true;
-          modified = true;
-          continue;
-        }
-        if (skipping) {
-          // Stop skipping at a blank line (end of block)
-          if (lines[i].trim() === '') {
-            skipping = false;
-            // Don't add the trailing blank line of the block
-            continue;
-          }
-          continue; // skip this line (part of the hook block)
-        }
-        result.push(lines[i]);
-      }
-      content = result.join('\n');
-    }
-
-    if (modified) {
-      // Clean up trailing newlines (max 1)
-      content = content.replace(/\n{3,}$/g, '\n');
-      writeFileSync(profile, content);
-      fmt.logStep(`Cleaned hooks from ${profile.replace(HOME, '~')}`);
-    }
-  }
-}
-
-// ── Step 3: Remove AW-created files (from manifest) ─────────────────────────
-
+// Remove AW-created files listed in manifest
 function removeCreatedFiles(manifest) {
   if (!manifest?.createdFiles?.length) return;
-
   let removed = 0;
   for (const rel of manifest.createdFiles) {
     const p = join(HOME, rel);
     try {
-      if (existsSync(p)) {
-        rmSync(p);
-        removed++;
-      }
+      if (existsSync(p)) { rmSync(p); removed++; }
     } catch { /* best effort */ }
   }
-  if (removed > 0) {
-    fmt.logStep(`Removed ${removed} generated file${removed > 1 ? 's' : ''}`);
-  }
+  if (removed > 0) fmt.logStep(`Removed ${removed} generated file${removed > 1 ? 's' : ''}`);
 }
 
-// ── Step 4: Remove AW symlinks from IDE dirs ────────────────────────────────
-
+// Remove symlinks from IDE dirs that point into .aw_registry
 function removeIdeSymlinks() {
   let removed = 0;
 
   for (const ide of IDE_DIRS) {
-    for (const type of CONTENT_TYPES) {
+    for (const type of [...CONTENT_TYPES, 'commands/aw', 'commands/ghl']) {
       const dir = join(HOME, ide, type);
       if (!existsSync(dir)) continue;
 
       for (const entry of readdirSync(dir)) {
         const p = join(dir, entry);
         try {
-          const stat = lstatSync(p);
-          if (stat.isSymbolicLink()) {
+          if (lstatSync(p).isSymbolicLink()) {
             const target = readlinkSync(p);
-            // Only remove if it points into .aw_registry
             if (target.includes('.aw_registry') || target.includes('aw_registry')) {
-              unlinkSync(p);
-              removed++;
+              unlinkSync(p); removed++;
             }
           }
         } catch { /* best effort */ }
       }
-    }
-
-    // Remove commands/aw/ dir (generated commands) and commands/ghl/ (generated platform commands)
-    for (const sub of ['commands/aw', 'commands/ghl']) {
-      const dir = join(HOME, ide, sub);
-      if (!existsSync(dir)) continue;
-      try {
-        // Only remove if contents are symlinks to .aw_registry or generated by AW
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-          const p = join(dir, entry);
-          const stat = lstatSync(p);
-          if (stat.isSymbolicLink()) {
-            unlinkSync(p);
-            removed++;
-          }
-        }
-        // Remove dir if now empty
-        if (readdirSync(dir).length === 0) rmSync(dir);
-      } catch { /* best effort */ }
+      // Remove dir if now empty
+      try { if (readdirSync(dir).length === 0) rmSync(dir); } catch {}
     }
   }
 
-  // Remove .agents/skills/ symlinks
-  const agentsSkills = join(HOME, '.agents', 'skills');
-  if (existsSync(agentsSkills)) {
-    try {
-      for (const entry of readdirSync(agentsSkills)) {
-        const p = join(agentsSkills, entry);
-        if (lstatSync(p).isSymbolicLink()) {
-          const target = readlinkSync(p);
-          if (target.includes('.aw_registry') || target.includes('aw_registry')) {
-            unlinkSync(p);
-            removed++;
-          }
-        }
-      }
-      if (readdirSync(agentsSkills).length === 0) rmSync(agentsSkills);
-      const agentsDir = join(HOME, '.agents');
-      if (existsSync(agentsDir) && readdirSync(agentsDir).length === 0) rmSync(agentsDir);
-    } catch { /* best effort */ }
-  }
-
-  if (removed > 0) {
-    fmt.logStep(`Removed ${removed} IDE symlink${removed > 1 ? 's' : ''}`);
-  }
+  if (removed > 0) fmt.logStep(`Removed ${removed} IDE symlink${removed > 1 ? 's' : ''}`);
 }
 
-// ── Step 5: Find and remove .aw_registry symlinks from project dirs ─────────
-
+// Find and remove .aw_registry symlinks from project directories
 function removeProjectSymlinks() {
-  // Check common project locations for .aw_registry symlinks
-  // We look in the current directory + scan known parent dirs
   let removed = 0;
+  const dirsToCheck = new Set([process.cwd()]);
 
-  const dirsToCheck = new Set();
-  dirsToCheck.add(process.cwd());
-
-  // Also check the home directory's immediate children (common project roots)
-  try {
-    for (const entry of readdirSync(HOME)) {
-      if (entry.startsWith('.')) continue; // skip dotfiles
-      const p = join(HOME, entry);
-      try {
-        if (lstatSync(p).isDirectory()) {
-          // Check this dir and its immediate children
-          dirsToCheck.add(p);
-          try {
-            for (const sub of readdirSync(p)) {
-              const sp = join(p, sub);
-              try { if (lstatSync(sp).isDirectory()) dirsToCheck.add(sp); } catch {}
-            }
-          } catch {}
-        }
-      } catch {}
-    }
-  } catch {}
+  // Scan ~/Documents, ~/Projects, ~/Desktop, ~/dev and their children
+  for (const parent of ['Documents', 'Projects', 'Desktop', 'dev', 'repos', 'src', 'code', 'work']) {
+    const p = join(HOME, parent);
+    if (!existsSync(p)) continue;
+    try {
+      for (const sub of readdirSync(p)) {
+        dirsToCheck.add(join(p, sub));
+      }
+    } catch {}
+  }
 
   for (const dir of dirsToCheck) {
     const link = join(dir, '.aw_registry');
     try {
-      if (lstatSync(link).isSymbolicLink()) {
-        unlinkSync(link);
-        removed++;
-      }
+      if (lstatSync(link).isSymbolicLink()) { unlinkSync(link); removed++; }
     } catch { /* doesn't exist or not a symlink */ }
   }
 
-  if (removed > 0) {
-    fmt.logStep(`Removed ${removed} project .aw_registry symlink${removed > 1 ? 's' : ''}`);
-  }
+  if (removed > 0) fmt.logStep(`Removed ${removed} project .aw_registry symlink${removed > 1 ? 's' : ''}`);
 }
 
-// ── Main ─────────────────────────────────────────────────────────────────────
-
 export function nukeCommand(args) {
   fmt.intro('aw nuke');
 
-  // Check if omnipresent install exists
   if (!existsSync(GLOBAL_AW_DIR)) {
-    // Fallback: check cwd for project-scope install
-    const localAw = join(process.cwd(), '.aw_registry');
-    if (existsSync(localAw)) {
-      try {
-        if (lstatSync(localAw).isSymbolicLink()) {
-          unlinkSync(localAw);
-          fmt.logSuccess('Removed local .aw_registry symlink');
-        } else {
-          rmSync(localAw, { recursive: true, force: true });
-          fmt.logSuccess('Removed local .aw_registry/');
-        }
-      } catch {}
+    // Check cwd for local symlink
+    const local = join(process.cwd(), '.aw_registry');
+    if (existsSync(local) && lstatSync(local).isSymbolicLink()) {
+      unlinkSync(local);
+      fmt.logSuccess('Removed local .aw_registry symlink');
       fmt.outro('Done');
       return;
     }
@@ -275,42 +112,70 @@ export function nukeCommand(args) {
   fmt.note([
     `${chalk.dim('source:')} ~/.aw_registry/`,
     manifest ? `${chalk.dim('installed:')} ${manifest.installedAt}` : null,
-    manifest?.daemon ? `${chalk.dim('daemon:')} ${manifest.daemon}` : null,
-  ].filter(Boolean).join('\n'), 'Cleaning up omnipresent install');
-
-  // 1. Stop daemon
-  removeDaemon(manifest);
+  ].filter(Boolean).join('\n'), 'Cleaning up');
 
-  // 2. Remove shell hooks
-  removeShellHooks(manifest);
-
-  // 3. Remove AW-created files (instruction files, MCP configs, etc.)
+  // 1. Remove AW-created files (instruction files, MCP configs)
   removeCreatedFiles(manifest);
 
-  // 4. Remove IDE symlinks (only those pointing to .aw_registry)
+  // 2. Remove IDE symlinks (only those pointing to .aw_registry)
   removeIdeSymlinks();
 
-  // 5. Remove .aw_registry symlinks from project directories
+  // 3. Remove .aw_registry symlinks from project directories
   removeProjectSymlinks();
 
-  // 6. Remove .aw_docs/ from home
+  // 4. Remove git template hook
+  const gitTemplateDir = manifest?.gitTemplate || join(HOME, '.git-templates', 'aw');
+  if (existsSync(gitTemplateDir)) {
+    rmSync(gitTemplateDir, { recursive: true, force: true });
+    // Unset git config if it pointed to our template
+    try {
+      const current = execSync('git config --global init.templateDir', {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+      if (current === gitTemplateDir) {
+        execSync('git config --global --unset init.templateDir', { stdio: 'pipe' });
+      }
+    } catch { /* not set */ }
+    fmt.logStep('Removed git template hook');
+  }
+
+  // 5. Remove IDE auto-pull tasks
+  for (const ide of ['Code', 'Cursor']) {
+    const tasksPath = join(HOME, 'Library', 'Application Support', ide, 'User', 'tasks.json');
+    if (!existsSync(tasksPath)) continue;
+    try {
+      const data = JSON.parse(readFileSync(tasksPath, 'utf8'));
+      const before = data.tasks?.length || 0;
+      data.tasks = (data.tasks || []).filter(t => t.label !== 'aw: sync registry' && t.label !== 'aw: pull registry');
+      if (data.tasks.length < before) {
+        if (data.tasks.length === 0) {
+          unlinkSync(tasksPath);
+        } else {
+          writeFileSync(tasksPath, JSON.stringify(data, null, 2) + '\n');
+        }
+        fmt.logStep(`Removed auto-pull task from ${ide}`);
+      }
+    } catch { /* best effort */ }
+  }
+
+  // 7. Remove ~/.aw_docs/
   const awDocs = join(HOME, '.aw_docs');
   if (existsSync(awDocs)) {
     rmSync(awDocs, { recursive: true, force: true });
     fmt.logStep('Removed ~/.aw_docs/');
   }
 
-  // 7. Remove ~/.aw_registry/ itself (the source of truth)
+  // 8. Remove ~/.aw_registry/ itself
   rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
   fmt.logStep('Removed ~/.aw_registry/');
 
   fmt.outro([
-    'Omnipresent install fully removed',
+    'Fully removed',
     '',
-    `  ${chalk.green('✓')} Daemon stopped`,
-    `  ${chalk.green('✓')} Shell hooks cleaned`,
-    `  ${chalk.green('✓')} IDE symlinks removed`,
-    `  ${chalk.green('✓')} Project symlinks removed`,
+    `  ${chalk.green('✓')} IDE symlinks cleaned`,
+    `  ${chalk.green('✓')} Project symlinks cleaned`,
+    `  ${chalk.green('✓')} Git template hook removed`,
+    `  ${chalk.green('✓')} IDE auto-pull tasks removed`,
     `  ${chalk.green('✓')} Source of truth deleted`,
     '',
     `  ${chalk.dim('No existing files were touched.')}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {