@ghl-ai/aw 0.1.69 → 0.1.70-beta.1

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 {
@@ -36,45 +27,48 @@ import {
   symlinkSync,
   unlinkSync,
 } from 'node:fs';
-import { join, basename, extname, relative } from 'node:path';
+import { join } from 'node:path';
+
+function awSkillsDir(awHome) {
+  return join(awHome, '.aw_registry', 'aw', 'skills');
+}
 
-// 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',
-]);
+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,29 +93,40 @@ 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 { unlinkSync(linkPath); } catch { /* may be a directory */ }
+    }
+    symlinkSync(route.sourcePath, linkPath);
     return true;
   } catch {
     return false;
@@ -129,15 +134,16 @@ function lstatExists(p) {
 }
 
 /**
- * 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[],
  *   installedAction: 'symlink' | 'noop' | 'unsupported',
@@ -147,23 +153,23 @@ 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: [],
       installedAction: 'noop',
@@ -175,38 +181,31 @@ export function ensureCommandSurface(opts) {
     return {
       harness,
       expectedCommands,
+      expectedSkills,
       found: [],
       missing: [],
       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],
       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],
       installedAction: 'symlink',
@@ -215,15 +214,16 @@ export function ensureCommandSurface(opts) {
 
   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,
     installedAction: 'symlink',
@@ -231,161 +231,59 @@ export function ensureCommandSurface(opts) {
 }
 
 /**
- * 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.