@ghl-ai/aw 0.1.0 → 0.1.2

package/cli.mjs

@@ -13,6 +13,7 @@ const COMMANDS = {
   status:  () => import('./commands/status.mjs').then(m => m.statusCommand),
   search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
   nuke:    () => import('./commands/nuke.mjs').then(m => m.nukeCommand),
+  daemon:  () => import('./commands/daemon.mjs').then(m => m.daemonCommand),
 };
 
 function parseArgs(argv) {
@@ -85,6 +86,10 @@ function printHelp() {
     cmd('aw status', 'Show synced paths, modified files & conflicts'),
     cmd('aw drop <path>', 'Stop syncing or delete local content'),
     cmd('aw nuke', 'Remove entire .aw_registry/ & start fresh'),
+    cmd('aw daemon install', 'Auto-pull on a schedule (macOS launchd / Linux cron)'),
+    cmd('aw daemon install --interval 30m', 'Set custom interval (e.g. 30m, 2h, 3600)'),
+    cmd('aw daemon uninstall', 'Stop the background daemon'),
+    cmd('aw daemon status', 'Check if daemon is running'),
 
     sec('Examples'),
     '',
@@ -128,7 +133,7 @@ export async function run(argv) {
 
   if (command && COMMANDS[command]) {
     const handler = await COMMANDS[command]();
-    handler(args);
+    await handler(args);
     return;
   }
 

package/commands/daemon.mjs

@@ -0,0 +1,192 @@
+// commands/daemon.mjs — Install/uninstall a launchd (macOS) or cron (Linux) job
+// that silently runs `aw pull` on a schedule without any user interaction.
+
+import { existsSync, writeFileSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+
+const LABEL = 'ai.ghl.aw.pull';
+const PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+const DEFAULT_INTERVAL = 3600; // 1 hour in seconds
+
+function getAwBin() {
+  try {
+    return execSync('which aw', { encoding: 'utf8' }).trim();
+  } catch {
+    return 'aw';
+  }
+}
+
+// ── macOS: launchd ──────────────────────────────────────────────────────────
+
+function installLaunchd(intervalSeconds) {
+  const awBin = getAwBin();
+  const logDir = join(homedir(), '.aw_registry', 'logs');
+  if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${awBin}</string>
+    <string>pull</string>
+    <string>--silent</string>
+  </array>
+
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${logDir}/pull.log</string>
+
+  <key>StandardErrorPath</key>
+  <string>${logDir}/pull-error.log</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+  </dict>
+</dict>
+</plist>`;
+
+  writeFileSync(PLIST_PATH, plist);
+
+  // Unload first if already loaded (to apply new interval)
+  try { execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
+  execSync(`launchctl load "${PLIST_PATH}"`);
+
+  fmt.logStep(`Daemon installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+}
+
+function uninstallLaunchd() {
+  if (!existsSync(PLIST_PATH)) {
+    fmt.logStep('No daemon installed.');
+    return;
+  }
+  try { execSync(`launchctl unload "${PLIST_PATH}"`); } catch { /* ignore */ }
+  unlinkSync(PLIST_PATH);
+  fmt.logStep('Daemon removed.');
+}
+
+function statusLaunchd() {
+  if (!existsSync(PLIST_PATH)) return null;
+  try {
+    const out = execSync(`launchctl list ${LABEL} 2>/dev/null`, { encoding: 'utf8' });
+    const pid = out.match(/"PID"\s*=\s*(\d+)/)?.[1];
+    const lastExit = out.match(/"LastExitStatus"\s*=\s*(\d+)/)?.[1];
+    return { running: !!pid, pid, lastExit };
+  } catch {
+    return { running: false };
+  }
+}
+
+// ── Linux: crontab ──────────────────────────────────────────────────────────
+
+function toCronExpression(intervalSeconds) {
+  const minutes = Math.round(intervalSeconds / 60);
+  if (minutes < 60) return `*/${minutes} * * * *`;
+  const hours = Math.round(minutes / 60);
+  return `0 */${hours} * * *`;
+}
+
+function installCron(intervalSeconds) {
+  const awBin = getAwBin();
+  const logDir = join(homedir(), '.aw_registry', 'logs');
+  if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+
+  const cronExpr = toCronExpression(intervalSeconds);
+  const cronLine = `${cronExpr} ${awBin} pull --silent >> ${logDir}/pull.log 2>&1 # aw-daemon`;
+
+  let current = '';
+  try { current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { /* empty */ }
+
+  // Remove old aw-daemon line if present
+  const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
+  const updated = cleaned.trimEnd() + '\n' + cronLine + '\n';
+
+  execSync(`echo ${JSON.stringify(updated)} | crontab -`);
+  fmt.logStep(`Cron job installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+}
+
+function uninstallCron() {
+  let current = '';
+  try { current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { return; }
+  const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
+  execSync(`echo ${JSON.stringify(cleaned)} | crontab -`);
+  fmt.logStep('Cron job removed.');
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function formatInterval(seconds) {
+  if (seconds < 3600) return `${seconds / 60} minutes`;
+  if (seconds === 3600) return '1 hour';
+  return `${seconds / 3600} hours`;
+}
+
+function parseInterval(str) {
+  if (!str) return DEFAULT_INTERVAL;
+  const n = parseInt(str);
+  if (str.endsWith('m')) return n * 60;
+  if (str.endsWith('h')) return n * 3600;
+  return n; // assume seconds
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+export function daemonCommand(args) {
+  const subcommand = args._positional[0] || 'install';
+  const interval = parseInterval(args['--interval'] || args._positional[1]);
+  const isMac = platform() === 'darwin';
+
+  fmt.intro(`aw daemon ${subcommand}`);
+
+  if (subcommand === 'install') {
+    fmt.logStep(`Platform: ${isMac ? 'macOS (launchd)' : 'Linux (cron)'}`);
+    fmt.logStep(`Interval: every ${formatInterval(interval)}`);
+    if (isMac) installLaunchd(interval);
+    else installCron(interval);
+    fmt.outro(`aw pull will run silently every ${formatInterval(interval)}`);
+
+  } else if (subcommand === 'uninstall' || subcommand === 'stop') {
+    if (isMac) uninstallLaunchd();
+    else uninstallCron();
+    fmt.outro('Daemon stopped.');
+
+  } else if (subcommand === 'status') {
+    if (isMac) {
+      const s = statusLaunchd();
+      if (!s) {
+        console.log(chalk.dim('  Not installed'));
+      } else {
+        console.log(`  ${s.running ? chalk.green('● running') : chalk.dim('○ not running')}  PID: ${s.pid || '—'}  Last exit: ${s.lastExit || '—'}`);
+        console.log(`  Plist: ${chalk.dim(PLIST_PATH)}`);
+      }
+    } else {
+      try {
+        const cron = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+        const line = cron.split('\n').find(l => l.includes('# aw-daemon'));
+        console.log(line ? chalk.green('  ● installed: ') + chalk.dim(line) : chalk.dim('  Not installed'));
+      } catch {
+        console.log(chalk.dim('  Not installed'));
+      }
+    }
+
+  } else {
+    fmt.cancel(`Unknown subcommand: ${subcommand}. Use install / uninstall / status`);
+  }
+}

package/commands/init.mjs

@@ -1,25 +1,106 @@
-// commands/init.mjs — Initialize workspace config + pull ghl + template
+// commands/init.mjs — True omnipresent init: one install, works everywhere
+//
+// 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 } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, readFileSync, chmodSync, symlinkSync, lstatSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join } from 'node:path';
+import { join, resolve, relative } from 'node:path';
+import { homedir, platform } from 'node:os';
 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';
 
-export function initCommand(args) {
+const HOME = homedir();
+const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
+const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
+
+// 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
+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') : '';
+
+  if (current.includes(CHPWD_MARKER)) {
+    fmt.logStep(`Omnipresence hook already in ${target.replace(HOME, '~')}`);
+    return target;
+  }
+
+  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;
+}
+
+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 && 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;
+
+  writeFileSync(target, current + snippet);
+  fmt.logStep('Auto-sync on new terminal (background, zero delay)');
+}
+
+function saveManifest(data) {
+  writeFileSync(MANIFEST_PATH, JSON.stringify(data, null, 2) + '\n');
+}
+
+export async function initCommand(args) {
   const namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
-  const cwd = process.cwd();
-  const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw init');
 
-  // Validate namespace slug if provided
+  // ── Validate ──────────────────────────────────────────────────────────
+
   if (namespace && !/^[a-z][a-z0-9-]{1,38}[a-z0-9]$/.test(namespace)) {
     fmt.cancel(`Invalid namespace '${namespace}' — must match: ^[a-z][a-z0-9-]{1,38}[a-z0-9]$`);
   }
@@ -28,48 +109,104 @@ export function initCommand(args) {
     fmt.cancel("'ghl' is a reserved namespace — it is the shared platform layer");
   }
 
-  // Auto-detect user from GitHub if not provided
+  // ── Check existing install ────────────────────────────────────────────
+
+  if (config.exists(GLOBAL_AW_DIR)) {
+    fmt.cancel(`.aw_registry already initialized at ~/\nRun ${chalk.bold('aw nuke')} first to start fresh.`);
+  }
+
+  // ── Auto-detect user ──────────────────────────────────────────────────
+
   if (!user) {
     try {
       user = execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-    } catch {
-      // gh not available or not logged in — skip
-    }
+    } catch { /* gh not available */ }
   }
 
-  // Create workspace dir
-  if (!existsSync(workspaceDir)) {
-    mkdirSync(workspaceDir, { recursive: true });
-    fmt.logStep('Created .aw_registry/');
-  }
+  // ── Step 1: Create global source of truth ─────────────────────────────
 
-  // Check existing config
-  if (config.exists(workspaceDir)) {
-    fmt.cancel('.sync-config.json already exists. Delete it to re-init.');
+  if (!existsSync(GLOBAL_AW_DIR)) {
+    mkdirSync(GLOBAL_AW_DIR, { recursive: true });
   }
 
-  // Create config
-  const cfg = config.create(workspaceDir, { namespace, user });
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace, user, scope: 'omnipresent' });
 
-  const infoLines = [
+  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,
-  ].filter(Boolean).join('\n');
+    `${chalk.dim('mode:')}       omnipresent — works in every project`,
+  ].filter(Boolean).join('\n'), 'Config created');
 
-  fmt.note(infoLines, 'Config created');
+  // ── Step 2: Pull registry content ─────────────────────────────────────
 
-  // Always pull ghl/ (platform layer)
-  pullCommand({ ...args, _positional: ['ghl'] });
+  pullCommand({ ...args, _positional: ['ghl'], _workspaceDir: GLOBAL_AW_DIR });
 
-  // Pull [template]/ as the team namespace
   if (namespace) {
-    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace });
+    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR });
   }
 
-  // Post-pull IDE integration
-  linkWorkspace(cwd);
-  generateCommands(cwd);
-  copyInstructions(cwd, null, namespace);
-  initAwDocs(cwd);
-  setupMcp(cwd, namespace);
+  // ── 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 ─────────────────────────
+
+  installAutoSync();
+
+  // ── 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'))) {
+    try {
+      symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
+      fmt.logStep(`Linked .aw_registry in current project`);
+    } catch { /* best effort */ }
+  }
+
+  // ── Step 8: Write manifest for perfect nuke cleanup ───────────────────
+
+  const manifest = {
+    version: 1,
+    installedAt: new Date().toISOString(),
+    globalDir: GLOBAL_AW_DIR,
+    createdFiles: [
+      ...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,
+  };
+  saveManifest(manifest);
+
+  // ── Done ──────────────────────────────────────────────────────────────
+
+  fmt.outro([
+    `Omnipresent 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'));
 }

package/commands/nuke.mjs

@@ -1,95 +1,319 @@
-// commands/nuke.mjs — Remove entire .aw_registry/ and all generated IDE files
+// commands/nuke.mjs — Safe omnipresent 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 } from 'node:fs';
+import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync, readFileSync, writeFileSync, readlinkSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { homedir, platform } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 
-// IDE dirs to scan for per-file symlinks
+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'];
 const CONTENT_TYPES = ['agents', 'skills', 'commands', 'blueprints', 'evals'];
 
-// Generated files from mcp.mjs + integrate.mjs
-const FILES_TO_CLEAN = [
-  '.claude/settings.local.json',
-  '.cursor/mcp.json',
-  '.codex/config.toml',
-  'mcp.json',
-  'CLAUDE.md',
-  'AGENTS.md',
-];
-
-// Dirs to remove if empty after cleanup (deepest first)
-const DIRS_TO_PRUNE = [
-  // IDE content dirs
-  ...IDE_DIRS.flatMap(ide => CONTENT_TYPES.map(t => `${ide}/${t}`)),
-  // IDE root dirs
-  ...IDE_DIRS,
-  // Codex agents dir
-  '.agents/skills',
-  '.agents',
-];
+function loadManifest() {
+  if (!existsSync(MANIFEST_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'));
+  } catch { return null; }
+}
 
-export function nukeCommand(args) {
-  const cwd = process.cwd();
-  const workspaceDir = join(cwd, '.aw_registry');
+// ── Step 1: Stop and remove daemon ──────────────────────────────────────────
 
-  fmt.intro('aw nuke');
+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 (!existsSync(workspaceDir)) {
-    fmt.cancel('No .aw_registry/ found — nothing to remove');
+    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) ─────────────────────────
+
+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++;
+      }
+    } catch { /* best effort */ }
+  }
+  if (removed > 0) {
+    fmt.logStep(`Removed ${removed} generated file${removed > 1 ? 's' : ''}`);
+  }
+}
+
+// ── Step 4: Remove AW symlinks from IDE dirs ────────────────────────────────
+
+function removeIdeSymlinks() {
+  let removed = 0;
 
-  // 1. Remove symlinks + generated files from all IDE dirs
   for (const ide of IDE_DIRS) {
     for (const type of CONTENT_TYPES) {
-      const dir = join(cwd, ide, type);
+      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()) {
-            unlinkSync(p);
+            const target = readlinkSync(p);
+            // Only remove if it points into .aw_registry
+            if (target.includes('.aw_registry') || target.includes('aw_registry')) {
+              unlinkSync(p);
+              removed++;
+            }
           }
         } catch { /* best effort */ }
       }
     }
-    // Clean commands/aw/ (generated commands + symlinked registry commands)
-    const awCmdDir = join(cwd, ide, 'commands/aw');
-    if (existsSync(awCmdDir)) {
-      rmSync(awCmdDir, { recursive: true, force: true });
+
+    // 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 */ }
     }
   }
-  // 2. Clean .agents/skills/ (symlinks + generated Codex skill dirs)
-  const agentsSkillsDir = join(cwd, '.agents/skills');
-  if (existsSync(agentsSkillsDir)) {
-    rmSync(agentsSkillsDir, { recursive: true, force: true });
-  }
 
-  // 3. Remove generated files
-  for (const rel of FILES_TO_CLEAN) {
-    const p = join(cwd, rel);
-    try { if (existsSync(p)) rmSync(p); } catch { /* best effort */ }
+  // 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 */ }
   }
 
-  // 4. Remove .aw_registry/ and .aw_docs/
-  rmSync(workspaceDir, { recursive: true, force: true });
-  const awDocsDir = join(cwd, '.aw_docs');
-  if (existsSync(awDocsDir)) {
-    rmSync(awDocsDir, { recursive: true, force: true });
+  if (removed > 0) {
+    fmt.logStep(`Removed ${removed} IDE symlink${removed > 1 ? 's' : ''}`);
   }
+}
+
+// ── Step 5: Find and remove .aw_registry symlinks from project dirs ─────────
+
+function removeProjectSymlinks() {
+  // Check common project locations for .aw_registry symlinks
+  // We look in the current directory + scan known parent dirs
+  let removed = 0;
 
-  // 5. Prune empty dirs
-  for (const rel of DIRS_TO_PRUNE) {
-    const p = join(cwd, rel);
+  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 {}
+
+  for (const dir of dirsToCheck) {
+    const link = join(dir, '.aw_registry');
     try {
-      if (existsSync(p) && readdirSync(p).length === 0) {
-        rmSync(p, { recursive: true });
+      if (lstatSync(link).isSymbolicLink()) {
+        unlinkSync(link);
+        removed++;
       }
-    } catch { /* best effort */ }
+    } catch { /* doesn't exist or not a symlink */ }
+  }
+
+  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 {}
+      fmt.outro('Done');
+      return;
+    }
+    fmt.cancel('No .aw_registry found — nothing to remove');
+    return;
+  }
+
+  const manifest = loadManifest();
+
+  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);
+
+  // 2. Remove shell hooks
+  removeShellHooks(manifest);
+
+  // 3. Remove AW-created files (instruction files, MCP configs, etc.)
+  removeCreatedFiles(manifest);
+
+  // 4. Remove IDE symlinks (only those pointing to .aw_registry)
+  removeIdeSymlinks();
+
+  // 5. Remove .aw_registry symlinks from project directories
+  removeProjectSymlinks();
+
+  // 6. Remove .aw_docs/ from home
+  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)
+  rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
+  fmt.logStep('Removed ~/.aw_registry/');
 
-  fmt.logSuccess('Removed .aw_registry/ and all generated IDE files');
-  fmt.outro(`Run ${chalk.dim('aw init')} to start fresh`);
+  fmt.outro([
+    'Omnipresent install fully removed',
+    '',
+    `  ${chalk.green('✓')} Daemon stopped`,
+    `  ${chalk.green('✓')} Shell hooks cleaned`,
+    `  ${chalk.green('✓')} IDE symlinks removed`,
+    `  ${chalk.green('✓')} Project symlinks removed`,
+    `  ${chalk.green('✓')} Source of truth deleted`,
+    '',
+    `  ${chalk.dim('No existing files were touched.')}`,
+    `  ${chalk.dim('Run')} ${chalk.bold('aw init')} ${chalk.dim('to reinstall.')}`,
+  ].join('\n'));
 }

package/integrate.mjs

@@ -92,6 +92,7 @@ export function generateCommands(cwd) {
  * Copy CLAUDE.md and AGENTS.md to project root.
  */
 export function copyInstructions(cwd, tempDir, namespace) {
+  const createdFiles = [];
   for (const file of ['CLAUDE.md', 'AGENTS.md']) {
     const dest = join(cwd, file);
     if (existsSync(dest)) continue;
@@ -105,6 +106,7 @@ export function copyInstructions(cwd, tempDir, namespace) {
         }
         writeFileSync(dest, content);
         fmt.logSuccess(`Created ${file}`);
+        createdFiles.push(dest);
         continue;
       }
     }
@@ -115,8 +117,10 @@ export function copyInstructions(cwd, tempDir, namespace) {
     if (content) {
       writeFileSync(dest, content);
       fmt.logSuccess(`Created ${file}`);
+      createdFiles.push(dest);
     }
   }
+  return createdFiles;
 }
 
 function generateClaudeMd(cwd, namespace) {

package/mcp.mjs

@@ -29,110 +29,98 @@ function detectPaths() {
 
 /**
  * Setup MCP configs for all IDEs. Only writes if file doesn't exist.
+ * Returns list of file paths that were actually created.
  */
 export function setupMcp(cwd, namespace) {
   const paths = detectPaths();
-  let created = 0;
+  const createdFiles = [];
+
+  const attempt = (filePath, contentFn, append = false) => {
+    if (writeIfMissing(filePath, contentFn, append)) {
+      createdFiles.push(filePath);
+    }
+  };
 
   // .claude/settings.local.json
-  created += writeIfMissing(
-    join(cwd, '.claude', 'settings.local.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (paths.gitJenkinsPath) {
-        servers['git-jenkins'] = {
-          command: 'node',
-          args: [paths.gitJenkinsPath],
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, '.claude', 'settings.local.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
+    }
+    if (paths.gitJenkinsPath) {
+      servers['git-jenkins'] = { command: 'node', args: [paths.gitJenkinsPath] };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
   // .cursor/mcp.json
-  created += writeIfMissing(
-    join(cwd, '.cursor', 'mcp.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (paths.gitJenkinsPath) {
-        servers['git-jenkins'] = {
-          command: 'node',
-          args: [paths.gitJenkinsPath],
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, '.cursor', 'mcp.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
+    }
+    if (paths.gitJenkinsPath) {
+      servers['git-jenkins'] = { command: 'node', args: [paths.gitJenkinsPath] };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
   // .codex/config.toml — append MCP servers
   const codexConfig = join(cwd, '.codex', 'config.toml');
   if (!hasMcpSection(codexConfig)) {
-    created += writeIfMissing(
-      codexConfig,
-      () => {
-        const lines = [];
-        if (paths.ghlAiBridge) {
-          lines.push(
-            '[mcp_servers.ghl-ai]',
-            'command = "node"',
-            `args = ["${paths.ghlAiBridge}"]`,
-            '',
-            '[mcp_servers.ghl-ai.env]',
-            `GHL_MCP_URL = "${paths.ghlMcpUrl}"`,
-            `TEAM_NAME = "${namespace || ''}"`,
-            '',
-          );
-        }
-        if (paths.gitJenkinsPath) {
-          lines.push(
-            '[mcp_servers.git-jenkins]',
-            'command = "node"',
-            `args = ["${paths.gitJenkinsPath}"]`,
-            '',
-          );
-        }
-        if (lines.length === 0) return null;
-        return lines.join('\n');
-      },
-      true // append mode
-    );
+    attempt(codexConfig, () => {
+      const lines = [];
+      if (paths.ghlAiBridge) {
+        lines.push(
+          '[mcp_servers.ghl-ai]',
+          'command = "node"',
+          `args = ["${paths.ghlAiBridge}"]`,
+          '',
+          '[mcp_servers.ghl-ai.env]',
+          `GHL_MCP_URL = "${paths.ghlMcpUrl}"`,
+          `TEAM_NAME = "${namespace || ''}"`,
+          '',
+        );
+      }
+      if (paths.gitJenkinsPath) {
+        lines.push(
+          '[mcp_servers.git-jenkins]',
+          'command = "node"',
+          `args = ["${paths.gitJenkinsPath}"]`,
+          '',
+        );
+      }
+      if (lines.length === 0) return null;
+      return lines.join('\n');
+    }, true /* append mode */);
   }
 
   // mcp.json at project root (Claude Code auto-discovery)
-  created += writeIfMissing(
-    join(cwd, 'mcp.json'),
-    () => {
-      const servers = {};
-      if (paths.ghlAiBridge) {
-        servers['ghl-ai'] = {
-          command: 'node',
-          args: [paths.ghlAiBridge],
-          env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
-        };
-      }
-      if (Object.keys(servers).length === 0) return null;
-      return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  attempt(join(cwd, 'mcp.json'), () => {
+    const servers = {};
+    if (paths.ghlAiBridge) {
+      servers['ghl-ai'] = {
+        command: 'node',
+        args: [paths.ghlAiBridge],
+        env: { GHL_MCP_URL: paths.ghlMcpUrl, TEAM_NAME: namespace || '' },
+      };
     }
-  );
+    if (Object.keys(servers).length === 0) return null;
+    return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+  });
 
-  if (created > 0) {
-    fmt.logSuccess(`Created ${created} MCP config${created > 1 ? 's' : ''}`);
+  if (createdFiles.length > 0) {
+    fmt.logSuccess(`Created ${createdFiles.length} MCP config${createdFiles.length > 1 ? 's' : ''}`);
   }
 
   const warnings = [];
@@ -142,13 +130,13 @@ export function setupMcp(cwd, namespace) {
     fmt.logWarn(w);
   }
 
-  return created;
+  return createdFiles;
 }
 
 function writeIfMissing(filePath, contentFn, append = false) {
-  if (!append && existsSync(filePath)) return 0;
+  if (!append && existsSync(filePath)) return false;
   const content = contentFn();
-  if (!content) return 0;
+  if (!content) return false;
   mkdirSync(join(filePath, '..'), { recursive: true });
   if (append && existsSync(filePath)) {
     const existing = readFileSync(filePath, 'utf8');
@@ -156,7 +144,7 @@ function writeIfMissing(filePath, contentFn, append = false) {
   } else {
     writeFileSync(filePath, content);
   }
-  return 1;
+  return true;
 }
 
 function hasMcpSection(filePath) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
-    "aw": "./bin.js"
+    "aw": "bin.js"
   },
   "files": [
     "bin.js",