@ghl-ai/aw 0.1.35 → 0.1.36-beta.2

package/cli.mjs

@@ -72,7 +72,8 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init --namespace <team/sub-team>', 'Initialize workspace (required)'),
+    cmd('aw init', 'Initialize workspace (platform/ only)'),
+    cmd('aw init --namespace <team/sub-team>', 'Add a team namespace (optional)'),
     `  ${chalk.dim('Teams: platform, revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
     `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
 

package/commands/drop.mjs

@@ -2,87 +2,85 @@
 
 import { join, resolve } from 'node:path';
 import { rmSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { matchesAny } from '../glob.mjs';
 import { resolveInput } from '../paths.mjs';
-import { load as loadManifest, save as saveManifest } from '../manifest.mjs';
+import { removeFromSparseCheckout, isValidClone } from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { linkWorkspace } from '../link.mjs';
 
 export function dropCommand(args) {
   const input = args._positional?.[0];
   const cwd = process.cwd();
+
+  const HOME = homedir();
+  const AW_HOME = join(HOME, '.aw');
+  const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
   const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw drop');
 
   if (!input) {
-    fmt.cancel('Missing target. Usage:\n  aw drop example-team                         (stop syncing namespace)\n  aw drop example-team/skills/example-skill     (stop syncing skill)\n  aw drop example-team/skills/example-skill/SKILL  (delete single file)');
+    fmt.cancel('Missing target. Usage:\n  aw drop example-team                         (stop syncing namespace)\n  aw drop example-team/skills/example-skill     (stop syncing skill)');
+    return;
   }
 
-  const cfg = config.load(workspaceDir);
-  if (!cfg) fmt.cancel('No .sync-config.json found. Run: aw init');
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  if (!isValidClone(AW_HOME, repoUrl)) {
+    fmt.cancel('Registry not initialized. Run: aw init');
+    return;
+  }
 
-  // Resolve to registry path (accepts both local and registry paths)
+  const cfg = config.load(GLOBAL_AW_DIR);
+  if (!cfg) {
+    fmt.cancel('No .sync-config.json found. Run: aw init');
+    return;
+  }
+
+  // Resolve to registry path
   const resolved = resolveInput(input, workspaceDir);
   const regPath = resolved.registryPath;
 
   if (!regPath) {
     fmt.cancel(`Could not resolve "${input}" to a registry path`);
+    return;
   }
 
-  // Check if this path (or a parent) is in config → remove from config + delete files
+  // Check if this path (or a parent) is in config
   const isConfigPath = cfg.include.some(p => p === regPath || p.startsWith(regPath + '/'));
 
   if (isConfigPath) {
-    config.removePattern(workspaceDir, regPath);
+    // Remove from sparse checkout
+    try {
+      removeFromSparseCheckout(AW_HOME, [`${REGISTRY_DIR}/${regPath}`]);
+    } catch (e) {
+      fmt.logWarn(`Could not update sparse checkout: ${e.message}`);
+    }
+
+    config.removePattern(GLOBAL_AW_DIR, regPath);
     fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sync config`);
   }
 
-  // Delete matching local files
-  const removed = deleteMatchingFiles(workspaceDir, regPath);
+  // Count removed files (they disappear from working tree via sparse checkout)
+  const registryAbsPath = join(AW_HOME, REGISTRY_DIR, regPath);
+  let removed = 0;
+  if (!existsSync(registryAbsPath)) {
+    removed = 1; // sparse checkout removed it
+  }
 
-  if (removed > 0) {
-    fmt.logInfo(`${chalk.bold(removed)} file${removed > 1 ? 's' : ''} removed from workspace`);
-  } else if (!isConfigPath) {
+  if (!isConfigPath && removed === 0) {
     fmt.cancel(`Nothing found for ${chalk.cyan(regPath)}.\n\n  Use ${chalk.dim('aw status')} to see synced paths.`);
+    return;
   }
 
-  if (!isConfigPath && removed > 0) {
-    fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
+  if (!isConfigPath) {
+    fmt.logWarn(`Path was not in sync config — no sparse checkout change made`);
   }
 
-  fmt.outro('Done');
-}
+  // Re-link to remove dead symlinks
+  linkWorkspace(HOME);
 
-/**
- * Find and delete local files whose registry path matches the given path.
- */
-function deleteMatchingFiles(workspaceDir, path) {
-  const manifest = loadManifest(workspaceDir);
-  let removed = 0;
-
-  for (const [manifestKey] of Object.entries(manifest.files)) {
-    const registryPath = manifestKeyToRegistryPath(manifestKey);
-
-    if (matchesAny(registryPath, [path])) {
-      const filePath = join(workspaceDir, manifestKey);
-      if (existsSync(filePath)) {
-        rmSync(filePath, { recursive: true, force: true });
-        removed++;
-      }
-      delete manifest.files[manifestKey];
-    }
-  }
-
-  saveManifest(workspaceDir, manifest);
-  return removed;
-}
-
-/**
- * Convert manifest key to registry path.
- * Manifest key now mirrors registry: "platform/agents/architecture-reviewer.md" → "platform/agents/architecture-reviewer"
- */
-function manifestKeyToRegistryPath(manifestKey) {
-  return manifestKey.replace(/\.md$/, '');
+  fmt.outro('Done');
 }

package/commands/init.mjs

@@ -1,10 +1,10 @@
-// commands/init.mjs — Clean init: clone registry, link IDEs, global git hooks.
+// commands/init.mjs — Clean init: persistent git clone of registry, link IDEs, global git hooks.
 //
 // No shell profile modifications. No daemons. No background processes.
 // Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { mkdirSync, existsSync, writeFileSync, symlinkSync } from 'node:fs';
+import { existsSync, writeFileSync, symlinkSync, lstatSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
@@ -13,24 +13,33 @@ import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { pullCommand, pullAsync } from './pull.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
+import { installAwEcc } from '../ecc.mjs';
+import {
+  initPersistentClone,
+  isValidClone,
+  fetchAndMerge,
+  addToSparseCheckout,
+  includeToSparsePaths,
+  sparseCheckoutAsync,
+  cleanup,
+} from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 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 AW_HOME = join(HOME, '.aw');
 
 // ── IDE tasks for auto-pull ─────────────────────────────────────────────
 
 function installIdeTasks() {
-  // VS Code / Cursor task — runs aw pull on folder open
   const vscodeTask = {
     version: '2.0.0',
     tasks: [
@@ -45,18 +54,15 @@ function installIdeTasks() {
     ],
   };
 
-  // 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');
@@ -69,33 +75,10 @@ function installIdeTasks() {
   }
 }
 
-function saveManifest(data) {
-  writeFileSync(MANIFEST_PATH, JSON.stringify(data, null, 2) + '\n');
-}
-
-
-function printPullSummary(pattern, actions) {
-  for (const type of ['agents', 'skills', 'commands', 'evals']) {
-    const typeActions = actions.filter(a => a.type === type);
-    if (typeActions.length === 0) continue;
-
-    const counts = { ADD: 0, UPDATE: 0, CONFLICT: 0 };
-    for (const a of typeActions) counts[a.action] = (counts[a.action] || 0) + 1;
-
-    const parts = [];
-    if (counts.ADD > 0) parts.push(chalk.green(`${counts.ADD} new`));
-    if (counts.UPDATE > 0) parts.push(chalk.cyan(`${counts.UPDATE} updated`));
-    if (counts.CONFLICT > 0) parts.push(chalk.red(`${counts.CONFLICT} conflict`));
-    const detail = parts.length > 0 ? ` (${parts.join(', ')})` : '';
-
-    fmt.logSuccess(`${chalk.cyan(pattern)}: ${typeActions.length} ${type}${detail}`);
-  }
-}
-
 const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
-  const namespace = args['--namespace'] || null;
+  let namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const silent = args['--silent'] === true;
 
@@ -103,24 +86,11 @@ export async function initCommand(args) {
 
   // ── Validate ──────────────────────────────────────────────────────────
 
-  if (!namespace && !silent) {
-    const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
-    fmt.cancel([
-      `Missing required ${chalk.bold('--namespace')} flag`,
-      '',
-      `  ${chalk.dim('Usage:')}  aw init --namespace <team/sub-team>`,
-      `  ${chalk.dim('Teams:')}  ${list}`,
-      '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
-    ].join('\n'));
-  }
-
-  // Parse team/sub-team
-  const nsParts = namespace ? namespace.split('/') : [];
-  const team = nsParts[0] || null;
-  const subTeam = nsParts[1] || null;
-  const teamNS = subTeam ? `${team}-${subTeam}` : team;          // for $TEAM_NS replacement
-  const folderName = subTeam ? `${team}/${subTeam}` : team;       // for .aw_registry/ path
+  let nsParts = namespace ? namespace.split('/') : [];
+  let team = nsParts[0] || null;
+  let subTeam = nsParts[1] || null;
+  let teamNS = subTeam ? `${team}-${subTeam}` : team;
+  let folderName = subTeam ? `${team}/${subTeam}` : team;
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
@@ -151,55 +121,81 @@ export async function initCommand(args) {
     fmt.cancel(`Invalid sub-team '${subTeam}' — must match: ${SLUG_RE}`);
   }
 
-  const hasConfig = config.exists(GLOBAL_AW_DIR);
-  const hasPlatform = existsSync(join(GLOBAL_AW_DIR, 'platform'));
-  const isExisting = hasConfig && hasPlatform;
+  // ── Detect installation state ─────────────────────────────────────────
+
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  const isGitNative = isValidClone(AW_HOME, repoUrl);
+  const isLegacy = !isGitNative && existsSync(GLOBAL_AW_DIR) && !lstatSync(GLOBAL_AW_DIR).isSymbolicLink();
+
+  // ── Probe remote registry to check if namespace exists (fresh install only) ──
+
+  let namespaceExistsInRemote = false;
+  if (folderName && !silent && !isGitNative && !isLegacy) {
+    try {
+      const probePaths = includeToSparsePaths([folderName]);
+      const probeDir = await sparseCheckoutAsync(REGISTRY_REPO, probePaths);
+      try {
+        const fullNsPath = join(probeDir, REGISTRY_DIR, ...folderName.split('/'));
+        namespaceExistsInRemote = existsSync(fullNsPath) &&
+          readdirSync(fullNsPath, { withFileTypes: true })
+            .some(d => d.isDirectory() && !d.name.startsWith('.'));
+      } finally {
+        cleanup(probeDir);
+      }
+    } catch {
+      namespaceExistsInRemote = true;
+    }
+  }
+
+  if (folderName && !silent && !isGitNative && !isLegacy && !namespaceExistsInRemote && process.stdin.isTTY) {
+    const choice = await fmt.select({
+      message: `The namespace '${folderName}' does not exist in the registry yet.\nplatform/ includes shared agents, skills & commands that cover most use cases.\nHow would you like to proceed?`,
+      options: [
+        { value: 'platform-only', label: 'Continue with platform/ only (recommended for most users)' },
+        { value: 'create-namespace', label: `Use '${folderName}' namespace (will be created)` },
+      ],
+    });
+
+    if (fmt.isCancel(choice)) {
+      fmt.cancel('Operation cancelled.');
+      process.exit(0);
+    }
+
+    if (choice === 'platform-only') {
+      namespace = null; team = null; subTeam = null; teamNS = null; folderName = null;
+    }
+  }
+
   const cwd = process.cwd();
 
-  // ── Fast path: already initialized → just pull + link ─────────────────
+  // ── Re-init path: already set up with native git clone ────────────────
 
-  if (isExisting) {
+  if (isGitNative) {
     const cfg = config.load(GLOBAL_AW_DIR);
 
-    // Add new sub-team if not already tracked
     const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
     if (isNewSubTeam) {
       if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
-      await pullAsync({
-        ...args,
-        _positional: ['[template]'],
-        _renameNamespace: folderName,
-        _teamNS: teamNS,
-        _workspaceDir: GLOBAL_AW_DIR,
-        _skipIntegrate: true,
-      });
+      const newSparsePaths = [`.aw_registry/${folderName}`, `content`];
+      addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
     } else {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
 
-    // Pull latest (parallel)
-    // cfg.include has the renamed namespace (e.g. 'revex/courses'), but the repo
-    // only has '.aw_registry/[template]/' — remap non-platform entries back.
-    const freshCfg = config.load(GLOBAL_AW_DIR);
-    if (freshCfg && freshCfg.include.length > 0) {
-      const pullJobs = freshCfg.include.map(p => {
-        const isTeamNs = p !== 'platform';
-        const derivedTeamNS = isTeamNs ? p.replace(/\//g, '-') : undefined;
-        return pullAsync({
-          ...args,
-          _positional: [isTeamNs ? '[template]' : p],
-          _workspaceDir: GLOBAL_AW_DIR,
-          _skipIntegrate: true,
-          _renameNamespace: isTeamNs ? p : undefined,
-          _teamNS: derivedTeamNS,
-        });
-      });
-      await Promise.all(pullJobs);
+    const s = fmt.spinner ? fmt.spinner() : { start: () => {}, stop: () => {} };
+    if (!silent) s.start('Fetching latest...');
+    try {
+      fetchAndMerge(AW_HOME);
+      if (!silent) s.stop('Registry updated');
+    } catch (e) {
+      if (!silent) s.stop(chalk.yellow('Fetch failed (continuing with local)'));
     }
 
-    // Re-link IDE dirs + hooks (idempotent)
+    const freshCfg = config.load(GLOBAL_AW_DIR);
+
     linkWorkspace(HOME);
+    await installAwEcc(cwd, { silent });
     generateCommands(HOME);
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
@@ -207,7 +203,6 @@ export async function initCommand(args) {
     if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
-    // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
       try {
         symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
@@ -229,57 +224,72 @@ export async function initCommand(args) {
     return;
   }
 
+  // ── Legacy migration: old ~/.aw_registry/ dir → notify user ──────────
+
+  if (isLegacy) {
+    if (!silent) {
+      fmt.logWarn([
+        'Legacy installation detected (~/.aw_registry/ is a plain directory).',
+        '',
+        `  Run ${chalk.bold('aw nuke')} first to remove the old install, then ${chalk.bold('aw init')} again.`,
+        `  This will migrate to the new native git clone at ~/.aw/`,
+      ].join('\n'));
+    }
+    // Fall through to full init — create AW_HOME fresh
+  }
+
   // ── Full init: first time setup ───────────────────────────────────────
 
-  // Auto-detect user
   if (!user) {
     try {
       user = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
     } catch { /* git not configured */ }
   }
 
-  // Step 1: Create global source of truth
-  mkdirSync(GLOBAL_AW_DIR, { recursive: true });
-
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  // Determine sparse paths
+  const sparsePaths = [`.aw_registry/platform`, `content`, `.aw_registry/AW-PROTOCOL.md`];
+  if (folderName) {
+    sparsePaths.push(`.aw_registry/${folderName}`);
+  }
 
   fmt.note([
-    `${chalk.dim('source:')}     ~/.aw_registry/`,
+    `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
     folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
-    user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
+    user ? `${chalk.dim('user:')}       ${user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
-  ].filter(Boolean).join('\n'), 'Config created');
+  ].filter(Boolean).join('\n'), 'Config');
 
-  // Step 2: Pull registry content (parallel)
   const s = fmt.spinner();
-  const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
-  s.start(`Pulling ${pullTargets}...`);
-
-  const pullJobs = [
-    pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
-  ];
-  if (folderName) {
-    pullJobs.push(
-      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: folderName, _teamNS: teamNS, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
-    );
-  }
+  s.start(`Cloning registry...`);
 
-  let pullResults;
   try {
-    pullResults = await Promise.all(pullJobs);
-    s.stop(`Pulled ${pullTargets}`);
+    initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    s.stop('Registry cloned');
   } catch (e) {
-    s.stop(chalk.red('Pull failed'));
+    s.stop(chalk.red('Clone failed'));
     fmt.cancel(e.message);
   }
 
-  for (const { pattern, actions } of pullResults) {
-    printPullSummary(pattern, actions);
+  // Create backward-compat symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/
+  if (!existsSync(GLOBAL_AW_DIR)) {
+    try {
+      symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
+      fmt.logStep('Created ~/.aw_registry/ symlink');
+    } catch (e) {
+      fmt.logWarn(`Could not create symlink ~/.aw_registry/: ${e.message}`);
+    }
+  }
+
+  // Create sync config
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  if (folderName) {
+    config.addPattern(GLOBAL_AW_DIR, folderName);
   }
 
   // Step 3: Link IDE dirs + setup tasks
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
+  await installAwEcc(cwd, { silent });
   generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
@@ -296,27 +306,14 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 5: Write manifest for 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),
-    ],
-    globalHooksDir: hooksInstalled ? join(HOME, '.aw', 'hooks') : null,
-  };
-  saveManifest(manifest);
-
   // Offer to update if a newer version is available
   await promptUpdate(await args._updateCheck);
 
-  // Done
   fmt.outro([
     'Install complete',
     '',
-    `  ${chalk.green('✓')} Source of truth: ~/.aw_registry/`,
+    `  ${chalk.green('✓')} Source of truth: ~/.aw/ (git clone)`,
+    `  ${chalk.green('✓')} Symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/`,
     `  ${chalk.green('✓')} IDE integration: ~/.claude/, ~/.cursor/, ~/.codex/`,
     hooksInstalled ? `  ${chalk.green('✓')} Git hooks: auto-sync on pull/clone (core.hooksPath)` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,

package/commands/nuke.mjs

@@ -9,6 +9,7 @@ import { execSync } from 'node:child_process';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { removeGlobalHooks } from '../hooks.mjs';
+import { uninstallAwEcc } from '../ecc.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
@@ -243,28 +244,31 @@ export function nukeCommand(args) {
   // 2. Remove IDE symlinks (only those pointing to .aw_registry)
   removeIdeSymlinks();
 
-  // 3. Remove .aw_registry symlinks from ALL project directories
+  // 3. Remove aw-ecc installed files (agents, commands, rules, skills, hooks)
+  uninstallAwEcc();
+
+  // 4. Remove .aw_registry symlinks from ALL project directories
   removeProjectSymlinks();
 
-  // 4. Remove git hooks (core.hooksPath + legacy template)
+  // 5. Remove git hooks (core.hooksPath + legacy template)
   removeGitHooks(manifest);
 
-  // 5. Remove IDE auto-init tasks
+  // 6. Remove IDE auto-init tasks
   removeIdeTasks();
 
-  // 5b. Remove upgrade lock/log (inside .aw_registry, must happen before dir removal)
+  // Remove upgrade lock/log (inside .aw_registry, must happen before dir removal)
   for (const p of [join(GLOBAL_AW_DIR, '.aw-upgrade.lock'), join(GLOBAL_AW_DIR, '.aw-upgrade.log')]) {
     try { if (existsSync(p)) rmSync(p, { recursive: true, force: true }); } catch { /* best effort */ }
   }
 
-  // 6. Remove ~/.aw_docs/
+  // 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 any manual `aw` symlinks (e.g. ~/.local/bin/aw)
+  // 8. Remove any manual `aw` symlinks (e.g. ~/.local/bin/aw)
   const manualBins = [
     join(HOME, '.local', 'bin', 'aw'),
     join(HOME, 'bin', 'aw'),
@@ -278,7 +282,7 @@ export function nukeCommand(args) {
     } catch { /* doesn't exist */ }
   }
 
-  // 8. Uninstall npm global package (skip if already in npm uninstall lifecycle)
+  // 9. Uninstall npm global package (skip if already in npm uninstall lifecycle)
   if (!process.env.npm_lifecycle_event) {
     try {
       execSync('npm uninstall -g @ghl-ai/aw', { stdio: 'pipe', timeout: 15000 });
@@ -286,19 +290,35 @@ export function nukeCommand(args) {
     } catch { /* not installed via npm or no permissions */ }
   }
 
-  // 9. Remove ~/.aw_registry/ itself (source of truth — last!)
-  rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
+  // 10. Remove ~/.aw_registry/ — now a symlink to ~/.aw/.aw_registry/
+  try {
+    rmSync(GLOBAL_AW_DIR, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  } catch {
+    try { execSync(`rm -rf "${GLOBAL_AW_DIR}"`, { stdio: 'pipe' }); } catch { /* best effort */ }
+  }
   fmt.logStep('Removed ~/.aw_registry/');
 
+  // 11. Remove ~/.aw/ (persistent git clone)
+  const AW_HOME = join(HOME, '.aw');
+  if (existsSync(AW_HOME)) {
+    try {
+      rmSync(AW_HOME, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    } catch {
+      try { execSync(`rm -rf "${AW_HOME}"`, { stdio: 'pipe' }); } catch { /* best effort */ }
+    }
+    fmt.logStep('Removed ~/.aw/');
+  }
+
   fmt.outro([
     'Fully removed',
     '',
     `  ${chalk.green('✓')} Generated files cleaned`,
     `  ${chalk.green('✓')} IDE symlinks cleaned`,
+    `  ${chalk.green('✓')} aw-ecc engine removed`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,
     `  ${chalk.green('✓')} Git hooks removed`,
     `  ${chalk.green('✓')} IDE auto-sync tasks removed`,
-    `  ${chalk.green('✓')} Source of truth deleted`,
+    `  ${chalk.green('✓')} Source of truth deleted (symlink + git clone)`,
     '',
     `  ${chalk.dim('No existing files were touched.')}`,
     `  ${chalk.dim('To reinstall:')} ${chalk.bold('aw init')}`,