@ghl-ai/aw 0.1.25-beta.1 → 0.1.25-beta.11

package/cli.mjs

@@ -71,8 +71,9 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init --namespace <team>', 'Initialize workspace (required)'),
+    cmd('aw init --namespace <team/sub-team>', 'Initialize workspace (required)'),
     `  ${chalk.dim('Teams: revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
+    `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
 
     sec('Download'),
     cmd('aw pull', 'Re-pull all synced paths (like git pull)'),
@@ -99,7 +100,7 @@ function printHelp() {
     sec('Examples'),
     '',
     `  ${chalk.dim('# Pull content from registry using path')}`,
-    cmd('aw pull ghl', 'All shared platform agents & skills'),
+    cmd('aw pull platform', 'All shared platform agents & skills'),
     cmd('aw pull <team>', 'Everything from a team namespace'),
     cmd('aw pull <team>/agents', 'All agents from a team'),
     cmd('aw pull <team>/agents/<name>', 'One specific agent'),

package/commands/init.mjs

@@ -13,7 +13,7 @@ import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { pullCommand } from './pull.mjs';
+import { pullCommand, pullAsync } from './pull.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
@@ -112,6 +112,24 @@ function saveManifest(data) {
 }
 
 
+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 = ['revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
@@ -128,45 +146,102 @@ export async function initCommand(args) {
     fmt.cancel([
       `Missing required ${chalk.bold('--namespace')} flag`,
       '',
-      `  ${chalk.dim('Usage:')}  aw init --namespace <team>`,
+      `  ${chalk.dim('Usage:')}  aw init --namespace <team/sub-team>`,
       `  ${chalk.dim('Teams:')}  ${list}`,
       '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce')}`,
+      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
     ].join('\n'));
   }
 
-  if (namespace && !ALLOWED_NAMESPACES.includes(namespace)) {
+  // 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
+
+  if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
     fmt.cancel([
-      `Unknown namespace ${chalk.red(namespace)}`,
+      `Unknown team ${chalk.red(team)}`,
       '',
       `  ${chalk.dim('Allowed:')} ${list}`,
       '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce')}`,
+      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
     ].join('\n'));
   }
 
-  if (namespace && !/^[a-z][a-z0-9-]{1,38}[a-z0-9]$/.test(namespace)) {
-    fmt.cancel(`Invalid namespace '${namespace}' — must match: ^[a-z][a-z0-9-]{1,38}[a-z0-9]$`);
+  if (team && !subTeam) {
+    fmt.cancel([
+      `Missing sub-team in ${chalk.red(namespace)}`,
+      '',
+      `  ${chalk.dim('Format:')}  --namespace <team>/<sub-team>`,
+      '',
+      `  ${chalk.dim('Example:')} ${chalk.bold(`aw init --namespace ${team}/courses`)}`,
+    ].join('\n'));
   }
 
-  const isExisting = config.exists(GLOBAL_AW_DIR);
+  const SLUG_RE = /^[a-z][a-z0-9-]{1,38}[a-z0-9]$/;
+  if (team && !SLUG_RE.test(team)) {
+    fmt.cancel(`Invalid team '${team}' — must match: ${SLUG_RE}`);
+  }
+  if (subTeam && !SLUG_RE.test(subTeam)) {
+    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;
   const cwd = process.cwd();
 
   // ── Fast path: already initialized → just pull + link ─────────────────
 
   if (isExisting) {
-    if (!silent) fmt.logStep('Already initialized — syncing...');
+    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...');
+    }
 
-    // Pull latest
-    pullCommand({ ...args, _positional: [], _workspaceDir: GLOBAL_AW_DIR, '--silent': silent });
+    // Pull latest (parallel)
+    // cfg.include has the renamed namespace (e.g. 'revex/courses'), but the repo
+    // only has '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 (idempotent)
     linkWorkspace(HOME);
     generateCommands(HOME);
-    copyInstructions(HOME, null, namespace) || [];
+    copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
-    setupMcp(HOME, namespace) || [];
+    setupMcp(HOME, freshCfg?.namespace || team) || [];
 
     // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
@@ -178,7 +253,7 @@ export async function initCommand(args) {
 
     if (!silent) {
       fmt.outro([
-        'Sync complete',
+        isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Sync complete',
         '',
         `  ${chalk.green('✓')} Registry updated`,
         `  ${chalk.green('✓')} IDE integration refreshed`,
@@ -200,36 +275,53 @@ export async function initCommand(args) {
   // Step 1: Create global source of truth
   mkdirSync(GLOBAL_AW_DIR, { recursive: true });
 
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace, user });
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
 
   fmt.note([
     `${chalk.dim('source:')}     ~/.aw_registry/`,
-    namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
     user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
-  // Step 2: Pull registry content
-  pullCommand({ ...args, _positional: ['ghl'], _workspaceDir: GLOBAL_AW_DIR });
+  // 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 }),
+    );
+  }
 
-  if (namespace) {
-    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR });
+  let pullResults;
+  try {
+    pullResults = await Promise.all(pullJobs);
+    s.stop(`Pulled ${pullTargets}`);
+  } catch (e) {
+    s.stop(chalk.red('Pull failed'));
+    fmt.cancel(e.message);
+  }
+
+  for (const { pattern, actions } of pullResults) {
+    printPullSummary(pattern, actions);
   }
 
-  // Step 3: Link to global IDE dirs
+  // Step 3: Link IDE dirs + setup tasks
+  fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
   generateCommands(HOME);
-  const instructionFiles = copyInstructions(HOME, null, namespace) || [];
+  const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
-  const mcpFiles = setupMcp(HOME, namespace) || [];
-
-  // Step 4: Git template hook (omnipresence)
+  const mcpFiles = setupMcp(HOME, team) || [];
   const gitTemplateInstalled = installGitTemplate();
-
-  // Step 5: IDE auto-init tasks
   installIdeTasks();
 
-  // Step 6: Symlink in current directory if it's a git repo
+  // 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'));
@@ -237,7 +329,7 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 7: Write manifest for nuke cleanup
+  // Step 5: Write manifest for nuke cleanup
   const manifest = {
     version: 1,
     installedAt: new Date().toISOString(),

package/commands/pull.mjs

@@ -7,7 +7,7 @@ import { execSync } from 'node:child_process';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { sparseCheckout, cleanup, includeToSparsePaths } from '../git.mjs';
+import { sparseCheckout, sparseCheckoutAsync, cleanup, includeToSparsePaths } from '../git.mjs';
 import { walkRegistryTree } from '../registry.mjs';
 import { matchesAny } from '../glob.mjs';
 import { computePlan } from '../plan.mjs';
@@ -17,7 +17,15 @@ import { resolveInput } from '../paths.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
-export function pullCommand(args) {
+// Platform-level types to skip (CLI meta-docs, not useful as agent content)
+const SKIP_PLATFORM_TYPES = new Set(['commands']);
+
+function filterActions(actions, pattern) {
+  if (pattern !== 'platform') return actions;
+  return actions.filter(a => !SKIP_PLATFORM_TYPES.has(a.type));
+}
+
+export async function pullCommand(args) {
   const input = args._positional?.[0] || '';
   const cwd = process.cwd();
   const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
@@ -27,6 +35,7 @@ export function pullCommand(args) {
   const verbose = args['-v'] === true || args['--verbose'] === true;
   const silent = args['--silent'] === true || args._silent === true;
   const renameNamespace = args._renameNamespace || null;
+  const teamNSOverride = args._teamNS || null;
 
   // Silent mode: wrap fmt to suppress all output and exit cleanly on errors
   const log = {
@@ -41,7 +50,7 @@ export function pullCommand(args) {
     spinner: silent ? () => ({ start: () => {}, stop: () => {} }) : fmt.spinner,
   };
 
-  // No args = re-pull everything in sync config
+  // No args = re-pull everything in sync config (parallel)
   if (!input) {
     const cfg = config.load(workspaceDir);
     if (!cfg) log.cancel('No .sync-config.json found. Run: aw init');
@@ -49,9 +58,19 @@ export function pullCommand(args) {
       log.cancel('Nothing to pull. Add paths first:\n\n  aw pull <path>');
     }
     log.logInfo(`Pulling ${chalk.cyan(cfg.include.length)} synced path${cfg.include.length > 1 ? 's' : ''}...`);
-    for (const p of cfg.include) {
-      pullCommand({ ...args, _positional: [p], _skipIntegrate: true });
-    }
+    const pullJobs = cfg.include.map(p => {
+      const isTeamNs = p !== 'platform';
+      const derivedTeamNS = isTeamNs ? p.replace(/\//g, '-') : undefined;
+      return pullAsync({
+        ...args,
+        _positional: [isTeamNs ? '[template]' : p],
+        _workspaceDir: workspaceDir,
+        _skipIntegrate: true,
+        _renameNamespace: isTeamNs ? p : undefined,
+        _teamNS: derivedTeamNS,
+      });
+    });
+    await Promise.all(pullJobs);
     // Post-pull IDE integration (once after all paths pulled)
     linkWorkspace(cwd);
     generateCommands(cwd);
@@ -145,9 +164,10 @@ export function pullCommand(args) {
     }
 
     // Compute plan
-    const { actions } = computePlan(registryDirs, workspaceDir, [pattern], {
+    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], {
       skipOrphans: true,
     });
+    const actions = filterActions(rawActions, pattern);
 
     if (dryRun) {
       printDryRun(actions, verbose);
@@ -157,7 +177,7 @@ export function pullCommand(args) {
     // Apply
     const s2 = log.spinner();
     s2.start('Applying changes...');
-    const conflictCount = applyActions(actions, { teamNS: renameNamespace || undefined });
+    const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
     updateManifest(workspaceDir, actions, cfg.namespace);
     s2.stop('Changes applied');
 
@@ -191,6 +211,84 @@ export function pullCommand(args) {
   }
 }
 
+/**
+ * Async pull for parallel use by init. Runs git fetch asynchronously,
+ * then applies changes synchronously. Returns a summary object instead
+ * of printing directly — the caller controls output.
+ */
+export async function pullAsync(args) {
+  const input = args._positional?.[0] || '';
+  const workspaceDir = args._workspaceDir;
+  const renameNamespace = args._renameNamespace || null;
+  const teamNSOverride = args._teamNS || null;
+
+  const resolved = resolveInput(input, workspaceDir);
+  let pattern = resolved.registryPath;
+  if (!pattern) throw new Error(`Could not resolve "${input}" to a registry path`);
+
+  if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
+
+  const cfg = config.load(workspaceDir);
+  if (!cfg) throw new Error('No .sync-config.json found');
+
+  const sparsePaths = includeToSparsePaths([pattern]);
+  const tempDir = await sparseCheckoutAsync(cfg.repo, sparsePaths);
+
+  try {
+    const registryDirs = [];
+    const regBase = join(tempDir, 'registry');
+
+    if (existsSync(regBase)) {
+      for (const name of listDirs(regBase)) {
+        registryDirs.push({ name, path: join(regBase, name) });
+      }
+    }
+
+    if (registryDirs.length === 0) {
+      throw new Error(`Nothing found in registry for ${pattern}`);
+    }
+
+    if (renameNamespace) {
+      for (const rd of registryDirs) {
+        if (rd.name === pattern) rd.name = renameNamespace;
+      }
+      pattern = renameNamespace;
+    }
+
+    let hasMatch = false;
+    for (const { name, path } of registryDirs) {
+      const entries = walkRegistryTree(path, name);
+      if (entries.some(e => matchesAny(e.registryPath, [pattern]))) {
+        hasMatch = true;
+        break;
+      }
+    }
+
+    if (!hasMatch) {
+      throw new Error(`Nothing found in registry for ${pattern}`);
+    }
+
+    if (!cfg.include.includes(pattern)) {
+      config.addPattern(workspaceDir, pattern);
+    }
+
+    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
+    const actions = filterActions(rawActions, pattern);
+    const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
+    updateManifest(workspaceDir, actions, cfg.namespace);
+
+    const ROOT_REGISTRY_FILES = ['AW-PROTOCOL.md'];
+    for (const fname of ROOT_REGISTRY_FILES) {
+      const src = join(regBase, fname);
+      if (existsSync(src)) copyFileSync(src, join(workspaceDir, fname));
+    }
+
+    return { pattern, actions, conflictCount };
+  } finally {
+    cleanup(tempDir);
+  }
+}
+
 function listDirs(dir) {
   return readdirSync(dir, { withFileTypes: true })
     .filter(d => d.isDirectory() && !d.name.startsWith('.'))

package/commands/push.mjs

@@ -92,8 +92,8 @@ export function pushCommand(args) {
   const namespacePath = namespaceParts.join('/');
   const topNamespace = namespaceParts[0];
 
-  if (topNamespace === 'ghl') {
-    fmt.cancel("Cannot push to 'ghl' namespace — it is the shared platform layer");
+  if (topNamespace === 'platform') {
+    fmt.cancel("Cannot push to 'platform' namespace — it is the shared platform layer");
   }
 
   const isDir = statSync(absPath).isDirectory();

package/git.mjs

@@ -1,13 +1,16 @@
 // git.mjs — Git sparse checkout helpers. Zero dependencies.
 
-import { execSync } from 'node:child_process';
+import { execSync, exec as execCb } from 'node:child_process';
 import { mkdtempSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { promisify } from 'node:util';
 import { REGISTRY_BASE_BRANCH } from './constants.mjs';
 
+const exec = promisify(execCb);
+
 /**
- * Sparse-checkout registry paths from GitHub.
+ * Sparse-checkout registry paths from GitHub (sync).
  * Returns the temp directory path containing the checkout.
  */
 export function sparseCheckout(repo, paths) {
@@ -35,6 +38,31 @@ export function sparseCheckout(repo, paths) {
   return tempDir;
 }
 
+/**
+ * Sparse-checkout registry paths from GitHub (async).
+ * Same as sparseCheckout but non-blocking — can run in parallel.
+ */
+export async function sparseCheckoutAsync(repo, paths) {
+  const tempDir = mkdtempSync(join(tmpdir(), 'aw-'));
+
+  const repoUrl = repo.startsWith('http') ? repo : `https://github.com/${repo}.git`;
+  try {
+    await exec(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${tempDir}"`);
+  } catch (e) {
+    throw new Error(`Failed to clone ${repo}. Check your git credentials and repo access.`);
+  }
+
+  try {
+    await exec('git sparse-checkout init --cone', { cwd: tempDir });
+    await exec(`git sparse-checkout set --skip-checks ${paths.map(p => `"${p}"`).join(' ')}`, { cwd: tempDir });
+    await exec(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir });
+  } catch (e) {
+    throw new Error(`Failed sparse checkout: ${e.message}`);
+  }
+
+  return tempDir;
+}
+
 /**
  * Clean up temp directory.
  */

package/link.mjs

@@ -3,6 +3,7 @@
 import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 
 const IDE_DIRS = ['.claude', '.cursor', '.codex'];
@@ -66,9 +67,12 @@ function cleanIdeSymlinks(cwd) {
     if (!existsSync(ideDir)) continue;
     cleanSymlinksRecursive(ideDir);
   }
-  // Also clean .agents/skills/
-  const agentsSkillsDir = join(cwd, '.agents', 'skills');
-  if (existsSync(agentsSkillsDir)) cleanSymlinksRecursive(agentsSkillsDir);
+  // Also clean .agents/skills/ (global only — Codex reads from ~/.agents/skills/)
+  const HOME = homedir();
+  if (cwd === HOME) {
+    const agentsSkillsDir = join(cwd, '.agents', 'skills');
+    if (existsSync(agentsSkillsDir)) cleanSymlinksRecursive(agentsSkillsDir);
+  }
 }
 
 /**
@@ -184,20 +188,22 @@ export function linkWorkspace(cwd) {
     }
   }
 
-  // Codex per-skill symlinks: .agents/skills/<name>
-  const agentsSkillsDir = join(cwd, '.agents/skills');
-  for (const ns of namespaces) {
-    for (const { typeDirPath: skillsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'skills')) {
-      mkdirSync(agentsSkillsDir, { recursive: true });
-      for (const skill of listDirs(skillsDir)) {
-        const flat = [ns, ...segments, skill].join('-');
-        const linkPath = join(agentsSkillsDir, flat);
-        const targetPath = join(skillsDir, skill);
-        const relTarget = relative(agentsSkillsDir, targetPath);
-        try {
-          execSync(`ln -sfn "${relTarget}" "${linkPath}"`, { stdio: 'pipe' });
-          created++;
-        } catch { /* best effort */ }
+  // Codex per-skill symlinks: ~/.agents/skills/<name> (global only)
+  if (cwd === homedir()) {
+    const agentsSkillsDir = join(cwd, '.agents/skills');
+    for (const ns of namespaces) {
+      for (const { typeDirPath: skillsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'skills')) {
+        mkdirSync(agentsSkillsDir, { recursive: true });
+        for (const skill of listDirs(skillsDir)) {
+          const flat = [ns, ...segments, skill].join('-');
+          const linkPath = join(agentsSkillsDir, flat);
+          const targetPath = join(skillsDir, skill);
+          const relTarget = relative(agentsSkillsDir, targetPath);
+          try {
+            execSync(`ln -sfn "${relTarget}" "${linkPath}"`, { stdio: 'pipe' });
+            created++;
+          } catch { /* best effort */ }
+        }
       }
     }
   }

package/package.json

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

package/plan.mjs

@@ -24,11 +24,12 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
         continue;
       }
 
-      // For skill files: key includes relative path to avoid collisions
-      // For other files: key is type/slug
+      // Key must include namespacePath to avoid collisions when the same
+      // slug exists under different domains (e.g. backend/agents/developer
+      // vs frontend/agents/developer).
       const key = entry.skillRelPath
-        ? `${entry.type}/${entry.slug}/${entry.skillRelPath}`
-        : `${entry.type}/${entry.slug}`;
+        ? `${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath}`
+        : `${entry.namespacePath}/${entry.type}/${entry.slug}`;
       plan.set(key, { ...entry, source: entry.namespacePath || name });
     }
   }
@@ -108,9 +109,10 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
         }
       }
       if (typeIdx === -1) continue;
+      const namespace = parts.slice(0, typeIdx).join('/');
       const type = parts[typeIdx];
       const slug = parts[typeIdx + 1]?.replace(/\.md$/, '');
-      const key = `${type}/${slug}`;
+      const key = `${namespace}/${type}/${slug}`;
       if (!plan.has(key)) {
         actions.push({
           slug,