@ghl-ai/aw 0.1.58-beta.0 → 0.1.59

package/integrations.mjs

@@ -19,10 +19,18 @@ import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { chalk } from './fmt.mjs';
+import {
+  ensureContextModeIntegration,
+  getContextModeIntegrationSummary,
+  removeContextModeIntegration,
+} from './integrations/context-mode.mjs';
 
 const execAsync = promisify(exec);
 const HOME = homedir();
-const MANIFEST_PATH = join(HOME, '.aw_registry', '.integration-manifest.json');
+
+function manifestPath(home = HOME) {
+  return join(home, '.aw_registry', '.integration-manifest.json');
+}
 
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -136,6 +144,16 @@ export const INTEGRATIONS = {
     requiresAuth: false,
     authNote: 'run /graphify . inside your IDE to build the graph whenever you need it',
   },
+
+  'context-mode': {
+    type: 'context-mode',
+    label: 'Context Mode',
+    description: 'Local context-mode MCP server and hook-based context preservation',
+    autoInstall: false,
+    teams: [],
+    requiresAuth: false,
+    authNote: 'Run aw doctor to verify context-mode health.',
+  },
 };
 
 // ────────────────────────────────────────────────────────────────────────────────
@@ -148,25 +166,27 @@ export const BUNDLES = {};
 // MANIFEST MANAGEMENT
 // ────────────────────────────────────────────────────────────────────────────────
 
-export function readManifest() {
-  if (!existsSync(MANIFEST_PATH)) {
+export function readManifest(home = HOME) {
+  const filePath = manifestPath(home);
+  if (!existsSync(filePath)) {
     return { version: 1, installed: {} };
   }
 
   try {
-    return JSON.parse(readFileSync(MANIFEST_PATH, 'utf8'));
+    return JSON.parse(readFileSync(filePath, 'utf8'));
   } catch {
     return { version: 1, installed: {} };
   }
 }
 
-export function writeManifest(manifest) {
-  mkdirSync(join(HOME, '.aw_registry'), { recursive: true });
-  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2) + '\n');
+export function writeManifest(manifest, home = HOME) {
+  const filePath = manifestPath(home);
+  mkdirSync(join(filePath, '..'), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n');
 }
 
-export function isInstalled(key) {
-  const manifest = readManifest();
+export function isInstalled(key, options = {}) {
+  const manifest = readManifest(options.home);
   const entry = manifest.installed[key];
   if (!entry) return false;
   // Backward compat: pre-existing entries have no `status` field — treat as installed.
@@ -175,25 +195,35 @@ export function isInstalled(key) {
   return entry.status !== 'skipped';
 }
 
-function recordInstalled(key, type) {
-  const manifest = readManifest();
+function recordInstalled(key, type, options = {}) {
+  if (options.dryRun) return;
+  const manifest = readManifest(options.home);
   manifest.installed[key] = {
     type,
     status: 'installed',
     installedAt: new Date().toISOString(),
+    ...(options.extra || {}),
   };
-  writeManifest(manifest);
+  writeManifest(manifest, options.home);
 }
 
-function recordSkipped(key, type, reason) {
-  const manifest = readManifest();
+function recordSkipped(key, type, reason, options = {}) {
+  if (options.dryRun) return;
+  const manifest = readManifest(options.home);
   manifest.installed[key] = {
     type,
     status: 'skipped',
     reason,
     installedAt: new Date().toISOString(),
   };
-  writeManifest(manifest);
+  writeManifest(manifest, options.home);
+}
+
+function removeInstalled(key, options = {}) {
+  if (options.dryRun) return;
+  const manifest = readManifest(options.home);
+  delete manifest.installed[key];
+  writeManifest(manifest, options.home);
 }
 
 // ────────────────────────────────────────────────────────────────────────────────
@@ -419,7 +449,7 @@ async function resolveCliInvocation(cliCommand, pythonCmd, installer) {
   }
 }
 
-async function runPythonCli(integration, key, { silent = false } = {}) {
+async function runPythonCli(integration, key, { silent = false, home = HOME } = {}) {
   const spinner = silent ? null : fmt.spinner();
 
   // 1. Detect Python ≥ minPython.
@@ -427,7 +457,7 @@ async function runPythonCli(integration, key, { silent = false } = {}) {
   const py = await detectPython(integration.minPython);
   if (!py) {
     if (!silent) spinner.stop(chalk.yellow('Python not found'));
-    recordSkipped(key, 'python-cli', 'python-not-found');
+    recordSkipped(key, 'python-cli', 'python-not-found', { home });
     if (!silent) {
       fmt.logWarn(
         `${integration.label} skipped — Python ${integration.minPython.major}.${integration.minPython.minor}+ required.`,
@@ -559,7 +589,7 @@ async function runClaudePlugin(installCmd, { silent = false, marketplaceSource =
 // UNIVERSAL INSTALLER (OS-detected master script — covers all IDEs in one shot)
 // ────────────────────────────────────────────────────────────────────────────────
 
-async function runUniversalInstaller(integration, key, { silent = false } = {}) {
+async function runUniversalInstaller(integration, key, { silent = false, home = HOME } = {}) {
   const spinner = silent ? null : fmt.spinner();
 
   if (!silent) spinner.start(`Installing ${integration.label} for all detected IDEs...`);
@@ -606,7 +636,7 @@ async function runUniversalInstaller(integration, key, { silent = false } = {})
               'Skipped',
             );
           }
-          recordSkipped(key, 'universal-installer', 'wsl-not-found');
+          recordSkipped(key, 'universal-installer', 'wsl-not-found', { home });
           return false;
         }
       }
@@ -649,13 +679,60 @@ async function runUniversalInstaller(integration, key, { silent = false } = {})
 // INTEGRATION INSTALLER
 // ────────────────────────────────────────────────────────────────────────────────
 
-export async function installIntegration(key, { silent = false } = {}) {
+function successResult(key, integration, extra = {}) {
+  return { success: true, key, integration, ...extra };
+}
+
+function failureResult(key, integration, error, extra = {}) {
+  return { success: false, key, integration, error, ...extra };
+}
+
+export function integrationSucceeded(result) {
+  return result === true || result?.success === true;
+}
+
+export async function installIntegration(key, options = {}) {
+  const { silent = false } = options;
+  const home = options.home || HOME;
+  const dryRun = options.dryRun === true;
   const integration = INTEGRATIONS[key];
   if (!integration) {
     throw new Error(`Unknown integration: ${key}`);
   }
 
-  if (isInstalled(key)) {
+  if (integration.type === 'context-mode') {
+    const result = ensureContextModeIntegration(home, {
+      ...options,
+      home,
+      env: options.env || process.env,
+      dryRun,
+    });
+    if (dryRun) {
+      return successResult(key, integration, result);
+    }
+    if (result.binary.present && result.complete) {
+      recordInstalled(key, integration.type, {
+        home,
+        extra: {
+          binaryPath: result.binary.path,
+          version: result.binary.version,
+        },
+      });
+      return successResult(key, integration, result);
+    }
+    return failureResult(
+      key,
+      integration,
+      result.binary.present ? 'partial-config' : (result.warnings?.[0] || 'binary-missing'),
+      result,
+    );
+  }
+
+  if (dryRun) {
+    return successResult(key, integration, { plannedInstall: true });
+  }
+
+  if (isInstalled(key, { home })) {
     if (!silent) fmt.logWarn(`${integration.label} is already installed`);
     return false;
   }
@@ -664,7 +741,7 @@ export async function installIntegration(key, { silent = false } = {}) {
     if (integration.type === 'plugin') {
       // PLUGIN: Run claude plugin install
       await runClaudePlugin(integration.installCmd, { silent, marketplaceSource: integration.marketplaceSource ?? null });
-      recordInstalled(key, 'plugin');
+      recordInstalled(key, 'plugin', { home });
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} plugin installed`);
@@ -699,7 +776,7 @@ export async function installIntegration(key, { silent = false } = {}) {
         integration.mcpUrl
       );
 
-      recordInstalled(key, 'remote-mcp');
+      recordInstalled(key, 'remote-mcp', { home });
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} added to MCP servers`);
@@ -709,10 +786,10 @@ export async function installIntegration(key, { silent = false } = {}) {
       }
     } else if (integration.type === 'python-cli') {
       // PYTHON CLI: pip-install + run post-install + per-project hooks
-      const ok = await runPythonCli(integration, key, { silent });
+      const ok = await runPythonCli(integration, key, { silent, home });
       if (!ok) return false;  // skipped (e.g. Python missing) — manifest already recorded
 
-      recordInstalled(key, 'python-cli');
+      recordInstalled(key, 'python-cli', { home });
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} installed`);
@@ -722,9 +799,9 @@ export async function installIntegration(key, { silent = false } = {}) {
       }
     } else if (integration.type === 'universal-installer') {
       // UNIVERSAL INSTALLER: OS-detected master script, covers all IDEs in one shot
-      const ok = await runUniversalInstaller(integration, key, { silent });
+      const ok = await runUniversalInstaller(integration, key, { silent, home });
       if (!ok) return false;  // skipped (e.g. WSL not found) — manifest already recorded
-      recordInstalled(key, 'universal-installer');
+      recordInstalled(key, 'universal-installer', { home });
 
       if (!silent) {
         fmt.logSuccess(`${integration.label} installed across all detected IDEs`);
@@ -748,13 +825,22 @@ export async function installIntegration(key, { silent = false } = {}) {
 // INTEGRATION REMOVER
 // ────────────────────────────────────────────────────────────────────────────────
 
-export async function removeIntegration(key, { silent = false } = {}) {
+export async function removeIntegration(key, options = {}) {
+  const { silent = false } = options;
+  const home = options.home || HOME;
+  const dryRun = options.dryRun === true;
   const integration = INTEGRATIONS[key];
   if (!integration) {
     throw new Error(`Unknown integration: ${key}`);
   }
 
-  if (!isInstalled(key)) {
+  if (integration.type === 'context-mode') {
+    const result = removeContextModeIntegration(home, { dryRun });
+    removeInstalled(key, { home, dryRun });
+    return successResult(key, integration, result);
+  }
+
+  if (!isInstalled(key, { home })) {
     if (!silent) fmt.logWarn(`${integration.label} is not installed`);
     return false;
   }
@@ -848,9 +934,7 @@ export async function removeIntegration(key, { silent = false } = {}) {
     }
 
     // Remove from manifest
-    const manifest = readManifest();
-    delete manifest.installed[key];
-    writeManifest(manifest);
+    removeInstalled(key, { home });
 
     return true;
   } catch (e) {
@@ -865,8 +949,8 @@ export async function removeIntegration(key, { silent = false } = {}) {
 // HELPERS
 // ────────────────────────────────────────────────────────────────────────────────
 
-export function getInstalledList() {
-  const manifest = readManifest();
+export function getInstalledList(options = {}) {
+  const manifest = readManifest(options.home);
   // Only return entries actually installed — skipped entries (e.g. Python missing)
   // shouldn't show up as "installed" to the rest of the system.
   return Object.entries(manifest.installed)
@@ -874,6 +958,34 @@ export function getInstalledList() {
     .map(([key]) => key);
 }
 
+export function getIntegrationSummary(key, options = {}) {
+  const integration = INTEGRATIONS[key];
+  if (!integration) return null;
+  if (integration.type === 'context-mode') {
+    return {
+      ...getContextModeIntegrationSummary(options.home || HOME, options),
+      label: integration.label,
+      description: integration.description,
+      type: integration.type,
+    };
+  }
+  const installed = isInstalled(key, options);
+  return {
+    name: key,
+    label: integration.label,
+    description: integration.description,
+    type: integration.type,
+    installed,
+    configured: installed,
+    state: installed ? 'installed' : 'available',
+    summary: installed ? `${integration.label} installed` : `${integration.label} available`,
+  };
+}
+
+export function getIntegrationSummaries(options = {}) {
+  return Object.keys(INTEGRATIONS).map(key => getIntegrationSummary(key, options));
+}
+
 export function suggestForTeam(namespace) {
   if (!namespace) return [];
 
@@ -895,7 +1007,8 @@ export function suggestForTeam(namespace) {
 // AUTO-INSTALL (called from init.mjs - installs suggested integrations)
 // ────────────────────────────────────────────────────────────────────────────────
 
-export async function autoInstallIntegrations(team, { silent = false, installer = installIntegration } = {}) {
+export async function autoInstallIntegrations(team, options = {}) {
+  const { silent = false, installer = installIntegration } = options;
   // Get suggested integrations for this team
   const suggested = suggestForTeam(team);
   if (!suggested || suggested.length === 0) {
@@ -903,7 +1016,7 @@ export async function autoInstallIntegrations(team, { silent = false, installer
   }
 
   // Only install if they're not already installed
-  const toInstall = suggested.filter((key) => !isInstalled(key));
+  const toInstall = suggested.filter((key) => !isInstalled(key, options));
   if (toInstall.length === 0) {
     return [];
   }
@@ -914,8 +1027,8 @@ export async function autoInstallIntegrations(team, { silent = false, installer
 
   const installed = [];
   for (const key of toInstall) {
-    const success = await installer(key, { silent });
-    if (success) {
+    const result = await installer(key, { ...options, silent });
+    if (integrationSucceeded(result)) {
       installed.push(INTEGRATIONS[key].label);
     }
   }
@@ -1011,8 +1124,8 @@ export async function promptAndInstall(team, { silent = false } = {}) {
   // Install all
   const installed = [];
   for (const key of toInstall) {
-    const success = await installIntegration(key, { silent: false });
-    if (success) {
+    const result = await installIntegration(key, { silent: false });
+    if (integrationSucceeded(result)) {
       installed.push(INTEGRATIONS[key].label);
     }
   }

package/package-manager.mjs

@@ -0,0 +1,72 @@
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SELF_PATH = fileURLToPath(import.meta.url);
+
+export function detectPackageManager(selfPath = SELF_PATH) {
+  const normalizedPath = String(selfPath || '').replace(/\\/g, '/');
+  if (normalizedPath.includes('/.volta/')) return 'volta';
+  if (normalizedPath.includes('/pnpm/')) return 'pnpm';
+  return 'npm';
+}
+
+export function buildGlobalPackageInstall(packageSpec, options = {}) {
+  const packageManager = options.packageManager || detectPackageManager(options.selfPath);
+  if (packageManager === 'volta') {
+    return { packageManager, command: 'volta', args: ['install', packageSpec] };
+  }
+  if (packageManager === 'pnpm') {
+    return { packageManager, command: 'pnpm', args: ['add', '-g', packageSpec] };
+  }
+  return { packageManager: 'npm', command: 'npm', args: ['i', '-g', packageSpec] };
+}
+
+export function formatCommand({ command, args = [] }) {
+  return [command, ...args].join(' ');
+}
+
+export function installGlobalPackage(packageSpec, options = {}) {
+  const plan = buildGlobalPackageInstall(packageSpec, options);
+  const result = spawnSync(plan.command, plan.args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    encoding: 'utf8',
+    stdio: options.stdio || 'pipe',
+    timeout: options.timeout || 5 * 60 * 1000,
+  });
+
+  return {
+    ...plan,
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error || null,
+    commandLine: formatCommand(plan),
+  };
+}
+
+export function getNpmPrefixBin(options = {}) {
+  const runner = options.runner || spawnSync;
+  const result = runner('npm', ['prefix', '-g'], {
+    env: options.env || process.env,
+    encoding: 'utf8',
+    stdio: 'pipe',
+    timeout: options.timeout || 10_000,
+  });
+  if (result.status !== 0) return null;
+  const prefix = String(result.stdout || '').trim();
+  if (!prefix) return null;
+  return join(prefix, process.platform === 'win32' ? '' : 'bin');
+}
+
+export function getAwPackageRoot(selfPath = SELF_PATH) {
+  if (selfPath.endsWith('package-manager.mjs')) return dirname(selfPath);
+  return dirname(selfPath);
+}
+
+export function executableExists(path) {
+  return Boolean(path && existsSync(path));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.58-beta.0",
+  "version": "0.1.59",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "link.mjs",
     "manifest.mjs",
     "mcp.mjs",
+    "package-manager.mjs",
     "paths.mjs",
     "plan.mjs",
     "registry.mjs",
@@ -54,9 +55,9 @@
   "license": "MIT",
   "scripts": {
     "test": "yarn test:vitest && yarn test:node",
-    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
+    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs tests/integrations tests/package-manager.test.mjs",
     "test:node": "node tests/run-node-tests.mjs",
-    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs",
+    "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/c4 tests/integrations-graphify.test.mjs tests/integrations tests/package-manager.test.mjs",
     "preuninstall": "node bin.js nuke 2>/dev/null || true"
   },
   "publishConfig": {

package/registry.mjs

@@ -28,10 +28,33 @@ export function getAllFiles(dirPath) {
   return results;
 }
 
+function findSkillRootDirs(skillsDir) {
+  const results = [];
+
+  function walk(dir, segments) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+      const childDir = join(dir, entry.name);
+      const childSegments = [...segments, entry.name];
+      if (existsSync(join(childDir, 'SKILL.md'))) {
+        results.push({ skillPath: childDir, slug: childSegments.join('/') });
+        continue;
+      }
+
+      walk(childDir, childSegments);
+    }
+  }
+
+  walk(skillsDir, []);
+  return results;
+}
+
 /**
  * Walk a registry directory tree and collect file-level entries.
  * Every file gets its own entry with its full registry path.
- * Skills are NOT atomic — each file inside a skill is registered individually.
+ * Skills are NOT atomic — each file inside a skill root is registered individually.
+ * A skill root is the nearest directory below skills/ that contains SKILL.md.
  */
 export function walkRegistryTree(baseDir, baseName) {
   const entries = [];
@@ -47,13 +70,9 @@ export function walkRegistryTree(baseDir, baseName) {
         const namespace = pathSegments.join('/');
 
         if (typeDir === 'skills') {
-          // Skills are directories — register each file inside individually
-          for (const skillEntry of readdirSync(fullPath, { withFileTypes: true })) {
-            if (skillEntry.name.startsWith('.')) continue;
-            const skillPath = join(fullPath, skillEntry.name);
-            if (!statSync(skillPath).isDirectory()) continue;
-            const slug = skillEntry.name;
-
+          // Skills can be grouped in nested folders. The actual skill root is
+          // the first nested directory that contains SKILL.md.
+          for (const { skillPath, slug } of findSkillRootDirs(fullPath)) {
             for (const file of getAllFiles(skillPath)) {
               const relPath = relative(skillPath, file);
               const relNoExt = relPath.replace(/\.md$/, '');

package/update.mjs

@@ -9,7 +9,7 @@
 //   .volta/  → volta install     pnpm/  → pnpm add -g
 //   else     → npm i -g
 
-import { readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync } from 'node:fs';
 import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import { join, dirname } from 'node:path';
@@ -39,15 +39,16 @@ const LOG_MAX_ENTRIES = 50;
 
 const SELF_PATH = fileURLToPath(import.meta.url);
 
-function detectPM() {
-  if (SELF_PATH.includes('/.volta/')) return 'volta';
-  if (SELF_PATH.includes('/pnpm/')) return 'pnpm';
+function detectPM(selfPath = SELF_PATH) {
+  const normalizedPath = String(selfPath || '').replace(/\\/g, '/');
+  if (normalizedPath.includes('/.volta/')) return 'volta';
+  if (normalizedPath.includes('/pnpm/')) return 'pnpm';
   return 'npm';
 }
 
 const PM = detectPM();
 
-function getInstallCmd(version = 'latest') {
+export function getInstallCmd(version = 'latest') {
   const spec = `${PKG_NAME}@${version}`;
   if (PM === 'volta') return `volta install ${spec}`;
   if (PM === 'pnpm') return `pnpm add -g ${spec}`;
@@ -91,23 +92,36 @@ function compareVersions(a, b) {
 // After install, re-resolve where the package actually landed and read
 // its package.json. Falls back to getLocalVersion() (our own bundle).
 
-function getInstalledVersion() {
+export function getInstalledPackageRoot(options = {}) {
+  const packageManager = options.packageManager || PM;
+  const runner = options.execSync || execSync;
   try {
-    if (PM === 'volta') {
+    if (packageManager === 'volta') {
       // Volta resolves via its own image; ask it directly
-      const resolved = execSync('volta which aw', {
+      const resolved = runner('volta which aw', {
         encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
       }).trim();
-      const pkgRoot = join(resolved, '..', '..');
-      return JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')).version;
+      const imageRoot = join(resolved, '..', '..');
+      const packageRoot = join(imageRoot, 'lib', 'node_modules', PKG_NAME);
+      return existsSync(join(packageRoot, 'package.json')) ? packageRoot : imageRoot;
     }
 
     // npm / pnpm: read from the global prefix
-    const prefix = execSync('npm prefix -g', {
+    const prefix = runner('npm prefix -g', {
       encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
     }).trim();
-    const pkgPath = join(prefix, 'lib', 'node_modules', PKG_NAME, 'package.json');
-    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+    if (packageManager === 'pnpm') {
+      return join(prefix, 'node_modules', PKG_NAME);
+    }
+    return join(prefix, 'lib', 'node_modules', PKG_NAME);
+  } catch {
+    return dirname(SELF_PATH);
+  }
+}
+
+function getInstalledVersion() {
+  try {
+    return JSON.parse(readFileSync(join(getInstalledPackageRoot(), 'package.json'), 'utf8')).version;
   } catch {
     return getLocalVersion();
   }
@@ -200,7 +214,8 @@ export function autoUpdate(result) {
     execSync(cmd, { stdio: 'pipe', timeout: 60_000 });
     const installed = getInstalledVersion();
     const ok = compareVersions(installed, result.current) > 0;
-    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, to: installed, ok };
+    const packageRoot = getInstalledPackageRoot();
+    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, to: installed, packageRoot, ok };
     appendLog(entry);
     return { status: ok ? 'upgraded' : 'failed', ...entry };
   } catch (e) {

package/integrations/index.mjs

@@ -1,31 +0,0 @@
-import {
-  ensureContextModeIntegration,
-  getContextModeIntegrationSummary,
-  removeContextModeIntegration,
-} from './context-mode.mjs';
-
-export const KNOWN_INTEGRATIONS = [
-  {
-    name: 'context-mode',
-    description: 'Local context-mode MCP server and hook integration.',
-    add: ensureContextModeIntegration,
-    remove: removeContextModeIntegration,
-    status: getContextModeIntegrationSummary,
-  },
-];
-
-export function resolveIntegration(name) {
-  const normalized = String(name || '').trim().toLowerCase();
-  const integration = KNOWN_INTEGRATIONS.find(item => item.name === normalized);
-  if (integration) return integration;
-
-  const known = KNOWN_INTEGRATIONS.map(item => item.name).join(', ');
-  throw new Error(`Unknown integration: ${name || '<missing>'}. Known integrations: ${known}`);
-}
-
-export function listIntegrations(home, options = {}) {
-  return KNOWN_INTEGRATIONS.map(integration => ({
-    ...integration.status(home, options),
-    description: integration.description,
-  }));
-}