@ghl-ai/aw 0.1.70-beta.2 → 0.1.70-beta.4

package/commands/c4.mjs

@@ -101,13 +101,11 @@ function safeReaddirSync(dir) {
   try { return readdirSync(dir); } catch { return []; }
 }
 
-function safeListNamespaceDirs(dir, fsApi = {}) {
-  const readDir = fsApi.readdirSync ?? readdirSync;
-  const stat = fsApi.statSync ?? statSync;
+function safeListNamespaceDirs(dir) {
   try {
-    return readDir(dir).filter((entry) => {
+    return readdirSync(dir).filter((entry) => {
       if (entry.startsWith('.')) return false;
-      try { return stat(join(dir, entry)).isDirectory(); } catch { return false; }
+      try { return statSync(join(dir, entry)).isDirectory(); } catch { return false; }
     });
   } catch { return []; }
 }
@@ -134,15 +132,17 @@ function setupGitAuth({ token, c4, home, cwd }) {
   c4.ensureOriginRemote({ cwd });
 }
 
-function resolveCodexRouterSkillPath({ awHome }) {
-  return join(awHome, '.aw_registry/aw/skills/using-aw-skills/SKILL.md');
+function resolveCodexRouterSkillPath({ awHome, eccHome, existsSync = fsExistsSync }) {
+  const eccRouterSkillPath = join(eccHome, 'skills/using-aw-skills/SKILL.md');
+  if (existsSync(eccRouterSkillPath)) return eccRouterSkillPath;
+  return join(awHome, '.aw_registry/platform/core/skills/using-aw-skills/SKILL.md');
 }
 
 /* ─────────────────────────────────────────────────────────────────────────
  * Per-harness branch (step 10).
  *
  * Returns `{ ok, bridge, injector }` so the summary line can pick up
- * codex-specific status ticks. Hard failures (injector / claude
+ * codex-specific status ticks. Hard failures (bridge / injector / claude
  * marketplace / slim card) bubble up as thrown Errors.
  * ───────────────────────────────────────────────────────────────────────── */
 
@@ -165,8 +165,9 @@ function runHarnessBranch({ harness, c4, home, eccHome, cwd, writer, existsSync
   }
   if (harness === 'codex-web') {
     const awHome = join(home, '.aw');
+    c4.applyEccRegistryBridge({ awHome, eccHome });
     c4.ensureCodexHooksFlag(home);
-    const routerSkillPath = resolveCodexRouterSkillPath({ awHome });
+    const routerSkillPath = resolveCodexRouterSkillPath({ awHome, eccHome, existsSync });
     // Pass hookPath explicitly: defaultHookPath() reads os.homedir() at module
     // load time, which ignores the orchestrator's `home` (env.HOME). Without
     // this, installs land in the real ~/.codex even when HOME is overridden
@@ -192,7 +193,7 @@ function runSelfTests({ harness, c4, home, awHome, eccHome }) {
   if (!skill.ok) failures.push('skill-resolution');
 
   // diagnoseCommandResolution is warn-only — does NOT add to failures.
-  const command = c4.diagnoseCommandResolution({ harness, home, awHome });
+  const command = c4.diagnoseCommandResolution({ harness, home });
 
   let view;
   let injector;
@@ -410,27 +411,12 @@ export async function c4Command(rawArgs, overrides = {}) {
   // check, so we specifically look for directories (namespaces like
   // "platform") to confirm the registry content was actually pulled.
   {
-    const registryNamespaces = safeListNamespaceDirs(awRegistry, fs);
+    const registryNamespaces = safeListNamespaceDirs(awRegistry);
     if (registryNamespaces.length === 0) {
       writer.stderr('[aw-c4] registry has no namespace directories after init — retrying with aw pull\n');
       const pullRes = spawnSync('aw', ['pull'], { stdio: 'pipe' });
-      if (pullRes?.status !== 0 || safeListNamespaceDirs(awRegistry, fs).length === 0) {
-        writer.stderr('[aw-c4] FATAL: registry skills were not fetched\n');
-        return exit(1);
-      }
-    }
-  }
-
-  // Step 9b — verify active AW skills exist. `/aw:*` adapters point directly
-  // at ~/.aw/.aw_registry/aw/skills/<skill>/SKILL.md, so an empty registry is
-  // not enough; the AW namespace must be present.
-  {
-    const awSkillsDir = join(awRegistry, 'aw', 'skills');
-    if (!fs.existsSync(awSkillsDir)) {
-      writer.stderr('[aw-c4] AW skills missing after init — retrying with aw pull\n');
-      const pullRes = spawnSync('aw', ['pull'], { stdio: 'pipe' });
-      if (pullRes?.status !== 0 || !fs.existsSync(awSkillsDir)) {
-        writer.stderr('[aw-c4] FATAL: AW skills were not fetched\n');
+      if (pullRes?.status !== 0 || safeListNamespaceDirs(awRegistry).length === 0) {
+        writer.stderr('[aw-c4] FATAL: registry commands were not fetched\n');
         return exit(1);
       }
     }
@@ -453,9 +439,26 @@ export async function c4Command(rawArgs, overrides = {}) {
     writer.stdout('[aw-c4] MCP disabled; skipping registerGhlAiMcp\n');
   }
 
-  // Step 12 — slash surface backed by active AW skills. No ECC command files
-  // are linked; each adapter points directly at a registry SKILL.md.
-  safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, awHome }), writer);
+  // Step 12 — slash command surface (10 stage commands from ECC).
+  safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, eccHome }), writer);
+
+  // Step 12a — full registry command surface.
+  // `ensureCommandSurface` only links the 10 AW routing-stage commands from
+  // ~/.aw-ecc/commands/. The full registry (~100+ domain commands like
+  // platform-review-security-hardening) lives in ~/.aw/.aw_registry/ and is
+  // populated by `aw init` (step 7). Link them all into the harness command
+  // dir so `/aw:*` resolution works for every registered command.
+  const registryCmdResult = safe(
+    'ensureRegistryCommandSurface',
+    () => c4.ensureRegistryCommandSurface({ harness, home, awRegistryDir: awRegistry }),
+    writer,
+  );
+  if (registryCmdResult.ok) {
+    const { linked, skipped } = registryCmdResult.value;
+    if (linked > 0) {
+      writer.stdout(`[aw-c4] registry commands: ${linked} linked, ${skipped} skipped\n`);
+    }
+  }
 
   // Step 12b — Cursor Cloud slash-expand rule (no-op on other harnesses).
   // The model-side workaround for Cursor Cloud's chat UI not pre-expanding

package/commands/doctor.mjs

@@ -523,14 +523,22 @@ function findBrokenRuleReferences(filePaths) {
   return broken;
 }
 
-function missingCoreAwSkillFiles(awRegistryDir) {
-  const expectedSkills = [
-    'using-aw-skills',
-    ...EXPECTED_AW_ROUTES.map(route => `aw-${route}`),
-  ];
-  return expectedSkills
-    .map(skillName => `aw/skills/${skillName}/SKILL.md`)
-    .filter(relativePath => !awRegistryDir || !existsSync(join(awRegistryDir, relativePath)));
+function missingCorePromptFiles(promptsDir) {
+  return EXPECTED_AW_ROUTES
+    .map(route => `aw-${route}.md`)
+    .filter(fileName => !existsSync(join(promptsDir, fileName)));
+}
+
+function missingCoreCursorCommandFiles(commandsDir) {
+  return EXPECTED_AW_ROUTES
+    .map(route => `${route}.md`)
+    .filter(fileName => !existsSync(join(commandsDir, fileName)));
+}
+
+function missingCoreClaudeCommandFiles(pluginRoot) {
+  return EXPECTED_AW_ROUTES
+    .map(route => `commands/${route}.md`)
+    .filter(relativePath => !existsSync(join(pluginRoot, relativePath)));
 }
 
 function buildDoctorChecks(homeDir, cwd) {
@@ -540,8 +548,8 @@ function buildDoctorChecks(homeDir, cwd) {
   const rulesDir = resolveRulesDir(homeDir);
 
   const usingAwHookPath = [
-    join(homeDir, '.aw_registry', 'aw', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh'),
-    join(homeDir, '.aw', '.aw_registry', 'aw', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh'),
+    join(homeDir, '.aw_registry', 'platform', 'core', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh'),
+    join(homeDir, '.aw', '.aw_registry', 'platform', 'core', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh'),
   ].find(existsSync);
 
   checks.push(usingAwHookPath
@@ -578,19 +586,6 @@ function buildDoctorChecks(homeDir, cwd) {
     );
   }
 
-  const missingAwSkills = missingCoreAwSkillFiles(awRegistryDir);
-  checks.push(
-    missingAwSkills.length === 0
-      ? makeCheck('aw-skills-source', 'AW skills source', 'pass', 'AW core route skills are synced under ~/.aw/.aw_registry/aw/skills')
-      : makeCheck(
-        'aw-skills-source',
-        'AW skills source',
-        'fail',
-        `AW registry is missing core skill files: ${missingAwSkills.join(', ')}`,
-        'Run `aw init` or `aw pull platform` to sync AW skills into ~/.aw/.aw_registry/aw/skills.',
-      ),
-  );
-
   if (cwd !== homeDir) {
     const projectAgentsPath = join(cwd, 'AGENTS.md');
     const projectClaudePath = join(cwd, 'CLAUDE.md');
@@ -651,10 +646,12 @@ function buildDoctorChecks(homeDir, cwd) {
     const missingBundleFiles = missingFiles(claudePluginRoot, [
       '.claude-plugin/plugin.json',
       'hooks/hooks.json',
+      'skills/using-aw-skills/SKILL.md',
+      'skills/using-aw-skills/hooks/session-start.sh',
     ]);
     checks.push(
       missingBundleFiles.length === 0 && claudeSessionStartStatus.ok
-        ? makeCheck('claude-plugin-bundle', 'Claude plugin bundle', 'pass', 'Claude plugin bundle contains AW routing hooks')
+        ? makeCheck('claude-plugin-bundle', 'Claude plugin bundle', 'pass', 'Claude plugin bundle contains AW routing hooks and router skill files')
         : makeCheck(
           'claude-plugin-bundle',
           'Claude plugin bundle',
@@ -670,8 +667,21 @@ function buildDoctorChecks(homeDir, cwd) {
         ),
     );
 
+    const missingPluginCommands = missingCoreClaudeCommandFiles(claudePluginRoot);
+    checks.push(
+      missingPluginCommands.length === 0
+        ? makeCheck('claude-plugin-commands', 'Claude public commands', 'pass', 'Claude plugin bundle exposes the current AW command surface (primary, conditional, and compatibility routes)')
+        : makeCheck(
+          'claude-plugin-commands',
+          'Claude public commands',
+          'fail',
+          `Claude plugin bundle is missing core command files: ${missingPluginCommands.join(', ')}`,
+          'Refresh the AW Claude plugin so the plugin bundle includes the full AW public command surface.',
+        ),
+    );
   } else {
     checks.push(makeCheck('claude-plugin-bundle', 'Claude plugin bundle', 'warn', 'Claude plugin bundle is not installed', 'Enable/install the AW Claude plugin, then rerun `aw doctor`.'));
+    checks.push(makeCheck('claude-plugin-commands', 'Claude public commands', 'warn', 'Claude plugin command bundle could not be inspected because the plugin is not installed'));
   }
 
   const claudeLegacyHooks = parseLegacyClaudeHookTargets(claudeSettings?.hooks?.SessionStart || []);
@@ -857,6 +867,19 @@ function buildDoctorChecks(homeDir, cwd) {
       : makeCheck('codex-references', 'Codex shared references', 'fail', 'Codex shared references are missing', projectRelinkFix(homeDir, cwd, '~/.codex/references')),
   );
 
+  const missingPrompts = missingCorePromptFiles(join(homeDir, '.codex', 'prompts'));
+  checks.push(
+      missingPrompts.length === 0
+      ? makeCheck('codex-prompts', 'Codex prompts', 'pass', 'Codex prompt sync produced the current AW prompt surface (primary, conditional, and compatibility routes)')
+      : makeCheck(
+        'codex-prompts',
+        'Codex prompts',
+        'fail',
+        `Codex is missing core prompt files: ${missingPrompts.join(', ')}`,
+        'Run `aw init` or refresh the AW ECC bundle to regenerate the Codex prompts.',
+      ),
+  );
+
   const codexAgentsPath = join(homeDir, '.codex', 'AGENTS.md');
   checks.push(
     existsSync(codexAgentsPath) && textHasManagedRouterBridge(readText(codexAgentsPath)) && textHasRulesReference(readText(codexAgentsPath))
@@ -921,6 +944,20 @@ function buildDoctorChecks(homeDir, cwd) {
     : makeCheck('cursor-install-state', 'Cursor install state', 'fail', 'Cursor install-state file is missing', globalInstallStateFix(homeDir, cwd, 'Cursor install state')),
   );
 
+  const cursorCommandsDir = join(homeDir, '.cursor', 'commands', 'aw');
+  const missingCursorCommands = missingCoreCursorCommandFiles(cursorCommandsDir);
+  checks.push(
+    missingCursorCommands.length === 0
+      ? makeCheck('cursor-commands', 'Cursor public commands', 'pass', 'Cursor has the current AW command surface under ~/.cursor/commands/aw/')
+      : makeCheck(
+        'cursor-commands',
+        'Cursor public commands',
+        'fail',
+        `Cursor is missing core command files: ${missingCursorCommands.join(', ')}`,
+        projectRelinkFix(homeDir, cwd, 'AW command files under ~/.cursor/commands/aw/'),
+      ),
+  );
+
   const cursorMcp = jsonMcpHealth(join(homeDir, '.cursor', 'mcp.json'));
   checks.push(
     cursorMcp.present && cursorMcp.url && cursorMcp.authorization

package/commands/init.mjs

@@ -35,7 +35,7 @@ import { loadConfig as ensureTelemetryConfig } from '../telemetry.mjs';
 import { installAwEcc, AW_ECC_TAG } from '../ecc.mjs';
 import { removeWorkspaceHookDefaults } from '../codex.mjs';
 import { readHookManifest, pruneStaleHooks, writeHookManifest } from '../hook-cleanup.mjs';
-import { installIntegration, autoInstallIntegrations } from '../integrations.mjs';
+import { installIntegration, autoInstallIntegrations, getSuggestedIntegrationStatuses } from '../integrations.mjs';
 import {
   initPersistentClone,
   isValidClone,
@@ -49,16 +49,7 @@ import {
   syncWorktreeSparseCheckout,
   findNearestWorktree,
 } from '../git.mjs';
-import {
-  REGISTRY_DIR,
-  REGISTRY_REPO,
-  REGISTRY_URL,
-  AW_REGISTRY_NAMESPACE_DIR,
-  DOCS_SOURCE_DIR,
-  AW_DOCS_DIR,
-  RULES_SOURCE_DIR,
-  RULES_RUNTIME_DIR,
-} from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, RULES_RUNTIME_DIR } from '../constants.mjs';
 import { syncFileTree } from '../file-tree.mjs';
 import { installAwUsageHooks, formatAwUsageHooksInstallReport } from '../install-aw-usage-hooks.mjs';
 
@@ -86,6 +77,30 @@ function writeHookManifestBestEffort(manifest, context) {
   }
 }
 
+function formatIntegrationStatusSummary(statuses, installedNow = []) {
+  if (!statuses || statuses.length === 0) return null;
+
+  const installedNowSet = new Set(installedNow);
+  const lines = statuses.map((entry) => {
+    if (entry.status === 'installed') {
+      const note = installedNowSet.has(entry.label) ? '(installed now)' : '(installed)';
+      return `    ${chalk.green('✓')} ${entry.label} ${chalk.dim(note)}`;
+    }
+
+    if (entry.status === 'skipped') {
+      const note = entry.reason ? `(skipped: ${entry.reason})` : '(skipped)';
+      return `    ${chalk.yellow('!')} ${entry.label} ${chalk.dim(note)}`;
+    }
+
+    return `    ${chalk.dim('○')} ${entry.label} ${chalk.dim('(not installed)')}`;
+  });
+
+  return [
+    `  ${chalk.green('✓')} Integrations:`,
+    ...lines,
+  ].join('\n');
+}
+
 export async function syncEccAfterAwUpdate(updateResult, cwd, { silent = false } = {}) {
   if (updateResult?.status !== 'upgraded' || !updateResult.packageRoot) {
     return { synced: false, reason: updateResult?.reason || updateResult?.status || 'not-upgraded' };
@@ -282,6 +297,7 @@ function installIdeTasks() {
 }
 
 const ALLOWED_NAMESPACES = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
+const DEFAULT_NAMESPACE = 'platform';
 
 export async function initCommand(args) {
   let namespace = args['--namespace'] || null;
@@ -307,6 +323,7 @@ export async function initCommand(args) {
   let team = nsParts[0] || null;
   let subTeam = nsParts[1] || null;
   let folderName = subTeam ? `${team}/${subTeam}` : team;
+  const activeNamespace = () => team || DEFAULT_NAMESPACE;
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
@@ -399,7 +416,7 @@ export async function initCommand(args) {
     const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
     if (isNewSubTeam) {
       if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
-      const newSparsePaths = [AW_REGISTRY_NAMESPACE_DIR, `.aw_registry/${folderName}`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR];
+      const newSparsePaths = [`.aw_registry/${folderName}`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR];
       addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
       scaffoldNamespace(AW_HOME, folderName);
@@ -447,8 +464,9 @@ export async function initCommand(args) {
     await installAwEcc(cwd, { silent });
 
     ensureAwRuntimeHook(HOME);
-    syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
-    await setupMcp(HOME, freshCfg?.namespace || team, { silent });
+    const effectiveNamespace = freshCfg?.namespace || activeNamespace();
+    syncHomeAndProjectInstructions(cwd, effectiveNamespace);
+    await setupMcp(HOME, effectiveNamespace, { silent });
     await maybeConfigureContextMode(args, { silent });
     applyStoredStartupPreferences(HOME);
     const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
@@ -493,8 +511,10 @@ export async function initCommand(args) {
 
     // Auto-install suggested integrations (Codex, Caveman, Graphify, etc) - unless --no-integrations
     let installedIntegrations = [];
+    let integrationStatuses = [];
     if (!silent && !skipIntegrations && !isNewSubTeam) {
-      installedIntegrations = await autoInstallIntegrations(freshCfg?.namespace || team, { silent });
+      installedIntegrations = await autoInstallIntegrations(effectiveNamespace, { silent });
+      integrationStatuses = getSuggestedIntegrationStatuses(effectiveNamespace, { home: HOME });
     }
 
     if (silent) {
@@ -517,7 +537,7 @@ export async function initCommand(args) {
           ? `  ${chalk.green('✓')} Removed ${removedLegacyStartupFiles.length} legacy repo startup file${removedLegacyStartupFiles.length > 1 ? 's' : ''}`
           : null,
         cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Project linked` : null,
-        installedIntegrations.length > 0 ? `  ${chalk.green('✓')} Integrations: ${installedIntegrations.join(', ')}` : null,
+        formatIntegrationStatusSummary(integrationStatuses, installedIntegrations),
       ].filter(Boolean).join('\n'));
     }
     return;
@@ -546,13 +566,13 @@ export async function initCommand(args) {
   }
 
   // Determine sparse paths
-  const sparsePaths = [AW_REGISTRY_NAMESPACE_DIR, `.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
+  const sparsePaths = [`.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
   if (folderName) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
 
   fmt.note([
-    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+    `${chalk.dim('namespace:')}  ${folderName || activeNamespace()}`,
     user ? `${chalk.dim('user:')}       ${user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config');
@@ -592,7 +612,7 @@ export async function initCommand(args) {
   }
 
   // Create sync config — default to 'platform' when no namespace specified
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: activeNamespace(), user });
   if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
     scaffoldNamespace(AW_HOME, folderName);
@@ -614,8 +634,8 @@ export async function initCommand(args) {
 
   // Parallel batch B: post-ECC setup (instructions and MCP are independent)
   const [, mcpFiles] = await Promise.all([
-    Promise.resolve(syncHomeAndProjectInstructions(cwd, team)),
-    setupMcp(HOME, team, { silent }),
+    Promise.resolve(syncHomeAndProjectInstructions(cwd, activeNamespace())),
+    setupMcp(HOME, activeNamespace(), { silent }),
   ]);
   await maybeConfigureContextMode(args, { silent });
   // applyStoredStartupPreferences reads settings written by ECC — keep after batch B
@@ -686,8 +706,10 @@ export async function initCommand(args) {
 
   // Auto-install suggested integrations (Codex, Caveman, Graphify, etc) - unless --no-integrations
   let installedIntegrations = [];
+  let integrationStatuses = [];
   if (!silent && !skipIntegrations) {
-    installedIntegrations = await autoInstallIntegrations(team, { silent });
+    installedIntegrations = await autoInstallIntegrations(activeNamespace(), { silent });
+    integrationStatuses = getSuggestedIntegrationStatuses(activeNamespace(), { home: HOME });
   }
 
   // Offer to update if a newer version is available
@@ -710,7 +732,7 @@ export async function initCommand(args) {
     awUsageHooksReport ? `  ${chalk.green('✓')} ${awUsageHooksReport}` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,
     cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Linked in current project` : null,
-    installedIntegrations.length > 0 ? `  ${chalk.green('✓')} Integrations: ${installedIntegrations.join(', ')}` : null,
+    formatIntegrationStatusSummary(integrationStatuses, installedIntegrations),
     '',
     `  ${chalk.dim('Existing repos:')} ${chalk.bold('cd <project> && aw link')}`,
     `  ${chalk.dim('New clones:')}     auto-linked via git hook`,

package/commands/pull.mjs

@@ -26,7 +26,6 @@ import {
 import {
   REGISTRY_DIR,
   REGISTRY_URL,
-  AW_REGISTRY_NAMESPACE_DIR,
   DOCS_SOURCE_DIR,
   AW_DOCS_DIR,
   RULES_SOURCE_DIR,
@@ -94,7 +93,7 @@ export async function pullCommand(args) {
   // Ensure platform pulls also fetch docs and rules on older installs that
   // pre-date the new sparse-checkout paths.
   if (input === 'platform') {
-    addToSparseCheckout(AW_HOME, [AW_REGISTRY_NAMESPACE_DIR, `.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR]);
+    addToSparseCheckout(AW_HOME, [`.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR]);
     if (!cfg.include.includes('platform')) {
       config.addPattern(GLOBAL_AW_DIR, 'platform');
     }

package/constants.mjs

@@ -19,9 +19,6 @@ export const REGISTRY_URL = process.env.AW_REGISTRY_URL
 /** Directory inside the registry repo that holds platform/ and [template]/ */
 export const REGISTRY_DIR = '.aw_registry';
 
-/** Top-level AW namespace in the registry. Holds active AW-owned skills. */
-export const AW_REGISTRY_NAMESPACE_DIR = `${REGISTRY_DIR}/aw`;
-
 /** Directory in platform-docs repo containing documentation (pulled into platform/docs/) */
 export const DOCS_SOURCE_DIR = 'content';
 

package/ecc.mjs

@@ -3,7 +3,7 @@ import { promisify } from "node:util";
 const execAsync = promisify(execCb);
 import {
   existsSync, readFileSync, readdirSync,
-  mkdirSync, rmSync, writeFileSync,
+  mkdirSync, rmSync, writeFileSync, renameSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
@@ -16,6 +16,7 @@ export const AW_ECC_TAG = "v1.4.66";
 const REQUIRED_ECC_FILES = [
   "package.json",
   "scripts/install-apply.js",
+  "scripts/sync-ecc-to-codex.sh",
 ];
 
 const MARKETPLACE_NAME = "aw-marketplace";
@@ -23,31 +24,19 @@ const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;
 
 function eccDir() { return join(homedir(), ".aw-ecc"); }
 
-// File-copy targets use explicit non-skill, non-command module sets so hooks,
-// rules, shared references, and install-state can remain available while AW
-// skills come from platform-docs/.aw_registry/aw. Slash access is backed by
-// those skills directly, so aw-ecc command artifacts are intentionally skipped.
+// "claude" uses a no-commands module set so hooks, rules, shared references,
+// and install-state land in ~/.claude/ — while slash commands stay owned by
+// the marketplace plugin under /aw:*.
+// Using `--without baseline:commands` with broader profiles is unsafe because
+// some optional modules depend on commands-core and cause install-apply to fail.
 const FILE_COPY_TARGETS = ["claude", "cursor", "codex"];
-const FILE_COPY_MODULES_BY_TARGET = {
-  claude: [
-    "rules-core",
-    "agents-core",
-    "hooks-runtime",
-    "platform-configs",
-  ],
-  cursor: [
-    "rules-core",
-    "agents-core",
-    "hooks-runtime",
-    "platform-configs",
-  ],
-  codex: [
-    "rules-core",
-    "agents-core",
-    "hooks-runtime",
-    "platform-configs",
-  ],
-};
+const CLAUDE_FILE_COPY_MODULES = [
+  "rules-core",
+  "agents-core",
+  "hooks-runtime",
+  "platform-configs",
+  "workflow-quality",
+];
 
 const TARGET_STATE = {
   claude: { state: ".claude/ecc/install-state.json" },
@@ -252,11 +241,12 @@ function cloneOrUpdate(tag, dest) {
 
 /**
  * Transform canonical /aw: references to Cursor-compatible /aw- in installed
- * rule files. Cursor's model-side rule still sees hyphenated route mentions in
- * some generated home instructions.
+ * skill and rule files. Cursor namespaces commands via directory structure
+ * (commands/aw/plan.md → /aw-plan) rather than colons.
  */
 function transformCursorAwRefs(home) {
   const dirs = [
+    join(home, ".cursor", "skills"),
     join(home, ".cursor", "rules"),
   ];
   for (const dir of dirs) {
@@ -290,16 +280,57 @@ function uninstallClaudePlugin() {
   try { run(`claude plugin marketplace remove ${MARKETPLACE_NAME}`); } catch { /* not registered */ }
 }
 
-function pruneEccAuthoredSkillsAndCommands(repoDir) {
-  // The local aw-ecc clone is now only a compatibility runtime for hooks,
-  // rules, agents, and configs. Active AW skills live in platform-docs under
-  // ~/.aw/.aw_registry/aw/skills, and slash adapters point at those SKILL.md
-  // files directly.
-  for (const relPath of ["commands", "skills"]) {
+/**
+ * Move ecc command files from ~/.cursor/commands/*.md → ~/.cursor/commands/aw/*.md
+ * so Cursor exposes them as /aw:tdd, /aw:plan — consistent with Claude Code's plugin namespace.
+ * Also updates the ecc-install-state.json paths so nuke can clean them up correctly.
+ */
+function namespaceCursorCommands(home) {
+  const commandsDir = join(home, ".cursor", "commands");
+  const awDir = join(commandsDir, "aw");
+  if (!existsSync(commandsDir)) return;
+
+  // Move any flat .md files (not already in a subdirectory) into aw/
+  const moved = [];
+  for (const file of readdirSync(commandsDir)) {
+    if (!file.endsWith(".md") || file.startsWith(".")) continue;
+    const src = join(commandsDir, file);
+    mkdirSync(awDir, { recursive: true });
+    const dest = join(awDir, file);
     try {
-      rmSync(join(repoDir, relPath), { recursive: true, force: true });
+      renameSync(src, dest);
+      moved.push({ from: src, to: dest });
     } catch { /* best effort */ }
   }
+
+  if (moved.length === 0) return;
+
+  // Update install-state so nuke removes files from the new aw/ location
+  const statePath = join(home, ".cursor", "ecc-install-state.json");
+  if (!existsSync(statePath)) return;
+  try {
+    const state = JSON.parse(readFileSync(statePath, "utf8"));
+    const pathMap = new Map(moved.map(({ from, to }) => [from, to]));
+    state.operations = (state.operations || []).map((op) => {
+      const newPath = op.destinationPath && pathMap.get(op.destinationPath);
+      return newPath ? { ...op, destinationPath: newPath } : op;
+    });
+    writeFileSync(statePath, JSON.stringify(state, null, 2));
+  } catch { /* best effort */ }
+}
+
+/**
+ * Run scripts/sync-ecc-to-codex.sh from the cloned ecc repo.
+ * Generates ~/.codex/prompts/*.md (Codex equivalent of slash commands),
+ * using aw-*.md for AW-namespaced commands and ecc-*.md for the rest,
+ * and merges ~/.codex/AGENTS.md. Best-effort — failure doesn't block init.
+ */
+function syncEccToCodex(repoDir) {
+  const syncScript = join(repoDir, "scripts", "sync-ecc-to-codex.sh");
+  if (!existsSync(syncScript)) return;
+  try {
+    run(`bash "${syncScript}"`, { cwd: homedir() });
+  } catch { /* best effort — codex sync failure is non-blocking */ }
 }
 
 export async function installAwEcc(
@@ -316,7 +347,6 @@ export async function installAwEcc(
   try {
     if (eccSpinner) eccSpinner.start('Cloning aw-ecc engine...');
     await cloneOrUpdateAsync(AW_ECC_TAG, repoDir);
-    pruneEccAuthoredSkillsAndCommands(repoDir);
     if (eccSpinner) eccSpinner.message('Installing aw-ecc dependencies...');
 
     // Claude Code: plugin install via marketplace CLI (proper agent dispatch)
@@ -351,17 +381,20 @@ export async function installAwEcc(
 
           // Always use HOME as cwd so files land in ~/.<target>/ globally.
           const runCwd = homedir();
-          const installModules = FILE_COPY_MODULES_BY_TARGET[target] || [];
-          const installArgs = installModules.length > 0
-            ? `--target ${target} --modules ${installModules.join(",")}`
-            : `--target ${target}`;
+          const installArgs = target === "claude"
+            ? `--target ${target} --modules ${CLAUDE_FILE_COPY_MODULES.join(",")}`
+            : `--target ${target} --profile full`;
           run(
             `node ${join(repoDir, "scripts/install-apply.js")} ${installArgs}`,
             { cwd: runCwd },
           );
           if (target === "cursor") {
+            namespaceCursorCommands(runCwd);
             transformCursorAwRefs(home);
           }
+          if (target === "codex") {
+            syncEccToCodex(repoDir);
+          }
           restoreProtectedConfigs(snapshot);
         } catch { /* target not supported — skip */ }
       }));
@@ -413,8 +446,8 @@ export function uninstallAwEcc({ silent = false } = {}) {
     } catch { /* corrupted state — skip */ }
   }
 
-  // Codex: remove legacy generated prompt files from older ECC sync flows
-  // (not tracked in install-state — cleaned via manifests, with prefix fallback).
+  // Codex: remove generated prompt files from sync-ecc-to-codex.sh
+  // (not tracked in install-state — cleaned via manifests, with prefix fallback)
   const codexPromptsDir = join(HOME, ".codex", "prompts");
   if (existsSync(codexPromptsDir)) {
     try {