@ghl-ai/aw 0.1.61 → 0.1.62-beta.0

package/c4/commandSurface.mjs

@@ -36,7 +36,7 @@ import {
   symlinkSync,
   unlinkSync,
 } from 'node:fs';
-import { join, basename, extname } from 'node:path';
+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).
@@ -230,6 +230,109 @@ 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 = []) {
+  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.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.

package/c4/index.mjs

@@ -49,7 +49,7 @@ export {
 export { MCP_URL_DEFAULT, registerGhlAiMcp } from './mcpServer.mjs';
 export { probeMcpServer } from './mcpSmokeProbe.mjs';
 export { ensureClaudeMarketplace } from './claudePluginRegistry.mjs';
-export { ensureCommandSurface, diagnoseCommandResolution } from './commandSurface.mjs';
+export { ensureCommandSurface, ensureRegistryCommandSurface, 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

@@ -112,4 +112,35 @@ echo "[aw-c4-bootstrap] installing ${AW_PACKAGE}"
 npm install -g "${AW_PACKAGE}"
 
 echo "[aw-c4-bootstrap] running: aw c4 $*"
-exec aw c4 "$@"
+aw c4 "$@"
+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
+    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/*' 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"
+    aw pull 2>&1 | tail -5 || true
+    local new_count
+    new_count=$(find "$aw_cmd_dir" -name '*.md' -path '*/commands/*' 2>/dev/null | wc -l | tr -d ' ')
+    echo "[aw-c4-bootstrap] registry commands: ${cmd_count} → ${new_count}"
+  else
+    echo "[aw-c4-bootstrap] registry: ${cmd_count} commands OK"
+  fi
+}
+verify_registry_commands || true
+
+exit "$aw_c4_exit"

package/commands/c4.mjs

@@ -24,7 +24,7 @@
  */
 
 import { spawnSync as nodeSpawnSync } from 'node:child_process';
-import { existsSync as fsExistsSync } from 'node:fs';
+import { existsSync as fsExistsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import * as c4Default from '../c4/index.mjs';
 import { isMcpEnabled } from '../mcp.mjs';
@@ -97,6 +97,10 @@ function safe(label, fn, writer) {
   }
 }
 
+function safeReaddirSync(dir) {
+  try { return readdirSync(dir); } catch { return []; }
+}
+
 async function safeAsync(label, fn, writer) {
   try {
     return { ok: true, value: await fn() };
@@ -392,6 +396,24 @@ export async function c4Command(rawArgs, overrides = {}) {
     return exit(1);
   }
 
+  // Step 9a — verify registry has content. `aw init --silent` can succeed
+  // (exit 0) but fail to fetch from remote (fetchAndMerge swallows the error
+  // in silent mode). When the registry dir exists but contains no namespace
+  // directories, the fetch likely failed. Retry with `aw pull` which runs
+  // a targeted git pull on the existing clone.
+  {
+    const registryEntries = safeReaddirSync(awRegistry).filter(
+      (e) => !e.startsWith('.'),
+    );
+    if (registryEntries.length === 0) {
+      writer.stderr('[aw-c4] registry empty after init — retrying with aw pull\n');
+      const pullRes = spawnSync('aw', ['pull'], { stdio: 'pipe' });
+      if (pullRes && pullRes.status !== 0) {
+        writer.stderr('[aw-c4] aw pull also failed; commands may be incomplete\n');
+      }
+    }
+  }
+
   // Step 10 — per-harness branch.
   let branch;
   try {
@@ -409,9 +431,27 @@ export async function c4Command(rawArgs, overrides = {}) {
     writer.stdout('[aw-c4] MCP disabled; skipping registerGhlAiMcp\n');
   }
 
-  // Step 12 — slash command surface.
+  // Step 12 — slash command surface (10 stage commands from ECC).
   safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, eccHome }), writer);
 
+  // Step 12a — full registry command surface.
+  // `ensureCommandSurface` only links the 10 AW routing-stage commands from
+  // ~/.aw-ecc/commands/. The full registry (~100+ domain commands like
+  // platform-review-security-hardening) lives in ~/.aw/.aw_registry/ and is
+  // populated by `aw init` (step 7). Link them all into the harness command
+  // dir so `/aw:*` resolution works for every registered command.
+  const registryCmdResult = safe(
+    'ensureRegistryCommandSurface',
+    () => c4.ensureRegistryCommandSurface({ harness, home, awRegistryDir: awRegistry }),
+    writer,
+  );
+  if (registryCmdResult.ok) {
+    const { linked, skipped } = registryCmdResult.value;
+    if (linked > 0) {
+      writer.stdout(`[aw-c4] registry commands: ${linked} linked, ${skipped} skipped\n`);
+    }
+  }
+
   // Step 12b — Cursor Cloud slash-expand rule (no-op on other harnesses).
   // The model-side workaround for Cursor Cloud's chat UI not pre-expanding
   // `/aw:<NAME>` slash commands. The function self-skips on other

package/package.json

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