@ghl-ai/aw 0.1.34-beta.13 → 0.1.34-beta.15

package/apply.mjs

@@ -0,0 +1,60 @@
+// apply.mjs — Apply sync plan (file operations). Zero dependencies.
+
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+function writeConflictMarkers(filePath, localContent, registryContent) {
+  writeFileSync(filePath, [
+    '<<<<<<< LOCAL',
+    localContent.trimEnd(),
+    '=======',
+    registryContent.trimEnd(),
+    '>>>>>>> REGISTRY',
+    '',
+  ].join('\n'));
+}
+
+/**
+ * Apply actions to the workspace.
+ * All actions are file-level (no directory-level operations).
+ *
+ * @param {Array} actions
+ * @param {{ teamNS?: string }} opts
+ *   teamNS — when set, replaces all occurrences of `$TEAM_NS` in file content
+ *   with this value. Used when pulling [template] as a renamed team namespace.
+ * @returns {number} count of files with conflicts
+ */
+export function applyActions(actions, { teamNS } = {}) {
+  let conflicts = 0;
+
+  for (const act of actions) {
+    switch (act.action) {
+      case 'ADD':
+      case 'UPDATE':
+        mkdirSync(dirname(act.targetPath), { recursive: true });
+        if (teamNS && act.sourcePath.endsWith('.md')) {
+          const content = readFileSync(act.sourcePath, 'utf8').replaceAll('$TEAM_NS', teamNS);
+          writeFileSync(act.targetPath, content);
+        } else {
+          cpSync(act.sourcePath, act.targetPath);
+        }
+        break;
+
+      case 'CONFLICT': {
+        const local = existsSync(act.targetPath) ? readFileSync(act.targetPath, 'utf8') : '';
+        let registry = readFileSync(act.sourcePath, 'utf8');
+        if (teamNS) registry = registry.replaceAll('$TEAM_NS', teamNS);
+        mkdirSync(dirname(act.targetPath), { recursive: true });
+        writeConflictMarkers(act.targetPath, local, registry);
+        conflicts++;
+        break;
+      }
+
+      case 'ORPHAN':
+      case 'UNCHANGED':
+        break;
+    }
+  }
+
+  return conflicts;
+}

package/commands/drop.mjs

@@ -1,21 +1,18 @@
 // commands/drop.mjs — Remove file or synced path from workspace
 
-import { join } from 'node:path';
+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 { gitSparseList, gitSparseSet, isGitRepo } from '../git.mjs';
-import { REGISTRY_DIR } from '../constants.mjs';
+import { load as loadManifest, save as saveManifest } from '../manifest.mjs';
 
 export function dropCommand(args) {
   const input = args._positional?.[0];
   const cwd = process.cwd();
-  const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
-  const localDir = join(cwd, '.aw_registry');
-  const workspaceDir = existsSync(join(localDir, '.sync-config.json')) ? localDir : GLOBAL_AW_DIR;
+  const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw drop');
 
@@ -26,10 +23,7 @@ export function dropCommand(args) {
   const cfg = config.load(workspaceDir);
   if (!cfg) fmt.cancel('No .sync-config.json found. Run: aw init');
 
-  if (!isGitRepo(workspaceDir)) {
-    fmt.cancel('Registry not initialized as git repo. Run: aw init');
-  }
-
+  // Resolve to registry path (accepts both local and registry paths)
   const resolved = resolveInput(input, workspaceDir);
   const regPath = resolved.registryPath;
 
@@ -37,37 +31,58 @@ export function dropCommand(args) {
     fmt.cancel(`Could not resolve "${input}" to a registry path`);
   }
 
-  // Check if this is a top-level synced path → remove from sparse-checkout
+  // Check if this path (or a parent) is in config → remove from config + delete files
   const isConfigPath = cfg.include.some(p => p === regPath || p.startsWith(regPath + '/'));
 
   if (isConfigPath) {
     config.removePattern(workspaceDir, regPath);
     fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sync config`);
+  }
 
-    // Remove from sparse checkout
-    const sparsePath = `${REGISTRY_DIR}/${regPath}`;
-    const currentPaths = gitSparseList(workspaceDir);
-    const newPaths = currentPaths.filter(p => p !== sparsePath && !p.startsWith(sparsePath + '/'));
+  // Delete matching local files
+  const removed = deleteMatchingFiles(workspaceDir, regPath);
 
-    if (newPaths.length !== currentPaths.length) {
-      gitSparseSet(workspaceDir, newPaths);
-      fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sparse checkout`);
-    }
-  } else {
-    // Sub-path: delete local files (restored on next pull since still in sparse checkout)
-    const targetPath = join(workspaceDir, regPath);
-    if (existsSync(targetPath)) {
-      rmSync(targetPath, { recursive: true, force: true });
-      fmt.logInfo(`Removed ${chalk.cyan(regPath)} from workspace`);
-      fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
-    } else if (existsSync(targetPath + '.md')) {
-      rmSync(targetPath + '.md', { force: true });
-      fmt.logInfo(`Removed ${chalk.cyan(regPath)}.md from workspace`);
-      fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
-    } else {
-      fmt.cancel(`Nothing found for ${chalk.cyan(regPath)}.\n\n  Use ${chalk.dim('aw status')} to see synced paths.`);
-    }
+  if (removed > 0) {
+    fmt.logInfo(`${chalk.bold(removed)} file${removed > 1 ? 's' : ''} removed from workspace`);
+  } else if (!isConfigPath) {
+    fmt.cancel(`Nothing found for ${chalk.cyan(regPath)}.\n\n  Use ${chalk.dim('aw status')} to see synced paths.`);
+  }
+
+  if (!isConfigPath && removed > 0) {
+    fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
   }
 
   fmt.outro('Done');
 }
+
+/**
+ * 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$/, '');
+}

package/commands/init.mjs

@@ -1,25 +1,19 @@
-// commands/init.mjs — Clean init: persistent sparse git checkout, link IDEs, global git hooks.
+// commands/init.mjs — Clean init: clone registry, link IDEs, global git hooks.
 //
-// Layout:
-//   ~/.aw_repo/       — git clone (repo root)
-//   ~/.aw_registry/   — symlink → ~/.aw_repo/.aw_registry/
-//
-// No temp dirs. No manifest hashing. Git handles sync natively.
+// 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, cpSync, readFileSync, readdirSync, renameSync, lstatSync, rmSync } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, symlinkSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 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 {
-  gitInit, gitPull, gitSparseAdd, gitSparseList, gitSparseSet, gitLsRemote,
-  isGitRepo, withLock, includeToSparsePaths, addGitExcludes,
-  GLOBAL_GIT_DIR,
-} from '../git.mjs';
-import { REGISTRY_BASE_BRANCH, REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { pullCommand, pullAsync } from './pull.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
@@ -36,6 +30,7 @@ const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
 // ── IDE tasks for auto-pull ─────────────────────────────────────────────
 
 function installIdeTasks() {
+  // VS Code / Cursor task — runs aw pull on folder open
   const vscodeTask = {
     version: '2.0.0',
     tasks: [
@@ -50,15 +45,18 @@ 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');
@@ -75,85 +73,27 @@ function saveManifest(data) {
   writeFileSync(MANIFEST_PATH, JSON.stringify(data, null, 2) + '\n');
 }
 
-const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
-/**
- * Bootstrap a new namespace from [template].
- * Copies [template]/ → folderName/, replaces $TEAM_NS.
- */
-function bootstrapFromTemplate(folderName, teamNS) {
-  // Template and target are inside GLOBAL_AW_DIR (which IS .aw_registry/)
-  const templateDir = join(GLOBAL_AW_DIR, '[template]');
-  const targetDir = join(GLOBAL_AW_DIR, ...folderName.split('/'));
-
-  if (!existsSync(templateDir)) {
-    throw new Error('Template directory not found. Ensure [template] is in sparse checkout.');
-  }
+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;
 
-  cpSync(templateDir, targetDir, { recursive: true });
-  walkAndReplace(targetDir, '$TEAM_NS', teamNS);
-}
+    const counts = { ADD: 0, UPDATE: 0, CONFLICT: 0 };
+    for (const a of typeActions) counts[a.action] = (counts[a.action] || 0) + 1;
 
-function walkAndReplace(dir, search, replace) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkAndReplace(fullPath, search, replace);
-    } else if (entry.name.endsWith('.md')) {
-      const content = readFileSync(fullPath, 'utf8');
-      if (content.includes(search)) {
-        writeFileSync(fullPath, content.replaceAll(search, replace));
-      }
-    }
-  }
-}
-
-/**
- * Ensure platform/docs symlink points to content/ in the git repo root.
- */
-function ensureDocsSymlink() {
-  const docsLink = join(GLOBAL_AW_DIR, 'platform', 'docs');
-  const contentDir = join(GLOBAL_GIT_DIR, 'content');
-
-  if (!existsSync(contentDir)) return;
-
-  try {
-    // Check if already a correct symlink
-    if (existsSync(docsLink) && lstatSync(docsLink).isSymbolicLink()) return;
-
-    // Remove existing real directory (sparse checkout creates it with just README.md)
-    if (existsSync(docsLink)) {
-      rmSync(docsLink, { recursive: true, force: true });
-    }
+    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(', ')})` : '';
 
-    mkdirSync(dirname(docsLink), { recursive: true });
-    // Relative: .aw_repo/.aw_registry/platform/docs → ../../../content
-    symlinkSync('../../../content', docsLink);
-  } catch { /* best effort */ }
-}
-
-/**
- * Create the ~/.aw_registry symlink pointing to the .aw_registry/ subdir inside the git repo.
- */
-function ensureWorkspaceSymlink() {
-  const target = join(GLOBAL_GIT_DIR, REGISTRY_DIR);
-
-  if (existsSync(GLOBAL_AW_DIR)) {
-    // Already exists — check if it's the right symlink
-    try {
-      if (lstatSync(GLOBAL_AW_DIR).isSymbolicLink()) return; // already a symlink, good
-    } catch { /* */ }
-    return; // exists as real dir, handled by caller (backup)
-  }
-
-  // Ensure parent dir for the symlink target exists
-  if (!existsSync(target)) {
-    mkdirSync(target, { recursive: true });
+    fmt.logSuccess(`${chalk.cyan(pattern)}: ${typeActions.length} ${type}${detail}`);
   }
-
-  symlinkSync(target, GLOBAL_AW_DIR);
 }
 
+const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
+
 export async function initCommand(args) {
   const namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
@@ -175,11 +115,12 @@ export async function initCommand(args) {
     ].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;
-  const folderName = subTeam ? `${team}/${subTeam}` : team;
+  const teamNS = subTeam ? `${team}-${subTeam}` : team;          // for $TEAM_NS replacement
+  const folderName = subTeam ? `${team}/${subTeam}` : team;       // for .aw_registry/ path
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
@@ -210,59 +151,63 @@ export async function initCommand(args) {
     fmt.cancel(`Invalid sub-team '${subTeam}' — must match: ${SLUG_RE}`);
   }
 
-  const cwd = process.cwd();
-  const hasGitRepo = existsSync(GLOBAL_GIT_DIR) && existsSync(join(GLOBAL_GIT_DIR, '.git'));
   const hasConfig = config.exists(GLOBAL_AW_DIR);
+  const hasPlatform = existsSync(join(GLOBAL_AW_DIR, 'platform'));
+  const isExisting = hasConfig && hasPlatform;
+  const cwd = process.cwd();
 
   // ── Fast path: already initialized → just pull + link ─────────────────
 
-  if (hasGitRepo && hasConfig) {
+  if (isExisting) {
     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,
+      });
+      config.addPattern(GLOBAL_AW_DIR, folderName);
+    } else {
+      if (!silent) fmt.logStep('Already initialized — syncing...');
+    }
 
-    await withLock(GLOBAL_AW_DIR, async () => {
-      if (!silent) fmt.logStep('Syncing registry...');
-      try {
-        const { updated, conflicts } = gitPull(GLOBAL_AW_DIR);
-        if (conflicts && !silent) {
-          fmt.logWarn('Merge conflicts detected — resolve manually in ~/.aw_repo/');
-        }
-      } catch (e) {
-        if (!silent) fmt.logWarn(`Pull failed: ${e.message}`);
-      }
-
-      if (isNewSubTeam) {
-        if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
-
-        const nsExists = gitLsRemote(GLOBAL_AW_DIR, folderName);
-        if (nsExists) {
-          gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/${folderName}`]);
-        } else {
-          gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/[template]`]);
-          try { gitPull(GLOBAL_AW_DIR); } catch { /* already up to date */ }
-          bootstrapFromTemplate(folderName, teamNS);
-          // Remove [template] from sparse checkout
-          const currentPaths = gitSparseList(GLOBAL_AW_DIR);
-          const cleanPaths = currentPaths.filter(p => !p.includes('[template]'));
-          if (cleanPaths.length !== currentPaths.length) {
-            gitSparseSet(GLOBAL_AW_DIR, cleanPaths);
-          }
-        }
-
-        config.addPattern(GLOBAL_AW_DIR, folderName);
-      }
-    }, { skipIfLocked: silent });
-
-    ensureDocsSymlink();
+    // 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);
+    }
+
+    // Re-link IDE dirs + hooks (idempotent)
     linkWorkspace(HOME);
     generateCommands(HOME);
-    copyInstructions(HOME, null, freshCfg?.namespace || team);
+    copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
-    setupMcp(HOME, freshCfg?.namespace || team);
+    setupMcp(HOME, freshCfg?.namespace || team) || [];
     if (cwd !== HOME) setupMcp(cwd, freshCfg?.namespace || team);
     installGlobalHooks();
 
+    // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
       try {
         symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
@@ -286,23 +231,6 @@ export async function initCommand(args) {
 
   // ── Full init: first time setup ───────────────────────────────────────
 
-  // Backup old non-git ~/.aw_registry/ if it's a real directory (not a symlink)
-  if (existsSync(GLOBAL_AW_DIR)) {
-    try {
-      if (!lstatSync(GLOBAL_AW_DIR).isSymbolicLink()) {
-        const backupDir = `${GLOBAL_AW_DIR}.bak-${new Date().toISOString().slice(0, 10)}`;
-        fmt.logWarn(`Existing ~/.aw_registry/ directory found — backing up to ${backupDir}`);
-        renameSync(GLOBAL_AW_DIR, backupDir);
-      }
-    } catch { /* */ }
-  }
-
-  // Backup old ~/.aw_repo/ if it exists but isn't a git repo
-  if (existsSync(GLOBAL_GIT_DIR) && !existsSync(join(GLOBAL_GIT_DIR, '.git'))) {
-    const backupDir = `${GLOBAL_GIT_DIR}.bak-${new Date().toISOString().slice(0, 10)}`;
-    renameSync(GLOBAL_GIT_DIR, backupDir);
-  }
-
   // Auto-detect user
   if (!user) {
     try {
@@ -310,74 +238,46 @@ export async function initCommand(args) {
     } 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 });
+
   fmt.note([
     `${chalk.dim('source:')}     ~/.aw_registry/`,
     folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
-    user ? `${chalk.dim('user:')}       ${user}` : null,
+    user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
-  // Step 1: Clone registry to ~/.aw_repo/
+  // Step 2: Pull registry content (parallel)
   const s = fmt.spinner();
   const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
-  s.start(`Cloning registry (${pullTargets})...`);
+  s.start(`Pulling ${pullTargets}...`);
 
-  const initialPaths = includeToSparsePaths(['platform']);
+  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 }),
+    );
+  }
 
+  let pullResults;
   try {
-    gitInit(REGISTRY_REPO, REGISTRY_BASE_BRANCH, GLOBAL_GIT_DIR, initialPaths);
-    s.stop('Repository cloned');
+    pullResults = await Promise.all(pullJobs);
+    s.stop(`Pulled ${pullTargets}`);
   } catch (e) {
-    s.stop(chalk.red('Clone failed'));
+    s.stop(chalk.red('Pull failed'));
     fmt.cancel(e.message);
   }
 
-  // Step 2: Symlink ~/.aw_registry → ~/.aw_repo/.aw_registry
-  ensureWorkspaceSymlink();
-
-  // Step 3: Add git excludes for local config files
-  addGitExcludes(GLOBAL_GIT_DIR, [
-    `${REGISTRY_DIR}/.sync-config.json`,
-    `${REGISTRY_DIR}/.aw-manifest.json`,
-    '.aw-lock/',
-  ]);
-
-  // Step 4: Write config (goes into the symlinked dir)
-  const newCfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
-
-  // Step 5: Add namespace via sparse-checkout
-  if (folderName) {
-    const s2 = fmt.spinner();
-    s2.start(`Setting up namespace ${chalk.cyan(folderName)}...`);
-
-    const nsExists = gitLsRemote(GLOBAL_AW_DIR, folderName);
-    if (nsExists) {
-      gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/${folderName}`]);
-      s2.stop(`Namespace ${chalk.cyan(folderName)} checked out`);
-    } else {
-      // Temporarily add [template] to sparse checkout, bootstrap, then remove it
-      gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/[template]`]);
-      bootstrapFromTemplate(folderName, teamNS);
-      // Remove [template] from sparse checkout — no longer needed
-      const currentPaths = gitSparseList(GLOBAL_AW_DIR);
-      const cleanPaths = currentPaths.filter(p => !p.includes('[template]'));
-      if (cleanPaths.length !== currentPaths.length) {
-        gitSparseSet(GLOBAL_AW_DIR, cleanPaths);
-      }
-      s2.stop(`Namespace ${chalk.cyan(folderName)} bootstrapped from template`);
-    }
-
-    config.addPattern(GLOBAL_AW_DIR, folderName);
-  }
-
-  if (!newCfg.include.includes('platform')) {
-    config.addPattern(GLOBAL_AW_DIR, 'platform');
+  for (const { pattern, actions } of pullResults) {
+    printPullSummary(pattern, actions);
   }
 
-  // Step 6: Docs symlink
-  ensureDocsSymlink();
-
-  // Step 7: Link IDE dirs + setup tasks
+  // Step 3: Link IDE dirs + setup tasks
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
   generateCommands(HOME);
@@ -388,7 +288,7 @@ export async function initCommand(args) {
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
-  // Step 8: Symlink in current directory
+  // Step 4: 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'));
@@ -396,12 +296,11 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 9: Write install manifest for nuke cleanup
+  // Step 5: Write manifest for nuke cleanup
   const manifest = {
-    version: 2,
+    version: 1,
     installedAt: new Date().toISOString(),
     globalDir: GLOBAL_AW_DIR,
-    gitDir: GLOBAL_GIT_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),
@@ -410,12 +309,14 @@ export async function initCommand(args) {
   };
   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/ (git)`,
+    `  ${chalk.green('✓')} Source of truth: ~/.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

@@ -286,20 +286,8 @@ export function nukeCommand(args) {
     } catch { /* not installed via npm or no permissions */ }
   }
 
-  // 9. Remove ~/.aw_repo/ (git clone) and ~/.aw_registry/ (symlink or dir)
-  const GLOBAL_GIT_DIR = join(HOME, '.aw_repo');
-  if (existsSync(GLOBAL_GIT_DIR)) {
-    rmSync(GLOBAL_GIT_DIR, { recursive: true, force: true });
-    fmt.logStep('Removed ~/.aw_repo/');
-  }
-  // Remove ~/.aw_registry/ — may be a symlink (new) or real dir (legacy)
-  try {
-    if (lstatSync(GLOBAL_AW_DIR).isSymbolicLink()) {
-      unlinkSync(GLOBAL_AW_DIR);
-    } else {
-      rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
-    }
-  } catch { rmSync(GLOBAL_AW_DIR, { recursive: true, force: true }); }
+  // 9. Remove ~/.aw_registry/ itself (source of truth — last!)
+  rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
   fmt.logStep('Removed ~/.aw_registry/');
 
   fmt.outro([