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

package/c4/claudePluginRegistry.mjs

@@ -12,7 +12,7 @@
  *
  *   2. enabledPlugins["aw@aw-marketplace"] = true
  *      Activates the plugin (without this Claude knows about the marketplace
- *      but does not surface its commands/skills).
+ *      but does not surface its routing hooks).
  *
  *   3. permissions.allow includes "Skill"
  *      Without this Claude refuses to dispatch the Skill tool. Append-only
@@ -114,8 +114,8 @@ function ensureSkillPermission(root) {
 }
 
 /**
- * Ensure Claude is wired up to surface ECC's `aw:<stage>` skills via plugin
- * marketplace + Skill permission.
+ * Ensure Claude is wired up to the AW plugin marketplace + Skill permission.
+ * Active AW skill bodies come from ~/.aw/.aw_registry/aw/skills.
  *
  * @param {string} home    User home (e.g. tmp dir in tests).
  * @param {string} eccDir  Path to the ECC plugin directory (~/.aw-ecc).

package/c4/commandSurface.mjs

@@ -1,30 +1,21 @@
 /**
- * c4/commandSurface.mjs — slash-command resolution per harness (G3).
+ * c4/commandSurface.mjs — slash-command resolution per harness.
  *
- * Why: intent-based routing fires via the slim card / SessionStart hook,
- * but a user typing `/aw:plan` directly relies on a per-harness slash
- * command surface. Without these symlinks (or, on Claude, the plugin
- * marketplace registration), `/aw:plan` errors out and the AC for
- * "manual command works" fails.
+ * `/aw:*` now resolves to AW skills directly. The active source of truth is
+ * `~/.aw/.aw_registry/aw/skills/<skill>/SKILL.md`; command markdown from
+ * aw-ecc is intentionally not installed into the cloud slash surface.
  *
- * Naming convention (verified, L4): ECC ships UN-PREFIXED command files
- * (`plan.md`, `build.md`, …). Slash namespacing is by SUBDIRECTORY:
- *   ~/.cursor/commands/aw/<name>.md  → /aw:<name>
- *   ~/.codex/commands/aw/<name>.md   → /aw:<name>
- * The legacy `~/.cursor/commands/aw-<name>.md` shape is NOT what the
- * pilot transcripts produced and is not what we install.
+ * Naming convention:
+ *   ~/.cursor/commands/aw/<name>.md  -> /aw:<name>
+ *   ~/.codex/commands/aw/<name>.md   -> /aw:<name>
  *
- * Per-harness behavior:
- *   - claude-web: 'noop' — plugin marketplace (registered separately by
- *     claudePluginRegistry.mjs) exposes the ECC commands directly.
- *   - cursor-cloud / codex-web: 'symlink' — link each ECC command into
- *     the harness command dir, replacing stale symlinks idempotently.
+ * The adapter file is a symlink to the skill's `SKILL.md`:
+ *   aw-plan/SKILL.md        -> /aw:plan
+ *   grill-with-docs/SKILL.md -> /aw:grill-with-docs
  *
- * `expectedCommands` is derived at runtime by globbing
- * `<eccHome>/commands/*.md` and filtering to the AW routing-stage list.
- * No hardcoded array drives the install; ECC is the source of truth.
- *
- * Contract: spec.md::§"c4/commandSurface.mjs", tasks.md::3.7.
+ * The `aw-` prefix is stripped only for slash aliases so skill directory
+ * names remain stable while user-facing routes stay `/aw:plan`, `/aw:build`,
+ * etc. Non-prefixed skill names are exposed unchanged.
  */
 
 import {
@@ -33,48 +24,52 @@ import {
   mkdirSync,
   readdirSync,
   readlinkSync,
+  rmSync,
   symlinkSync,
   unlinkSync,
 } from 'node:fs';
-import { join, basename, extname, relative } from 'node:path';
-
-// Canonical AW routing-stage commands. Anything in <eccHome>/commands/*.md
-// not on this list is treated as "not a slash-command" (e.g. README.md).
-// This list is a filter applied AFTER globbing; it is not a source of truth
-// for what gets installed — only what we recognize as a stage.
-const AW_STAGE_COMMANDS = new Set([
-  'plan',
-  'build',
-  'investigate',
-  'review',
-  'test',
-  'deploy',
-  'ship',
-  'feature',
-  'adk',
-  'publish',
-]);
+import { join } from 'node:path';
+
+function awSkillsDir(awHome) {
+  return join(awHome, '.aw_registry', 'aw', 'skills');
+}
+
+function slashNameForSkill(skillName) {
+  return skillName.startsWith('aw-') && skillName.length > 3
+    ? skillName.slice(3)
+    : skillName;
+}
 
 /**
- * Walk <eccHome>/commands/*.md and return the AW-stage basenames in
- * alphabetical order. Stage filename matching is case-sensitive (ECC ships
- * lowercase).
+ * Discover active AW skills and their slash aliases.
  *
- * @param {string} eccHome
- * @returns {string[]}
+ * @param {string} awHome
+ * @returns {Array<{ skillName: string, slashName: string, sourcePath: string }>}
  */
-function discoverEccStageCommands(eccHome) {
-  const commandsDir = join(eccHome, 'commands');
-  if (!existsSync(commandsDir)) return [];
-  const entries = readdirSync(commandsDir);
-  const stageNames = [];
-  for (const entry of entries) {
-    if (extname(entry).toLowerCase() !== '.md') continue;
-    const name = basename(entry, '.md');
-    if (AW_STAGE_COMMANDS.has(name)) stageNames.push(name);
+function discoverAwSkillRoutes(awHome) {
+  const skillsDir = awSkillsDir(awHome);
+  if (!existsSync(skillsDir)) return [];
+
+  const routes = new Map();
+  for (const entry of safeReaddir(skillsDir)) {
+    if (entry.startsWith('.')) continue;
+    const skillDir = join(skillsDir, entry);
+    if (!isDir(skillDir)) continue;
+    const sourcePath = join(skillDir, 'SKILL.md');
+    if (!existsSync(sourcePath)) continue;
+
+    const slashName = slashNameForSkill(entry);
+    const existing = routes.get(slashName);
+    const candidate = { skillName: entry, slashName, sourcePath };
+    if (!existing || (entry.startsWith('aw-') && !existing.skillName.startsWith('aw-'))) {
+      routes.set(slashName, candidate);
+    }
   }
-  stageNames.sort();
-  return stageNames;
+
+  return [...routes.values()].sort((a, b) => {
+    const bySlash = a.slashName.localeCompare(b.slashName);
+    return bySlash === 0 ? a.skillName.localeCompare(b.skillName) : bySlash;
+  });
 }
 
 function harnessTargetDir(harness, home) {
@@ -99,47 +94,79 @@ function isCorrectSymlink(linkPath, expectedTarget) {
   }
 }
 
-/**
- * Symlink one stage command from ECC into the harness command directory,
- * replacing a stale symlink if needed. Returns true on success.
- */
-function linkStageCommand(stageName, eccHome, targetDir) {
-  const sourcePath = join(eccHome, 'commands', `${stageName}.md`);
-  const linkPath = join(targetDir, `${stageName}.md`);
-  if (isCorrectSymlink(linkPath, sourcePath)) return true;
-  // Replace any stale symlink or wrong-type entry.
+function lstatExists(p) {
   try {
-    if (existsSync(linkPath) || lstatExists(linkPath)) {
-      try { unlinkSync(linkPath); } catch { /* may be a directory */ }
-    }
-    symlinkSync(sourcePath, linkPath);
+    lstatSync(p);
     return true;
   } catch {
     return false;
   }
 }
 
-function lstatExists(p) {
+function isDir(p) {
   try {
-    lstatSync(p);
+    return lstatSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function safeReaddir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function linkSkillRoute(route, targetDir) {
+  const linkPath = join(targetDir, `${route.slashName}.md`);
+  if (isCorrectSymlink(linkPath, route.sourcePath)) return true;
+
+  try {
+    if (existsSync(linkPath) || lstatExists(linkPath)) {
+      try { rmSync(linkPath, { recursive: true, force: true }); } catch { /* best effort */ }
+    }
+    symlinkSync(route.sourcePath, linkPath);
     return true;
   } catch {
     return false;
   }
 }
 
+function pruneStaleSlashAdapters(targetDir, routes) {
+  const expectedFiles = new Set(routes.map((route) => `${route.slashName}.md`));
+  let pruned = 0;
+
+  for (const entry of safeReaddir(targetDir)) {
+    if (entry.startsWith('.')) continue;
+    if (expectedFiles.has(entry)) continue;
+
+    try {
+      rmSync(join(targetDir, entry), { recursive: true, force: true });
+      pruned++;
+    } catch {
+      // Best effort: stale command cleanup must not block skill adapters.
+    }
+  }
+
+  return pruned;
+}
+
 /**
- * Ensure the harness slash-command surface for AW stages.
+ * Ensure the harness slash surface for active AW skills.
  *
  * @param {object} opts
  * @param {'claude-web'|'cursor-cloud'|'codex-web'|string} opts.harness
  * @param {string} opts.home
- * @param {string} opts.eccHome
+ * @param {string} opts.awHome
  * @returns {{
  *   harness: string,
  *   expectedCommands: string[],
+ *   expectedSkills: string[],
  *   found: string[],
  *   missing: string[],
+ *   pruned: number,
  *   installedAction: 'symlink' | 'noop' | 'unsupported',
  * }}
  */
@@ -147,25 +174,26 @@ export function ensureCommandSurface(opts) {
   if (!opts || typeof opts !== 'object') {
     throw new Error('ensureCommandSurface: opts object is required');
   }
-  const { harness, home, eccHome } = opts;
+  const { harness, home, awHome } = opts;
   if (!home || typeof home !== 'string') {
     throw new Error('ensureCommandSurface: opts.home is required');
   }
-  if (!eccHome || typeof eccHome !== 'string') {
-    throw new Error('ensureCommandSurface: opts.eccHome is required');
+  if (!awHome || typeof awHome !== 'string') {
+    throw new Error('ensureCommandSurface: opts.awHome is required');
   }
 
-  const expectedCommands = discoverEccStageCommands(eccHome);
+  const routes = discoverAwSkillRoutes(awHome);
+  const expectedCommands = routes.map((route) => route.slashName);
+  const expectedSkills = routes.map((route) => route.skillName);
 
   if (harness === 'claude-web') {
-    // Plugin marketplace (handled by claudePluginRegistry) exposes the same
-    // commands. We only verify resolution; a separate per-repo resolver will
-    // catch missing-marketplace cases via dumpPostInitState.
     return {
       harness,
       expectedCommands,
+      expectedSkills,
       found: [...expectedCommands],
       missing: [],
+      pruned: 0,
       installedAction: 'noop',
     };
   }
@@ -175,217 +203,114 @@ export function ensureCommandSurface(opts) {
     return {
       harness,
       expectedCommands,
+      expectedSkills,
       found: [],
       missing: [],
+      pruned: 0,
       installedAction: 'unsupported',
     };
   }
 
-  // Best-effort directory creation. If the parent path is blocked (e.g. a
-  // file already occupies the directory location), we cannot symlink and
-  // every command will surface as missing.
   try {
     mkdirSync(targetDir, { recursive: true });
   } catch {
     return {
       harness,
       expectedCommands,
+      expectedSkills,
       found: [],
       missing: [...expectedCommands],
+      pruned: 0,
       installedAction: 'symlink',
     };
   }
-  // mkdirSync(recursive:true) is a no-op if a non-directory file exists at
-  // the target; we must verify the target is actually a directory now.
-  let isDir = false;
-  try {
-    isDir = lstatSync(targetDir).isDirectory();
-  } catch {
-    isDir = false;
-  }
-  if (!isDir) {
+
+  if (!isDir(targetDir)) {
     return {
       harness,
       expectedCommands,
+      expectedSkills,
       found: [],
       missing: [...expectedCommands],
+      pruned: 0,
       installedAction: 'symlink',
     };
   }
 
+  const pruned = pruneStaleSlashAdapters(targetDir, routes);
   const found = [];
   const missing = [];
-  for (const stageName of expectedCommands) {
-    const ok = linkStageCommand(stageName, eccHome, targetDir);
-    if (ok) found.push(stageName);
-    else missing.push(stageName);
+  for (const route of routes) {
+    const ok = linkSkillRoute(route, targetDir);
+    if (ok) found.push(route.slashName);
+    else missing.push(route.slashName);
   }
 
   return {
     harness,
     expectedCommands,
+    expectedSkills,
     found,
     missing,
+    pruned,
     installedAction: 'symlink',
   };
 }
 
 /**
- * Link ALL registry commands from ~/.aw/.aw_registry into the harness
- * command directory — not just the 10 stage commands.
- *
- * `ensureCommandSurface` only links ECC stage commands (plan, build, etc.).
- * The full registry (synced by `aw init`) contains 100+ domain-specific
- * commands (e.g. platform-review-security-hardening) that were invisible
- * in cloud harnesses because nothing linked them.
- *
- * This function mirrors the logic in link.mjs::linkWorkspace's command
- * section but is callable from the c4 orchestrator without importing the
- * full link surface.
- *
- * @param {object} opts
- * @param {'claude-web'|'cursor-cloud'|'codex-web'|string} opts.harness
- * @param {string} opts.home
- * @param {string} opts.awRegistryDir  e.g. ~/.aw/.aw_registry
- * @returns {{ linked: number, skipped: number, harness: string }}
- */
-export function ensureRegistryCommandSurface(opts) {
-  if (!opts || typeof opts !== 'object') {
-    throw new Error('ensureRegistryCommandSurface: opts object is required');
-  }
-  const { harness, home, awRegistryDir } = opts;
-
-  if (harness === 'claude-web') {
-    return { linked: 0, skipped: 0, harness, installedAction: 'noop' };
-  }
-
-  const targetDir = harnessTargetDir(harness, home);
-  if (!targetDir || !existsSync(awRegistryDir)) {
-    return { linked: 0, skipped: 0, harness, installedAction: 'unsupported' };
-  }
-
-  try {
-    mkdirSync(targetDir, { recursive: true });
-  } catch {
-    return { linked: 0, skipped: 0, harness, installedAction: 'symlink' };
-  }
-
-  let linked = 0;
-  let skipped = 0;
-
-  const namespaces = safeReaddir(awRegistryDir).filter(
-    (d) => !d.startsWith('.') && isDir(join(awRegistryDir, d)),
-  );
-
-  for (const ns of namespaces) {
-    for (const { dir: commandsDir, segments } of findCommandDirs(join(awRegistryDir, ns))) {
-      for (const file of safeReaddir(commandsDir).filter((f) => f.endsWith('.md') && !f.startsWith('.'))) {
-        const cmdFileName = [ns, ...segments, file].join('-');
-        const sourcePath = join(commandsDir, file);
-        const linkPath = join(targetDir, cmdFileName);
-
-        if (isCorrectSymlink(linkPath, sourcePath)) {
-          skipped++;
-          continue;
-        }
-
-        try {
-          if (existsSync(linkPath) || lstatExists(linkPath)) {
-            try { unlinkSync(linkPath); } catch { /* stale entry */ }
-          }
-          symlinkSync(sourcePath, linkPath);
-          linked++;
-        } catch {
-          skipped++;
-        }
-      }
-    }
-  }
-
-  return { linked, skipped, harness, installedAction: 'symlink' };
-}
-
-function safeReaddir(dir) {
-  try { return readdirSync(dir); } catch { return []; }
-}
-
-function isDir(p) {
-  try { return lstatSync(p).isDirectory(); } catch { return false; }
-}
-
-/**
- * Recursively find `commands/` directories under a namespace dir.
- * Supports nested domain dirs (e.g. platform/review/commands/).
- */
-function findCommandDirs(nsDir, segments = []) {
-  if (segments.includes('evals')) return [];
-
-  const results = [];
-  const commandsDir = join(nsDir, 'commands');
-  if (existsSync(commandsDir) && isDir(commandsDir)) {
-    results.push({ dir: commandsDir, segments });
-  }
-  for (const entry of safeReaddir(nsDir)) {
-    if (entry === 'commands' || entry === 'evals' || entry.startsWith('.')) continue;
-    const sub = join(nsDir, entry);
-    if (isDir(sub)) {
-      results.push(...findCommandDirs(sub, [...segments, entry]));
-    }
-  }
-  return results;
-}
-
-/**
- * Read-only diagnostic. Walks the harness command directory and reports
- * which AW stage commands are resolvable. Does not fix.
+ * Read-only diagnostic. For Cursor/Codex, verifies that slash adapter files
+ * point to the active AW skill `SKILL.md` files. Claude is skill/plugin
+ * routed and does not require adapter files.
  *
  * @param {object} opts
  * @param {'claude-web'|'cursor-cloud'|'codex-web'|string} opts.harness
  * @param {string} opts.home
+ * @param {string} [opts.awHome]
  * @returns {{ expected: string[], found: string[], missing: string[], ok: boolean }}
  */
 export function diagnoseCommandResolution(opts) {
   if (!opts || typeof opts !== 'object') {
     throw new Error('diagnoseCommandResolution: opts object is required');
   }
-  const { harness, home } = opts;
+  const { harness, home, awHome } = opts;
   if (!home || typeof home !== 'string') {
     throw new Error('diagnoseCommandResolution: opts.home is required');
   }
-  const expected = [...AW_STAGE_COMMANDS].sort();
+
+  const routes = awHome && typeof awHome === 'string' ? discoverAwSkillRoutes(awHome) : [];
+  const expected = routes.map((route) => route.slashName);
 
   if (harness === 'claude-web') {
-    // Plugin marketplace path. If a `~/.claude/commands` dir exists we
-    // honor it; otherwise we trust marketplace dispatch and report ok.
-    const claudeDir = join(home, '.claude/commands');
-    if (!existsSync(claudeDir)) {
-      return { expected, found: [], missing: [], ok: true };
-    }
-    return walkCommandsDir(claudeDir, expected);
+    return { expected, found: [...expected], missing: [], ok: true };
   }
 
   const targetDir = harnessTargetDir(harness, home);
   if (!targetDir) {
     return { expected, found: [], missing: [...expected], ok: false };
   }
-  return walkCommandsDir(targetDir, expected);
+  return walkSkillAdapterDir(targetDir, routes);
 }
 
-function walkCommandsDir(dir, expected) {
+function walkSkillAdapterDir(dir, routes) {
   if (!existsSync(dir)) {
+    const expected = routes.map((route) => route.slashName);
     return { expected, found: [], missing: [...expected], ok: expected.length === 0 };
   }
-  const present = new Set();
-  try {
-    for (const entry of readdirSync(dir)) {
-      if (extname(entry).toLowerCase() !== '.md') continue;
-      const name = basename(entry, '.md');
-      if (AW_STAGE_COMMANDS.has(name)) present.add(name);
-    }
-  } catch {
-    // Unreadable directory: treat as nothing-found.
+
+  const found = [];
+  const missing = [];
+  for (const route of routes) {
+    const linkPath = join(dir, `${route.slashName}.md`);
+    if (isCorrectSymlink(linkPath, route.sourcePath)) found.push(route.slashName);
+    else missing.push(route.slashName);
   }
-  const found = expected.filter((n) => present.has(n));
-  const missing = expected.filter((n) => !present.has(n));
+
+  const expected = routes.map((route) => route.slashName);
   return { expected, found, missing, ok: missing.length === 0 };
 }
+
+export const __test__ = {
+  awSkillsDir,
+  discoverAwSkillRoutes,
+  slashNameForSkill,
+};

package/c4/cursorRulesShim.mjs

@@ -4,12 +4,12 @@
  * Why: Cursor Cloud Agent's chat UI does not pre-expand `/aw:<NAME>` slash
  * commands the way Cursor Desktop's plugin does. The model sees the raw
  * literal `/aw:...` and falls through to natural-language interpretation,
- * losing the contract from the matching command file even though the file
- * is correctly installed on disk by `commandSurface.mjs`.
+ * losing the contract from the matching AW skill even though the slash
+ * adapter is correctly installed on disk by `commandSurface.mjs`.
  *
  * Workaround: write `<repoRoot>/.cursor/rules/aw-slash-expand.mdc` — a
  * Cursor project rule that teaches the MODEL itself to read the matching
- * command file and execute its contract verbatim. Cursor's `.mdc` rule
+ * AW skill file and execute its contract verbatim. Cursor's `.mdc` rule
  * format is honored in Agent mode (verified via Cursor docs); the rule
  * loads on every session when `alwaysApply: true`.
  *
@@ -47,56 +47,35 @@ const CURSOR_RULES_SUBPATH = '.cursor/rules';
  * via npm — no additional asset bundling needed.
  */
 export const CURSOR_SLASH_SHIM_RULE = `---
-description: Expand \`/aw:<NAME>\` user messages by reading the matching command file
+description: Expand \`/aw:<NAME>\` user messages by reading the matching AW skill file
 alwaysApply: true
 ---
 
-# AW slash-command expansion (Cursor Cloud workaround)
+# AW skill slash expansion (Cursor Cloud workaround)
 
 When the user message starts with \`/aw:<NAME>\` (case-sensitive; \`<NAME>\` may
-contain hyphens — both in the namespace path and in the command name), do
-the following BEFORE producing any other response.
+contain hyphens), do the following BEFORE producing any other response.
 
-## 1. Stage-command lookup (primary)
+## 1. Skill adapter lookup (primary)
 
 Read \`~/.cursor/commands/aw/<NAME>.md\`. If the file exists, jump to step 3
 with its content as the resolved instructions.
 
-## 2. Registry-command lookup (fallback, hyphen-disambiguation)
+## 2. Registry skill lookup (fallback)
 
-If step 1 did not resolve and \`<NAME>\` contains at least one hyphen, the
-slash form is a flattened \`<ns_segments...>-<cmd_segments...>\` token. The
-boundary between namespace and command is ambiguous because both can
-contain hyphens (registry has e.g. \`pr-review\`, \`capture-learning\`,
-\`ship-auto\`, \`draw-architecture\`).
-
-Disambiguate by **iterating every hyphen position in \`<NAME>\` from
-RIGHTMOST to LEFTMOST**, and use the first candidate file that exists. The
+If step 1 did not resolve, read the first candidate below that exists. The
 repo registry root is \`.aw/.aw_registry/\` (relative to the agent's CWD —
 the repo root in Cursor Cloud).
 
-For each split position \`i\` from rightmost to leftmost:
-- \`prefix = <NAME>[:i]\` (everything before the hyphen at position \`i\`)
-- \`suffix = <NAME>[i+1:]\` (everything after; may itself contain hyphens)
-- candidate = \`.aw/.aw_registry/<prefix-with-hyphens-replaced-by-slashes>/commands/<suffix>.md\`
-- Try \`Read\` on the candidate. If the file exists, jump to step 3 with
-  that content.
-
-### Worked examples
-
-| User typed                                         | Registry file                                              | Splits tried (rightmost first)                                                                                          |
-|----------------------------------------------------|------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|
-| \`/aw:platform-core-brainstorm\`                     | \`platform/core/commands/brainstorm.md\`                     | \`platform/core/commands/brainstorm.md\` ✓ (first try)                                                                    |
-| \`/aw:platform-core-pr-review\`                      | \`platform/core/commands/pr-review.md\`                      | \`platform/core/pr/commands/review.md\` ❌ → \`platform/core/commands/pr-review.md\` ✓                                      |
-| \`/aw:platform-core-capture-learning\`               | \`platform/core/commands/capture-learning.md\`               | \`platform/core/capture/commands/learning.md\` ❌ → \`platform/core/commands/capture-learning.md\` ✓                        |
-| \`/aw:platform-data-clickhouse-cluster-creation\`    | \`platform/data/clickhouse/commands/cluster-creation.md\`    | \`…/cluster/commands/creation.md\` ❌ → \`platform/data/clickhouse/commands/cluster-creation.md\` ✓                         |
+1. \`.aw/.aw_registry/aw/skills/aw-<NAME>/SKILL.md\`
+2. \`.aw/.aw_registry/aw/skills/<NAME>/SKILL.md\`
 
 ## 3. Execute
 
 Treat the resolved file's full content as your operating instructions for
-this turn. Execute the command's phased contract on the text that follows
-the slash command in the user message. Do not summarize or paraphrase the
-command file — execute it verbatim, including any "ask one question at a
+this turn. Execute the skill's contract on the text that follows the slash
+command in the user message. Do not summarize or paraphrase the skill file
+— execute it verbatim, including any "ask one question at a
 time and wait" interaction protocol.
 
 ## 4. No match
@@ -104,11 +83,10 @@ time and wait" interaction protocol.
 If neither lookup resolves to an existing file, do NOT silently fall back
 to natural-language interpretation. Reply with exactly:
 
-> \`/aw:<NAME>\` is not a registered AW command on this machine. Run
+> \`/aw:<NAME>\` is not a registered AW skill on this machine. Run
 > \`aw c4 --diagnose\` and check the output of
-> \`ls ~/.cursor/commands/aw/\` for available stage commands and
-> \`find .aw/.aw_registry -path '*/commands/*.md'\` for available registry
-> commands.
+> \`ls ~/.cursor/commands/aw/\` for available slash skill adapters and
+> \`find .aw/.aw_registry/aw/skills -name SKILL.md\` for available AW skills.
 
 This precise reply text is the smoke-test fingerprint for the rule itself.
 The string is unique enough that it cannot be confused with the model's
@@ -117,8 +95,8 @@ natural-language fallback.
 ---
 
 This rule exists because Cursor Cloud's chat UI does not pre-expand slash
-commands the way Cursor Desktop does. The command files ARE installed on
-disk by \`aw c4\`; this rule teaches the model to load them itself. See
+commands the way Cursor Desktop does. The skill adapter files ARE installed
+on disk by \`aw c4\`; this rule teaches the model to load them itself. See
 \`.aw_docs/features/aw-c4-cursor-slash-shim/overview.md\` for context. Do
 not edit this file by hand — \`aw c4 --harness cursor-cloud\` regenerates
 it on every run.

package/c4/index.mjs

@@ -48,7 +48,7 @@ export {
 export { MCP_URL_DEFAULT, registerGhlAiMcp } from './mcpServer.mjs';
 export { probeMcpServer } from './mcpSmokeProbe.mjs';
 export { ensureClaudeMarketplace } from './claudePluginRegistry.mjs';
-export { ensureCommandSurface, ensureRegistryCommandSurface, diagnoseCommandResolution } from './commandSurface.mjs';
+export { ensureCommandSurface, diagnoseCommandResolution } from './commandSurface.mjs';
 export { installCursorSlashShim, CURSOR_SLASH_SHIM_RULE } from './cursorRulesShim.mjs';
 export { ensureRepoLocalClaudeSettings } from './repoLocalClaudeSettings.mjs';
 export { copyRepoRootInstructions } from './repoRootInstructions.mjs';

package/c4/templates/scripts/aw-c4-bootstrap.sh

@@ -129,30 +129,30 @@ aw_c4_exit=$?
 
 # Defense-in-depth: `aw c4` delegates registry sync to `aw init --silent`,
 # which can fail to fetch in silent mode without surfacing an error. When
-# that happens, the registry (~/.aw/.aw_registry) may be empty or incomplete
-# and only the 10 hardcoded stage commands get linked. Re-run `aw pull`
-# post-c4 if the command count looks low.
-verify_registry_commands() {
-  local aw_cmd_dir="$HOME/.aw/.aw_registry"
-  if [ ! -d "$aw_cmd_dir" ]; then
+# that happens, the registry (~/.aw/.aw_registry) may be empty or incomplete.
+# Re-run `aw pull` post-c4 if the AW skill count looks low.
+verify_registry_skills() {
+  local aw_registry_dir="$HOME/.aw/.aw_registry"
+  local aw_skills_dir="$aw_registry_dir/aw/skills"
+  if [ ! -d "$aw_registry_dir" ]; then
     echo "[aw-c4-bootstrap] registry dir missing — running aw init + pull"
     aw init --no-integrations --silent 2>&1 | tail -3 || true
     aw pull 2>&1 | tail -5 || true
     return
   fi
 
-  local cmd_count
-  cmd_count=$(find "$aw_cmd_dir" -name '*.md' -path '*/commands/*' ! -path '*/evals/*' 2>/dev/null | wc -l | tr -d ' ')
-  if [ "${cmd_count:-0}" -lt 20 ]; then
-    echo "[aw-c4-bootstrap] only ${cmd_count} registry commands found — running aw pull"
+  local skill_count
+  skill_count=$( (find "$aw_skills_dir" -name 'SKILL.md' 2>/dev/null || true) | wc -l | tr -d ' ' )
+  if [ "${skill_count:-0}" -lt 5 ]; then
+    echo "[aw-c4-bootstrap] only ${skill_count} AW registry skills found — running aw pull"
     aw pull 2>&1 | tail -5 || true
     local new_count
-    new_count=$(find "$aw_cmd_dir" -name '*.md' -path '*/commands/*' ! -path '*/evals/*' 2>/dev/null | wc -l | tr -d ' ')
-    echo "[aw-c4-bootstrap] registry commands: ${cmd_count} → ${new_count}"
+    new_count=$( (find "$aw_skills_dir" -name 'SKILL.md' 2>/dev/null || true) | wc -l | tr -d ' ' )
+    echo "[aw-c4-bootstrap] AW registry skills: ${skill_count} -> ${new_count}"
   else
-    echo "[aw-c4-bootstrap] registry: ${cmd_count} commands OK"
+    echo "[aw-c4-bootstrap] registry: ${skill_count} AW skills OK"
   fi
 }
-verify_registry_commands || true
+verify_registry_skills || true
 
 exit "$aw_c4_exit"

package/commands/c4.mjs

@@ -192,7 +192,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 });
+  const command = c4.diagnoseCommandResolution({ harness, home, awHome });
 
   let view;
   let injector;
@@ -415,7 +415,22 @@ export async function c4Command(rawArgs, overrides = {}) {
       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 commands were not fetched\n');
+        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');
         return exit(1);
       }
     }
@@ -438,26 +453,9 @@ export async function c4Command(rawArgs, overrides = {}) {
     writer.stdout('[aw-c4] MCP disabled; skipping registerGhlAiMcp\n');
   }
 
-  // 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 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 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,22 +523,14 @@ function findBrokenRuleReferences(filePaths) {
   return broken;
 }
 
-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 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 buildDoctorChecks(homeDir, cwd) {
@@ -586,6 +578,19 @@ 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');
@@ -646,12 +651,10 @@ 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 and router skill files')
+        ? makeCheck('claude-plugin-bundle', 'Claude plugin bundle', 'pass', 'Claude plugin bundle contains AW routing hooks')
         : makeCheck(
           'claude-plugin-bundle',
           'Claude plugin bundle',
@@ -667,21 +670,8 @@ 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 || []);
@@ -867,19 +857,6 @@ 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))
@@ -944,20 +921,6 @@ 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/ecc.mjs

@@ -3,7 +3,7 @@ import { promisify } from "node:util";
 const execAsync = promisify(execCb);
 import {
   existsSync, readFileSync, readdirSync,
-  mkdirSync, rmSync, writeFileSync, renameSync,
+  mkdirSync, rmSync, writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
@@ -16,7 +16,6 @@ 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";
@@ -24,11 +23,10 @@ const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;
 
 function eccDir() { return join(homedir(), ".aw-ecc"); }
 
-// File-copy targets use explicit non-skill module sets so hooks, rules,
-// command compatibility, shared references, and install-state can remain
-// available while AW skills come from platform-docs/.aw_registry/aw.
-// Using `--without baseline:commands` with broader profiles is unsafe because
-// some optional modules depend on commands-core and cause install-apply to fail.
+// 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.
 const FILE_COPY_TARGETS = ["claude", "cursor", "codex"];
 const FILE_COPY_MODULES_BY_TARGET = {
   claude: [
@@ -40,7 +38,6 @@ const FILE_COPY_MODULES_BY_TARGET = {
   cursor: [
     "rules-core",
     "agents-core",
-    "commands-core",
     "hooks-runtime",
     "platform-configs",
   ],
@@ -255,8 +252,8 @@ function cloneOrUpdate(tag, dest) {
 
 /**
  * Transform canonical /aw: references to Cursor-compatible /aw- in installed
- * skill and rule files. Cursor namespaces commands via directory structure
- * (commands/aw/plan.md → /aw-plan) rather than colons.
+ * rule files. Cursor's model-side rule still sees hyphenated route mentions in
+ * some generated home instructions.
  */
 function transformCursorAwRefs(home) {
   const dirs = [
@@ -293,79 +290,16 @@ function uninstallClaudePlugin() {
   try { run(`claude plugin marketplace remove ${MARKETPLACE_NAME}`); } catch { /* not registered */ }
 }
 
-/**
- * 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);
+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"]) {
     try {
-      renameSync(src, dest);
-      moved.push({ from: src, to: dest });
+      rmSync(join(repoDir, relPath), { recursive: true, force: true });
     } 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 */ }
-}
-
-/**
- * Generate Codex prompt files from ECC commands only.
- *
- * The old ECC sync script also materialized ECC skills into Codex-owned
- * skill directories. AW skills now come from platform-docs/.aw_registry/aw,
- * so this runtime keeps the command prompt compatibility surface and does
- * not run the broad ECC skill sync.
- */
-function syncEccCommandsToCodex(repoDir) {
-  const commandsDir = join(repoDir, "commands");
-  if (!existsSync(commandsDir)) return;
-  try {
-    const promptsDir = join(homedir(), ".codex", "prompts");
-    mkdirSync(promptsDir, { recursive: true });
-    const manifest = [];
-
-    for (const file of readdirSync(commandsDir).filter((entry) => entry.endsWith(".md") && !entry.startsWith("."))) {
-      const commandPath = join(commandsDir, file);
-      const content = readFileSync(commandPath, "utf8");
-      const basename = file.replace(/\.md$/, "");
-      const heading = content.match(/^#\s+(\/\S+)/m)?.[1];
-      const promptName = heading?.startsWith("/aw:")
-        ? heading.slice(1).replace(/:/g, "-").replace(/[^\w.-]/g, "-")
-        : `ecc-${basename}`;
-      const promptFile = `${promptName}.md`;
-      writeFileSync(join(promptsDir, promptFile), content);
-      manifest.push(promptFile);
-    }
-
-    writeFileSync(
-      join(promptsDir, "ecc-prompts-manifest.txt"),
-      manifest.sort().map((entry) => `${entry}\n`).join(""),
-    );
-  } catch { /* best effort — codex sync failure is non-blocking */ }
 }
 
 export async function installAwEcc(
@@ -382,6 +316,7 @@ 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)
@@ -425,12 +360,8 @@ export async function installAwEcc(
             { cwd: runCwd },
           );
           if (target === "cursor") {
-            namespaceCursorCommands(runCwd);
             transformCursorAwRefs(home);
           }
-          if (target === "codex") {
-            syncEccCommandsToCodex(repoDir);
-          }
           restoreProtectedConfigs(snapshot);
         } catch { /* target not supported — skip */ }
       }));
@@ -482,8 +413,8 @@ export function uninstallAwEcc({ silent = false } = {}) {
     } catch { /* corrupted state — skip */ }
   }
 
-  // Codex: remove generated prompt files from sync-ecc-to-codex.sh
-  // (not tracked in install-state — cleaned via manifests, with prefix fallback)
+  // Codex: remove legacy generated prompt files from older ECC sync flows
+  // (not tracked in install-state — cleaned via manifests, with prefix fallback).
   const codexPromptsDir = join(HOME, ".codex", "prompts");
   if (existsSync(codexPromptsDir)) {
     try {

package/integrate.mjs

@@ -1,10 +1,9 @@
 // integrate.mjs — Generate commands for all IDEs, instructions (CLAUDE.md, AGENTS.md)
 
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
-import * as config from './config.mjs';
 import { getLocalRegistryDir } from './git.mjs';
 import {
   generateAgentsMdRulesSection,
@@ -174,8 +173,8 @@ function applyManagedInstructionSections(content, file, rulesSections = {}, opti
 }
 
 /**
- * Count hand-written commands already present in the registry.
- * No CLI stub generation — all commands come from the registry itself.
+ * Command slash adapters are deprecated. Keep this function as a compatibility
+ * no-op for older call sites and clean the removed generated-command folder.
  */
 export function generateCommands(cwd, { silent = false } = {}) {
   const awDir = getLocalRegistryDir(cwd, join(homedir(), '.aw_registry'));
@@ -184,47 +183,8 @@ export function generateCommands(cwd, { silent = false } = {}) {
   const oldGenDir = join(awDir, '.generated-commands');
   if (existsSync(oldGenDir)) rmSync(oldGenDir, { recursive: true, force: true });
 
-  // Count hand-written commands across all namespaces for reporting
-  let count = 0;
-  const namespaces = getTeamNamespaces(awDir);
-  for (const ns of namespaces) {
-    const nsDir = join(awDir, ns);
-    if (existsSync(nsDir)) {
-      const cmdFiles = findFiles(nsDir, 'commands');
-      count += cmdFiles.length;
-    }
-  }
-
-  if (count > 0 && !silent) {
-    fmt.logSuccess(`Generated ${count} aw commands`);
-  }
-
-  return count;
-}
-
-function findFiles(dir, typeName) {
-  const results = [];
-  function walk(d) {
-    let entries;
-    try {
-      entries = readdirSync(d, { withFileTypes: true });
-    } catch { return; } // not a directory — skip gracefully
-    for (const entry of entries) {
-      if (entry.name.startsWith('.')) continue;
-      const full = join(d, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === typeName) {
-          for (const f of readdirSync(full)) {
-            if (f.endsWith('.md')) results.push(join(full, f));
-          }
-        } else {
-          walk(full);
-        }
-      }
-    }
-  }
-  walk(dir);
-  return results;
+  if (!silent) fmt.logSuccess('Command adapters are disabled; use registry-backed AW skills');
+  return 0;
 }
 
 /**
@@ -711,19 +671,3 @@ No active tasks. Tasks are created during workflow execution.
     fmt.logSuccess('Orchestration state ready');
   }
 }
-
-/**
- * Return top-level team namespace names from config (excludes 'platform').
- * cfg.include may contain full paths like 'mobile/core/backend/agents/dev.md'
- * so we extract only the first path segment (the actual namespace folder).
- * E.g. ['mobile/core/backend/agents/dev.md', 'revex'] → ['mobile', 'revex']
- */
-function getTeamNamespaces(awDir) {
-  const cfg = config.load(awDir);
-  if (!cfg || !cfg.include) return [];
-  return [...new Set(
-    cfg.include
-      .filter(p => p !== 'platform')
-      .map(p => p.split('/')[0]),
-  )];
-}

package/link.mjs

@@ -1,9 +1,10 @@
 // link.mjs — Create symlinks from IDE dirs → .aw_registry/
 
-import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync, rmdirSync, realpathSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync, rmdirSync, realpathSync, rmSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
+import { ensureCommandSurface } from './c4/commandSurface.mjs';
 import { getLocalRegistryDir } from './git.mjs';
 
 function forceSymlink(target, linkPath) {
@@ -130,6 +131,31 @@ function cleanIdeSymlinks(cwd) {
   }
 }
 
+function pruneManagedAwCommandNamespaces(cwd) {
+  let pruned = 0;
+  for (const ide of IDE_DIRS) {
+    const commandDir = join(cwd, ide, 'commands', 'aw');
+    if (!existsSync(commandDir)) continue;
+    try {
+      rmSync(commandDir, { recursive: true, force: true });
+      pruned++;
+    } catch {
+      // Best effort: stale command cleanup should not block registry linking.
+    }
+  }
+  return pruned;
+}
+
+function ensureSkillSlashAdapters(cwd, awDir) {
+  const awHome = dirname(awDir);
+  let linked = 0;
+  for (const harness of ['cursor-cloud', 'codex-web']) {
+    const result = ensureCommandSurface({ harness, home: cwd, awHome });
+    linked += result.found.length;
+  }
+  return linked;
+}
+
 /**
  * Remove all symlinks in a directory, then prune empty subdirectories.
  * Walks depth-first so children are cleaned before parents.
@@ -196,6 +222,9 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
 
   // Clean old symlinks first
   cleanIdeSymlinks(cwd);
+  if (cwd === HOME) {
+    pruneManagedAwCommandNamespaces(cwd);
+  }
 
   const namespaces = listNamespaceDirs(awDir);
 
@@ -344,22 +373,10 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
     }
   }
 
-  // Commands: per-file symlinks (recursive for nested domain dirs)
-  for (const ns of namespaces) {
-    for (const { typeDirPath: commandsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'commands')) {
-      for (const file of readdirSync(commandsDir).filter(f => f.endsWith('.md') && !f.startsWith('.'))) {
-        const cmdFileName = flatRegistryName(ns, ...segments, file);
-
-        for (const ide of IDE_DIRS) {
-          const linkDir = join(cwd, ide, 'commands', 'aw');
-          mkdirSync(linkDir, { recursive: true });
-          const linkPath = join(linkDir, cmdFileName);
-          const targetPath = join(commandsDir, file);
-          const relTarget = relative(linkDir, targetPath);
-          try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
-        }
-      }
-    }
+  // Slash adapters are skills-only. Keep the harness discovery paths populated,
+  // but point every /aw:* file at .aw_registry/aw/skills/*/SKILL.md.
+  if (cwd === HOME) {
+    try { created += ensureSkillSlashAdapters(cwd, awDir); } catch { /* best effort */ }
   }
 
   // AW-PROTOCOL.md: symlink into each IDE dir root so commands can always find it

package/package.json

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