@ghl-ai/aw 0.1.35 → 0.1.36-beta.1

package/cli.mjs

@@ -72,7 +72,8 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init --namespace <team/sub-team>', 'Initialize workspace (required)'),
+    cmd('aw init', 'Initialize workspace (platform/ only)'),
+    cmd('aw init --namespace <team/sub-team>', 'Add a team namespace (optional)'),
     `  ${chalk.dim('Teams: platform, revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
     `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
 

package/commands/init.mjs

@@ -4,7 +4,7 @@
 // Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { mkdirSync, existsSync, writeFileSync, symlinkSync } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, symlinkSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
@@ -14,11 +14,14 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { pullCommand, pullAsync } from './pull.mjs';
+import { sparseCheckoutAsync, includeToSparsePaths, cleanup } from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
+import { installAwEcc } from '../ecc.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -95,7 +98,7 @@ function printPullSummary(pattern, actions) {
 const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
-  const namespace = args['--namespace'] || null;
+  let namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const silent = args['--silent'] === true;
 
@@ -103,24 +106,12 @@ export async function initCommand(args) {
 
   // ── Validate ──────────────────────────────────────────────────────────
 
-  if (!namespace && !silent) {
-    const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
-    fmt.cancel([
-      `Missing required ${chalk.bold('--namespace')} flag`,
-      '',
-      `  ${chalk.dim('Usage:')}  aw init --namespace <team/sub-team>`,
-      `  ${chalk.dim('Teams:')}  ${list}`,
-      '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
-    ].join('\n'));
-  }
-
   // 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
+  let nsParts = namespace ? namespace.split('/') : [];
+  let team = nsParts[0] || null;
+  let subTeam = nsParts[1] || null;
+  let teamNS = subTeam ? `${team}-${subTeam}` : team;          // for $TEAM_NS replacement
+  let 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(', ');
@@ -151,6 +142,47 @@ export async function initCommand(args) {
     fmt.cancel(`Invalid sub-team '${subTeam}' — must match: ${SLUG_RE}`);
   }
 
+  // ── Probe remote registry to check if namespace exists ────────────────
+
+  let namespaceExistsInRemote = false;
+  if (folderName && !silent) {
+    try {
+      const probePaths = includeToSparsePaths([folderName]);
+      const probeDir = await sparseCheckoutAsync(REGISTRY_REPO, probePaths);
+      try {
+        const fullNsPath = join(probeDir, REGISTRY_DIR, ...folderName.split('/'));
+        namespaceExistsInRemote = existsSync(fullNsPath) &&
+          readdirSync(fullNsPath, { withFileTypes: true })
+            .some(d => d.isDirectory() && !d.name.startsWith('.'));
+      } finally {
+        cleanup(probeDir);
+      }
+    } catch {
+      // Network error — skip probe, proceed without prompt
+      namespaceExistsInRemote = true;
+    }
+  }
+
+  // If namespace does NOT exist in remote, ask user to confirm
+  if (folderName && !silent && !namespaceExistsInRemote && process.stdin.isTTY) {
+    const choice = await fmt.select({
+      message: `The namespace '${folderName}' does not exist in the registry yet and will be created from [template].\nplatform/ includes shared agents, skills & commands that cover most use cases.\nHow would you like to proceed?`,
+      options: [
+        { value: 'platform-only', label: 'Continue with platform/ only (recommended for most users)' },
+        { value: 'create-namespace', label: `Create '${folderName}' namespace from template` },
+      ],
+    });
+
+    if (fmt.isCancel(choice)) {
+      fmt.cancel('Operation cancelled.');
+      process.exit(0);
+    }
+
+    if (choice === 'platform-only') {
+      namespace = null; team = null; subTeam = null; teamNS = null; folderName = null;
+    }
+  }
+
   const hasConfig = config.exists(GLOBAL_AW_DIR);
   const hasPlatform = existsSync(join(GLOBAL_AW_DIR, 'platform'));
   const isExisting = hasConfig && hasPlatform;
@@ -181,25 +213,30 @@ export async function initCommand(args) {
     // Pull latest (parallel)
     // cfg.include has the renamed namespace (e.g. 'revex/courses'), but the repo
     // only has '.aw_registry/[template]/' — remap non-platform entries back.
+    // Platform is never stored in cfg.include but must always be pulled.
     const freshCfg = config.load(GLOBAL_AW_DIR);
+    const pullJobs = [
+      pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
+    ];
     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({
+      for (const p of freshCfg.include) {
+        if (p === 'platform') continue; // already added above
+        const derivedTeamNS = p.replace(/\//g, '-');
+        pullJobs.push(pullAsync({
           ...args,
-          _positional: [isTeamNs ? '[template]' : p],
+          _positional: ['[template]'],
           _workspaceDir: GLOBAL_AW_DIR,
           _skipIntegrate: true,
-          _renameNamespace: isTeamNs ? p : undefined,
+          _renameNamespace: p,
           _teamNS: derivedTeamNS,
-        });
-      });
-      await Promise.all(pullJobs);
+        }));
+      }
     }
+    await Promise.all(pullJobs);
 
     // Re-link IDE dirs + hooks (idempotent)
     linkWorkspace(HOME);
+    await installAwEcc(cwd, { silent });
     generateCommands(HOME);
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
@@ -280,6 +317,7 @@ export async function initCommand(args) {
   // Step 3: Link IDE dirs + setup tasks
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
+  await installAwEcc(cwd, { silent });
   generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);

package/commands/nuke.mjs

@@ -9,6 +9,7 @@ import { execSync } from 'node:child_process';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { removeGlobalHooks } from '../hooks.mjs';
+import { uninstallAwEcc } from '../ecc.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
@@ -243,28 +244,31 @@ export function nukeCommand(args) {
   // 2. Remove IDE symlinks (only those pointing to .aw_registry)
   removeIdeSymlinks();
 
-  // 3. Remove .aw_registry symlinks from ALL project directories
+  // 3. Remove aw-ecc installed files (agents, commands, rules, skills, hooks)
+  uninstallAwEcc();
+
+  // 4. Remove .aw_registry symlinks from ALL project directories
   removeProjectSymlinks();
 
-  // 4. Remove git hooks (core.hooksPath + legacy template)
+  // 5. Remove git hooks (core.hooksPath + legacy template)
   removeGitHooks(manifest);
 
-  // 5. Remove IDE auto-init tasks
+  // 6. Remove IDE auto-init tasks
   removeIdeTasks();
 
-  // 5b. Remove upgrade lock/log (inside .aw_registry, must happen before dir removal)
+  // Remove upgrade lock/log (inside .aw_registry, must happen before dir removal)
   for (const p of [join(GLOBAL_AW_DIR, '.aw-upgrade.lock'), join(GLOBAL_AW_DIR, '.aw-upgrade.log')]) {
     try { if (existsSync(p)) rmSync(p, { recursive: true, force: true }); } catch { /* best effort */ }
   }
 
-  // 6. Remove ~/.aw_docs/
+  // 7. Remove ~/.aw_docs/
   const awDocs = join(HOME, '.aw_docs');
   if (existsSync(awDocs)) {
     rmSync(awDocs, { recursive: true, force: true });
     fmt.logStep('Removed ~/.aw_docs/');
   }
 
-  // 7. Remove any manual `aw` symlinks (e.g. ~/.local/bin/aw)
+  // 8. Remove any manual `aw` symlinks (e.g. ~/.local/bin/aw)
   const manualBins = [
     join(HOME, '.local', 'bin', 'aw'),
     join(HOME, 'bin', 'aw'),
@@ -278,7 +282,7 @@ export function nukeCommand(args) {
     } catch { /* doesn't exist */ }
   }
 
-  // 8. Uninstall npm global package (skip if already in npm uninstall lifecycle)
+  // 9. Uninstall npm global package (skip if already in npm uninstall lifecycle)
   if (!process.env.npm_lifecycle_event) {
     try {
       execSync('npm uninstall -g @ghl-ai/aw', { stdio: 'pipe', timeout: 15000 });
@@ -286,8 +290,12 @@ export function nukeCommand(args) {
     } catch { /* not installed via npm or no permissions */ }
   }
 
-  // 9. Remove ~/.aw_registry/ itself (source of truth — last!)
-  rmSync(GLOBAL_AW_DIR, { recursive: true, force: true });
+  // 10. Remove ~/.aw_registry/ itself (source of truth — last!)
+  try {
+    rmSync(GLOBAL_AW_DIR, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  } catch {
+    try { execSync(`rm -rf "${GLOBAL_AW_DIR}"`, { stdio: 'pipe' }); } catch { /* best effort */ }
+  }
   fmt.logStep('Removed ~/.aw_registry/');
 
   fmt.outro([
@@ -295,6 +303,7 @@ export function nukeCommand(args) {
     '',
     `  ${chalk.green('✓')} Generated files cleaned`,
     `  ${chalk.green('✓')} IDE symlinks cleaned`,
+    `  ${chalk.green('✓')} aw-ecc engine removed`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,
     `  ${chalk.green('✓')} Git hooks removed`,
     `  ${chalk.green('✓')} IDE auto-sync tasks removed`,

package/commands/push.mjs

@@ -1,6 +1,6 @@
 // commands/push.mjs — Push local agents/skills to registry via PR (single file or batch)
 
-import { existsSync, statSync, mkdirSync, cpSync, mkdtempSync, readFileSync, appendFileSync, readdirSync } from 'node:fs';
+import { existsSync, statSync, mkdirSync, cpSync, mkdtempSync, readFileSync, appendFileSync, readdirSync, unlinkSync, rmdirSync } from 'node:fs';
 import { basename, dirname, resolve, join, relative } from 'node:path';
 import { execSync, execFileSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
@@ -68,20 +68,40 @@ function collectBatchFiles(folderAbsPath, workspaceDir) {
         namespace: entry.namespacePath,
         slug: entry.slug,
         isDir: false,
+        deleted: false,
       };
     });
 }
 
 /**
  * Collect all modified files from manifest (for no-args push).
- * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
+ * Returns array of { absPath, registryTarget, type, namespace, slug, isDir, deleted }.
  */
 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;
+
+    // File deleted locally — include as deletion if it was previously pushed
+    if (!existsSync(filePath)) {
+      if (entry.registry_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,
+            deleted: true,
+          });
+        }
+      }
+      continue;
+    }
+
     const currentHash = hashFile(filePath);
     const isModified = currentHash !== entry.sha256;
     const isNew = !entry.registry_sha256;  // Template-derived, never pushed to remote
@@ -95,6 +115,7 @@ function collectModifiedFiles(workspaceDir) {
           namespace: meta.namespace,
           slug: meta.slug,
           isDir: false,
+          deleted: false,
         });
       }
     }
@@ -124,69 +145,108 @@ function parseManifestKey(key) {
 function generateBranchName(files) {
   const shortId = Date.now().toString(36).slice(-5);
   const namespaces = [...new Set(files.map(f => f.namespace))];
+  const hasDeletes = files.some(f => f.deleted);
+  const allDeletes = files.every(f => f.deleted);
+  const prefix = allDeletes ? 'remove' : hasDeletes ? 'sync' : 'upload';
 
   if (files.length === 1) {
     const f = files[0];
     const nsSlug = f.namespace.replace(/\//g, '-');
-    return `upload/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
+    return `${prefix}/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
   }
 
   if (namespaces.length === 1) {
-    return `sync/${namespaces[0].replace(/\//g, '-')}-${shortId}`;
+    return `${prefix}/${namespaces[0].replace(/\//g, '-')}-${shortId}`;
   }
 
-  return `sync/batch-${shortId}`;
+  return `${prefix}/batch-${shortId}`;
 }
 
 function generatePrTitle(files) {
   if (files.length === 1) {
     const f = files[0];
-    return `Add ${f.slug} (${f.type}) to ${f.namespace}`;
+    const verb = f.deleted ? 'Remove' : 'Add';
+    const prep = f.deleted ? 'from' : 'to';
+    return `${verb} ${f.slug} (${f.type}) ${prep} ${f.namespace}`;
   }
 
-  const counts = {};
+  const addCounts = {};
+  const deleteCounts = {};
   for (const f of files) {
-    counts[f.type] = (counts[f.type] || 0) + 1;
+    const target = f.deleted ? deleteCounts : addCounts;
+    target[f.type] = (target[f.type] || 0) + 1;
+  }
+  const parts = [];
+  for (const [type, count] of Object.entries(addCounts)) {
+    parts.push(`+${count} ${type}`);
+  }
+  for (const [type, count] of Object.entries(deleteCounts)) {
+    parts.push(`-${count} ${type}`);
   }
-  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: ${parts.join(', ')} in ${namespaces[0]}`;
   }
-  return `sync: ${countParts.join(', ')} across ${namespaces.join(', ')}`;
+  return `sync: ${parts.join(', ')} across ${namespaces.join(', ')}`;
 }
 
 function generatePrBody(files, newNamespaces) {
   if (files.length === 1) {
     const f = files[0];
+    const action = f.deleted ? 'Registry Removal' : 'Registry Upload';
     const bodyParts = [
-      '## Registry Upload',
+      `## ${action}`,
       '',
       `- **Type:** ${f.type}`,
       `- **Slug:** ${f.slug}`,
       `- **Namespace:** ${f.namespace}`,
       `- **Path:** \`${f.registryTarget}\``,
     ];
+    if (f.deleted) {
+      bodyParts.push('', '> File was deleted locally and removed from registry.');
+    }
     if (newNamespaces.length > 0) {
       bodyParts.push('', '> **New namespace** — CODEOWNERS entry auto-added.');
     }
-    bodyParts.push('', 'Uploaded via `aw push`');
+    bodyParts.push('', `${f.deleted ? 'Removed' : 'Uploaded'} via \`aw push\``);
     return bodyParts.join('\n');
   }
 
-  // Batch body — group by type
-  const grouped = {};
-  for (const f of files) {
-    if (!grouped[f.type]) grouped[f.type] = [];
-    grouped[f.type].push(f);
-  }
+  // Batch body — group by action then type
+  const added = files.filter(f => !f.deleted);
+  const deleted = files.filter(f => f.deleted);
 
   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})`);
+
+  if (added.length > 0) {
+    const grouped = {};
+    for (const f of added) {
+      if (!grouped[f.type]) grouped[f.type] = [];
+      grouped[f.type].push(f);
+    }
+    bodyParts.push('### Added / Updated');
+    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('');
+  }
+
+  if (deleted.length > 0) {
+    const grouped = {};
+    for (const f of deleted) {
+      if (!grouped[f.type]) grouped[f.type] = [];
+      grouped[f.type].push(f);
+    }
+    bodyParts.push('### Removed');
+    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('');
   }
@@ -196,7 +256,7 @@ function generatePrBody(files, newNamespaces) {
     bodyParts.push('');
   }
 
-  bodyParts.push(`---`, `Synced via \`aw push\` (${files.length} files)`);
+  bodyParts.push(`---`, `Synced via \`aw push\` (${files.length} files: ${added.length} added/updated, ${deleted.length} removed)`);
   return bodyParts.join('\n');
 }
 
@@ -205,16 +265,22 @@ function generatePrBody(files, newNamespaces) {
 function pushFiles(files, { repo, dryRun, workspaceDir }) {
   // Summary
   const counts = {};
+  const deleteCounts = {};
   for (const f of files) {
-    counts[f.type] = (counts[f.type] || 0) + 1;
+    const target = f.deleted ? deleteCounts : counts;
+    target[f.type] = (target[f.type] || 0) + 1;
   }
-  const countParts = Object.entries(counts).map(([type, count]) => `${count} ${type}`);
+  const countParts = [
+    ...Object.entries(counts).map(([type, count]) => `${count} ${type}`),
+    ...Object.entries(deleteCounts).map(([type, count]) => `${count} ${type} removed`),
+  ];
   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}`);
+      const label = f.deleted ? chalk.red('DELETE') : chalk.yellow(f.type);
+      fmt.logMessage(`  ${label}/${f.slug}${ns}`);
     }
     fmt.logWarn('No changes made (--dry-run)');
     fmt.outro(chalk.dim('Remove --dry-run to push'));
@@ -235,12 +301,14 @@ function pushFiles(files, { repo, dryRun, workspaceDir }) {
     const branch = generateBranchName(files);
     execSync(`git checkout -b ${branch}`, { cwd: tempDir, stdio: 'pipe' });
 
+    const addedFiles = files.filter(f => !f.deleted);
+    const deletedFiles = files.filter(f => f.deleted);
     const s2 = fmt.spinner();
-    s2.start(`Copying ${files.length} file${files.length > 1 ? 's' : ''} to registry...`);
+    s2.start(`Applying ${files.length} change${files.length > 1 ? 's' : ''} to registry...`);
 
-    // Copy each file
+    // Copy added/modified files
     let copyErrors = [];
-    for (const file of files) {
+    for (const file of addedFiles) {
       try {
         const targetFull = join(tempDir, file.registryTarget);
         mkdirSync(dirname(targetFull), { recursive: true });
@@ -254,9 +322,33 @@ function pushFiles(files, { repo, dryRun, workspaceDir }) {
       }
     }
 
+    // Remove deleted files from the clone
+    for (const file of deletedFiles) {
+      try {
+        const targetFull = join(tempDir, file.registryTarget);
+        if (existsSync(targetFull)) {
+          unlinkSync(targetFull);
+          // Prune empty parent dirs up to REGISTRY_DIR
+          let dir = dirname(targetFull);
+          while (basename(dir) !== REGISTRY_DIR && dir !== tempDir) {
+            try {
+              if (readdirSync(dir).length === 0) {
+                rmdirSync(dir);
+                dir = dirname(dir);
+              } else {
+                break;
+              }
+            } catch { break; }
+          }
+        }
+      } catch (e) {
+        copyErrors.push({ file: file.registryTarget, error: e.message });
+      }
+    }
+
     if (copyErrors.length > 0) {
       for (const err of copyErrors) {
-        fmt.logWarn(`Failed to copy ${err.file}: ${err.error}`);
+        fmt.logWarn(`Failed to process ${err.file}: ${err.error}`);
       }
     }
 
@@ -289,7 +381,7 @@ function pushFiles(files, { repo, dryRun, workspaceDir }) {
 
     const prTitle = generatePrTitle(files);
     const commitMsg = files.length === 1
-      ? `registry: add ${files[0].type}/${files[0].slug} to ${files[0].namespace}`
+      ? `registry: ${files[0].deleted ? 'remove' : 'add'} ${files[0].type}/${files[0].slug} ${files[0].deleted ? 'from' : 'to'} ${files[0].namespace}`
       : `registry: sync ${files.length} files (${countParts.join(', ')})`;
     execSync(`git commit -m "${commitMsg}"`, { cwd: tempDir, stdio: 'pipe' });
 
@@ -323,20 +415,28 @@ function pushFiles(files, { repo, dryRun, workspaceDir }) {
       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'))) {
+      for (const [type, items] of Object.entries(groupBy(addedFiles, 'type'))) {
         fmt.logSuccess(`${items.length} ${type} pushed`);
       }
+      for (const [type, items] of Object.entries(groupBy(deletedFiles, 'type'))) {
+        fmt.logSuccess(`${items.length} ${type} removed`);
+      }
+    } else if (files.length === 1 && files[0].deleted) {
+      fmt.logSuccess(`${files[0].type}/${files[0].slug} removed`);
     }
-    // Update manifest — mark pushed files as synced (set registry_sha256 = sha256)
+    // Update manifest — mark pushed files as synced, remove deleted entries
     if (workspaceDir) {
       const manifest = loadManifest(workspaceDir);
-      for (const file of files) {
-        // Convert registryTarget back to manifest key (strip REGISTRY_DIR/ prefix)
+      for (const file of addedFiles) {
         const manifestKey = file.registryTarget.replace(`${REGISTRY_DIR}/`, '');
         if (manifest.files[manifestKey]) {
           manifest.files[manifestKey].registry_sha256 = manifest.files[manifestKey].sha256;
         }
       }
+      for (const file of deletedFiles) {
+        const manifestKey = file.registryTarget.replace(`${REGISTRY_DIR}/`, '');
+        delete manifest.files[manifestKey];
+      }
       saveManifest(workspaceDir, manifest);
     }
 
@@ -374,7 +474,7 @@ export function pushCommand(args) {
   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.');
+      fmt.cancel('Nothing to push — no modified, new, or deleted files.\n\n  Use `aw status` to see synced files.');
     }
     pushFiles(files, { repo, dryRun, workspaceDir });
     return;
@@ -445,6 +545,7 @@ export function pushCommand(args) {
     namespace: namespacePath,
     slug,
     isDir,
+    deleted: false,
   }], { repo, dryRun, workspaceDir });
 }
 

package/config.mjs

@@ -48,7 +48,7 @@ export function create(workspaceDir, { namespace, user }) {
 
 export function addPattern(workspaceDir, pattern) {
   const config = load(workspaceDir);
-  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  if (!config) throw new Error('No .sync-config.json found. Run: aw init');
   // If a parent path already covers this, skip
   if (config.include.some(p => pattern === p || pattern.startsWith(p + '/'))) {
     return config;
@@ -62,7 +62,7 @@ export function addPattern(workspaceDir, pattern) {
 
 export function removePattern(workspaceDir, pattern) {
   const config = load(workspaceDir);
-  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  if (!config) throw new Error('No .sync-config.json found. Run: aw init');
   // Remove exact match + all children
   config.include = config.include.filter(p => p !== pattern && !p.startsWith(pattern + '/'));
   save(workspaceDir, config);

package/ecc.mjs

@@ -0,0 +1,180 @@
+import { execSync } from "node:child_process";
+import {
+  existsSync, readFileSync, readdirSync,
+  mkdirSync, rmSync, writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import * as fmt from "./fmt.mjs";
+
+const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
+const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
+const AW_ECC_TAG = "v1.2.2";
+
+const MARKETPLACE_NAME = "aw-marketplace";
+const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;
+
+function eccDir() { return join(homedir(), ".aw-ecc"); }
+
+const FILE_COPY_TARGETS = ["cursor", "codex"];
+
+const TARGET_STATE = {
+  cursor: { state: ".cursor/ecc-install-state.json" },
+  codex:  { state: ".codex/ecc-install-state.json" },
+};
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { stdio: "pipe", ...opts });
+}
+
+function cloneOrUpdate(tag, dest) {
+  if (existsSync(join(dest, ".git"))) {
+    try {
+      run(`git -C ${dest} fetch --quiet --depth 1 origin tag ${tag}`);
+      run(`git -C ${dest} checkout --quiet ${tag}`);
+      return;
+    } catch { /* fall through to fresh clone */ }
+  }
+  if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  try {
+    run(`git clone --quiet --depth 1 --branch ${tag} ${AW_ECC_REPO_SSH} ${dest}`);
+  } catch {
+    run(`git clone --quiet --depth 1 --branch ${tag} ${AW_ECC_REPO_HTTPS} ${dest}`);
+  }
+}
+
+function installClaudePlugin(repoDir) {
+  try {
+    run(`claude plugin marketplace add ${repoDir} --scope user`);
+  } catch {
+    try { run(`claude plugin marketplace update ${MARKETPLACE_NAME}`); } catch { /* ok */ }
+  }
+  run(`claude plugin install ${PLUGIN_KEY} --scope user`);
+}
+
+function uninstallClaudePlugin() {
+  try { run(`claude plugin uninstall ${PLUGIN_KEY} --scope user`); } catch { /* not installed */ }
+  try { run(`claude plugin marketplace remove ${MARKETPLACE_NAME}`); } catch { /* not registered */ }
+}
+
+export async function installAwEcc(
+  cwd,
+  { targets = ["cursor", "claude", "codex"], silent = false } = {},
+) {
+  if (!silent) fmt.logStep("Installing aw-ecc engine...");
+
+  const repoDir = eccDir();
+
+  try {
+    cloneOrUpdate(AW_ECC_TAG, repoDir);
+
+    // Claude Code: plugin install via marketplace CLI (proper agent dispatch)
+    if (targets.includes("claude")) {
+      try {
+        installClaudePlugin(repoDir);
+      } catch (err) {
+        if (!silent) fmt.logWarn(`Claude plugin install skipped: ${err.message}`);
+      }
+    }
+
+    // Cursor + Codex: file-copy via install-apply.js
+    const fileCopyTargets = targets.filter((t) => FILE_COPY_TARGETS.includes(t));
+    if (fileCopyTargets.length > 0) {
+      run("npm install --no-audit --no-fund --ignore-scripts --loglevel=error", {
+        cwd: repoDir,
+      });
+      for (const target of fileCopyTargets) {
+        try {
+          run(
+            `node ${join(repoDir, "scripts/install-apply.js")} --target ${target} --profile full`,
+            { cwd },
+          );
+        } catch { /* target not supported — skip */ }
+      }
+    }
+
+    if (!silent) fmt.logSuccess("aw-ecc engine installed");
+  } catch (err) {
+    if (!silent) fmt.logWarn(`aw-ecc install failed: ${err.message}`);
+  }
+}
+
+export function uninstallAwEcc({ silent = false } = {}) {
+  const HOME = homedir();
+  let removed = 0;
+
+  // Claude Code: uninstall plugin + remove marketplace via CLI
+  try {
+    uninstallClaudePlugin();
+    removed++;
+  } catch { /* best effort */ }
+
+  // Cursor + Codex: remove file-copied content via install-state
+  for (const cfg of Object.values(TARGET_STATE)) {
+    const statePath = join(HOME, cfg.state);
+    if (!existsSync(statePath)) continue;
+
+    try {
+      const data = JSON.parse(readFileSync(statePath, "utf8"));
+      for (const op of data.operations || []) {
+        if (op.destinationPath && existsSync(op.destinationPath)) {
+          rmSync(op.destinationPath, { recursive: true, force: true });
+          removed++;
+          pruneEmptyParents(op.destinationPath, join(HOME, cfg.state.split("/")[0]));
+        }
+      }
+      rmSync(statePath, { force: true });
+      pruneEmptyParents(statePath, join(HOME, cfg.state.split("/")[0]));
+    } catch { /* corrupted state — skip */ }
+  }
+
+  // Clean leftover claude install-state from older file-copy versions
+  const claudeState = join(HOME, ".claude", "ecc", "install-state.json");
+  if (existsSync(claudeState)) {
+    try {
+      const data = JSON.parse(readFileSync(claudeState, "utf8"));
+      for (const op of data.operations || []) {
+        if (op.destinationPath && existsSync(op.destinationPath)) {
+          rmSync(op.destinationPath, { recursive: true, force: true });
+          removed++;
+        }
+      }
+      rmSync(claudeState, { force: true });
+      pruneEmptyParents(claudeState, join(HOME, ".claude"));
+    } catch { /* best effort */ }
+  }
+
+  // Clean leftover manual plugin cache from older versions
+  const oldCache = join(HOME, ".claude", "plugins", "cache", "aw");
+  if (existsSync(oldCache)) {
+    rmSync(oldCache, { recursive: true, force: true });
+    removed++;
+  }
+
+  // Remove permanent aw-ecc repo clone
+  const repoDir = eccDir();
+  if (existsSync(repoDir)) {
+    rmSync(repoDir, { recursive: true, force: true });
+    removed++;
+  }
+
+  if (!silent && removed > 0)
+    fmt.logStep(`Removed ${removed} aw-ecc file${removed > 1 ? "s" : ""}`);
+  return removed;
+}
+
+function pruneEmptyParents(filePath, stopAt) {
+  let dir = dirname(filePath);
+  while (dir !== stopAt && dir.startsWith(stopAt)) {
+    try {
+      if (readdirSync(dir).length === 0) {
+        rmSync(dir);
+        dir = dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}

package/fmt.mjs

@@ -36,6 +36,8 @@ export function banner(text, opts = {}) {
 export const intro    = (msg) => p.intro(chalk.bgCyan.black(` ${msg} `));
 export const outro    = (msg) => p.outro(chalk.green(msg));
 export const spinner  = () => p.spinner();
+export const select   = p.select;
+export const isCancel = p.isCancel;
 
 export function cancel(msg) {
   p.cancel(msg);

package/integrate.mjs

@@ -56,11 +56,13 @@ function findFiles(dir, typeName) {
 }
 
 /**
- * Copy CLAUDE.md and AGENTS.md to project root.
+ * Copy AGENTS.md to project root.
+ * CLAUDE.md is intentionally NOT generated — its routing rule hijacks plugin
+ * commands like /aw:plan, preventing proper agent dispatch.
  */
 export function copyInstructions(cwd, tempDir, namespace) {
   const createdFiles = [];
-  for (const file of ['CLAUDE.md', 'AGENTS.md']) {
+  for (const file of ['AGENTS.md']) {
     const dest = join(cwd, file);
     if (existsSync(dest)) continue;
 
@@ -78,9 +80,7 @@ export function copyInstructions(cwd, tempDir, namespace) {
       }
     }
 
-    const content = file === 'CLAUDE.md'
-      ? generateClaudeMd(cwd, namespace)
-      : generateAgentsMd(cwd, namespace);
+    const content = generateAgentsMd(cwd, namespace);
     if (content) {
       writeFileSync(dest, content);
       fmt.logSuccess(`Created ${file}`);
@@ -100,7 +100,9 @@ Team: ${team} | Local-first orchestration via \`.aw_docs/\` | MCPs: \`memory/*\`
 
 > **Every non-trivial task MUST call \`Skill(skill: "platform-ai-task-router")\` BEFORE any response.**
 >
-> **Trivial** (do directly): typo fixes, single-line edits, git ops, file exploration, factual code questions.
+> **Exempt from routing (execute directly):**
+> - **Plugin commands**: any \`/aw:*\` slash command — these have their own agent dispatch via the plugin system. Execute the plugin command as-is, do NOT re-route through the task router.
+> - **Trivial tasks**: typo fixes, single-line edits, git ops, file exploration, factual code questions.
 >
 > Everything else — including tasks phrased as questions, suggestions, or discussions — routes first.
 > **No conversational responses first. No planning first. Route first.**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.35",
+  "version": "0.1.36-beta.1",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -24,7 +24,8 @@
     "registry.mjs",
     "apply.mjs",
     "update.mjs",
-    "hooks.mjs"
+    "hooks.mjs",
+    "ecc.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"