@ghl-ai/aw 0.1.33 → 0.1.34-beta.2

package/cli.mjs

@@ -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/pull.mjs

@@ -178,7 +178,7 @@ export async function pullCommand(args) {
     const s2 = log.spinner();
     s2.start('Applying changes...');
     const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
-    updateManifest(workspaceDir, actions, cfg.namespace);
+    updateManifest(workspaceDir, actions, cfg.namespace, { fromTemplate: !!renameNamespace });
     s2.stop('Changes applied');
 
     // Copy root-level registry files (e.g. AW-PROTOCOL.md) that are fetched via
@@ -282,7 +282,7 @@ export async function pullAsync(args) {
     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);
+    updateManifest(workspaceDir, actions, cfg.namespace, { fromTemplate: !!renameNamespace });
 
     const ROOT_REGISTRY_FILES = ['AW-PROTOCOL.md'];
     for (const fname of ROOT_REGISTRY_FILES) {

package/commands/push.mjs

@@ -1,120 +1,193 @@
-// 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';
 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 { load as loadManifest, save as saveManifest } from '../manifest.mjs';
+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);
+    const isModified = currentHash !== entry.sha256;
+    const isNew = !entry.registry_sha256;  // Template-derived, never pushed to remote
+    if (isModified || isNew) {
+      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');
+}
+
+// ── Git pipeline (works for single file or batch) ────────────────────
 
-  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'
-  );
+function pushFiles(files, { repo, dryRun, workspaceDir }) {
+  // 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 +202,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 +264,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 +276,145 @@ 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`);
+      }
+    }
+    // Update manifest — mark pushed files as synced (set registry_sha256 = sha256)
+    if (workspaceDir) {
+      const manifest = loadManifest(workspaceDir);
+      for (const file of files) {
+        // Convert registryTarget back to manifest key (strip REGISTRY_DIR/ prefix)
+        const manifestKey = file.registryTarget.replace(`${REGISTRY_DIR}/`, '');
+        if (manifest.files[manifestKey]) {
+          manifest.files[manifestKey].registry_sha256 = manifest.files[manifestKey].sha256;
+        }
+      }
+      saveManifest(workspaceDir, manifest);
+    }
+
     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 + new (unpushed) files
+  if (!input) {
+    const files = collectModifiedFiles(workspaceDir);
+    if (files.length === 0) {
+      fmt.cancel('Nothing to push — no modified or new files.\n\n  Use `aw status` to see synced files.');
+    }
+    pushFiles(files, { repo, dryRun, workspaceDir });
+    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, workspaceDir });
+    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, workspaceDir });
+}
+
+// ── 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/commands/status.mjs

@@ -39,6 +39,7 @@ export function statusCommand(args) {
 
   const files = Object.entries(manifest.files || {});
   const modified = [];
+  const unpushed = [];
   const missing = [];
   const conflicts = [];
 
@@ -51,6 +52,12 @@ export function statusCommand(args) {
 
     const currentHash = hashFile(filePath);
 
+    // Template-derived files that were never pushed to the remote registry
+    if (!entry.registry_sha256) {
+      unpushed.push(key);
+      continue;
+    }
+
     if (currentHash !== entry.sha256) {
       const content = readFileSync(filePath, 'utf8');
       if (content.includes('<<<<<<<')) {
@@ -64,6 +71,7 @@ export function statusCommand(args) {
   // Summary line
   const summaryParts = [
     `${files.length} synced`,
+    unpushed.length > 0 ? chalk.green(`${unpushed.length} new (unpushed)`) : null,
     modified.length > 0 ? chalk.yellow(`${modified.length} modified`) : null,
     conflicts.length > 0 ? chalk.red(`${conflicts.length} conflicts`) : null,
     missing.length > 0 ? chalk.dim(`${missing.length} missing`) : null,
@@ -78,6 +86,17 @@ export function statusCommand(args) {
     );
   }
 
+  if (unpushed.length > 0) {
+    // Group by namespace for cleaner display
+    const nsCounts = {};
+    for (const key of unpushed) {
+      const ns = key.split('/').slice(0, 2).join('/');
+      nsCounts[ns] = (nsCounts[ns] || 0) + 1;
+    }
+    const nsLines = Object.entries(nsCounts).map(([ns, count]) => chalk.green(`  ${ns}: ${count} files`)).join('\n');
+    fmt.note(nsLines, chalk.green('New (unpushed)'));
+  }
+
   if (modified.length > 0) {
     fmt.note(
       modified.map(m => chalk.yellow(m)).join('\n'),
@@ -92,7 +111,7 @@ export function statusCommand(args) {
     );
   }
 
-  if (modified.length === 0 && conflicts.length === 0 && missing.length === 0) {
+  if (modified.length === 0 && conflicts.length === 0 && missing.length === 0 && unpushed.length === 0) {
     fmt.logSuccess('Workspace is clean');
   }
 
@@ -100,6 +119,9 @@ export function statusCommand(args) {
   if (conflicts.length > 0) {
     fmt.logWarn(`Fix conflicts: ${chalk.dim('grep -r "<<<<<<< " .aw_registry/')}`);
   }
+  if (unpushed.length > 0) {
+    fmt.logInfo(`Push new files: ${chalk.dim('aw push')} or ${chalk.dim('aw push <namespace>')}`);
+  }
   if (modified.length > 0) {
     fmt.logInfo(`Push changes: ${chalk.dim('aw push <path>')}`);
   }

package/constants.mjs

@@ -1,7 +1,7 @@
 // constants.mjs — Single source of truth for registry settings.
 
 /** Base branch for PRs and sync checkout */
-export const REGISTRY_BASE_BRANCH = 'main';
+export const REGISTRY_BASE_BRANCH = 'feat/aw-push-batch';
 
 /** Default registry repository */
 export const REGISTRY_REPO = 'GoHighLevel/platform-docs';

package/manifest.mjs

@@ -24,7 +24,7 @@ export function save(workspaceDir, manifest) {
   writeFileSync(manifestPath(workspaceDir), JSON.stringify(manifest, null, 2) + '\n');
 }
 
-export function update(workspaceDir, actions, namespaceName) {
+export function update(workspaceDir, actions, namespaceName, opts = {}) {
   const manifest = load(workspaceDir);
   manifest.synced_at = new Date().toISOString();
   manifest.namespace = namespaceName || manifest.namespace;
@@ -38,7 +38,9 @@ export function update(workspaceDir, actions, namespaceName) {
         manifest.files[manifestKey] = {
           sha256: hashFile(act.targetPath),
           source: act.source,
-          registry_sha256: act.registryHash,
+          // When pulled from template (renamed namespace), these files don't exist
+          // in the remote registry yet — mark as null so push detects them as new.
+          registry_sha256: opts.fromTemplate ? null : act.registryHash,
         };
       }
     } else if (act.action === 'CONFLICT') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.33",
+  "version": "0.1.34-beta.2",
   "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,
   };
 }
 

package/plan.mjs

@@ -68,7 +68,10 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
           action = 'UPDATE';
         } else {
           const localChanged = localHash !== manifestEntry.sha256;
-          const registryChanged = registryHash !== manifestEntry.registry_sha256;
+          // registry_sha256 is null for template-derived files (never pushed).
+          // Treat null as "no known registry version" — can't conflict with unknown.
+          const registryChanged = manifestEntry.registry_sha256 != null
+            && registryHash !== manifestEntry.registry_sha256;
           if (localChanged && registryChanged) {
             action = 'CONFLICT';
           } else if (localChanged) {