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

package/git.mjs

@@ -5,14 +5,7 @@ import { mkdtempSync, existsSync, lstatSync, rmSync, readFileSync, symlinkSync,
 import { join, basename, dirname } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { promisify } from 'node:util';
-import {
-  REGISTRY_BASE_BRANCH,
-  REGISTRY_DIR,
-  AW_REGISTRY_NAMESPACE_DIR,
-  DOCS_SOURCE_DIR,
-  AW_DOCS_DIR,
-  RULES_SOURCE_DIR,
-} from './constants.mjs';
+import { REGISTRY_BASE_BRANCH, REGISTRY_DIR, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR } from './constants.mjs';
 
 const exec = promisify(execCb);
 
@@ -162,7 +155,6 @@ export function includeToSparsePaths(paths) {
   }
   result.add(`${REGISTRY_DIR}/AW-PROTOCOL.md`);
   if (paths.includes('platform')) {
-    result.add(AW_REGISTRY_NAMESPACE_DIR);
     result.add(DOCS_SOURCE_DIR);
     result.add(AW_DOCS_DIR);
     result.add(RULES_SOURCE_DIR);
@@ -397,9 +389,14 @@ export async function fetchAndMerge(awHome, { silent = true } = {}) {
   // git 2.46+ bug on blob:none + no-cone sparse-checkout repos that silently
   // drops bare-name patterns (e.g. "content", "CODEOWNERS") when HEAD advances.
   //
-  // --autostash: AW can have local registry edits pending when sync runs.
-  // Without autostash, git refuses to rebase and the pull silently aborts.
-  // Autostash stashes dirty bytes, rebases cleanly, and reapplies them.
+  // --autostash: AW writes into the registry working tree from external
+  // sources (ensureAwRuntimeHook copies ~/.aw-ecc/.../session-start.sh into a
+  // tracked path; transformCursorAwRefs rewrites /aw: → /aw- through Cursor
+  // skill directory symlinks that resolve into .aw_registry/). When those
+  // versions drift, the working tree is dirty at rebase time and rebase
+  // refuses to run, silently aborting the entire pull. Autostash stashes the
+  // dirty bytes, rebases cleanly, and reapplies them — so the registry stays
+  // in sync even when external sources have leaked into the tracked tree.
   try {
     await exec(`git -C "${awHome}" rebase --autostash origin/${REGISTRY_BASE_BRANCH}`);
     updated = true;

package/hooks/codex-home.mjs

@@ -26,10 +26,10 @@ const CODEX_HOME_PHASE_BLUEPRINTS = {
         marker: this.scriptMarker,
         phase: 'SessionStart',
         targetCandidates: [
-          '$HOME/.aw_registry/aw/skills/using-aw-skills/hooks/session-start.sh',
-          '$HOME/.aw/.aw_registry/aw/skills/using-aw-skills/hooks/session-start.sh',
+          '$HOME/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh',
+          '$HOME/.aw/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh',
         ],
-        warningMessage: 'WARNING: AW using-aw-skills hook not found in ~/.aw_registry/aw. Run aw init or aw pull platform.',
+        warningMessage: 'WARNING: AW using-aw-skills hook not found in ~/.aw_registry. Run aw init or aw pull platform.',
         telemetryHookPath: '$HOME/.aw-ecc/scripts/hooks/aw-usage-session-start.js',
         harnessEnv: 'codex',
       });

package/integrate.mjs

@@ -1,9 +1,10 @@
 // integrate.mjs — Generate commands for all IDEs, instructions (CLAUDE.md, AGENTS.md)
 
-import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, 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,
@@ -173,8 +174,8 @@ function applyManagedInstructionSections(content, file, rulesSections = {}, opti
 }
 
 /**
- * Command slash adapters are deprecated. Keep this function as a compatibility
- * no-op for older call sites and clean the removed generated-command folder.
+ * Count hand-written commands already present in the registry.
+ * No CLI stub generation — all commands come from the registry itself.
  */
 export function generateCommands(cwd, { silent = false } = {}) {
   const awDir = getLocalRegistryDir(cwd, join(homedir(), '.aw_registry'));
@@ -183,8 +184,47 @@ export function generateCommands(cwd, { silent = false } = {}) {
   const oldGenDir = join(awDir, '.generated-commands');
   if (existsSync(oldGenDir)) rmSync(oldGenDir, { recursive: true, force: true });
 
-  if (!silent) fmt.logSuccess('Command adapters are disabled; use registry-backed AW skills');
-  return 0;
+  // 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;
 }
 
 /**
@@ -671,3 +711,19 @@ 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/integrations.mjs

@@ -94,6 +94,7 @@ export const INTEGRATIONS = {
     label: 'Caveman',
     installCmd: 'caveman@caveman',
     marketplaceSource: 'JuliusBrussee/caveman',
+    requiresGitSubmodule: true,
     description: 'Token-efficient responses — ~75% fewer output tokens (lite / full / ultra / wenyan modes)',
     teams: [],  // universal — every team benefits
     requiresAuth: false,
@@ -219,6 +220,15 @@ function recordSkipped(key, type, reason, options = {}) {
   writeManifest(manifest, options.home);
 }
 
+function hasGitSubmoduleSupport() {
+  try {
+    execSync('git submodule -h', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function removeInstalled(key, options = {}) {
   if (options.dryRun) return;
   const manifest = readManifest(options.home);
@@ -651,7 +661,10 @@ async function runUniversalInstaller(integration, key, { silent = false, home =
       });
     }
 
-    // Run post-install commands (e.g. rtk init -g to wire the agent hook)
+    // Run post-install commands (e.g. rtk init -g to wire the agent hook).
+    // A failed post-install means the integration is not fully configured, so
+    // do not record it as installed. The next `aw init` can retry it.
+    const failedPostInstalls = [];
     for (const postCmd of integration.postInstall || []) {
       let finalPostCmd = postCmd;
       // If on Windows and we used WSL for the main install, we must use it for the post command too
@@ -662,11 +675,16 @@ async function runUniversalInstaller(integration, key, { silent = false, home =
       try {
         await execAsync(finalPostCmd, { timeout: 60 * 1000, maxBuffer: 10 * 1024 * 1024 });
       } catch (e) {
-        if (!silent) fmt.logWarn(`Post-install step failed: ${finalPostCmd} — ${e.message}`);
-        // Non-fatal — user can re-run later
+        failedPostInstalls.push(finalPostCmd);
+        if (!silent) fmt.logWarn(`Post-install step failed: ${finalPostCmd} — ${getErrorMessage(e)}`);
       }
     }
 
+    if (failedPostInstalls.length > 0) {
+      if (!silent) spinner.stop(chalk.yellow('Post-install failed'));
+      return false;
+    }
+
     if (!silent) spinner.stop('✓ Installed');
     return true;
   } catch (e) {
@@ -739,6 +757,13 @@ export async function installIntegration(key, options = {}) {
 
   try {
     if (integration.type === 'plugin') {
+      if (integration.requiresGitSubmodule && !hasGitSubmoduleSupport()) {
+        if (!silent) {
+          fmt.logWarn(`${integration.label} skipped — this Git installation does not include submodule support.`);
+        }
+        return false;
+      }
+
       // PLUGIN: Run claude plugin install
       await runClaudePlugin(integration.installCmd, { silent, marketplaceSource: integration.marketplaceSource ?? null });
       recordInstalled(key, 'plugin', { home });
@@ -1003,6 +1028,52 @@ export function suggestForTeam(namespace) {
     .map(([key]) => key);
 }
 
+export function getSuggestedIntegrationStatuses(namespace, options = {}) {
+  const manifest = readManifest(options.home);
+
+  return suggestForTeam(namespace).map((key) => {
+    const integration = INTEGRATIONS[key];
+    const entry = manifest.installed[key];
+
+    if (entry && entry.status !== 'skipped') {
+      return {
+        key,
+        label: integration.label,
+        type: integration.type,
+        status: 'installed',
+        installedAt: entry.installedAt || null,
+      };
+    }
+
+    if (entry?.status === 'skipped') {
+      return {
+        key,
+        label: integration.label,
+        type: integration.type,
+        status: 'skipped',
+        reason: entry.reason || 'previous setup skipped',
+      };
+    }
+
+    if (integration.requiresGitSubmodule && !hasGitSubmoduleSupport()) {
+      return {
+        key,
+        label: integration.label,
+        type: integration.type,
+        status: 'skipped',
+        reason: 'Git submodule support unavailable',
+      };
+    }
+
+    return {
+      key,
+      label: integration.label,
+      type: integration.type,
+      status: 'pending',
+    };
+  });
+}
+
 // ────────────────────────────────────────────────────────────────────────────────
 // AUTO-INSTALL (called from init.mjs - installs suggested integrations)
 // ────────────────────────────────────────────────────────────────────────────────

package/link.mjs

@@ -1,10 +1,9 @@
 // link.mjs — Create symlinks from IDE dirs → .aw_registry/
 
-import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync, rmdirSync, realpathSync, rmSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync, rmdirSync, realpathSync } from 'node:fs';
+import { 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) {
@@ -131,31 +130,6 @@ 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.
@@ -184,12 +158,10 @@ function cleanSymlinksRecursive(dir) {
 }
 
 /**
- * Compute flat IDE names. The top-level `aw` namespace is already encoded in
- * its skill and command names, so keep those names stable instead of producing
- * aw-aw-plan or aw-plan.md variants.
+ * Compute flat IDE name: namespace-slug (always includes namespace).
  */
-function flatRegistryName(ns, ...parts) {
-  return (ns === 'aw' ? parts : [ns, ...parts]).join('-');
+function flatName(ns, name) {
+  return `${ns}-${name}`;
 }
 
 /**
@@ -222,9 +194,6 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
 
   // Clean old symlinks first
   cleanIdeSymlinks(cwd);
-  if (cwd === HOME) {
-    pruneManagedAwCommandNamespaces(cwd);
-  }
 
   const namespaces = listNamespaceDirs(awDir);
 
@@ -233,7 +202,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
     for (const type of FILE_TYPES) {
       for (const { typeDirPath, segments } of findNestedTypeDirs(join(awDir, ns), type)) {
         for (const file of readdirSync(typeDirPath).filter(f => f.endsWith('.md') && !f.startsWith('.'))) {
-          const flat = flatRegistryName(ns, ...segments, file);
+          const flat = [ns, ...segments, file].join('-');
 
           for (const ide of IDE_DIRS) {
             const linkDir = join(cwd, ide, type);
@@ -250,7 +219,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
     // Skills: per-skill directory symlinks (recursive for nested domain dirs)
     for (const { typeDirPath: skillsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'skills')) {
       for (const skill of listDirs(skillsDir)) {
-        const flat = flatRegistryName(ns, ...segments, skill);
+        const flat = [ns, ...segments, skill].join('-');
 
         for (const ide of IDE_DIRS) {
           const linkDir = join(cwd, ide, 'skills');
@@ -264,7 +233,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
 
       for (const { skillDirPath, segments: skillSegments } of findSkillRootDirs(skillsDir)) {
         if (skillSegments.length <= 1) continue;
-        const flat = flatRegistryName(ns, ...segments, ...skillSegments);
+        const flat = [ns, ...segments, ...skillSegments].join('-');
 
         for (const ide of IDE_DIRS) {
           const linkDir = join(cwd, ide, 'skills');
@@ -285,7 +254,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
       if (isColocated) {
         // Colocated evals: agents/evals/<slug>/ — one level of slug dirs
         for (const evalSlug of listDirs(evalsDir)) {
-          const flat = flatRegistryName(ns, ...segments, evalSlug);
+          const flat = [ns, ...segments, evalSlug].join('-');
           for (const ide of IDE_DIRS) {
             const linkDir = join(cwd, ide, 'evals');
             mkdirSync(linkDir, { recursive: true });
@@ -300,7 +269,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
         for (const subType of listDirs(evalsDir)) {
           const subDir = join(evalsDir, subType);
           for (const evalName of listDirs(subDir)) {
-            const flat = flatRegistryName(ns, ...segments, subType, evalName);
+            const flat = [ns, ...segments, subType, evalName].join('-');
             for (const ide of IDE_DIRS) {
               const linkDir = join(cwd, ide, 'evals');
               mkdirSync(linkDir, { recursive: true });
@@ -341,7 +310,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
       for (const { typeDirPath: skillsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'skills')) {
         mkdirSync(agentsSkillsDir, { recursive: true });
         for (const skill of listDirs(skillsDir)) {
-          const flat = flatRegistryName(ns, ...segments, skill);
+          const flat = [ns, ...segments, skill].join('-');
           const linkPath = join(agentsSkillsDir, flat);
           const targetPath = join(skillsDir, skill);
           const relTarget = relative(agentsSkillsDir, targetPath);
@@ -350,7 +319,7 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
 
         for (const { skillDirPath, segments: skillSegments } of findSkillRootDirs(skillsDir)) {
           if (skillSegments.length <= 1) continue;
-          const flat = flatRegistryName(ns, ...segments, ...skillSegments);
+          const flat = [ns, ...segments, ...skillSegments].join('-');
           const linkPath = join(agentsSkillsDir, flat);
           const relTarget = relative(agentsSkillsDir, skillDirPath);
           if (linkNestedSkillRoot(relTarget, linkPath, { silent })) created++;
@@ -373,10 +342,22 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
     }
   }
 
-  // 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 */ }
+  // 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 = [ns, ...segments, file].join('-');
+
+        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 */ }
+        }
+      }
+    }
   }
 
   // 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.2",
+  "version": "0.1.70-beta.4",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {

package/startup.mjs

@@ -83,10 +83,8 @@ function resolveRegistryRoot(homeDir = homedir()) {
   ].find(existsSync) || null;
 }
 
-function awRuntimeHookDestinationPath(homeDir = homedir()) {
-  const registryRoot = resolveRegistryRoot(homeDir);
-  if (!registryRoot) return null;
-  return join(registryRoot, 'aw', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh');
+function awRuntimeHookSourcePath(homeDir = homedir()) {
+  return join(homeDir, '.aw-ecc', 'skills', 'using-aw-skills', 'hooks', 'session-start.sh');
 }
 
 function readJson(filePath, fallback = {}) {
@@ -395,10 +393,27 @@ function hasCodexSessionStartScript(homeDir = homedir()) {
 }
 
 export function ensureAwRuntimeHook(homeDir = homedir()) {
-  const destinationPath = awRuntimeHookDestinationPath(homeDir);
-  if (!destinationPath || !existsSync(destinationPath)) return [];
+  const sourcePath = awRuntimeHookSourcePath(homeDir);
+  const registryRoot = resolveRegistryRoot(homeDir);
+  if (!existsSync(sourcePath) || !registryRoot) return [];
+
+  const destinationPath = join(
+    registryRoot,
+    'platform',
+    'core',
+    'skills',
+    'using-aw-skills',
+    'hooks',
+    'session-start.sh',
+  );
+  const sourceContent = readFileSync(sourcePath, 'utf8');
+  const existingContent = existsSync(destinationPath) ? readFileSync(destinationPath, 'utf8') : null;
+  if (existingContent === sourceContent) return [];
+
+  mkdirSync(dirname(destinationPath), { recursive: true });
+  writeFileSync(destinationPath, sourceContent);
   try { chmodSync(destinationPath, 0o755); } catch { /* best effort */ }
-  return [];
+  return [destinationPath];
 }
 
 function hasCodexHooksEnabled(homeDir = homedir()) {