@ghl-ai/aw 0.1.51 → 0.1.53

package/c4/templates/scripts/aw-c4-bootstrap.sh

@@ -12,12 +12,13 @@
 #   - .codex/scripts/codex-web-bootstrap.sh    (passes --harness codex-web)
 #
 # Override knobs (env):
-#   AW_PACKAGE   npm spec to install. Defaults to @ghl-ai/aw@latest. Override
-#                with @ghl-ai/aw@beta to opt into pre-release builds, or pin to
-#                @ghl-ai/aw@0.1.x for reproducible CI runs.
+#   AW_PACKAGE   npm spec to install. Defaults to @ghl-ai/aw@latest.
+#                Override to pin a specific @ghl-ai/aw@0.1.x for reproducible
+#                CI runs.
 set -Eeuo pipefail
 
-: "${GITHUB_PAT:?ERROR: Set GITHUB_PAT in your harness secrets UI before running aw c4}"
+# GitHub auth is resolved inside `aw c4` so GITHUB_PAT, GITHUB_TOKEN, and
+# no-token diagnostics stay centralized in the CLI preflight.
 
 # Ensure npm is on PATH. Cursor Cloud's install shell is non-interactive — nvm
 # is not auto-sourced, and Node may not be pre-installed at all. Walk common

package/cli.mjs

@@ -21,13 +21,14 @@ const COMMANDS = {
   doctor:  () => import('./commands/doctor.mjs').then(m => m.doctorCommand),
   routing: () => import('./commands/startup.mjs').then(m => m.routingCommand),
   startup: () => import('./commands/startup.mjs').then(m => m.startupCommand),
+  mcp:     () => import('./commands/mcp.mjs').then(m => m.mcpCommand),
   search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
   link:    () => import('./commands/link-project.mjs').then(m => m.linkProjectCommand),
   nuke:    () => import('./commands/nuke.mjs').then(m => m.nukeCommand),
   daemon:  () => import('./commands/daemon.mjs').then(m => m.daemonCommand),
-  integration: () => import('./commands/integration.mjs').then(m => m.integrationCommand),
-  integrations: () => import('./commands/integration.mjs').then(m => m.integrationCommand),
   telemetry: () => import('./commands/telemetry.mjs').then(m => m.telemetryCommand),
+  integration: () => import('./commands/integration.mjs').then(m => m.integrationCommand),
+  integrations: () => import('./commands/integrations.mjs').then(m => m.integrationsCommand),
   'slack-sim': () => import('./commands/slack-sim.mjs').then(m => m.slackSimCommand),
   c4:      () => import('./commands/c4.mjs').then(m => m.c4Command),
   'init-repo': () => import('./commands/init-repo.mjs').then(m => m.initRepoCommand),
@@ -87,8 +88,9 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init', 'Initialize workspace (platform/ only)'),
+    cmd('aw init', 'Initialize workspace (auto-installs suggested integrations)'),
     cmd('aw init --namespace <team/sub-team>', 'Add a team namespace (optional)'),
+    cmd('aw init --no-integrations', 'Skip integration setup (Codex, Caveman, Graphify, etc)'),
     `  ${chalk.dim('Teams: platform, revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
     `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
     cmd('aw init-repo', 'Scaffold cloud-bootstrap files (idempotent, --dry-run/--force/--diff)'),
@@ -114,12 +116,18 @@ function printHelp() {
     cmd('aw doctor', 'Run a health check for routing, MCP, plugin, and AW ECC surfaces'),
     cmd('aw link', 'Link current project as a git worktree (wires IDE symlinks)'),
     cmd('aw routing status', 'Show global AW session-routing mode for Claude/Cursor/Codex'),
-    cmd('aw routing disable', 'Disable automatic AW session routing globally'),
-    cmd('aw routing enable', 'Re-enable automatic AW session routing globally'),
-    cmd('aw integration list', 'List addable third-party integrations'),
-    cmd('aw integration add <name>', 'Add a specific integration, e.g. context-mode'),
-    cmd('aw integration status <name>', 'Show integration health and configured surfaces'),
-    cmd('aw integration remove <name>', 'Remove a specific integration'),
+    cmd('aw routing disable', 'Disable default AW router/rules injection globally'),
+    cmd('aw routing enable', 'Re-enable default AW router/rules injection globally'),
+    cmd('aw mcp status', 'Show global AW MCP mode for Claude/Cursor/Codex'),
+    cmd('aw mcp disable', 'Remove AW-managed MCP server across Claude/Cursor/Codex'),
+    cmd('aw mcp enable', 'Restore AW-managed MCP server across Claude/Cursor/Codex'),
+    cmd('aw integrations', 'Manage third-party integrations (Codex, Caveman, etc)'),
+    cmd('aw integrations add <key>', 'Install a specific tool (e.g. codex, caveman)'),
+    cmd('aw integrations remove <key>', 'Remove a tool'),
+    cmd('aw integrations bundle <name>', 'Install a preset bundle'),
+    cmd('aw integration add <name>', 'Configure an installed local integration, e.g. context-mode'),
+    cmd('aw integration status <name>', 'Show local integration health'),
+    cmd('aw integration remove <name>', 'Remove AW-managed local integration entries'),
     cmd('aw drop <path>', 'Stop syncing or delete local content'),
     cmd('aw nuke', 'Remove entire .aw_registry/ & start fresh'),
     cmd('aw daemon install', 'Auto-pull on a schedule (macOS launchd / Linux cron)'),

package/commands/c4.mjs

@@ -24,6 +24,7 @@ import { spawnSync as nodeSpawnSync } from 'node:child_process';
 import { existsSync as fsExistsSync } from 'node:fs';
 import { join } from 'node:path';
 import * as c4Default from '../c4/index.mjs';
+import { isMcpEnabled } from '../mcp.mjs';
 
 /* ─────────────────────────────────────────────────────────────────────────
  * Constants — referenced by self-tests.
@@ -349,10 +350,10 @@ export async function c4Command(rawArgs, overrides = {}) {
     return exit(0);
   }
 
-  // Step 6 — npm install -g @ghl-ai/aw.
-  const npmRes = spawnSync('npm', ['install', '-g', '@ghl-ai/aw'], { stdio: 'pipe' });
+  // Step 6 — npm install -g @ghl-ai/aw@latest.
+  const npmRes = spawnSync('npm', ['install', '-g', '@ghl-ai/aw@latest'], { stdio: 'pipe' });
   if (npmRes && npmRes.status !== 0) {
-    writer.stderr('[aw-c4] npm install -g @ghl-ai/aw failed (non-fatal); using existing aw if present\n');
+    writer.stderr('[aw-c4] npm install -g @ghl-ai/aw@latest failed (non-fatal); using existing aw if present\n');
   }
 
   // Step 7 — aw init --silent.
@@ -380,7 +381,12 @@ export async function c4Command(rawArgs, overrides = {}) {
   }
 
   // Step 11 — MCP register.
-  safe('registerGhlAiMcp', () => c4.registerGhlAiMcp(harness, home, token), writer);
+  const mcpEnabled = isMcpEnabled(home, env);
+  if (mcpEnabled) {
+    safe('registerGhlAiMcp', () => c4.registerGhlAiMcp(harness, home, token), writer);
+  } else {
+    writer.stdout('[aw-c4] MCP disabled; skipping registerGhlAiMcp\n');
+  }
 
   // Step 12 — slash command surface.
   safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, eccHome }), writer);
@@ -403,11 +409,13 @@ export async function c4Command(rawArgs, overrides = {}) {
   safe('ensureRepoLocalIgnore', () => c4.ensureRepoLocalIgnore({ cwd, harness }), writer);
 
   // Step 15 — MCP smoke probe (best-effort).
-  const mcpProbe = await safeAsync(
-    'probeMcpServer',
-    () => c4.probeMcpServer({ url: c4.MCP_URL_DEFAULT, token }),
-    writer,
-  );
+  const mcpProbe = mcpEnabled
+    ? await safeAsync(
+      'probeMcpServer',
+      () => c4.probeMcpServer({ url: c4.MCP_URL_DEFAULT, token }),
+      writer,
+    )
+    : null;
 
   // Step 16 — self-tests.
   const self = runSelfTests({ harness, c4, home, awHome, eccHome });

package/commands/doctor.mjs

@@ -210,7 +210,7 @@ function directoryContainsGeneratedRuleFiles(dirPath, extension) {
   try {
     return readdirSync(dirPath, { withFileTypes: true })
       .filter(entry => entry.isFile() && entry.name.endsWith(extension))
-      .some(entry => readText(join(dirPath, entry.name)).startsWith(GENERATED_RULE_HEADER));
+      .some(entry => readText(join(dirPath, entry.name)).includes(GENERATED_RULE_HEADER));
   } catch {
     return false;
   }
@@ -501,7 +501,7 @@ function listGeneratedRuleFiles(dirPath, extension) {
     return readdirSync(dirPath, { withFileTypes: true })
       .filter(entry => entry.isFile() && entry.name.endsWith(extension))
       .map(entry => join(dirPath, entry.name))
-      .filter(filePath => readText(filePath).startsWith(GENERATED_RULE_HEADER));
+      .filter(filePath => readText(filePath).includes(GENERATED_RULE_HEADER));
   } catch {
     return [];
   }

package/commands/init.mjs

@@ -35,6 +35,7 @@ import { loadConfig as ensureTelemetryConfig } from '../telemetry.mjs';
 import { installAwEcc, AW_ECC_TAG } from '../ecc.mjs';
 import { removeWorkspaceHookDefaults } from '../codex.mjs';
 import { readHookManifest, pruneStaleHooks, writeHookManifest } from '../hook-cleanup.mjs';
+import { promptAndInstall, autoInstallIntegrations } from '../integrations.mjs';
 import {
   initPersistentClone,
   isValidClone,
@@ -48,7 +49,7 @@ import {
   syncWorktreeSparseCheckout,
   findNearestWorktree,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, RULES_SOURCE_DIR, RULES_RUNTIME_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, RULES_RUNTIME_DIR } from '../constants.mjs';
 import { syncFileTree } from '../file-tree.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -136,8 +137,8 @@ function scaffoldNamespace(awHome, folderName) {
 
 // ── Ensure ~/.aw/.git/info/exclude has the whitelist block ─────────────
 //
-// Strategy: only .aw_registry/, .aw_rules/, content/ are tracked — everything
-// else at the top level of ~/.aw/ is local-only (telemetry/, hooks/, logs,
+// Strategy: only .aw_registry/, .aw_rules/, content/, and .aw_docs/ are
+// tracked — everything else at the top level of ~/.aw/ is local-only (telemetry/, hooks/, logs,
 // .DS_Store, etc.). We write to .git/info/exclude (not tracked .gitignore)
 // so upstream pulls never conflict.
 
@@ -151,6 +152,7 @@ const AW_MANAGED_BLOCK = [
   '!/.aw_registry',
   '!/.aw_rules',
   '!/content',
+  '!/.aw_docs',
   '',
   '# Nested local state within whitelisted dirs',
   '/.aw_registry/.sync-config.json',
@@ -239,6 +241,7 @@ export async function initCommand(args) {
   let namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const silent = args['--silent'] === true;
+  const skipIntegrations = args['--no-integrations'] === true;
 
   // In silent mode, suppress ALL fmt output and show a single spinner.
   // setSilent(true) makes every fmt.* call a no-op — internal functions
@@ -350,7 +353,7 @@ export async function initCommand(args) {
     const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
     if (isNewSubTeam) {
       if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
-      const newSparsePaths = [`.aw_registry/${folderName}`, 'content', RULES_SOURCE_DIR];
+      const newSparsePaths = [`.aw_registry/${folderName}`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR];
       addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
       scaffoldNamespace(AW_HOME, folderName);
@@ -442,6 +445,12 @@ export async function initCommand(args) {
     // Write hook manifest after all hook installation is complete
     try { writeHookManifest({ eccVersion: AW_ECC_TAG, awVersion: VERSION }); } catch { /* best effort */ }
 
+    // Auto-install suggested integrations (Codex, Caveman, Graphify, etc) - unless --no-integrations
+    let installedIntegrations = [];
+    if (!silent && !skipIntegrations && !isNewSubTeam) {
+      installedIntegrations = await autoInstallIntegrations(freshCfg?.namespace || team, { silent });
+    }
+
     if (silent) {
       if (silentSpinner) { silentSpinner.stop('Done'); setSilent(false); }
       autoUpdate(await args._updateCheck);
@@ -455,6 +464,7 @@ export async function initCommand(args) {
           ? `  ${chalk.green('✓')} Removed ${removedLegacyStartupFiles.length} legacy repo startup file${removedLegacyStartupFiles.length > 1 ? 's' : ''}`
           : null,
         cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Project linked` : null,
+        installedIntegrations.length > 0 ? `  ${chalk.green('✓')} Integrations: ${installedIntegrations.join(', ')}` : null,
       ].filter(Boolean).join('\n'));
     }
     return;
@@ -483,7 +493,7 @@ export async function initCommand(args) {
   }
 
   // Determine sparse paths
-  const sparsePaths = [`.aw_registry/platform`, `content`, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
+  const sparsePaths = [`.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
   if (folderName) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
@@ -603,6 +613,12 @@ export async function initCommand(args) {
   // Ensure telemetry config exists (generates machine_id on first run)
   ensureTelemetryConfig();
 
+  // Auto-install suggested integrations (Codex, Caveman, Graphify, etc) - unless --no-integrations
+  let installedIntegrations = [];
+  if (!silent && !skipIntegrations) {
+    installedIntegrations = await autoInstallIntegrations(team, { silent });
+  }
+
   // Offer to update if a newer version is available
   if (!silent) await promptUpdate(await args._updateCheck);
 
@@ -622,10 +638,12 @@ export async function initCommand(args) {
     hooksInstalled ? `  ${chalk.green('✓')} Git hooks: auto-sync on pull/clone (core.hooksPath)` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,
     cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Linked in current project` : null,
+    installedIntegrations.length > 0 ? `  ${chalk.green('✓')} Integrations: ${installedIntegrations.join(', ')}` : null,
     '',
     `  ${chalk.dim('Existing repos:')} ${chalk.bold('cd <project> && aw link')}`,
     `  ${chalk.dim('New clones:')}     auto-linked via git hook`,
     `  ${chalk.dim('Update:')}         ${chalk.bold('aw init')} ${chalk.dim('(or auto on pull/IDE open)')}`,
+    `  ${chalk.dim('Integrations:')}   ${chalk.bold('aw integrations')} ${chalk.dim('(manage Codex, Caveman, etc)')}`,
     `  ${chalk.dim('Uninstall:')}      ${chalk.bold('aw nuke')}`,
   ].filter(Boolean).join('\n'));
 }

package/commands/integrations.mjs

@@ -0,0 +1,268 @@
+// commands/integrations.mjs — CLI command: aw integrations add/remove/list/bundle
+
+import * as p from '@clack/prompts';
+import { homedir } from 'node:os';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+import { listIntegrations as listLocalIntegrations } from '../integrations/index.mjs';
+import {
+  INTEGRATIONS,
+  BUNDLES,
+  installIntegration,
+  removeIntegration,
+  getInstalledList,
+} from '../integrations.mjs';
+
+export async function integrationsCommand(args) {
+  const subcommand = args._positional[0];
+
+  switch (subcommand) {
+    case 'add':
+      return cmdAdd(args);
+    case 'remove':
+      return cmdRemove(args);
+    case 'bundle':
+      return cmdBundle(args);
+    case 'list':
+    case undefined:
+      return cmdList();
+    default:
+      fmt.cancel(`Unknown subcommand: ${subcommand}`);
+  }
+}
+
+// ────────────────────────────────────────────────────────────────────────────────
+// aw integrations list
+// ────────────────────────────────────────────────────────────────────────────────
+
+async function cmdList() {
+  fmt.banner('Integrations', {
+    icon: '🔗',
+    subtitle: '  Available tools and MCP servers',
+  });
+
+  const installed = getInstalledList();
+  const localIntegrations = listLocalIntegrations(homedir(), { env: process.env });
+
+  // Group by type
+  const plugins = Object.entries(INTEGRATIONS).filter(
+    ([, i]) => i.type === 'plugin'
+  );
+  const remoteRcps = Object.entries(INTEGRATIONS).filter(
+    ([, i]) => i.type === 'remote-mcp'
+  );
+  const universalInstallers = Object.entries(INTEGRATIONS).filter(
+    ([, i]) => i.type === 'universal-installer'
+  );
+  const pythonClis = Object.entries(INTEGRATIONS).filter(
+    ([, i]) => i.type === 'python-cli'
+  );
+
+  const typeIcon = (type) =>
+    type === 'plugin' ? '🔌' : type === 'remote-mcp' ? '🌐' : type === 'universal-installer' ? '🪨' : '⚙️';
+
+  // Installed section
+  if (installed.length > 0) {
+    fmt.logMessage(`\n${chalk.bold.underline('Installed')}`);
+    for (const key of installed) {
+      const integration = INTEGRATIONS[key];
+      if (!integration) continue;
+      fmt.logSuccess(`  ${typeIcon(integration.type)} ${integration.label}`);
+    }
+  }
+
+  // Local Integrations
+  if (localIntegrations.length > 0) {
+    fmt.logMessage(`\n${chalk.bold.underline('Local Integrations')}`);
+    for (const integration of localIntegrations) {
+      fmt.logMessage(
+        `  ⚙️ ${integration.name.padEnd(25)} — ${integration.summary}`
+      );
+    }
+  }
+
+  // Available Plugins
+  fmt.logMessage(`\n${chalk.bold.underline('Available Plugins')}`);
+  for (const [key, integration] of plugins) {
+    if (!installed.includes(key)) {
+      fmt.logMessage(
+        `  🔌 ${integration.label.padEnd(25)} — ${integration.description}`
+      );
+    }
+  }
+
+  // Available Remote MCPs
+  fmt.logMessage(`\n${chalk.bold.underline('Available Remote MCPs')}`);
+  for (const [key, integration] of remoteRcps) {
+    if (!installed.includes(key)) {
+      fmt.logMessage(
+        `  🌐 ${integration.label.padEnd(25)} — ${integration.description}`
+      );
+    }
+  }
+
+  // Universal Installers
+  if (universalInstallers.length > 0) {
+    fmt.logMessage(`\n${chalk.bold.underline('Universal Tools')}`);
+    for (const [key, integration] of universalInstallers) {
+      if (!installed.includes(key)) {
+        fmt.logMessage(
+          `  🪨 ${integration.label.padEnd(25)} — ${integration.description}`
+        );
+      }
+    }
+  }
+
+  // Python CLIs
+  if (pythonClis.length > 0) {
+    fmt.logMessage(`\n${chalk.bold.underline('Available Python Tools')}`);
+    for (const [key, integration] of pythonClis) {
+      if (!installed.includes(key)) {
+        fmt.logMessage(
+          `  🐍 ${integration.label.padEnd(25)} — ${integration.description}`
+        );
+      }
+    }
+  }
+
+  // Bundles
+  fmt.logMessage(`\n${chalk.bold.underline('Bundles')}`);
+  for (const [bundleKey, bundle] of Object.entries(BUNDLES)) {
+    fmt.logMessage(
+      `  📦 ${bundle.label.padEnd(25)} — ${bundle.description}`
+    );
+    fmt.logMessage(
+      `     Includes: ${bundle.includes.map((k) => INTEGRATIONS[k].label).join(', ')}`
+    );
+  }
+
+  fmt.logMessage(`\n${chalk.dim('Commands:')}`);
+  fmt.logMessage(`  aw integrations add <key>      Install a specific tool`);
+  fmt.logMessage(`  aw integrations remove <key>   Remove a tool`);
+  fmt.logMessage(`  aw integrations bundle <name>  Install a preset bundle`);
+  fmt.logMessage(`  aw integration add <name>      Configure a local integration`);
+}
+
+// ────────────────────────────────────────────────────────────────────────────────
+// aw integrations add <key>
+// ────────────────────────────────────────────────────────────────────────────────
+
+async function cmdAdd(args) {
+  const key = args._positional[1];
+
+  if (!key) {
+    fmt.cancel('Usage: aw integrations add <key>');
+  }
+
+  if (!INTEGRATIONS[key]) {
+    // Suggest similar keys
+    const available = Object.keys(INTEGRATIONS);
+    fmt.cancel(
+      [
+        `Unknown integration: ${chalk.red(key)}`,
+        '',
+        `Available: ${available.join(', ')}`,
+      ].join('\n')
+    );
+  }
+
+  const integration = INTEGRATIONS[key];
+  fmt.intro(`Installing ${integration.label}`);
+
+  const success = await installIntegration(key, { silent: false });
+
+  if (success) {
+    fmt.outro(`✓ ${integration.label} installed successfully`);
+  } else {
+    fmt.cancel(`Failed to install ${integration.label}`);
+  }
+}
+
+// ────────────────────────────────────────────────────────────────────────────────
+// aw integrations remove <key>
+// ────────────────────────────────────────────────────────────────────────────────
+
+async function cmdRemove(args) {
+  const key = args._positional[1];
+
+  if (!key) {
+    fmt.cancel('Usage: aw integrations remove <key>');
+  }
+
+  if (!INTEGRATIONS[key]) {
+    const available = Object.keys(INTEGRATIONS);
+    fmt.cancel(
+      [
+        `Unknown integration: ${chalk.red(key)}`,
+        '',
+        `Available: ${available.join(', ')}`,
+      ].join('\n')
+    );
+  }
+
+  const integration = INTEGRATIONS[key];
+  fmt.intro(`Removing ${integration.label}`);
+
+  const success = await removeIntegration(key, { silent: false });
+
+  if (success) {
+    fmt.outro(`✓ ${integration.label} removed successfully`);
+  } else {
+    fmt.cancel(`Failed to remove ${integration.label}`);
+  }
+}
+
+// ────────────────────────────────────────────────────────────────────────────────
+// aw integrations bundle <bundleName>
+// ────────────────────────────────────────────────────────────────────────────────
+
+async function cmdBundle(args) {
+  const bundleName = args._positional[1];
+
+  if (!bundleName) {
+    fmt.cancel('Usage: aw integrations bundle <name>');
+  }
+
+  if (!BUNDLES[bundleName]) {
+    const available = Object.keys(BUNDLES);
+    fmt.cancel(
+      [
+        `Unknown bundle: ${chalk.red(bundleName)}`,
+        '',
+        `Available: ${available.join(', ')}`,
+      ].join('\n')
+    );
+  }
+
+  const bundle = BUNDLES[bundleName];
+  fmt.intro(`Installing bundle: ${bundle.label}`);
+
+  fmt.logMessage(`${bundle.description}\n`);
+  fmt.logMessage(`Includes:`);
+  for (const key of bundle.includes) {
+    const integration = INTEGRATIONS[key];
+    fmt.logMessage(`  • ${integration.label}`);
+  }
+
+  const confirm = await p.default.confirm({
+    message: `Continue installing ${bundle.includes.length} tool(s)?`,
+    initialValue: true,
+  });
+
+  if (p.default.isCancel(confirm) || !confirm) {
+    fmt.cancel('Cancelled');
+  }
+
+  fmt.logMessage('');
+
+  // Install all
+  let successCount = 0;
+  for (const key of bundle.includes) {
+    const success = await installIntegration(key, { silent: false });
+    if (success) successCount++;
+  }
+
+  fmt.outro(
+    `✓ Bundle installation complete (${successCount}/${bundle.includes.length} installed)`
+  );
+}

package/commands/mcp.mjs

@@ -0,0 +1,90 @@
+import { homedir } from 'node:os';
+
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+import {
+  getMcpStatus,
+  removeMcpConfig,
+  saveMcpPreferences,
+  setupMcp,
+} from '../mcp.mjs';
+
+const HOME = homedir();
+
+function isTruthyEnv(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+export async function mcpCommand(args) {
+  const action = String(args._positional?.[0] || 'status').toLowerCase();
+
+  if (!['status', 'enable', 'disable'].includes(action)) {
+    fmt.cancel(`Unknown MCP action: ${action}. Use: aw mcp status|enable|disable`);
+    return;
+  }
+
+  fmt.intro(`aw mcp ${action}`);
+
+  if (action === 'status') {
+    return renderStatus();
+  }
+
+  if (action === 'disable') {
+    saveMcpPreferences('disabled', HOME);
+    const removed = removeMcpConfig();
+    const status = getMcpStatus(HOME);
+    fmt.outro([
+      '⟁  MCP disabled',
+      '',
+      `  ${chalk.green('✓')} Preference saved: ${chalk.dim(status.preferencesPath.replace(`${HOME}/`, '~/'))}`,
+      `  ${chalk.green('✓')} Removed AW-managed MCP server from ${removed} config file${removed === 1 ? '' : 's'}`,
+    ].join('\n'));
+    return;
+  }
+
+  saveMcpPreferences('enabled', HOME);
+  const silent = !!args['--silent'] || isTruthyEnv(process.env.CI);
+  const updatedFiles = await setupMcp(HOME, null, { silent });
+  const status = getMcpStatus(HOME);
+  if (status.effectiveMode === 'disabled') {
+    fmt.outro([
+      '⟁  MCP preference enabled',
+      '',
+      `  ${chalk.green('✓')} Preference saved: ${chalk.dim(status.preferencesPath.replace(`${HOME}/`, '~/'))}`,
+      `  ${chalk.yellow('!')} ${status.envDisableMcpName}=1 override is still active`,
+    ].join('\n'));
+    return;
+  }
+  fmt.outro([
+    '⟁  MCP enabled',
+    '',
+    `  ${chalk.green('✓')} Preference saved: ${chalk.dim(status.preferencesPath.replace(`${HOME}/`, '~/'))}`,
+    updatedFiles.length > 0
+      ? `  ${chalk.green('✓')} Updated ${updatedFiles.length} MCP config file${updatedFiles.length === 1 ? '' : 's'}`
+      : `  ${chalk.dim('Note:')} MCP config files already up to date`,
+  ].join('\n'));
+}
+
+function renderStatus() {
+  const status = getMcpStatus(HOME);
+  const modeLabel = status.envDisableMcp
+    ? `${status.effectiveMode} (${status.envDisableMcpName}=1 override; saved preference: ${status.mode})`
+    : status.mode;
+
+  fmt.note([
+    `${chalk.dim('mode:')} ${modeLabel}`,
+    `${chalk.dim('prefs:')} ${status.preferencesPath.replace(`${HOME}/`, '~/')}`,
+    `${chalk.dim('claude MCP:')} ${formatHealth(status.claude)}`,
+    `${chalk.dim('cursor MCP:')} ${formatHealth(status.cursor)}`,
+    `${chalk.dim('codex MCP:')} ${formatHealth(status.codex)}`,
+    `${chalk.dim('aw-ecc Codex MCP source:')} ${formatHealth(status.eccCodex)}`,
+  ].join('\n'), 'MCP');
+
+  fmt.outro('⟁  MCP status complete');
+}
+
+function formatHealth(health) {
+  if (!health.present) return 'disabled';
+  if (health.url && health.authorization) return 'enabled';
+  return `incomplete (url=${health.url}, authorization=${health.authorization})`;
+}

package/commands/nuke.mjs

@@ -366,7 +366,7 @@ export async function nukeCommand(args) {
     '',
     `  ${chalk.green('✓')} Generated files cleaned`,
     `  ${chalk.green('✓')} IDE symlinks cleaned`,
-    `  ${chalk.green('✓')} MCP config removed (ghl-ai and context-mode)`,
+    `  ${chalk.green('✓')} MCP config removed (ghl-ai and AW-managed context-mode entries)`,
     `  ${chalk.green('✓')} aw-ecc engine removed`,
     `  ${chalk.green('✓')} Project worktrees removed`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,

package/commands/pull.mjs

@@ -27,6 +27,7 @@ import {
   REGISTRY_DIR,
   REGISTRY_URL,
   DOCS_SOURCE_DIR,
+  AW_DOCS_DIR,
   RULES_SOURCE_DIR,
   RULES_RUNTIME_DIR,
 } from '../constants.mjs';
@@ -92,7 +93,7 @@ export async function pullCommand(args) {
   // Ensure platform pulls also fetch docs and rules on older installs that
   // pre-date the new sparse-checkout paths.
   if (input === 'platform') {
-    addToSparseCheckout(AW_HOME, [`.aw_registry/platform`, DOCS_SOURCE_DIR, RULES_SOURCE_DIR]);
+    addToSparseCheckout(AW_HOME, [`.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR]);
     if (!cfg.include.includes('platform')) {
       config.addPattern(GLOBAL_AW_DIR, 'platform');
     }
@@ -110,7 +111,7 @@ export async function pullCommand(args) {
     const label = input.split('/').pop();
     if (!cfg.include.includes(input)) {
       log.logStep(`Adding ${chalk.cyan(label)} to sparse checkout...`);
-      addToSparseCheckout(AW_HOME, [sparsePath, DOCS_SOURCE_DIR]);
+      addToSparseCheckout(AW_HOME, [sparsePath, DOCS_SOURCE_DIR, AW_DOCS_DIR]);
       config.addPattern(GLOBAL_AW_DIR, input);
       addedInput = input;
       addedSparsePath = sparsePath;