@ghl-ai/aw 0.1.25-beta.9 → 0.1.26-beta.1

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)'),

package/commands/init.mjs

@@ -146,26 +146,47 @@ 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 (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'));
   }
 
-  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]$`);
+  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);
@@ -176,21 +197,40 @@ export async function initCommand(args) {
   // ── 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 (parallel)
-    // cfg.include has the renamed namespace (e.g. 'revex'), but the repo
-    // only has 'registry/[template]/' — remap non-platform entries back.
-    const cfg = config.load(GLOBAL_AW_DIR);
-    if (cfg && cfg.include.length > 0) {
-      const pullJobs = cfg.include.map(p => {
+    // 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);
@@ -199,9 +239,9 @@ export async function initCommand(args) {
     // 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'))) {
@@ -213,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`,
@@ -235,26 +275,26 @@ 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 (parallel)
   const s = fmt.spinner();
-  const pullTargets = namespace ? `platform + ${namespace}` : 'platform';
+  const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
   s.start(`Pulling ${pullTargets}...`);
 
   const pullJobs = [
     pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
   ];
-  if (namespace) {
+  if (folderName) {
     pullJobs.push(
-      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
+      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: folderName, _teamNS: teamNS, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
     );
   }
 
@@ -275,9 +315,9 @@ export async function initCommand(args) {
   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) || [];
+  const mcpFiles = setupMcp(HOME, team) || [];
   const gitTemplateInstalled = installGitTemplate();
   installIdeTasks();
 

package/commands/pull.mjs

@@ -8,6 +8,7 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { sparseCheckout, sparseCheckoutAsync, cleanup, includeToSparsePaths } from '../git.mjs';
+import { REGISTRY_DIR } from '../constants.mjs';
 import { walkRegistryTree } from '../registry.mjs';
 import { matchesAny } from '../glob.mjs';
 import { computePlan } from '../plan.mjs';
@@ -17,6 +18,13 @@ import { resolveInput } from '../paths.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
+// Filter out top-level platform CLI meta-commands (drop, pull, push, etc.)
+// but keep domain-specific commands (platform/design/commands/, platform/infra/commands/).
+function filterActions(actions, pattern) {
+  if (pattern !== 'platform') return actions;
+  return actions.filter(a => !(a.type === 'commands' && a.namespacePath === 'platform'));
+}
+
 export async function pullCommand(args) {
   const input = args._positional?.[0] || '';
   const cwd = process.cwd();
@@ -27,6 +35,7 @@ export async 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 = {
@@ -51,12 +60,14 @@ export async function pullCommand(args) {
     log.logInfo(`Pulling ${chalk.cyan(cfg.include.length)} synced path${cfg.include.length > 1 ? 's' : ''}...`);
     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);
@@ -101,7 +112,7 @@ export async function pullCommand(args) {
 
   try {
     const registryDirs = [];
-    const regBase = join(tempDir, 'registry');
+    const regBase = join(tempDir, REGISTRY_DIR);
 
     if (existsSync(regBase)) {
       for (const name of listDirs(regBase)) {
@@ -153,9 +164,10 @@ export async 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);
@@ -165,7 +177,7 @@ export async 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');
 
@@ -208,6 +220,7 @@ 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;
@@ -223,7 +236,7 @@ export async function pullAsync(args) {
 
   try {
     const registryDirs = [];
-    const regBase = join(tempDir, 'registry');
+    const regBase = join(tempDir, REGISTRY_DIR);
 
     if (existsSync(regBase)) {
       for (const name of listDirs(regBase)) {
@@ -259,8 +272,9 @@ export async function pullAsync(args) {
       config.addPattern(workspaceDir, pattern);
     }
 
-    const { actions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
-    const conflictCount = applyActions(actions, { teamNS: renameNamespace || undefined });
+    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'];

package/commands/push.mjs

@@ -6,7 +6,7 @@ import { execSync, execFileSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { REGISTRY_REPO, REGISTRY_BASE_BRANCH } from '../constants.mjs';
+import { REGISTRY_REPO, REGISTRY_BASE_BRANCH, REGISTRY_DIR } from '../constants.mjs';
 import { resolveInput } from '../paths.mjs';
 import { load as loadManifest } from '../manifest.mjs';
 import { hashFile } from '../registry.mjs';
@@ -98,8 +98,8 @@ export function pushCommand(args) {
 
   const isDir = statSync(absPath).isDirectory();
   const registryTarget = isDir
-    ? `registry/${namespacePath}/${parentDir}/${slug}`
-    : `registry/${namespacePath}/${parentDir}/${slug}.md`;
+    ? `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}`
+    : `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}.md`;
 
   fmt.note(
     [
@@ -148,13 +148,13 @@ export function pushCommand(args) {
 
     // Check if this is a new namespace — auto-add CODEOWNERS entry
     let newNamespace = false;
-    const nsDir = join(tempDir, 'registry', topNamespace);
+    const nsDir = join(tempDir, REGISTRY_DIR, topNamespace);
     const codeownersPath = join(tempDir, 'CODEOWNERS');
     if (!existsSync(nsDir) || isNewNamespaceInCodeowners(codeownersPath, topNamespace)) {
       newNamespace = true;
       const ghUser = getGitHubUser();
       if (ghUser && existsSync(codeownersPath)) {
-        const line = `/registry/${topNamespace}/ @${ghUser}\n`;
+        const line = `/${REGISTRY_DIR}/${topNamespace}/ @${ghUser}\n`;
         appendFileSync(codeownersPath, line);
         execSync('git add CODEOWNERS', { cwd: tempDir, stdio: 'pipe' });
       }
@@ -236,5 +236,5 @@ function getGitHubUser() {
 function isNewNamespaceInCodeowners(codeownersPath, namespace) {
   if (!existsSync(codeownersPath)) return true;
   const content = readFileSync(codeownersPath, 'utf8');
-  return !content.includes(`/registry/${namespace}/`);
+  return !content.includes(`/${REGISTRY_DIR}/${namespace}/`);
 }

package/commands/search.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 { REGISTRY_BASE_BRANCH, REGISTRY_REPO } from '../constants.mjs';
+import { REGISTRY_BASE_BRANCH, REGISTRY_REPO, REGISTRY_DIR } from '../constants.mjs';
 
 export function searchCommand(args) {
   const query = (args._positional || []).join(' ').toLowerCase();
@@ -150,14 +150,14 @@ function searchRemote(repo, query) {
     try {
       // git archive fetches a single file from remote — no clone needed
       content = execSync(
-        `git archive --remote="${repoUrl}" ${REGISTRY_BASE_BRANCH} registry/registry.json | tar -xO registry/registry.json`,
+        `git archive --remote="${repoUrl}" ${REGISTRY_BASE_BRANCH} ${REGISTRY_DIR}/registry.json | tar -xO ${REGISTRY_DIR}/registry.json`,
         { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
       );
     } catch {
       // GitHub doesn't support git archive — fallback to gh API
       try {
         const raw = execSync(
-          `gh api "repos/${repo}/contents/registry/registry.json?ref=${REGISTRY_BASE_BRANCH}" --jq .content -H "Accept: application/vnd.github.v3+json"`,
+          `gh api "repos/${repo}/contents/${REGISTRY_DIR}/registry.json?ref=${REGISTRY_BASE_BRANCH}" --jq .content -H "Accept: application/vnd.github.v3+json"`,
           { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
         );
         content = Buffer.from(raw.trim(), 'base64').toString('utf8');
@@ -167,9 +167,9 @@ function searchRemote(repo, query) {
         try {
           execSync(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${tempDir}"`, { stdio: 'pipe' });
           execSync('git sparse-checkout init --cone', { cwd: tempDir, stdio: 'pipe' });
-          execSync('git sparse-checkout set --skip-checks "registry/registry.json"', { cwd: tempDir, stdio: 'pipe' });
+          execSync(`git sparse-checkout set --skip-checks "${REGISTRY_DIR}/registry.json"`, { cwd: tempDir, stdio: 'pipe' });
           execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir, stdio: 'pipe' });
-          content = readFileSync(join(tempDir, 'registry', 'registry.json'), 'utf8');
+          content = readFileSync(join(tempDir, REGISTRY_DIR, 'registry.json'), 'utf8');
         } finally {
           try { execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' }); } catch {}
         }

package/constants.mjs

@@ -1,7 +1,10 @@
 // constants.mjs — Single source of truth for registry settings.
 
 /** Base branch for PRs and sync checkout */
-export const REGISTRY_BASE_BRANCH = 'chore/restructure';
+export const REGISTRY_BASE_BRANCH = 'feat/aw-platform-docs';
 
 /** Default registry repository */
-export const REGISTRY_REPO = 'GoHighLevel/ghl-agentic-workspace';
+export const REGISTRY_REPO = 'GoHighLevel/platform-docs';
+
+/** Directory inside the registry repo that holds platform/ and [template]/ */
+export const REGISTRY_DIR = '.aw_registry';

package/git.mjs

@@ -5,7 +5,7 @@ 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';
+import { REGISTRY_BASE_BRANCH, REGISTRY_DIR } from './constants.mjs';
 
 const exec = promisify(execCb);
 
@@ -76,16 +76,13 @@ export function cleanup(tempDir) {
 
 /**
  * Compute sparse checkout paths from include paths.
- * e.g., ["platform", "dev/agents/debugger"] -> ["registry/platform", "registry/dev/agents/debugger"]
+ * e.g., ["platform", "dev/agents/debugger"] -> [".aw_registry/platform", ".aw_registry/dev/agents/debugger"]
  */
 export function includeToSparsePaths(paths) {
   const result = new Set();
   for (const p of paths) {
-    result.add(`registry/${p}`);
+    result.add(`${REGISTRY_DIR}/${p}`);
   }
-  // Also fetch root instruction files
-  result.add('registry/CLAUDE.md');
-  result.add('registry/AGENTS.md');
-  result.add('registry/AW-PROTOCOL.md');
+  result.add(`${REGISTRY_DIR}/AW-PROTOCOL.md`);
   return [...result];
 }

package/integrate.mjs

@@ -3,24 +3,11 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import * as fmt from './fmt.mjs';
-
-// AW CLI commands to generate
-const AW_COMMANDS = [
-  { name: 'pull',   description: 'Pull agents & skills from registry',           hint: '<path>' },
-  { name: 'push',   description: 'Push local changes to registry',               hint: '<path>' },
-  { name: 'status', description: 'Show workspace sync status',                   hint: '' },
-  { name: 'drop',   description: 'Stop syncing a path',                          hint: '<path>' },
-  { name: 'search', description: 'Search local and remote registry',             hint: '<query>' },
-  { name: 'nuke',   description: 'Remove entire .aw_registry/',            hint: '' },
-];
+import * as config from './config.mjs';
 
 /**
- * Generate /aw:* commands directly into namespace commands/ dirs.
- * Writes CLI commands + agent invoke commands alongside hand-written commands.
- * link.mjs symlinks everything from commands/ → .claude/commands/aw/ for discovery.
- *
- * A .generated-manifest.json tracks which files were generated so they can be
- * cleaned on rebuild without needing filename prefixes.
+ * Count hand-written commands already present in the registry.
+ * No CLI stub generation — all commands come from the registry itself.
  */
 export function generateCommands(cwd) {
   const awDir = join(cwd, '.aw_registry');
@@ -29,56 +16,15 @@ export function generateCommands(cwd) {
   const oldGenDir = join(awDir, '.generated-commands');
   if (existsSync(oldGenDir)) rmSync(oldGenDir, { recursive: true, force: true });
 
+  // Count hand-written commands across all namespaces for reporting
   let count = 0;
-  const namespaces = listNamespaceDirs(awDir);
-
+  const namespaces = getTeamNamespaces(awDir);
   for (const ns of namespaces) {
-    const commandsDir = join(awDir, ns, 'commands');
-    mkdirSync(commandsDir, { recursive: true });
-
-    // 1. CLI commands
-    for (const cmd of AW_COMMANDS) {
-      const fileName = `${cmd.name}.md`;
-      // Skip if a hand-written command with same name exists
-      if (existsSync(join(commandsDir, fileName))) continue;
-
-      const content = [
-        '---',
-        `name: aw:${cmd.name}`,
-        `description: ${cmd.description}`,
-        cmd.hint ? `argument-hint: "${cmd.hint}"` : null,
-        '---',
-        '',
-        'Run the following command:',
-        '',
-        '```',
-        `node bin/aw ${cmd.name} $ARGUMENTS`,
-        '```',
-        '',
-      ].filter(v => v !== null).join('\n');
-
-      writeFileSync(join(commandsDir, fileName), content);
-      count++;
+    const nsDir = join(awDir, ns);
+    if (existsSync(nsDir)) {
+      const cmdFiles = findFiles(nsDir, 'commands');
+      count += cmdFiles.length;
     }
-
-  }
-
-  // Codex skills — .agents/skills/<name>/SKILL.md
-  const agentsSkillsDir = join(cwd, '.agents/skills');
-  mkdirSync(agentsSkillsDir, { recursive: true });
-  for (const cmd of AW_COMMANDS) {
-    const skillDir = join(agentsSkillsDir, cmd.name);
-    mkdirSync(skillDir, { recursive: true });
-    const content = [
-      '---',
-      `name: ${cmd.name}`,
-      `description: ${cmd.description}`,
-      '---',
-      '',
-      `Run: \`node bin/aw ${cmd.name}\` followed by the user's arguments.`,
-      '',
-    ].join('\n');
-    writeFileSync(join(skillDir, 'SKILL.md'), content);
   }
 
   if (count > 0) {
@@ -88,6 +34,27 @@ export function generateCommands(cwd) {
   return count;
 }
 
+function findFiles(dir, typeName) {
+  const results = [];
+  function walk(d) {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === typeName) {
+          for (const f of readdirSync(full)) {
+            if (f.endsWith('.md')) results.push(join(full, f));
+          }
+        } else {
+          walk(full);
+        }
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
 /**
  * Copy CLAUDE.md and AGENTS.md to project root.
  */
@@ -98,7 +65,7 @@ export function copyInstructions(cwd, tempDir, namespace) {
     if (existsSync(dest)) continue;
 
     if (tempDir) {
-      const src = join(tempDir, 'registry', file);
+      const src = join(tempDir, '.aw_registry', file);
       if (existsSync(src)) {
         let content = readFileSync(src, 'utf8');
         if (namespace) {
@@ -460,10 +427,13 @@ No active tasks. Tasks are created during workflow execution.
   fmt.logSuccess('Created .aw_docs/ (local orchestration state)');
 }
 
-function listNamespaceDirs(awDir) {
-  if (!existsSync(awDir)) return [];
-  return readdirSync(awDir, { withFileTypes: true })
-    .filter(d => d.isDirectory() && !d.name.startsWith('.'))
-    .map(d => d.name);
+/**
+ * Return team namespace paths from config (excludes 'platform').
+ * E.g. ['revex/courses'] — generated CLI commands only go into team namespaces.
+ */
+function getTeamNamespaces(awDir) {
+  const cfg = config.load(awDir);
+  if (!cfg || !cfg.include) return [];
+  return cfg.include.filter(p => p !== 'platform');
 }
 

package/mcp.mjs

@@ -35,12 +35,12 @@ export function setupMcp(cwd, namespace) {
 
   const mcpUrl = paths.ghlMcpUrl;
 
-  const ghlAiServer = { type: 'url', url: mcpUrl };
+  const ghlAiServer = { type: 'http', url: mcpUrl };
   const gitJenkinsServer = paths.gitJenkinsPath
     ? { command: 'node', args: [paths.gitJenkinsPath] }
     : null;
 
-  // ── Claude Code: ~/.claude/settings.json ──
+  // ── Claude Code: ~/.claude/settings.json (global) ──
   const claudeSettingsPath = join(HOME, '.claude', 'settings.json');
   if (mergeJsonMcpServer(claudeSettingsPath, 'ghl-ai', ghlAiServer)) {
     updatedFiles.push(claudeSettingsPath);
@@ -49,7 +49,37 @@ export function setupMcp(cwd, namespace) {
     updatedFiles.push(claudeSettingsPath);
   }
 
-  // ── Cursor: ~/.cursor/mcp.json ──
+  // ── Claude Code: .mcp.json (project root — highest priority) ──
+  // Claude Code resolves project .mcp.json before global settings.json,
+  // so we must write here to ensure the HTTP URL takes precedence over
+  // any stale command-based configs in parent directories.
+  const projectMcpPath = join(cwd, '.mcp.json');
+  if (mergeJsonMcpServer(projectMcpPath, 'ghl-ai', ghlAiServer)) {
+    updatedFiles.push(projectMcpPath);
+  }
+
+  // ── Claude Code: .claude/mcp.json (workspace-level) ──
+  // Claude Code also reads .claude/mcp.json for workspace-scoped MCP config.
+  // Write here so the MCP server is available regardless of which resolution
+  // path Claude Code uses (root .mcp.json or .claude/mcp.json).
+  const claudeWorkspaceMcpPath = join(cwd, '.claude', 'mcp.json');
+  if (mergeJsonMcpServer(claudeWorkspaceMcpPath, 'ghl-ai', ghlAiServer)) {
+    updatedFiles.push(claudeWorkspaceMcpPath);
+  }
+  if (gitJenkinsServer && mergeJsonMcpServer(claudeWorkspaceMcpPath, 'git-jenkins', gitJenkinsServer)) {
+    updatedFiles.push(claudeWorkspaceMcpPath);
+  }
+
+  // ── Cursor: project .cursor/mcp.json (workspace-level) ──
+  const cursorProjectMcpPath = join(cwd, '.cursor', 'mcp.json');
+  if (mergeJsonMcpServer(cursorProjectMcpPath, 'ghl-ai', ghlAiServer)) {
+    updatedFiles.push(cursorProjectMcpPath);
+  }
+  if (gitJenkinsServer && mergeJsonMcpServer(cursorProjectMcpPath, 'git-jenkins', gitJenkinsServer)) {
+    updatedFiles.push(cursorProjectMcpPath);
+  }
+
+  // ── Cursor: ~/.cursor/mcp.json (global) ──
   const cursorMcpPath = join(HOME, '.cursor', 'mcp.json');
   if (mergeJsonMcpServer(cursorMcpPath, 'ghl-ai', ghlAiServer)) {
     updatedFiles.push(cursorMcpPath);
@@ -94,12 +124,18 @@ function mergeJsonMcpServer(filePath, serverName, serverConfig) {
     config.mcpServers = {};
   }
 
-  // Check if already configured with same URL
+  // Check if already configured with same config
   const existing = config.mcpServers[serverName];
   if (existing && JSON.stringify(existing) === JSON.stringify(serverConfig)) {
     return false;
   }
 
+  // If we're writing an HTTP URL server, remove any stale command-based config
+  // to prevent old local MCP servers from shadowing the remote one.
+  if (serverConfig.type === 'http' && existing && existing.command) {
+    fmt.logStep(`Replacing stale command-based '${serverName}' with HTTP URL`);
+  }
+
   config.mcpServers[serverName] = serverConfig;
 
   mkdirSync(join(filePath, '..'), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.25-beta.9",
+  "version": "0.1.26-beta.1",
   "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,