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

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

@@ -111,5 +111,48 @@ AW_PACKAGE="${AW_PACKAGE:-@ghl-ai/aw@latest}"
 echo "[aw-c4-bootstrap] installing ${AW_PACKAGE}"
 npm install -g "${AW_PACKAGE}"
 
+# --dry-run and --diagnose are read-only modes; skip post-c4 verification
+# so we don't mutate $HOME or contact the registry unexpectedly.
+is_readonly_mode=false
+for arg in "$@"; do
+  case "$arg" in --dry-run|--diagnose) is_readonly_mode=true ;; esac
+done
+
+if "$is_readonly_mode"; then
+  echo "[aw-c4-bootstrap] running: aw c4 $*"
+  exec aw c4 "$@"
+fi
+
 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/*' ! -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"
+    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}"
+  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, statSync } from 'node:fs';
 import { join } from 'node:path';
 import * as c4Default from '../c4/index.mjs';
 import { isMcpEnabled } from '../mcp.mjs';
@@ -97,6 +97,19 @@ function safe(label, fn, writer) {
   }
 }
 
+function safeReaddirSync(dir) {
+  try { return readdirSync(dir); } catch { return []; }
+}
+
+function safeListNamespaceDirs(dir) {
+  try {
+    return readdirSync(dir).filter((entry) => {
+      if (entry.startsWith('.')) return false;
+      try { return statSync(join(dir, entry)).isDirectory(); } catch { return false; }
+    });
+  } catch { return []; }
+}
+
 async function safeAsync(label, fn, writer) {
   try {
     return { ok: true, value: await fn() };
@@ -392,6 +405,22 @@ export async function c4Command(rawArgs, overrides = {}) {
     return exit(1);
   }
 
+  // Step 9a — verify registry has namespace directories. `aw init --silent`
+  // can exit 0 but fail to fetch (fetchAndMerge swallows the error in silent
+  // mode). Metadata-only artifacts (AW-PROTOCOL.md) pass a simple non-empty
+  // check, so we specifically look for directories (namespaces like
+  // "platform") to confirm the registry content was actually pulled.
+  {
+    const registryNamespaces = safeListNamespaceDirs(awRegistry);
+    if (registryNamespaces.length === 0) {
+      writer.stderr('[aw-c4] registry has no namespace directories after init — retrying with aw pull\n');
+      const pullRes = spawnSync('aw', ['pull'], { stdio: 'pipe' });
+      if (pullRes && 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 +438,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.1",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {