@ghl-ai/aw 0.1.34-beta.10 → 0.1.34-beta.12

package/commands/drop.mjs

@@ -54,8 +54,8 @@ export function dropCommand(args) {
       fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sparse checkout`);
     }
   } else {
-    // Sub-path: delete local files (they become "deleted" in git status, restored on next pull)
-    const targetPath = join(workspaceDir, REGISTRY_DIR, regPath);
+    // 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`);

package/commands/init.mjs

@@ -1,8 +1,12 @@
 // commands/init.mjs — Clean init: persistent sparse git checkout, link IDEs, global git hooks.
 //
-// No temp dirs. No manifest hashing. ~/.aw_registry/ IS the git repo.
+// Layout:
+//   ~/.aw_repo/       — git clone (repo root)
+//   ~/.aw_registry/   — symlink → ~/.aw_repo/.aw_registry/
+//
+// No temp dirs. No manifest hashing. Git handles sync natively.
 
-import { mkdirSync, existsSync, writeFileSync, symlinkSync, cpSync, readFileSync, readdirSync, renameSync } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, symlinkSync, cpSync, readFileSync, readdirSync, renameSync, lstatSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
@@ -11,8 +15,9 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import {
-  gitInit, gitPull, gitSparseAdd, gitLsRemote,
-  isGitRepo, withLock, includeToSparsePaths,
+  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 { linkWorkspace } from '../link.mjs';
@@ -74,19 +79,18 @@ const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen'
 
 /**
  * Bootstrap a new namespace from [template].
- * Copies [template]/ → folderName/, replaces $TEAM_NS, removes local [template] copy.
+ * Copies [template]/ → folderName/, replaces $TEAM_NS.
  */
 function bootstrapFromTemplate(folderName, teamNS) {
-  const templateDir = join(GLOBAL_AW_DIR, REGISTRY_DIR, '[template]');
-  const targetDir = join(GLOBAL_AW_DIR, REGISTRY_DIR, ...folderName.split('/'));
+  // 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.');
   }
 
   cpSync(templateDir, targetDir, { recursive: true });
-
-  // Replace $TEAM_NS in .md files
   walkAndReplace(targetDir, '$TEAM_NS', teamNS);
 }
 
@@ -105,20 +109,44 @@ function walkAndReplace(dir, search, replace) {
 }
 
 /**
- * Ensure platform/docs symlink points to ../../content.
+ * Ensure platform/docs symlink points to content/ in the git repo root.
  */
 function ensureDocsSymlink() {
-  const docsLink = join(GLOBAL_AW_DIR, REGISTRY_DIR, 'platform', 'docs');
-  const contentDir = join(GLOBAL_AW_DIR, 'content');
+  const docsLink = join(GLOBAL_AW_DIR, 'platform', 'docs');
+  const contentDir = join(GLOBAL_GIT_DIR, 'content');
 
   if (existsSync(contentDir) && !existsSync(docsLink)) {
     try {
       mkdirSync(dirname(docsLink), { recursive: true });
-      symlinkSync('../../content', docsLink);
+      // Relative symlink: .aw_registry/platform/docs → ../../../content
+      // (from ~/.aw_repo/.aw_registry/platform/docs to ~/.aw_repo/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 });
+  }
+
+  symlinkSync(target, GLOBAL_AW_DIR);
+}
+
 export async function initCommand(args) {
   const namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
@@ -176,7 +204,7 @@ export async function initCommand(args) {
   }
 
   const cwd = process.cwd();
-  const hasGitRepo = existsSync(GLOBAL_AW_DIR) && isGitRepo(GLOBAL_AW_DIR);
+  const hasGitRepo = existsSync(GLOBAL_GIT_DIR) && existsSync(join(GLOBAL_GIT_DIR, '.git'));
   const hasConfig = config.exists(GLOBAL_AW_DIR);
 
   // ── Fast path: already initialized → just pull + link ─────────────────
@@ -186,38 +214,38 @@ export async function initCommand(args) {
     const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
 
     await withLock(GLOBAL_AW_DIR, async () => {
-      // Pull latest
       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_registry/');
+          fmt.logWarn('Merge conflicts detected — resolve manually in ~/.aw_repo/');
         }
       } catch (e) {
         if (!silent) fmt.logWarn(`Pull failed: ${e.message}`);
       }
 
-      // Add new namespace if needed
       if (isNewSubTeam) {
         if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
 
-        // Check if namespace exists in remote
         const nsExists = gitLsRemote(GLOBAL_AW_DIR, folderName);
         if (nsExists) {
           gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/${folderName}`]);
         } else {
-          // Template bootstrap
           gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/[template]`]);
-          // Pull to get template content
           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 });
 
-    // Re-link IDE dirs + hooks (idempotent)
     ensureDocsSymlink();
     const freshCfg = config.load(GLOBAL_AW_DIR);
     linkWorkspace(HOME);
@@ -228,7 +256,6 @@ export async function initCommand(args) {
     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'));
@@ -252,11 +279,21 @@ export async function initCommand(args) {
 
   // ── Full init: first time setup ───────────────────────────────────────
 
-  // Backup old non-git ~/.aw_registry/ if it exists
-  if (existsSync(GLOBAL_AW_DIR) && !isGitRepo(GLOBAL_AW_DIR)) {
-    const backupDir = `${GLOBAL_AW_DIR}.bak-${new Date().toISOString().slice(0, 10)}`;
-    fmt.logWarn(`Existing non-git ~/.aw_registry/ found — backing up to ${backupDir}`);
-    renameSync(GLOBAL_AW_DIR, backupDir);
+  // 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
@@ -266,8 +303,6 @@ export async function initCommand(args) {
     } catch { /* git not configured */ }
   }
 
-  const cfg = config.exists(GLOBAL_AW_DIR) ? config.load(GLOBAL_AW_DIR) : null;
-
   fmt.note([
     `${chalk.dim('source:')}     ~/.aw_registry/`,
     folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
@@ -275,7 +310,7 @@ export async function initCommand(args) {
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
-  // Step 1: Clone registry as persistent sparse checkout
+  // Step 1: Clone registry to ~/.aw_repo/
   const s = fmt.spinner();
   const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
   s.start(`Cloning registry (${pullTargets})...`);
@@ -283,18 +318,27 @@ export async function initCommand(args) {
   const initialPaths = includeToSparsePaths(['platform']);
 
   try {
-    const repo = cfg?.repo || REGISTRY_REPO;
-    gitInit(repo, REGISTRY_BASE_BRANCH, GLOBAL_AW_DIR, initialPaths);
+    gitInit(REGISTRY_REPO, REGISTRY_BASE_BRANCH, GLOBAL_GIT_DIR, initialPaths);
     s.stop('Repository cloned');
   } catch (e) {
     s.stop(chalk.red('Clone failed'));
     fmt.cancel(e.message);
   }
 
-  // Step 2: Write config now that dir exists
+  // 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 3: Add namespace via sparse-checkout
+  // Step 5: Add namespace via sparse-checkout
   if (folderName) {
     const s2 = fmt.spinner();
     s2.start(`Setting up namespace ${chalk.cyan(folderName)}...`);
@@ -304,24 +348,29 @@ export async function initCommand(args) {
       gitSparseAdd(GLOBAL_AW_DIR, [`${REGISTRY_DIR}/${folderName}`]);
       s2.stop(`Namespace ${chalk.cyan(folderName)} checked out`);
     } else {
-      // Template bootstrap
+      // 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);
   }
 
-  // Always track platform
   if (!newCfg.include.includes('platform')) {
     config.addPattern(GLOBAL_AW_DIR, 'platform');
   }
 
-  // Step 4: Docs symlink
+  // Step 6: Docs symlink
   ensureDocsSymlink();
 
-  // Step 5: Link IDE dirs + setup tasks
+  // Step 7: Link IDE dirs + setup tasks
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
   generateCommands(HOME);
@@ -332,7 +381,7 @@ export async function initCommand(args) {
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
-  // Step 6: Symlink in current directory
+  // Step 8: Symlink in current directory
   if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
     try {
       symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
@@ -340,11 +389,12 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 7: Write install manifest for nuke cleanup
+  // Step 9: Write install manifest for nuke cleanup
   const manifest = {
     version: 2,
     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),
@@ -353,10 +403,8 @@ 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',
     '',

package/commands/nuke.mjs

@@ -286,8 +286,20 @@ 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 });
+  // 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 }); }
   fmt.logStep('Removed ~/.aw_registry/');
 
   fmt.outro([

package/commands/pull.mjs

@@ -11,7 +11,7 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import {
-  gitPull, gitSparseAdd, gitLsRemote, isGitRepo, withLock,
+  gitPull, gitSparseAdd, gitLsRemote, isGitRepo, withLock, resolveRepoRoot,
 } from '../git.mjs';
 import { REGISTRY_BASE_BRANCH, REGISTRY_DIR } from '../constants.mjs';
 import { resolveInput } from '../paths.mjs';
@@ -165,10 +165,11 @@ export async function pullCommand(args) {
 // ── Helpers ──────────────────────────────────────────────────────────
 
 function dryRunDiff(workspaceDir, log) {
+  const repoDir = resolveRepoRoot(workspaceDir);
   try {
-    execSync('git fetch origin', { cwd: workspaceDir, stdio: 'pipe' });
+    execSync('git fetch origin', { cwd: repoDir, stdio: 'pipe' });
     const diff = execSync(`git diff HEAD..origin/${REGISTRY_BASE_BRANCH} --stat`, {
-      cwd: workspaceDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
 
     if (diff.trim()) {
@@ -184,9 +185,10 @@ function dryRunDiff(workspaceDir, log) {
 }
 
 function printConflicts(workspaceDir, log) {
+  const repoDir = resolveRepoRoot(workspaceDir);
   try {
     const output = execSync('git diff --name-only --diff-filter=U', {
-      cwd: workspaceDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     const conflictFiles = output.trim().split('\n').filter(Boolean);
 
@@ -195,7 +197,7 @@ function printConflicts(workspaceDir, log) {
       log.note(
         lines + '\n\n' +
         chalk.dim('Resolve conflicts, then run:\n') +
-        chalk.dim('  cd ~/.aw_registry && git add -A && git merge --continue'),
+        chalk.dim('  cd ~/.aw_repo && git add -A && git merge --continue'),
         chalk.red('Merge Conflicts')
       );
     }

package/commands/push.mjs

@@ -87,11 +87,13 @@ function collectModifiedFiles(workspaceDir) {
     // Only files under .aw_registry/
     if (!entry.path.startsWith(REGISTRY_DIR + '/')) continue;
 
+    // regRelPath is relative to .aw_registry/ (e.g. "platform/agents/foo.md")
     const regRelPath = entry.path.slice(REGISTRY_DIR.length + 1);
     const meta = parseRegistryPath(regRelPath);
     if (!meta) continue;
 
-    const absPath = join(workspaceDir, entry.path);
+    // workspaceDir IS .aw_registry/, so absPath uses regRelPath (not the full git-relative path)
+    const absPath = join(workspaceDir, regRelPath);
     if (!existsSync(absPath)) continue;
 
     files.push({

package/commands/status.mjs

@@ -138,7 +138,7 @@ export function statusCommand(args) {
 
   // Hints
   if (conflicts.length > 0) {
-    fmt.logWarn(`Resolve conflicts: ${chalk.dim('cd ~/.aw_registry && git diff --name-only --diff-filter=U')}`);
+    fmt.logWarn(`Resolve conflicts: ${chalk.dim('cd ~/.aw_repo && git diff --name-only --diff-filter=U')}`);
   }
   if (untracked.length > 0 || modified.length > 0) {
     fmt.logInfo(`Push changes: ${chalk.dim('aw push')} or ${chalk.dim('aw push <path>')}`);

package/git.mjs

@@ -1,28 +1,63 @@
-// git.mjs — Git-native sync engine. Persistent sparse checkout at ~/.aw_registry/.
+// git.mjs — Git-native sync engine. Persistent sparse checkout.
 //
-// The global registry dir IS a git repo. Pull = git pull. Status = git status.
-// No temp dirs, no manifest hashing, no plan/apply pipeline.
+// Layout:
+//   ~/.aw_repo/          — the git clone (repo root, has .git/)
+//   ~/.aw_registry/      — symlink → ~/.aw_repo/.aw_registry/
+//
+// All git commands run at the repo root. Callers pass workspaceDir
+// (~/.aw_registry/) and functions auto-resolve to the repo root.
 
 import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync, rmSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, rmSync, statSync, realpathSync, readFileSync, appendFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
 import { REGISTRY_BASE_BRANCH, REGISTRY_DIR, DOCS_SOURCE_DIR } from './constants.mjs';
 
+/** Where the git repo is cloned (the actual .git/ lives here). */
+export const GLOBAL_GIT_DIR = join(homedir(), '.aw_repo');
+
+// ── Repo root resolution ─────────────────────────────────────────────
+
+/**
+ * Resolve a workspace/target dir to the git repo root (where .git/ lives).
+ *
+ * - ~/.aw_repo/ → ~/.aw_repo/ (direct)
+ * - ~/.aw_registry/ (symlink → ~/.aw_repo/.aw_registry/) → ~/.aw_repo/
+ * - Any dir with .git/ → that dir
+ */
+export function resolveRepoRoot(dir) {
+  // Direct .git check
+  if (existsSync(join(dir, '.git'))) return dir;
+
+  // Resolve symlinks and walk up to find .git/
+  try {
+    let resolved = realpathSync(dir);
+    for (let i = 0; i < 3; i++) {
+      const parent = dirname(resolved);
+      if (parent === resolved) break; // reached filesystem root
+      if (existsSync(join(parent, '.git'))) return parent;
+      resolved = parent;
+    }
+  } catch { /* not a valid path */ }
+
+  return dir; // fallback — caller will get a git error if it's not a repo
+}
+
 // ── Core operations ──────────────────────────────────────────────────
 
 /**
- * Clone + sparse-checkout init. Creates a persistent repo at targetDir.
+ * Clone + sparse-checkout init. Creates a persistent repo at gitDir.
  *
  * @param {string} repo — GitHub owner/name or full URL
  * @param {string} branch — branch to checkout
- * @param {string} targetDir — e.g. ~/.aw_registry
+ * @param {string} gitDir — repo root (e.g. ~/.aw_repo)
  * @param {string[]} sparsePaths — initial sparse-checkout paths
  */
-export function gitInit(repo, branch, targetDir, sparsePaths) {
+export function gitInit(repo, branch, gitDir, sparsePaths) {
   const repoUrl = repo.startsWith('http') ? repo : `https://github.com/${repo}.git`;
 
   try {
-    execSync(`git clone --filter=blob:none --sparse "${repoUrl}" "${targetDir}"`, {
+    execSync(`git clone --filter=blob:none --sparse "${repoUrl}" "${gitDir}"`, {
       stdio: 'pipe',
     });
   } catch (e) {
@@ -30,13 +65,13 @@ export function gitInit(repo, branch, targetDir, sparsePaths) {
   }
 
   try {
-    execSync('git sparse-checkout init --cone', { cwd: targetDir, stdio: 'pipe' });
+    execSync('git sparse-checkout init --cone', { cwd: gitDir, stdio: 'pipe' });
     if (sparsePaths.length > 0) {
       execSync(`git sparse-checkout set --skip-checks ${sparsePaths.map(p => `"${p}"`).join(' ')}`, {
-        cwd: targetDir, stdio: 'pipe',
+        cwd: gitDir, stdio: 'pipe',
       });
     }
-    execSync(`git checkout ${branch}`, { cwd: targetDir, stdio: 'pipe' });
+    execSync(`git checkout ${branch}`, { cwd: gitDir, stdio: 'pipe' });
   } catch (e) {
     throw new Error(`Failed sparse checkout: ${e.message}`);
   }
@@ -44,12 +79,14 @@ export function gitInit(repo, branch, targetDir, sparsePaths) {
 
 /**
  * Fetch + merge. Returns { updated, conflicts, summary }.
+ * @param {string} targetDir — workspace or git dir (auto-resolved)
  */
 export function gitPull(targetDir) {
+  const repoDir = resolveRepoRoot(targetDir);
   const branch = REGISTRY_BASE_BRANCH;
 
   try {
-    execSync('git fetch origin', { cwd: targetDir, stdio: 'pipe' });
+    execSync('git fetch origin', { cwd: repoDir, stdio: 'pipe' });
   } catch (e) {
     throw new Error(`Fetch failed: ${e.message}`);
   }
@@ -60,11 +97,10 @@ export function gitPull(targetDir) {
 
   try {
     summary = execSync(`git merge origin/${branch} --no-edit`, {
-      cwd: targetDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     updated = !summary.includes('Already up to date');
   } catch (e) {
-    // Merge conflict
     const stderr = e.stderr?.toString() || '';
     const stdout = e.stdout?.toString() || '';
     if (stderr.includes('CONFLICT') || stdout.includes('CONFLICT')) {
@@ -80,12 +116,13 @@ export function gitPull(targetDir) {
 }
 
 /**
- * Add paths to sparse-checkout (additive — keeps existing paths).
+ * Add paths to sparse-checkout (additive).
  */
 export function gitSparseAdd(targetDir, paths) {
   if (paths.length === 0) return;
+  const repoDir = resolveRepoRoot(targetDir);
   execSync(`git sparse-checkout add --skip-checks ${paths.map(p => `"${p}"`).join(' ')}`, {
-    cwd: targetDir, stdio: 'pipe',
+    cwd: repoDir, stdio: 'pipe',
   });
 }
 
@@ -93,8 +130,9 @@ export function gitSparseAdd(targetDir, paths) {
  * Replace sparse-checkout paths entirely.
  */
 export function gitSparseSet(targetDir, paths) {
+  const repoDir = resolveRepoRoot(targetDir);
   execSync(`git sparse-checkout set --skip-checks ${paths.map(p => `"${p}"`).join(' ')}`, {
-    cwd: targetDir, stdio: 'pipe',
+    cwd: repoDir, stdio: 'pipe',
   });
 }
 
@@ -102,9 +140,10 @@ export function gitSparseSet(targetDir, paths) {
  * Get sparse-checkout list.
  */
 export function gitSparseList(targetDir) {
+  const repoDir = resolveRepoRoot(targetDir);
   try {
     const output = execSync('git sparse-checkout list', {
-      cwd: targetDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     return output.trim().split('\n').filter(Boolean);
   } catch {
@@ -114,12 +153,13 @@ export function gitSparseList(targetDir) {
 
 /**
  * Git porcelain status. Returns array of { status, path }.
- * Status codes: M=modified, ??=untracked, D=deleted, A=added, UU/AA=conflict
+ * Paths are relative to repo root (e.g. ".aw_registry/platform/agents/foo.md").
  */
 export function gitStatus(targetDir) {
+  const repoDir = resolveRepoRoot(targetDir);
   try {
     const output = execSync('git status --porcelain', {
-      cwd: targetDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     if (!output.trim()) return [];
     return output.trim().split('\n').map(line => {
@@ -134,12 +174,12 @@ export function gitStatus(targetDir) {
 
 /**
  * Check if a path exists in the remote tree (without checking it out).
- * Used to detect if a namespace already exists in the registry.
  */
 export function gitLsRemote(targetDir, path) {
+  const repoDir = resolveRepoRoot(targetDir);
   try {
     const output = execSync(`git ls-tree -d HEAD "${REGISTRY_DIR}/${path}"`, {
-      cwd: targetDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: repoDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
     });
     return output.trim().length > 0;
   } catch {
@@ -148,10 +188,13 @@ export function gitLsRemote(targetDir, path) {
 }
 
 /**
- * Check if targetDir is a git repo.
+ * Check if targetDir (or its resolved parent) is backed by a git repo.
  */
 export function isGitRepo(targetDir) {
-  return existsSync(join(targetDir, '.git'));
+  if (existsSync(join(targetDir, '.git'))) return true;
+  // Check if it's a symlink into a git repo
+  const resolved = resolveRepoRoot(targetDir);
+  return existsSync(join(resolved, '.git'));
 }
 
 // ── Concurrency lock ─────────────────────────────────────────────────
@@ -160,15 +203,12 @@ const LOCK_DIR_NAME = '.aw-lock';
 const LOCK_STALE_MS = 30_000;
 
 /**
- * Acquire a directory-based lock, run fn, release.
- * @param {string} targetDir
- * @param {Function} fn — async or sync function to run under lock
- * @param {{ skipIfLocked?: boolean }} opts
+ * Acquire a directory-based lock on the git repo, run fn, release.
  */
 export async function withLock(targetDir, fn, { skipIfLocked = false } = {}) {
-  const lockDir = join(targetDir, LOCK_DIR_NAME);
+  const repoDir = resolveRepoRoot(targetDir);
+  const lockDir = join(repoDir, LOCK_DIR_NAME);
 
-  // Check for stale lock
   if (existsSync(lockDir)) {
     try {
       const age = Date.now() - statSync(lockDir).mtimeMs;
@@ -177,7 +217,6 @@ export async function withLock(targetDir, fn, { skipIfLocked = false } = {}) {
       } else if (skipIfLocked) {
         return null;
       } else {
-        // Wait briefly then retry
         await new Promise(r => setTimeout(r, 1000));
         if (existsSync(lockDir)) {
           throw new Error('Another aw instance is running. Retry in a moment.');
@@ -205,14 +244,24 @@ export async function withLock(targetDir, fn, { skipIfLocked = false } = {}) {
   }
 }
 
+/**
+ * Add patterns to .git/info/exclude so local config files don't show in git status.
+ */
+export function addGitExcludes(gitDir, patterns) {
+  const excludePath = join(gitDir, '.git', 'info', 'exclude');
+  try {
+    const existing = existsSync(excludePath) ? readFileSync(excludePath, 'utf8') : '';
+    const toAdd = patterns.filter(p => !existing.includes(p));
+    if (toAdd.length > 0) {
+      appendFileSync(excludePath, '\n# aw local config\n' + toAdd.join('\n') + '\n');
+    }
+  } catch { /* best effort */ }
+}
+
 // ── Path helpers ─────────────────────────────────────────────────────
 
 /**
  * Compute sparse checkout paths from include paths.
- * e.g., ["platform", "dev/agents/debugger"] -> [".aw_registry/platform", ".aw_registry/dev/agents/debugger"]
- *
- * When "platform" is in the paths, also includes the repo's docs source
- * directory (content/) so docs are pulled on-the-fly into platform/docs/.
  */
 export function includeToSparsePaths(paths) {
   const result = new Set();

package/link.mjs

@@ -21,7 +21,7 @@ const ALL_KNOWN_TYPES = new Set([...FILE_TYPES, 'skills', 'commands', 'evals', '
 function listNamespaceDirs(awDir) {
   if (!existsSync(awDir)) return [];
   return readdirSync(awDir, { withFileTypes: true })
-    .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+    .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== '[template]')
     .map(d => d.name);
 }
 

package/package.json

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