@ghl-ai/aw 0.1.50-beta.0 → 0.1.50

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

@@ -12,13 +12,12 @@
 #   - .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 to pin a specific @ghl-ai/aw@0.1.x for reproducible
-#                CI runs.
+#   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.
 set -Eeuo pipefail
 
-# GitHub auth is resolved inside `aw c4` so GITHUB_PAT, GITHUB_TOKEN, and
-# no-token diagnostics stay centralized in the CLI preflight.
+: "${GITHUB_PAT:?ERROR: Set GITHUB_PAT in your harness secrets UI before running aw c4}"
 
 # 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,13 @@ 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),
-  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),
@@ -50,9 +50,6 @@ function parseArgs(argv) {
     if (arg === '--dry-run') {
       args['--dry-run'] = true;
       i++;
-    } else if (arg === '--aw-docs-only' || arg === '--docs-only') {
-      args[arg] = true;
-      i++;
     } else if (arg === '-v' || arg === '--verbose') {
       args['-v'] = true;
       i++;
@@ -87,13 +84,10 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init', 'Initialize workspace (auto-installs suggested integrations)'),
+    cmd('aw init', 'Initialize workspace (platform/ only)'),
     cmd('aw init --namespace <team/sub-team>', 'Add a team namespace (optional)'),
-    cmd('aw init skills <path...>', 'Initialize/link only specific skill folders'),
-    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')}`,
-    `  ${chalk.dim('Example: aw init skills platform/core/skills/pr-review')}`,
     cmd('aw init-repo', 'Scaffold cloud-bootstrap files (idempotent, --dry-run/--force/--diff)'),
 
     sec('Download'),
@@ -103,8 +97,6 @@ function printHelp() {
 
     sec('Upload'),
     cmd('aw push', 'Push all modified files (creates one PR)'),
-    cmd('aw push --aw-docs-only', 'Publish generated .aw_docs companions and print share links'),
-    cmd('aw push --aw-docs-only --feature <slug>', 'Publish one .aw_docs feature folder and print share links'),
     cmd('aw push <path>', 'Push file, folder, or namespace to registry'),
     cmd('aw push-rules [path]', 'Push platform rules to platform-docs'),
     cmd('aw push --dry-run [path]', 'Preview what would be pushed'),
@@ -117,15 +109,12 @@ 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 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 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 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)'),
@@ -154,7 +143,6 @@ function printHelp() {
     cmd('aw pull <team>/agents', 'All agents from a team'),
     cmd('aw pull <team>/agents/<name>', 'One specific agent'),
     cmd('aw pull <team>/skills/<name>', 'One specific skill folder'),
-    cmd('aw init skills <team>/<path>/skills/<name>', 'Install and link only selected skill symlinks'),
     '',
     `  ${chalk.dim('# Push your local changes to registry')}`,
     cmd('aw push', 'Push all modified files (one PR)'),

package/commands/c4.mjs

@@ -24,7 +24,6 @@ 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.
@@ -350,10 +349,10 @@ export async function c4Command(rawArgs, overrides = {}) {
     return exit(0);
   }
 
-  // Step 6 — npm install -g @ghl-ai/aw@latest.
-  const npmRes = spawnSync('npm', ['install', '-g', '@ghl-ai/aw@latest'], { stdio: 'pipe' });
+  // Step 6 — npm install -g @ghl-ai/aw.
+  const npmRes = spawnSync('npm', ['install', '-g', '@ghl-ai/aw'], { stdio: 'pipe' });
   if (npmRes && npmRes.status !== 0) {
-    writer.stderr('[aw-c4] npm install -g @ghl-ai/aw@latest failed (non-fatal); using existing aw if present\n');
+    writer.stderr('[aw-c4] npm install -g @ghl-ai/aw failed (non-fatal); using existing aw if present\n');
   }
 
   // Step 7 — aw init --silent.
@@ -381,12 +380,7 @@ export async function c4Command(rawArgs, overrides = {}) {
   }
 
   // Step 11 — MCP register.
-  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');
-  }
+  safe('registerGhlAiMcp', () => c4.registerGhlAiMcp(harness, home, token), writer);
 
   // Step 12 — slash command surface.
   safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, eccHome }), writer);
@@ -409,13 +403,11 @@ export async function c4Command(rawArgs, overrides = {}) {
   safe('ensureRepoLocalIgnore', () => c4.ensureRepoLocalIgnore({ cwd, harness }), writer);
 
   // Step 15 — MCP smoke probe (best-effort).
-  const mcpProbe = mcpEnabled
-    ? await safeAsync(
-      'probeMcpServer',
-      () => c4.probeMcpServer({ url: c4.MCP_URL_DEFAULT, token }),
-      writer,
-    )
-    : null;
+  const mcpProbe = await safeAsync(
+    'probeMcpServer',
+    () => c4.probeMcpServer({ url: c4.MCP_URL_DEFAULT, token }),
+    writer,
+  );
 
   // Step 16 — self-tests.
   const self = runSelfTests({ harness, c4, home, awHome, eccHome });

package/commands/doctor.mjs

@@ -7,6 +7,7 @@ import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { AW_ECC_TAG } from '../ecc.mjs';
 import { getSupportedHarnessPhaseEntries } from '../hook-manifest.mjs';
+import { getContextModeDoctorStatus } from '../integrations/context-mode.mjs';
 import { getStartupStatus, hasLegacyRepoStartupDefaults } from '../startup.mjs';
 
 const STATUS_PRIORITY = { pass: 0, warn: 1, fail: 2 };
@@ -209,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)).includes(GENERATED_RULE_HEADER));
+      .some(entry => readText(join(dirPath, entry.name)).startsWith(GENERATED_RULE_HEADER));
   } catch {
     return false;
   }
@@ -500,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).includes(GENERATED_RULE_HEADER));
+      .filter(filePath => readText(filePath).startsWith(GENERATED_RULE_HEADER));
   } catch {
     return [];
   }
@@ -1026,6 +1027,8 @@ function buildDoctorChecks(homeDir, cwd) {
         ),
   );
 
+  checks.push(...getContextModeDoctorStatus(homeDir, { env: process.env }));
+
   const eccDir = join(homeDir, '.aw-ecc');
   const eccSyncScript = join(eccDir, 'scripts', 'sync-ecc-to-codex.sh');
   if (!existsSync(eccDir)) {

package/commands/init.mjs

@@ -23,9 +23,10 @@ import * as p from '@clack/prompts';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk, setSilent } from '../fmt.mjs';
-import { linkWorkspace, linkSkills, normalizeSkillTarget } from '../link.mjs';
+import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs, syncHomeHarnessInstructions } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
+import { ensureContextModeIntegration, isContextModeRequested } from '../integrations/context-mode.mjs';
 import { applyStoredStartupPreferences, ensureAwRuntimeHook } from '../startup.mjs';
 import { installLocalCommitHook } from '../hooks.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
@@ -34,7 +35,6 @@ 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 +48,7 @@ import {
   syncWorktreeSparseCheckout,
   findNearestWorktree,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, RULES_RUNTIME_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, RULES_SOURCE_DIR, RULES_RUNTIME_DIR } from '../constants.mjs';
 import { syncFileTree } from '../file-tree.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -92,6 +92,32 @@ function syncHomeAndProjectInstructions(cwd, namespace) {
   }
 }
 
+function maybeConfigureContextMode(args, { silent = false } = {}) {
+  if (!isContextModeRequested(args, process.env)) {
+    return null;
+  }
+
+  const result = ensureContextModeIntegration(HOME, {
+    env: process.env,
+    silent,
+  });
+
+  if (!silent) {
+    for (const warning of result.warnings) {
+      fmt.logWarn(warning);
+    }
+    if (result.changedFiles.length > 0) {
+      fmt.logStep(`Context Mode configured (${result.changedFiles.length} file${result.changedFiles.length === 1 ? '' : 's'})`);
+    } else if (result.warnings.length > 0) {
+      fmt.logWarn('Context Mode was requested but not configured');
+    } else {
+      fmt.logStep('Context Mode already configured');
+    }
+  }
+
+  return result;
+}
+
 /**
  * Create scaffold directories for a new team namespace so the developer
  * has the standard folder structure ready for agents, skills, commands, and evals.
@@ -108,39 +134,10 @@ function scaffoldNamespace(awHome, folderName) {
   }
 }
 
-function getSkillInitSpecs(args) {
-  const positional = args._positional || [];
-  const mode = positional[0];
-  const rawTargets = [];
-
-  if (mode === 'skill' || mode === 'skills') {
-    rawTargets.push(...positional.slice(1));
-  }
-
-  if (args['--skill']) {
-    rawTargets.push(args['--skill']);
-  }
-
-  if ((mode === 'skill' || mode === 'skills' || args['--skill']) && rawTargets.length === 0) {
-    fmt.cancel(`Missing skill path.\n\n  ${chalk.dim('Example:')} ${chalk.bold('aw init skills platform/core/skills/pr-review')}`);
-  }
-
-  if (rawTargets.length === 0) return [];
-
-  try {
-    return [...new Map(rawTargets.map(input => {
-      const spec = normalizeSkillTarget(input);
-      return [spec.registryPath, spec];
-    })).values()];
-  } catch (e) {
-    fmt.cancel(e.message);
-  }
-}
-
 // ── Ensure ~/.aw/.git/info/exclude has the whitelist block ─────────────
 //
-// 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,
+// Strategy: only .aw_registry/, .aw_rules/, content/ 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.
 
@@ -154,7 +151,6 @@ const AW_MANAGED_BLOCK = [
   '!/.aw_registry',
   '!/.aw_rules',
   '!/content',
-  '!/.aw_docs',
   '',
   '# Nested local state within whitelisted dirs',
   '/.aw_registry/.sync-config.json',
@@ -243,15 +239,6 @@ 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;
-  const skillSpecs = getSkillInitSpecs(args);
-  const skillTargets = skillSpecs.map(spec => spec.registryPath);
-  const isSkillInit = skillTargets.length > 0;
-  const skillNamespace = skillSpecs[0]?.namespace || null;
-
-  if (isSkillInit && namespace) {
-    fmt.cancel('Use either `aw init skills <path...>` or `aw init --namespace <team/sub-team>`, not both.');
-  }
 
   // In silent mode, suppress ALL fmt output and show a single spinner.
   // setSilent(true) makes every fmt.* call a no-op — internal functions
@@ -360,28 +347,10 @@ export async function initCommand(args) {
   if (isGitNative) {
     const cfg = config.load(GLOBAL_AW_DIR);
 
-    const newSkillTargets = isSkillInit && cfg
-      ? skillTargets.filter(target => !cfg.include.some(pattern => target === pattern || target.startsWith(pattern + '/')))
-      : [];
-    const isNewSubTeam = !isSkillInit && folderName && cfg && !cfg.include.includes(folderName);
-
-    if (isSkillInit) {
-      if (newSkillTargets.length > 0) {
-        if (!silent) fmt.logStep(`Adding ${chalk.cyan(newSkillTargets.length)} skill${newSkillTargets.length > 1 ? 's' : ''}...`);
-        addToSparseCheckout(AW_HOME, [
-          ...newSkillTargets.map(target => `.aw_registry/${target}`),
-          DOCS_SOURCE_DIR,
-          AW_DOCS_DIR,
-          RULES_SOURCE_DIR,
-          `.aw_registry/AW-PROTOCOL.md`,
-        ]);
-        for (const target of newSkillTargets) config.addPattern(GLOBAL_AW_DIR, target);
-      } else if (!silent) {
-        fmt.logStep('Already initialized — syncing selected skills...');
-      }
-    } else if (isNewSubTeam) {
+    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}`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR];
+      const newSparsePaths = [`.aw_registry/${folderName}`, 'content', RULES_SOURCE_DIR];
       addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
       scaffoldNamespace(AW_HOME, folderName);
@@ -407,7 +376,6 @@ export async function initCommand(args) {
 
     ensureAwGitignore(AW_HOME);
     const freshCfg = config.load(GLOBAL_AW_DIR);
-    const activeNamespace = skillNamespace || freshCfg?.namespace || team;
     syncRulesTargets(HOME);
     if (cwd !== HOME) {
       syncRulesTargets(cwd);
@@ -430,8 +398,9 @@ export async function initCommand(args) {
     await installAwEcc(cwd, { silent });
 
     ensureAwRuntimeHook(HOME);
-    syncHomeAndProjectInstructions(cwd, activeNamespace);
-    await setupMcp(HOME, activeNamespace, { silent });
+    syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
+    await setupMcp(HOME, freshCfg?.namespace || team, { silent });
+    maybeConfigureContextMode(args, { silent });
     applyStoredStartupPreferences(HOME);
     const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
     installGlobalHooks();
@@ -465,22 +434,14 @@ export async function initCommand(args) {
     if (!silent) fmt.logStep('Wiring IDE symlinks...');
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-    const symlinks = isSkillInit
-      ? linkSkills(HOME, skillTargets, awDirForLinks, { silent: true, exclusive: true })
-      : linkWorkspace(HOME, awDirForLinks, { silent: true });
-    const commands = isSkillInit ? 0 : generateCommands(HOME, { silent: true });
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
     if (cwd !== HOME) installLocalCommitHook(cwd);
-    if (!silent) fmt.logStep(`IDE wired — ${chalk.bold(symlinks)} ${isSkillInit ? 'skill symlinks' : 'symlinks'} · ${chalk.bold(commands)} commands`);
+    if (!silent) fmt.logStep(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
     // 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(activeNamespace, { silent });
-    }
-
     if (silent) {
       if (silentSpinner) { silentSpinner.stop('Done'); setSilent(false); }
       autoUpdate(await args._updateCheck);
@@ -489,12 +450,11 @@ export async function initCommand(args) {
         `⟁  ${isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Up to date'}`,
         '',
         `  ${chalk.green('✓')} Registry synced`,
-        `  ${chalk.green('✓')} IDE refreshed — ${chalk.bold(symlinks)} ${isSkillInit ? 'skill symlinks' : 'symlinks'} · ${chalk.bold(commands)} commands`,
+        `  ${chalk.green('✓')} IDE refreshed — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`,
         removedLegacyStartupFiles.length > 0
           ? `  ${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;
@@ -523,24 +483,13 @@ export async function initCommand(args) {
   }
 
   // Determine sparse paths
-  const sparsePaths = isSkillInit
-    ? [
-        ...skillTargets.map(target => `.aw_registry/${target}`),
-        DOCS_SOURCE_DIR,
-        AW_DOCS_DIR,
-        RULES_SOURCE_DIR,
-        `.aw_registry/AW-PROTOCOL.md`,
-        `CODEOWNERS`,
-      ]
-    : [`.aw_registry/platform`, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
-  if (!isSkillInit && folderName) {
+  const sparsePaths = [`.aw_registry/platform`, `content`, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
+  if (folderName) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
 
   fmt.note([
-    isSkillInit
-      ? `${chalk.dim('skills:')}     ${skillTargets.join(', ')}`
-      : (folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`),
+    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
     user ? `${chalk.dim('user:')}       ${user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config');
@@ -580,11 +529,8 @@ export async function initCommand(args) {
   }
 
   // Create sync config — default to 'platform' when no namespace specified
-  const activeNamespace = skillNamespace || team || 'platform';
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace: activeNamespace, user });
-  if (isSkillInit) {
-    for (const target of skillTargets) config.addPattern(GLOBAL_AW_DIR, target);
-  } else if (folderName) {
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
+  if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
     scaffoldNamespace(AW_HOME, folderName);
   }
@@ -605,9 +551,10 @@ export async function initCommand(args) {
 
   // Parallel batch B: post-ECC setup (instructions and MCP are independent)
   const [, mcpFiles] = await Promise.all([
-    Promise.resolve(syncHomeAndProjectInstructions(cwd, activeNamespace)),
-    setupMcp(HOME, activeNamespace, { silent }),
+    Promise.resolve(syncHomeAndProjectInstructions(cwd, team)),
+    setupMcp(HOME, team, { silent }),
   ]);
+  maybeConfigureContextMode(args, { silent });
   // applyStoredStartupPreferences reads settings written by ECC — keep after batch B
   applyStoredStartupPreferences(HOME);
   const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
@@ -644,13 +591,11 @@ export async function initCommand(args) {
   const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
   // Parallel batch C: symlinks + commands are independent
   if (cwd !== HOME) installLocalCommitHook(cwd);
-  const [symlinks, commands] = isSkillInit
-    ? [linkSkills(HOME, skillTargets, awDirForLinks, { silent: true, exclusive: true }), 0]
-    : [
-        linkWorkspace(HOME, awDirForLinks, { silent: true }),
-        generateCommands(HOME, { silent: true }),
-      ];
-  if (!silent) fmt.logStep(`IDE wired — ${chalk.bold(symlinks)} ${isSkillInit ? 'skill symlinks' : 'symlinks'} · ${chalk.bold(commands)} commands`);
+  const [symlinks, commands] = [
+    linkWorkspace(HOME, awDirForLinks, { silent: true }),
+    generateCommands(HOME, { silent: true }),
+  ];
+  if (!silent) fmt.logStep(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
   // Write hook manifest after all hook installation is complete
   try { writeHookManifest({ eccVersion: AW_ECC_TAG, awVersion: VERSION }); } catch { /* best effort */ }
@@ -658,12 +603,6 @@ 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(activeNamespace, { silent });
-  }
-
   // Offer to update if a newer version is available
   if (!silent) await promptUpdate(await args._updateCheck);
 
@@ -683,12 +622,10 @@ 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/integration.mjs

@@ -0,0 +1,111 @@
+import { homedir } from 'node:os';
+
+import * as fmt from '../fmt.mjs';
+import { listIntegrations, resolveIntegration } from '../integrations/index.mjs';
+
+function printWarnings(warnings = []) {
+  for (const warning of warnings) {
+    fmt.logWarn(warning);
+  }
+}
+
+function printChangedFiles(changedFiles = []) {
+  if (changedFiles.length === 0) return;
+  fmt.note(changedFiles.map(file => file.replace(homedir(), '~')).join('\n'), 'Changed files');
+}
+
+function requireIntegration(name) {
+  if (!name) {
+    fmt.cancel('Missing integration name. Known integrations: context-mode');
+  }
+
+  try {
+    return resolveIntegration(name);
+  } catch (err) {
+    fmt.cancel(err.message);
+  }
+}
+
+export async function integrationCommand(args) {
+  const [subcommand = 'list', name] = args._positional;
+  const home = homedir();
+
+  if (args['--help']) {
+    fmt.intro('aw integration');
+    fmt.note(
+      [
+        'aw integration list',
+        'aw integration add context-mode [--dry-run]',
+        'aw integration status context-mode',
+        'aw integration remove context-mode [--dry-run]',
+      ].join('\n'),
+      'Usage',
+    );
+    fmt.outro('Done');
+    return;
+  }
+
+  if (subcommand === 'list') {
+    fmt.intro('aw integration list');
+    const rows = listIntegrations(home, { env: process.env });
+    fmt.note(
+      rows.map(row => `${row.name}  ${row.state}  ${row.summary}`).join('\n'),
+      'Known integrations',
+    );
+    fmt.outro('Done');
+    return;
+  }
+
+  const integration = requireIntegration(name);
+
+  if (subcommand === 'add') {
+    fmt.intro(`aw integration add ${integration.name}`);
+    const result = integration.add(home, {
+      env: process.env,
+      dryRun: args['--dry-run'] === true,
+    });
+    printWarnings(result.warnings);
+    printChangedFiles(result.changedFiles);
+    if (result.changedFiles.length > 0) {
+      fmt.outro(`${integration.name} configured`);
+    } else if (result.warnings.length > 0) {
+      fmt.outro(`${integration.name} not configured; binary is missing or config was unsafe to edit`);
+    } else {
+      fmt.outro(`${integration.name} already configured`);
+    }
+    return;
+  }
+
+  if (subcommand === 'remove') {
+    fmt.intro(`aw integration remove ${integration.name}`);
+    const result = integration.remove(home, {
+      dryRun: args['--dry-run'] === true,
+    });
+    printWarnings(result.warnings);
+    printChangedFiles(result.changedFiles);
+    fmt.outro(result.changedFiles.length > 0
+      ? `${integration.name} removed`
+      : `${integration.name} not configured`);
+    return;
+  }
+
+  if (subcommand === 'status') {
+    fmt.intro(`aw integration status ${integration.name}`);
+    const status = integration.status(home, { env: process.env });
+    fmt.note(
+      [
+        `state: ${status.state}`,
+        `installed: ${status.installed}`,
+        `configured: ${status.configured}`,
+        status.version ? `version: ${status.version}` : null,
+        status.path ? `path: ${status.path}` : null,
+        `summary: ${status.summary}`,
+      ].filter(Boolean).join('\n'),
+      integration.name,
+    );
+    fmt.outro('Done');
+    return;
+  }
+
+  fmt.cancel(`Unknown integration subcommand: ${subcommand}. Use add / remove / status / list`);
+}

package/commands/nuke.mjs

@@ -14,6 +14,7 @@ import { chalk } from '../fmt.mjs';
 import { removeGlobalHooks } from '../hooks.mjs';
 import { uninstallAwEcc } from '../ecc.mjs';
 import { removeMcpConfig } from '../mcp.mjs';
+import { removeContextModeIntegration } from '../integrations/context-mode.mjs';
 import { listProjectWorktrees } from '../git.mjs';
 import { removeWorkspaceHookDefaults } from '../codex.mjs';
 import { readHookManifest, pruneStaleHooks, removeHookManifest } from '../hook-cleanup.mjs';
@@ -245,6 +246,7 @@ export async function nukeCommand(args) {
   const ideCount = removeIdeSymlinks();
   uninstallAwEcc();
   removeMcpConfig();
+  removeContextModeIntegration(HOME);
   // Prune stale hook entries using manifest (catches entries not tracked by install-state)
   if (hookManifest) pruneStaleHooks(hookManifest);
   removeHookManifest();
@@ -364,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 from Claude, Cursor, and Codex configs)`,
+    `  ${chalk.green('✓')} MCP config removed (ghl-ai and context-mode)`,
     `  ${chalk.green('✓')} aw-ecc engine removed`,
     `  ${chalk.green('✓')} Project worktrees removed`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,