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

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 routing hooks).
+ *      but does not surface its commands/skills).
  *
  *   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 the AW plugin marketplace + Skill permission.
- * Active AW skill bodies come from ~/.aw/.aw_registry/aw/skills.
+ * Ensure Claude is wired up to surface ECC's `aw:<stage>` skills via plugin
+ * marketplace + Skill permission.
  *
  * @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,21 +1,30 @@
 /**
- * c4/commandSurface.mjs — slash-command resolution per harness.
+ * c4/commandSurface.mjs — slash-command resolution per harness (G3).
  *
- * `/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.
+ * 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.
  *
- * Naming convention:
- *   ~/.cursor/commands/aw/<name>.md  -> /aw:<name>
- *   ~/.codex/commands/aw/<name>.md   -> /aw:<name>
+ * 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.
  *
- * 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
+ * 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 `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.
+ * `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.
  */
 
 import {
@@ -27,48 +36,45 @@ import {
   symlinkSync,
   unlinkSync,
 } from 'node:fs';
-import { join } from 'node:path';
-
-function awSkillsDir(awHome) {
-  return join(awHome, '.aw_registry', 'aw', 'skills');
-}
+import { join, basename, extname, relative } from 'node:path';
 
-function slashNameForSkill(skillName) {
-  return skillName.startsWith('aw-') && skillName.length > 3
-    ? skillName.slice(3)
-    : skillName;
-}
+// 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',
+]);
 
 /**
- * Discover active AW skills and their slash aliases.
+ * Walk <eccHome>/commands/*.md and return the AW-stage basenames in
+ * alphabetical order. Stage filename matching is case-sensitive (ECC ships
+ * lowercase).
  *
- * @param {string} awHome
- * @returns {Array<{ skillName: string, slashName: string, sourcePath: string }>}
+ * @param {string} eccHome
+ * @returns {string[]}
  */
-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);
-    }
+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);
   }
-
-  return [...routes.values()].sort((a, b) => {
-    const bySlash = a.slashName.localeCompare(b.slashName);
-    return bySlash === 0 ? a.skillName.localeCompare(b.skillName) : bySlash;
-  });
+  stageNames.sort();
+  return stageNames;
 }
 
 function harnessTargetDir(harness, home) {
@@ -93,40 +99,29 @@ function isCorrectSymlink(linkPath, expectedTarget) {
   }
 }
 
-function lstatExists(p) {
+/**
+ * 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.
   try {
-    lstatSync(p);
+    if (existsSync(linkPath) || lstatExists(linkPath)) {
+      try { unlinkSync(linkPath); } catch { /* may be a directory */ }
+    }
+    symlinkSync(sourcePath, linkPath);
     return true;
   } catch {
     return false;
   }
 }
 
-function isDir(p) {
-  try {
-    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;
-
+function lstatExists(p) {
   try {
-    if (existsSync(linkPath) || lstatExists(linkPath)) {
-      try { unlinkSync(linkPath); } catch { /* may be a directory */ }
-    }
-    symlinkSync(route.sourcePath, linkPath);
+    lstatSync(p);
     return true;
   } catch {
     return false;
@@ -134,16 +129,15 @@ function linkSkillRoute(route, targetDir) {
 }
 
 /**
- * Ensure the harness slash surface for active AW skills.
+ * Ensure the harness slash-command surface for AW stages.
  *
  * @param {object} opts
  * @param {'claude-web'|'cursor-cloud'|'codex-web'|string} opts.harness
  * @param {string} opts.home
- * @param {string} opts.awHome
+ * @param {string} opts.eccHome
  * @returns {{
  *   harness: string,
  *   expectedCommands: string[],
- *   expectedSkills: string[],
  *   found: string[],
  *   missing: string[],
  *   installedAction: 'symlink' | 'noop' | 'unsupported',
@@ -153,23 +147,23 @@ export function ensureCommandSurface(opts) {
   if (!opts || typeof opts !== 'object') {
     throw new Error('ensureCommandSurface: opts object is required');
   }
-  const { harness, home, awHome } = opts;
+  const { harness, home, eccHome } = opts;
   if (!home || typeof home !== 'string') {
     throw new Error('ensureCommandSurface: opts.home is required');
   }
-  if (!awHome || typeof awHome !== 'string') {
-    throw new Error('ensureCommandSurface: opts.awHome is required');
+  if (!eccHome || typeof eccHome !== 'string') {
+    throw new Error('ensureCommandSurface: opts.eccHome is required');
   }
 
-  const routes = discoverAwSkillRoutes(awHome);
-  const expectedCommands = routes.map((route) => route.slashName);
-  const expectedSkills = routes.map((route) => route.skillName);
+  const expectedCommands = discoverEccStageCommands(eccHome);
 
   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',
@@ -181,31 +175,38 @@ 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',
     };
   }
-
-  if (!isDir(targetDir)) {
+  // 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) {
     return {
       harness,
       expectedCommands,
-      expectedSkills,
       found: [],
       missing: [...expectedCommands],
       installedAction: 'symlink',
@@ -214,16 +215,15 @@ export function ensureCommandSurface(opts) {
 
   const found = [];
   const missing = [];
-  for (const route of routes) {
-    const ok = linkSkillRoute(route, targetDir);
-    if (ok) found.push(route.slashName);
-    else missing.push(route.slashName);
+  for (const stageName of expectedCommands) {
+    const ok = linkStageCommand(stageName, eccHome, targetDir);
+    if (ok) found.push(stageName);
+    else missing.push(stageName);
   }
 
   return {
     harness,
     expectedCommands,
-    expectedSkills,
     found,
     missing,
     installedAction: 'symlink',
@@ -231,59 +231,161 @@ export function ensureCommandSurface(opts) {
 }
 
 /**
- * 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.
+ * 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.
  *
  * @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, awHome } = opts;
+  const { harness, home } = opts;
   if (!home || typeof home !== 'string') {
     throw new Error('diagnoseCommandResolution: opts.home is required');
   }
-
-  const routes = awHome && typeof awHome === 'string' ? discoverAwSkillRoutes(awHome) : [];
-  const expected = routes.map((route) => route.slashName);
+  const expected = [...AW_STAGE_COMMANDS].sort();
 
   if (harness === 'claude-web') {
-    return { expected, found: [...expected], missing: [], ok: true };
+    // 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);
   }
 
   const targetDir = harnessTargetDir(harness, home);
   if (!targetDir) {
     return { expected, found: [], missing: [...expected], ok: false };
   }
-  return walkSkillAdapterDir(targetDir, routes);
+  return walkCommandsDir(targetDir, expected);
 }
 
-function walkSkillAdapterDir(dir, routes) {
+function walkCommandsDir(dir, expected) {
   if (!existsSync(dir)) {
-    const expected = routes.map((route) => route.slashName);
     return { expected, found: [], missing: [...expected], ok: expected.length === 0 };
   }
-
-  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 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 expected = routes.map((route) => route.slashName);
+  const found = expected.filter((n) => present.has(n));
+  const missing = expected.filter((n) => !present.has(n));
   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 AW skill even though the slash
- * adapter is correctly installed on disk by `commandSurface.mjs`.
+ * losing the contract from the matching command file even though the file
+ * 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
- * AW skill file and execute its contract verbatim. Cursor's `.mdc` rule
+ * command 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,35 +47,56 @@ 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 AW skill file
+description: Expand \`/aw:<NAME>\` user messages by reading the matching command file
 alwaysApply: true
 ---
 
-# AW skill slash expansion (Cursor Cloud workaround)
+# AW slash-command expansion (Cursor Cloud workaround)
 
 When the user message starts with \`/aw:<NAME>\` (case-sensitive; \`<NAME>\` may
-contain hyphens), do the following BEFORE producing any other response.
+contain hyphens — both in the namespace path and in the command name), do
+the following BEFORE producing any other response.
 
-## 1. Skill adapter lookup (primary)
+## 1. Stage-command 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 skill lookup (fallback)
+## 2. Registry-command lookup (fallback, hyphen-disambiguation)
 
-If step 1 did not resolve, read the first candidate below that exists. The
+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
 repo registry root is \`.aw/.aw_registry/\` (relative to the agent's CWD —
 the repo root in Cursor Cloud).
 
-1. \`.aw/.aw_registry/aw/skills/aw-<NAME>/SKILL.md\`
-2. \`.aw/.aw_registry/aw/skills/<NAME>/SKILL.md\`
+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\` ✓                         |
 
 ## 3. Execute
 
 Treat the resolved file's full content as your operating instructions for
-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
+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
 time and wait" interaction protocol.
 
 ## 4. No match
@@ -83,10 +104,11 @@ 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 skill on this machine. Run
+> \`/aw:<NAME>\` is not a registered AW command on this machine. Run
 > \`aw c4 --diagnose\` and check the output of
-> \`ls ~/.cursor/commands/aw/\` for available slash skill adapters and
-> \`find .aw/.aw_registry/aw/skills -name SKILL.md\` for available AW skills.
+> \`ls ~/.cursor/commands/aw/\` for available stage commands and
+> \`find .aw/.aw_registry -path '*/commands/*.md'\` for available registry
+> commands.
 
 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
@@ -95,8 +117,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 skill adapter 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 command 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.