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

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, getLocalRegistryDir } 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 workspaceDir = join(cwd, '.aw_registry');
+
+  const HOME = homedir();
+  const AW_HOME = join(HOME, '.aw');
+  const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
+  const workspaceDir = getLocalRegistryDir(cwd, GLOBAL_AW_DIR);
 
   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,36 +1,46 @@
-// 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, readFileSync, rmSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join, dirname } from 'node:path';
+import { join, dirname, sep } 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, 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,
+  addProjectWorktree,
+  isWorktree,
+  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 +55,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 +76,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 +87,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,70 +122,113 @@ 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)
-    linkWorkspace(HOME);
-    generateCommands(HOME);
+    const freshCfg = config.load(GLOBAL_AW_DIR);
+
+    await installAwEcc(cwd, { silent });
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
     if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
-    // Link current project if needed
-    if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
+    // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
+    if (cwd !== HOME) {
+      const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
       try {
-        symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
-        if (!silent) fmt.logStep('Linked .aw_registry in current project');
+        const content = readFileSync(oldLocalHook, 'utf8');
+        if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+          rmSync(oldLocalHook);
+          if (!silent) fmt.logStep('Removed legacy .git/hooks/post-checkout');
+        }
+      } catch { /* not there, fine */ }
+    }
+
+    const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
+    if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
+      try {
+        addProjectWorktree(AW_HOME, cwd);
+        if (!silent) fmt.logStep('Linked current project as git worktree');
       } catch { /* best effort */ }
     }
 
+    // Wire ~/.claude/.cursor/.codex to the project's registry when in a project,
+    // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
+    const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
+    const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
+    linkWorkspace(HOME, awDirForLinks);
+    generateCommands(HOME);
+
     if (silent) {
       autoUpdate(await args._updateCheck);
     } else {
@@ -223,64 +237,76 @@ export async function initCommand(args) {
         '',
         `  ${chalk.green('✓')} Registry updated`,
         `  ${chalk.green('✓')} IDE integration refreshed`,
-        cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Current project linked` : null,
+        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Current project linked` : null,
       ].filter(Boolean).join('\n'));
     }
     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`, `CODEOWNERS`];
+  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}...`);
+  s.start(`Cloning registry...`);
 
-  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 {
-    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}`);
+    }
   }
 
-  // Step 3: Link IDE dirs + setup tasks
-  fmt.logStep('Linking IDE symlinks...');
-  linkWorkspace(HOME);
-  generateCommands(HOME);
+  // Create sync config
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  if (folderName) {
+    config.addPattern(GLOBAL_AW_DIR, folderName);
+  }
+
+  // Step 3: Setup tasks, MCP, hooks
+  await installAwEcc(cwd, { silent });
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
   const mcpFiles = await setupMcp(HOME, team) || [];
@@ -288,39 +314,46 @@ export async function initCommand(args) {
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
-  // Step 4: Symlink in current directory if it's a git repo
-  if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
+  // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
+  if (cwd !== HOME) {
+    const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
+    try {
+      const content = readFileSync(oldLocalHook, 'utf8');
+      if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+        rmSync(oldLocalHook);
+      }
+    } catch { /* not there, fine */ }
+  }
+
+  // Step 4: Link current project as a git worktree (gives IDE git panel)
+  const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
+  if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
     try {
-      symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
-      fmt.logStep('Linked .aw_registry in current project');
+      addProjectWorktree(AW_HOME, cwd);
+      fmt.logStep('Linked current project as git worktree');
     } 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);
+  // Step 5: Wire ~/.claude/.cursor/.codex to the project's registry when in a project,
+  // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
+  fmt.logStep('Linking IDE symlinks...');
+  const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
+  const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
+  linkWorkspace(HOME, awDirForLinks);
+  generateCommands(HOME);
 
   // 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`,
-    cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Linked in current project` : null,
+    cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${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`,