@ghl-ai/aw 0.1.32 → 0.1.34-beta.1

package/cli.mjs

@@ -73,7 +73,7 @@ function printHelp() {
   const help = [
     sec('Setup'),
     cmd('aw init --namespace <team/sub-team>', 'Initialize workspace (required)'),
-    `  ${chalk.dim('Teams: revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
+    `  ${chalk.dim('Teams: platform, revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
     `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
 
     sec('Download'),
@@ -82,9 +82,9 @@ function printHelp() {
     cmd('aw pull --dry-run <path>', 'Preview what would be downloaded'),
 
     sec('Upload'),
-    cmd('aw push', 'Show modified files ready to push'),
-    cmd('aw push <path>', 'Create a PR to add/update registry content'),
-    cmd('aw push --dry-run <path>', 'Preview the upload without creating PR'),
+    cmd('aw push', 'Push all modified files (creates one PR)'),
+    cmd('aw push <path>', 'Push file, folder, or namespace to registry'),
+    cmd('aw push --dry-run [path]', 'Preview what would be pushed'),
 
     sec('Discover'),
     cmd('aw search <query>', 'Find agents & skills (local + registry)'),
@@ -108,8 +108,10 @@ function printHelp() {
     cmd('aw pull <team>/skills/<name>', 'One specific skill folder'),
     '',
     `  ${chalk.dim('# Push your local changes to registry')}`,
-    cmd('aw push .aw_registry/agents/<name>.md', 'Upload an agent'),
-    cmd('aw push .aw_registry/skills/<name>/', 'Upload a skill folder'),
+    cmd('aw push', 'Push all modified files (one PR)'),
+    cmd('aw push .aw_registry/<team>/', 'Push entire namespace (one PR)'),
+    cmd('aw push .aw_registry/agents/<name>.md', 'Push a single agent'),
+    cmd('aw push .aw_registry/skills/<name>/', 'Push a single skill folder'),
     '',
     `  ${chalk.dim('# Remove content from workspace')}`,
     cmd('aw drop <team>', 'Stop syncing a namespace (removes all files)'),

package/commands/init.mjs

@@ -92,7 +92,7 @@ function printPullSummary(pattern, actions) {
   }
 }
 
-const ALLOWED_NAMESPACES = ['revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
+const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
   const namespace = args['--namespace'] || null;
@@ -133,7 +133,7 @@ export async function initCommand(args) {
     ].join('\n'));
   }
 
-  if (team && !subTeam) {
+  if (team && !subTeam && team !== 'platform') {
     fmt.cancel([
       `Missing sub-team in ${chalk.red(namespace)}`,
       '',

package/commands/push.mjs

@@ -1,7 +1,7 @@
-// commands/push.mjs — Push local agent/skill to registry via PR
+// commands/push.mjs — Push local agents/skills to registry via PR (single file or batch)
 
-import { existsSync, statSync, mkdirSync, cpSync, mkdtempSync, readFileSync, appendFileSync } from 'node:fs';
-import { basename, dirname, resolve, join } from 'node:path';
+import { existsSync, statSync, mkdirSync, cpSync, mkdtempSync, readFileSync, appendFileSync, readdirSync } from 'node:fs';
+import { basename, dirname, resolve, join, relative } from 'node:path';
 import { execSync, execFileSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import * as fmt from '../fmt.mjs';
@@ -9,112 +9,183 @@ import { chalk } from '../fmt.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';
-
-export function pushCommand(args) {
-  const input = args._positional?.[0];
-  const dryRun = args['--dry-run'] === true;
-  const repo = args['--repo'] || REGISTRY_REPO;
-  const cwd = process.cwd();
-  const workspaceDir = join(cwd, '.aw_registry');
-
-  fmt.intro('aw push');
+import { hashFile, walkRegistryTree } from '../registry.mjs';
+
+const PUSHABLE_TYPES = ['agents', 'skills', 'commands', 'evals'];
+
+// ── Batch file collection ────────────────────────────────────────────
+
+/**
+ * Collect all pushable files under a local .aw_registry folder.
+ * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
+ */
+function collectBatchFiles(folderAbsPath, workspaceDir) {
+  // Determine the namespace name from path relative to workspaceDir
+  const relPath = relative(workspaceDir, folderAbsPath);
+  const nameSegments = relPath.split('/');
+  const baseName = nameSegments[0];
+
+  const entries = walkRegistryTree(folderAbsPath, baseName);
+  return entries.map(entry => {
+    // Build the registry target path for git
+    const registryTarget = entry.type === 'skills'
+      ? `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath || entry.filename}`
+      : `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.filename}`;
+    return {
+      absPath: entry.sourcePath,
+      registryTarget,
+      type: entry.type,
+      namespace: entry.namespacePath,
+      slug: entry.slug,
+      isDir: false,
+    };
+  });
+}
 
-  // No args = find and list modified files for user to push
-  if (!input) {
-    const manifest = loadManifest(workspaceDir);
-    const modified = [];
-    for (const [key, entry] of Object.entries(manifest.files || {})) {
-      const filePath = join(workspaceDir, key);
-      if (!existsSync(filePath)) continue;
-      const currentHash = hashFile(filePath);
-      if (currentHash !== entry.sha256) {
-        modified.push(key);
+/**
+ * Collect all modified files from manifest (for no-args push).
+ * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
+ */
+function collectModifiedFiles(workspaceDir) {
+  const manifest = loadManifest(workspaceDir);
+  const files = [];
+  for (const [key, entry] of Object.entries(manifest.files || {})) {
+    const filePath = join(workspaceDir, key);
+    if (!existsSync(filePath)) continue;
+    const currentHash = hashFile(filePath);
+    if (currentHash !== entry.sha256) {
+      const meta = parseManifestKey(key);
+      if (meta) {
+        files.push({
+          absPath: filePath,
+          registryTarget: `${REGISTRY_DIR}/${key}`,
+          type: meta.type,
+          namespace: meta.namespace,
+          slug: meta.slug,
+          isDir: false,
+        });
       }
     }
-    if (modified.length === 0) {
-      fmt.cancel('Nothing to push — no modified files.\n\n  To push a specific file:\n  aw push <path>');
-    }
-    fmt.logInfo(`${chalk.bold(modified.length)} modified file${modified.length > 1 ? 's' : ''}:`);
-    for (const m of modified) {
-      fmt.logMessage(`  ${chalk.yellow(m)}`);
+  }
+  return files;
+}
+
+/**
+ * Parse a manifest key like "commerce/agents/unit-tester.md" into { type, namespace, slug }.
+ */
+function parseManifestKey(key) {
+  const parts = key.split('/');
+  for (let i = 0; i < parts.length; i++) {
+    if (PUSHABLE_TYPES.includes(parts[i]) && i + 1 < parts.length) {
+      return {
+        type: parts[i],
+        namespace: parts.slice(0, i).join('/'),
+        slug: parts[i + 1].replace(/\.md$/, ''),
+      };
     }
-    fmt.cancel(`\nSpecify which file to push:\n  aw push .aw_registry/${modified[0]}`);
   }
+  return null;
+}
 
-  // Resolve input — accept both registry path and local path
-  const resolved = resolveInput(input, workspaceDir);
+// ── PR content generation ────────────────────────────────────────────
 
-  if (!resolved.registryPath) {
-    const hint = input.startsWith('.claude/') || input.startsWith('.cursor/') || input.startsWith('.codex/')
-      ? `\n\n  Tip: Use the .aw_registry/ path instead:\n  aw push .aw_registry/${input.split('/').slice(1).join('/')}`
-      : '';
-    fmt.cancel(`Could not resolve "${input}" to a registry path.${hint}\n\n  Only files inside .aw_registry/ can be pushed.`);
+function generateBranchName(files) {
+  const shortId = Date.now().toString(36).slice(-5);
+  const namespaces = [...new Set(files.map(f => f.namespace))];
+
+  if (files.length === 1) {
+    const f = files[0];
+    const nsSlug = f.namespace.replace(/\//g, '-');
+    return `upload/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
   }
 
-  // Find the local file to upload
-  let absPath = resolved.localAbsPath;
-  if (!absPath || !existsSync(absPath)) {
-    // Try resolving with .md extension for flat files
-    if (absPath && !absPath.endsWith('.md') && existsSync(absPath + '.md')) {
-      absPath = absPath + '.md';
-    } else {
-      fmt.cancel(`File not found: ${absPath || input}\n\n  Only files inside .aw_registry/ can be pushed.\n  Use ${chalk.dim('aw status')} to see modified files.`);
-    }
+  if (namespaces.length === 1) {
+    return `sync/${namespaces[0].replace(/\//g, '-')}-${shortId}`;
   }
 
-  // Parse registry path to get type, namespace, slug
-  // The path must contain agents/, skills/, or commands/ as a parent directory.
-  // Nesting before that doesn't matter (e.g. platform/services/agents/ is fine).
-  const regParts = resolved.registryPath.split('/');
-  let typeIdx = -1;
-  const PUSHABLE_TYPES = ['agents', 'skills', 'commands', 'evals'];
-  for (let i = regParts.length - 1; i >= 0; i--) {
-    if (PUSHABLE_TYPES.includes(regParts[i])) { typeIdx = i; break; }
+  return `sync/batch-${shortId}`;
+}
+
+function generatePrTitle(files) {
+  if (files.length === 1) {
+    const f = files[0];
+    return `Add ${f.slug} (${f.type}) to ${f.namespace}`;
   }
 
-  if (typeIdx === -1 || typeIdx + 1 >= regParts.length) {
-    fmt.cancel([
-      `Invalid push path: ${chalk.red(resolved.registryPath)}`,
-      '',
-      `  Content must live under an ${chalk.bold('agents/')}, ${chalk.bold('skills/')}, ${chalk.bold('commands/')}, or ${chalk.bold('evals/')} directory.`,
+  const counts = {};
+  for (const f of files) {
+    counts[f.type] = (counts[f.type] || 0) + 1;
+  }
+  const countParts = Object.entries(counts).map(([type, count]) => `${count} ${type}`);
+  const namespaces = [...new Set(files.map(f => f.namespace))];
+
+  if (namespaces.length === 1) {
+    return `sync: ${countParts.join(', ')} in ${namespaces[0]}`;
+  }
+  return `sync: ${countParts.join(', ')} across ${namespaces.join(', ')}`;
+}
+
+function generatePrBody(files, newNamespaces) {
+  if (files.length === 1) {
+    const f = files[0];
+    const bodyParts = [
+      '## Registry Upload',
       '',
-      `  ${chalk.dim('Valid examples:')}`,
-      `    aw push .aw_registry/commerce/quality/agents/unit-tester.md`,
-      `    aw push .aw_registry/platform/services/skills/development`,
-      `    aw push .aw_registry/commerce/shared/commands/ship.md`,
-    ].join('\n'));
+      `- **Type:** ${f.type}`,
+      `- **Slug:** ${f.slug}`,
+      `- **Namespace:** ${f.namespace}`,
+      `- **Path:** \`${f.registryTarget}\``,
+    ];
+    if (newNamespaces.length > 0) {
+      bodyParts.push('', '> **New namespace** — CODEOWNERS entry auto-added.');
+    }
+    bodyParts.push('', 'Uploaded via `aw push`');
+    return bodyParts.join('\n');
   }
 
-  const namespaceParts = regParts.slice(0, typeIdx);
-  const parentDir = regParts[typeIdx];
-  const slug = regParts[typeIdx + 1];
-  const namespacePath = namespaceParts.join('/');
-  const topNamespace = namespaceParts[0];
+  // Batch body — group by type
+  const grouped = {};
+  for (const f of files) {
+    if (!grouped[f.type]) grouped[f.type] = [];
+    grouped[f.type].push(f);
+  }
 
-  if (topNamespace === 'platform') {
-    fmt.cancel("Cannot push to 'platform' namespace — it is the shared platform layer");
+  const bodyParts = ['## Registry Sync', ''];
+  for (const [type, items] of Object.entries(grouped)) {
+    bodyParts.push(`### ${type}`);
+    for (const item of items.sort((a, b) => a.slug.localeCompare(b.slug))) {
+      bodyParts.push(`- \`${item.slug}\` (${item.namespace})`);
+    }
+    bodyParts.push('');
   }
 
-  const isDir = statSync(absPath).isDirectory();
-  const registryTarget = isDir
-    ? `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}`
-    : `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}.md`;
+  if (newNamespaces.length > 0) {
+    bodyParts.push(`> **New namespace${newNamespaces.length > 1 ? 's' : ''}:** ${newNamespaces.join(', ')} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} auto-added.`);
+    bodyParts.push('');
+  }
+
+  bodyParts.push(`---`, `Synced via \`aw push\` (${files.length} files)`);
+  return bodyParts.join('\n');
+}
 
-  fmt.note(
-    [
-      `${chalk.dim('source:')}     ${absPath}`,
-      `${chalk.dim('type:')}       ${parentDir}`,
-      `${chalk.dim('namespace:')}  ${namespacePath}`,
-      `${chalk.dim('slug:')}       ${slug}`,
-      `${chalk.dim('target:')}     ${registryTarget}`,
-    ].join('\n'),
-    'Upload mapping'
-  );
+// ── Git pipeline (works for single file or batch) ────────────────────
+
+function pushFiles(files, { repo, dryRun }) {
+  // Summary
+  const counts = {};
+  for (const f of files) {
+    counts[f.type] = (counts[f.type] || 0) + 1;
+  }
+  const countParts = Object.entries(counts).map(([type, count]) => `${count} ${type}`);
+  fmt.logInfo(`${chalk.bold(files.length)} file${files.length > 1 ? 's' : ''} to push (${countParts.join(', ')})`);
 
   if (dryRun) {
+    for (const f of files) {
+      const ns = chalk.dim(` [${f.namespace}]`);
+      fmt.logMessage(`  ${chalk.yellow(f.type)}/${f.slug}${ns}`);
+    }
     fmt.logWarn('No changes made (--dry-run)');
-    fmt.outro(chalk.dim('Remove --dry-run to upload'));
+    fmt.outro(chalk.dim('Remove --dry-run to push'));
     return;
   }
 
@@ -129,43 +200,59 @@ export function pushCommand(args) {
     execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir, stdio: 'pipe' });
     s.stop('Repository cloned');
 
-    const shortId = Date.now().toString(36).slice(-5);
-    const branch = `upload/${namespacePath.replace(/\//g, '-')}-${parentDir}-${slug}-${shortId}`;
+    const branch = generateBranchName(files);
     execSync(`git checkout -b ${branch}`, { cwd: tempDir, stdio: 'pipe' });
 
     const s2 = fmt.spinner();
-    s2.start('Preparing upload...');
+    s2.start(`Copying ${files.length} file${files.length > 1 ? 's' : ''} to registry...`);
+
+    // Copy each file
+    let copyErrors = [];
+    for (const file of files) {
+      try {
+        const targetFull = join(tempDir, file.registryTarget);
+        mkdirSync(dirname(targetFull), { recursive: true });
+        if (file.isDir) {
+          cpSync(file.absPath, targetFull, { recursive: true });
+        } else {
+          cpSync(file.absPath, targetFull);
+        }
+      } catch (e) {
+        copyErrors.push({ file: file.registryTarget, error: e.message });
+      }
+    }
 
-    // Copy to target
-    const targetFull = join(tempDir, registryTarget);
-    if (isDir) {
-      mkdirSync(targetFull, { recursive: true });
-      cpSync(absPath, targetFull, { recursive: true });
-    } else {
-      mkdirSync(dirname(targetFull), { recursive: true });
-      cpSync(absPath, targetFull);
+    if (copyErrors.length > 0) {
+      for (const err of copyErrors) {
+        fmt.logWarn(`Failed to copy ${err.file}: ${err.error}`);
+      }
     }
 
-    // Check if this is a new namespace — auto-add CODEOWNERS entry
-    let newNamespace = false;
-    const nsDir = join(tempDir, REGISTRY_DIR, topNamespace);
+    // Check for new namespaces — auto-add CODEOWNERS entries
+    const topNamespaces = [...new Set(files.map(f => f.namespace.split('/')[0]))];
     const codeownersPath = join(tempDir, 'CODEOWNERS');
-    if (!existsSync(nsDir) || isNewNamespaceInCodeowners(codeownersPath, topNamespace)) {
-      newNamespace = true;
-      const ghUser = getGitHubUser();
-      if (ghUser && existsSync(codeownersPath)) {
-        const line = `/${REGISTRY_DIR}/${topNamespace}/ @${ghUser}\n`;
-        appendFileSync(codeownersPath, line);
-        execSync('git add CODEOWNERS', { cwd: tempDir, stdio: 'pipe' });
+    const newNamespaces = [];
+    for (const ns of topNamespaces) {
+      if (isNewNamespaceInCodeowners(codeownersPath, ns)) {
+        newNamespaces.push(ns);
+        const ghUser = getGitHubUser();
+        if (ghUser && existsSync(codeownersPath)) {
+          const line = `/${REGISTRY_DIR}/${ns}/ @${ghUser}\n`;
+          appendFileSync(codeownersPath, line);
+        }
       }
     }
+    if (newNamespaces.length > 0) {
+      execSync('git add CODEOWNERS', { cwd: tempDir, stdio: 'pipe' });
+    }
 
-    // Stage + commit + push + PR
-    execSync(`git add "${registryTarget}"`, { cwd: tempDir, stdio: 'pipe' });
+    // Stage all registry changes
+    execSync(`git add "${REGISTRY_DIR}"`, { cwd: tempDir, stdio: 'pipe' });
 
-    const commitMsg = newNamespace
-      ? `registry: create namespace ${topNamespace} + add ${parentDir}/${slug}`
-      : `registry: add ${parentDir}/${slug} to ${namespacePath}`;
+    const prTitle = generatePrTitle(files);
+    const commitMsg = files.length === 1
+      ? `registry: add ${files[0].type}/${files[0].slug} to ${files[0].namespace}`
+      : `registry: sync ${files.length} files (${countParts.join(', ')})`;
     execSync(`git commit -m "${commitMsg}"`, { cwd: tempDir, stdio: 'pipe' });
 
     s2.stop('Upload prepared');
@@ -175,21 +262,7 @@ export function pushCommand(args) {
 
     execSync(`git push -u origin ${branch}`, { cwd: tempDir, stdio: 'pipe' });
 
-    const bodyParts = [
-      '## Registry Upload',
-      '',
-      `- **Type:** ${parentDir}`,
-      `- **Slug:** ${slug}`,
-      `- **Namespace:** ${namespacePath}`,
-      `- **Path:** \`${registryTarget}\``,
-    ];
-    if (newNamespace) {
-      bodyParts.push('', '> **New namespace** — CODEOWNERS entry auto-added.');
-    }
-    bodyParts.push('', 'Uploaded via `aw push`');
-
-    const prTitle = `Add ${slug} (${parentDir}) to ${namespacePath}`;
-    const prBody = bodyParts.join('\n');
+    const prBody = generatePrBody(files, newNamespaces);
 
     // Try gh for PR creation, fall back to manual URL
     let prUrl;
@@ -201,27 +274,132 @@ export function pushCommand(args) {
         '--body', prBody,
       ], { cwd: tempDir, encoding: 'utf8' }).trim();
     } catch {
-      // gh not available — construct PR URL manually
       const repoBase = repo.replace(/\.git$/, '');
       prUrl = `https://github.com/${repoBase}/compare/${REGISTRY_BASE_BRANCH}...${branch}?expand=1`;
     }
 
     s3.stop('Branch pushed');
 
-    if (newNamespace) {
-      fmt.logInfo(`New namespace ${chalk.cyan(topNamespace)} — CODEOWNERS entry added`);
+    // Print summary
+    if (newNamespaces.length > 0) {
+      fmt.logInfo(`New namespace${newNamespaces.length > 1 ? 's' : ''} ${chalk.cyan(newNamespaces.join(', '))} — CODEOWNERS entr${newNamespaces.length > 1 ? 'ies' : 'y'} added`);
+    }
+    if (files.length > 1) {
+      for (const [type, items] of Object.entries(groupBy(files, 'type'))) {
+        fmt.logSuccess(`${items.length} ${type} pushed`);
+      }
     }
     fmt.logSuccess(`PR: ${chalk.cyan(prUrl)}`);
-    fmt.outro('Upload complete — open the link above to create the PR');
+    fmt.outro('Push complete');
   } catch (e) {
-    fmt.cancel(`Upload failed: ${e.message}`);
+    fmt.cancel(`Push failed: ${e.message}`);
   } finally {
     execSync(`rm -rf "${tempDir}"`, { stdio: 'pipe' });
   }
 }
 
+function groupBy(arr, key) {
+  const result = {};
+  for (const item of arr) {
+    const k = item[key];
+    if (!result[k]) result[k] = [];
+    result[k].push(item);
+  }
+  return result;
+}
+
+// ── Main command ─────────────────────────────────────────────────────
+
+export function pushCommand(args) {
+  const input = args._positional?.[0];
+  const dryRun = args['--dry-run'] === true;
+  const repo = args['--repo'] || REGISTRY_REPO;
+  const cwd = process.cwd();
+  const workspaceDir = join(cwd, '.aw_registry');
+
+  fmt.intro('aw push');
+
+  // No args = push all modified files
+  if (!input) {
+    const files = collectModifiedFiles(workspaceDir);
+    if (files.length === 0) {
+      fmt.cancel('Nothing to push — no modified files.\n\n  Use `aw status` to see synced files.');
+    }
+    pushFiles(files, { repo, dryRun });
+    return;
+  }
+
+  // Resolve input — accept both registry path and local path
+  const resolved = resolveInput(input, workspaceDir);
+
+  if (!resolved.registryPath) {
+    const hint = input.startsWith('.claude/') || input.startsWith('.cursor/') || input.startsWith('.codex/')
+      ? `\n\n  Tip: Use the .aw_registry/ path instead:\n  aw push .aw_registry/${input.split('/').slice(1).join('/')}`
+      : '';
+    fmt.cancel(`Could not resolve "${input}" to a registry path.${hint}\n\n  Only files inside .aw_registry/ can be pushed.`);
+  }
+
+  let absPath = resolved.localAbsPath;
+  if (!absPath || !existsSync(absPath)) {
+    if (absPath && !absPath.endsWith('.md') && existsSync(absPath + '.md')) {
+      absPath = absPath + '.md';
+    } else {
+      fmt.cancel(`Path not found: ${absPath || input}\n\n  Only files inside .aw_registry/ can be pushed.\n  Use ${chalk.dim('aw status')} to see modified files.`);
+    }
+  }
+
+  // Folder/namespace input → batch push
+  if (statSync(absPath).isDirectory()) {
+    const files = collectBatchFiles(absPath, workspaceDir);
+    if (files.length === 0) {
+      fmt.cancel(`Nothing to push in ${chalk.cyan(input)} — no agents, skills, commands, or evals found.`);
+    }
+    pushFiles(files, { repo, dryRun });
+    return;
+  }
+
+  // Single file input → wrap in array and push
+  const regParts = resolved.registryPath.split('/');
+  let typeIdx = -1;
+  for (let i = regParts.length - 1; i >= 0; i--) {
+    if (PUSHABLE_TYPES.includes(regParts[i])) { typeIdx = i; break; }
+  }
+
+  if (typeIdx === -1 || typeIdx + 1 >= regParts.length) {
+    fmt.cancel([
+      `Invalid push path: ${chalk.red(resolved.registryPath)}`,
+      '',
+      `  Content must live under an ${chalk.bold('agents/')}, ${chalk.bold('skills/')}, ${chalk.bold('commands/')}, or ${chalk.bold('evals/')} directory.`,
+      '',
+      `  ${chalk.dim('Valid examples:')}`,
+      `    aw push .aw_registry/commerce/quality/agents/unit-tester.md`,
+      `    aw push .aw_registry/platform/services/skills/development`,
+      `    aw push .aw_registry/commerce/shared/commands/ship.md`,
+    ].join('\n'));
+  }
+
+  const namespaceParts = regParts.slice(0, typeIdx);
+  const parentDir = regParts[typeIdx];
+  const slug = regParts[typeIdx + 1];
+  const namespacePath = namespaceParts.join('/');
+  const isDir = statSync(absPath).isDirectory();
+  const registryTarget = isDir
+    ? `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}`
+    : `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}.md`;
+
+  pushFiles([{
+    absPath,
+    registryTarget,
+    type: parentDir,
+    namespace: namespacePath,
+    slug,
+    isDir,
+  }], { repo, dryRun });
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
 function getGitHubUser() {
-  // Try gh first, fall back to git config
   try {
     return execSync('gh api user --jq .login', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
   } catch {

package/package.json

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

package/paths.mjs

@@ -89,20 +89,25 @@ export function resolveInput(input, workspaceDir) {
   if (rewritten.startsWith('.aw_registry/') || rewritten.startsWith('.aw_registry\\')) {
     const registryPath = localToRegistry(rewritten);
     const absPath = resolve(rewritten);
+    const isDirectory = existsSync(absPath) && statSync(absPath).isDirectory();
     return {
       registryPath: registryPath?.replace(/\.md$/, '') || null,
       localAbsPath: absPath,
       isLocalPath: true,
+      isDirectory,
     };
   }
 
   // Registry path
   const cleanPath = rewritten.replace(/\.md$/, '');
   const localRel = registryToLocal(cleanPath);
+  const absPath = localRel ? join(workspaceDir, localRel) : null;
+  const isDirectory = absPath && existsSync(absPath) && statSync(absPath).isDirectory();
   return {
     registryPath: cleanPath,
-    localAbsPath: localRel ? join(workspaceDir, localRel) : null,
+    localAbsPath: absPath,
     isLocalPath: false,
+    isDirectory: !!isDirectory,
   };
 }