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

package/integrations/context-mode.mjs

@@ -1,67 +1,64 @@
-import { accessSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { accessSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { constants as fsConstants } from 'node:fs';
 import { spawnSync } from 'node:child_process';
-import { delimiter, dirname, isAbsolute, join } from 'node:path';
+import { delimiter, dirname, join } from 'node:path';
 
 import TOML from '@iarna/toml';
-import {
-  buildGlobalPackageInstall,
-  formatCommand,
-  getNpmPrefixBin,
-  installGlobalPackage,
-} from '../package-manager.mjs';
 
 const INTEGRATION_NAME = 'context-mode';
 const BINARY_NAME = 'context-mode';
-const PACKAGE_SPEC = 'context-mode@latest';
 const INSTALL_STATE_RELATIVE_PATH = ['.aw', 'context-mode-install-state.json'];
 const INSTALL_STATE_VERSION = 1;
+const CONTEXT_MODE_MCP_SERVER = { command: BINARY_NAME };
 const MCP_TARGETS = {
   codex: 'codex-config-toml',
   cursor: 'cursor-mcp-json',
   claude: 'claude-json',
 };
 
-function shellQuote(value) {
-  const text = String(value);
-  if (!isAbsolute(text)) return text;
-  if (process.platform === 'win32') return `"${text.replace(/"/g, '\\"')}"`;
-  return `'${text.replace(/'/g, `'\\''`)}'`;
-}
-
-function hookCommand(commandTarget, harness, phase) {
-  return `${shellQuote(commandTarget)} hook ${harness} ${phase}`;
-}
-
-function codexHookCommands(commandTarget = BINARY_NAME) {
-  return {
-    PreToolUse: hookCommand(commandTarget, 'codex', 'pretooluse'),
-    PostToolUse: hookCommand(commandTarget, 'codex', 'posttooluse'),
-    SessionStart: hookCommand(commandTarget, 'codex', 'sessionstart'),
-    PreCompact: hookCommand(commandTarget, 'codex', 'precompact'),
-    UserPromptSubmit: hookCommand(commandTarget, 'codex', 'userpromptsubmit'),
-    Stop: hookCommand(commandTarget, 'codex', 'stop'),
-  };
-}
+const CODEX_HOOK_COMMANDS = {
+  PreToolUse: 'context-mode hook codex pretooluse',
+  PostToolUse: 'context-mode hook codex posttooluse',
+  SessionStart: 'context-mode hook codex sessionstart',
+  PreCompact: 'context-mode hook codex precompact',
+  UserPromptSubmit: 'context-mode hook codex userpromptsubmit',
+  Stop: 'context-mode hook codex stop',
+};
 
-function codexHookMatcherForPhase(phase) {
-  if (phase === 'SessionStart') return 'startup|resume';
-  if (phase === 'PreToolUse' || phase === 'PostToolUse') return '*';
-  return undefined;
-}
+const CODEX_PRE_TOOL_MATCHER = [
+  'local_shell',
+  'shell',
+  'shell_command',
+  'exec_command',
+  'Bash',
+  'Shell',
+  'apply_patch',
+  'Edit',
+  'Write',
+  'grep_files',
+  'ctx_execute',
+  'ctx_execute_file',
+  'ctx_batch_execute',
+  'ctx_fetch_and_index',
+  'ctx_search',
+  'ctx_index',
+  'mcp__',
+].join('|');
+
+const CODEX_HOOK_MATCHERS = {
+  PreToolUse: CODEX_PRE_TOOL_MATCHER,
+  PostToolUse: '*',
+  SessionStart: 'startup|resume',
+};
 
-function cursorHookCommands(commandTarget = BINARY_NAME) {
-  const preToolUse = hookCommand(commandTarget, 'cursor', 'pretooluse');
-  const postToolUse = hookCommand(commandTarget, 'cursor', 'posttooluse');
-  return [
-    { event: 'beforeShellExecution', command: preToolUse },
-    { event: 'beforeMCPExecution', command: preToolUse },
-    { event: 'afterShellExecution', command: postToolUse },
-    { event: 'afterFileEdit', command: postToolUse },
-    { event: 'afterMCPExecution', command: postToolUse },
-    { event: 'stop', command: hookCommand(commandTarget, 'cursor', 'stop') },
-  ];
-}
+const CURSOR_HOOK_COMMANDS = [
+  { event: 'beforeShellExecution', command: 'context-mode hook cursor pretooluse' },
+  { event: 'beforeMCPExecution', command: 'context-mode hook cursor pretooluse' },
+  { event: 'afterShellExecution', command: 'context-mode hook cursor posttooluse' },
+  { event: 'afterFileEdit', command: 'context-mode hook cursor posttooluse' },
+  { event: 'afterMCPExecution', command: 'context-mode hook cursor posttooluse' },
+  { event: 'stop', command: 'context-mode hook cursor stop' },
+];
 
 function truthy(value) {
   return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
@@ -145,16 +142,8 @@ function unmarkMcpTargetOwned(installState, target) {
   installState.mcpServers = installState.mcpServers.filter(item => item !== target);
 }
 
-function mcpServerConfig(commandTarget = BINARY_NAME) {
-  return { command: commandTarget };
-}
-
 function isDesiredMcpServer(value) {
-  return value
-    && typeof value === 'object'
-    && !Array.isArray(value)
-    && Object.keys(value).length === 1
-    && isContextModeMcpCommand(value.command);
+  return JSON.stringify(value) === JSON.stringify(CONTEXT_MODE_MCP_SERVER);
 }
 
 function parseTomlConfig(filePath, warnings) {
@@ -200,108 +189,8 @@ function findExecutable(binaryName, env = process.env) {
   return null;
 }
 
-function findExecutableInDirs(binaryName, dirs = []) {
-  for (const dir of unique(dirs.filter(Boolean))) {
-    for (const candidate of executableCandidates(binaryName)) {
-      const fullPath = join(dir, candidate);
-      try {
-        accessSync(fullPath, fsConstants.X_OK);
-        return fullPath;
-      } catch {
-        // Keep scanning known package-manager directories.
-      }
-    }
-  }
-  return null;
-}
-
-function childDirs(parent) {
-  try {
-    return readdirSync(parent, { withFileTypes: true })
-      .filter(entry => entry.isDirectory())
-      .map(entry => join(parent, entry.name));
-  } catch {
-    return [];
-  }
-}
-
-function readManifestBinaryPath(home) {
-  const manifestPath = join(home, '.aw_registry', '.integration-manifest.json');
-  if (!existsSync(manifestPath)) return null;
-  try {
-    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-    return manifest.installed?.[INTEGRATION_NAME]?.binaryPath || null;
-  } catch {
-    return null;
-  }
-}
-
-function knownExecutableDirs(home, env = process.env, options = {}) {
-  const dirs = [];
-  const skipSystemPrefixes = env.AW_CONTEXT_MODE_SKIP_SYSTEM_PREFIXES === '1';
-
-  const manifestPath = readManifestBinaryPath(home);
-  if (manifestPath) dirs.push(dirname(manifestPath));
-
-  if (Array.isArray(options.extraSearchDirs)) dirs.push(...options.extraSearchDirs);
-
-  const npmPrefixBin = options.npmPrefixBin ?? getNpmPrefixBin({ env });
-  if (npmPrefixBin) dirs.push(npmPrefixBin);
-
-  dirs.push(
-    join(home, '.volta', 'bin'),
-    join(home, '.local', 'share', 'pnpm'),
-  );
-
-  const voltaPackages = join(home, '.volta', 'tools', 'image', 'packages');
-  dirs.push(
-    join(voltaPackages, 'context-mode', 'bin'),
-    join(voltaPackages, 'context-mode', 'lib', 'node_modules', 'context-mode'),
-  );
-
-  for (const nodeDir of childDirs(join(home, '.volta', 'tools', 'image', 'node'))) {
-    dirs.push(join(nodeDir, 'bin'));
-  }
-
-  for (const nodeDir of childDirs(join(home, '.local', 'share', 'mise', 'installs', 'node'))) {
-    dirs.push(join(nodeDir, 'bin'));
-  }
-
-  if (env.PNPM_HOME) dirs.push(env.PNPM_HOME);
-
-  if (process.platform === 'darwin' && !skipSystemPrefixes) {
-    dirs.push('/opt/homebrew/bin', '/usr/local/bin');
-  }
-
-  return unique(dirs);
-}
-
-function commandTargetForBinary(binary) {
-  return binary.source === 'path' ? BINARY_NAME : binary.path;
-}
-
 function isContextModeCommand(command) {
-  const text = String(command || '').trim();
-  if (text.startsWith('context-mode hook ')) return true;
-  return /(^|[/\\'" ])context-mode(?:\.cmd|\.exe)?['"]? hook /.test(text);
-}
-
-function isContextModeMcpCommand(command) {
-  const text = String(command || '').trim();
-  if (text === BINARY_NAME) return true;
-  const commandName = text.replace(/^['"]|['"]$/g, '').split(/[/\\]/).pop().toLowerCase();
-  return commandName === BINARY_NAME
-    || commandName === `${BINARY_NAME}.cmd`
-    || commandName === `${BINARY_NAME}.exe`;
-}
-
-function normalizeCommandTarget(command) {
-  return String(command || '').trim().replace(/^['"]|['"]$/g, '');
-}
-
-function isExpectedMcpServer(value, expectedCommand) {
-  return isDesiredMcpServer(value)
-    && normalizeCommandTarget(value.command) === normalizeCommandTarget(expectedCommand);
+  return String(command || '').startsWith('context-mode hook ');
 }
 
 function hasHookCommand(entry, command) {
@@ -310,7 +199,7 @@ function hasHookCommand(entry, command) {
 }
 
 function hasCanonicalCodexMatcher(entry, phase) {
-  const expectedMatcher = codexHookMatcherForPhase(phase);
+  const expectedMatcher = CODEX_HOOK_MATCHERS[phase];
   return expectedMatcher === undefined
     ? entry?.matcher === undefined
     : entry?.matcher === expectedMatcher;
@@ -324,7 +213,7 @@ function buildCodexHookEntry(phase, command) {
   const entry = {
     hooks: [{ type: 'command', command }],
   };
-  const matcher = codexHookMatcherForPhase(phase);
+  const matcher = CODEX_HOOK_MATCHERS[phase];
   if (matcher !== undefined) entry.matcher = matcher;
   return entry;
 }
@@ -336,7 +225,7 @@ function ensureObject(parent, key) {
   return parent[key];
 }
 
-function mergeJsonMcpServer(filePath, installState, target, commandTarget = BINARY_NAME, dryRun = false) {
+function mergeJsonMcpServer(filePath, installState, target, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
@@ -344,16 +233,12 @@ function mergeJsonMcpServer(filePath, installState, target, commandTarget = BINA
 
   const mcpServers = ensureObject(config, 'mcpServers');
   const existing = mcpServers[INTEGRATION_NAME];
-  const desired = mcpServerConfig(commandTarget);
   if (existing && !isDesiredMcpServer(existing)) {
     throw new Error('Refusing to overwrite existing user-owned context-mode MCP config');
   }
-  if (existing && JSON.stringify(existing) === JSON.stringify(desired)) {
-    markMcpTargetOwned(installState, target);
-    return false;
-  }
+  if (existing) return false;
 
-  mcpServers[INTEGRATION_NAME] = desired;
+  mcpServers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
   markMcpTargetOwned(installState, target);
   return writeJsonIfChanged(filePath, config, dryRun);
 }
@@ -382,7 +267,7 @@ function removeJsonMcpServer(filePath, installState, target, warnings, dryRun =
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function mergeCodexToml(filePath, warnings, installState, target, commandTarget = BINARY_NAME, dryRun = false) {
+function mergeCodexToml(filePath, warnings, installState, target, dryRun = false) {
   const config = parseTomlConfig(filePath, warnings);
   if (config === null) return false;
   const existing = config.mcp_servers?.[INTEGRATION_NAME];
@@ -400,8 +285,10 @@ function mergeCodexToml(filePath, warnings, installState, target, commandTarget
   config.mcp_servers = config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)
     ? config.mcp_servers
     : {};
-  config.mcp_servers[INTEGRATION_NAME] = mcpServerConfig(commandTarget);
-  markMcpTargetOwned(installState, target);
+  if (!existing) {
+    config.mcp_servers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
+    markMcpTargetOwned(installState, target);
+  }
 
   if (JSON.stringify(config) === before) return false;
   return writeTomlIfChanged(filePath, config, dryRun);
@@ -446,7 +333,7 @@ function ensureCodexHook(config, phase, command) {
       continue;
     }
 
-    const nextHooks = entry.hooks.filter(hook => !isContextModeCommand(hook?.command));
+    const nextHooks = entry.hooks.filter(hook => hook?.command !== command);
     if (nextHooks.length === 0) continue;
     nextEntries.push(nextHooks.length === entry.hooks.length ? entry : { ...entry, hooks: nextHooks });
   }
@@ -456,14 +343,14 @@ function ensureCodexHook(config, phase, command) {
   return JSON.stringify(nextEntries) !== before;
 }
 
-function mergeCodexHooks(filePath, commandTarget = BINARY_NAME, dryRun = false) {
+function mergeCodexHooks(filePath, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
   }
 
   let changed = false;
-  for (const [phase, command] of Object.entries(codexHookCommands(commandTarget))) {
+  for (const [phase, command] of Object.entries(CODEX_HOOK_COMMANDS)) {
     changed = ensureCodexHook(config, phase, command) || changed;
   }
   return changed && writeJsonIfChanged(filePath, config, dryRun);
@@ -505,7 +392,7 @@ function ensureCursorHook(config, event, command) {
   config.hooks[event] = entries;
 }
 
-function mergeCursorHooks(filePath, commandTarget = BINARY_NAME, dryRun = false) {
+function mergeCursorHooks(filePath, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
@@ -526,7 +413,7 @@ function mergeCursorHooks(filePath, commandTarget = BINARY_NAME, dryRun = false)
     else delete config.hooks[phase];
   }
 
-  for (const { event, command } of cursorHookCommands(commandTarget)) {
+  for (const { event, command } of CURSOR_HOOK_COMMANDS) {
     ensureCursorHook(config, event, command);
   }
 
@@ -562,61 +449,45 @@ function removeCursorHooks(filePath, dryRun = false) {
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function hasJsonMcpServer(filePath, expectedCommand = null) {
+function hasJsonMcpServer(filePath) {
   if (!existsSync(filePath)) return false;
   try {
-    const server = readJson(filePath, {}).mcpServers?.[INTEGRATION_NAME];
-    return expectedCommand
-      ? isExpectedMcpServer(server, expectedCommand)
-      : isContextModeMcpCommand(server?.command);
+    return readJson(filePath, {}).mcpServers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
   } catch {
     return false;
   }
 }
 
-function hasCodexMcpServer(filePath, expectedCommand = null) {
+function hasCodexMcpServer(filePath) {
   if (!existsSync(filePath)) return false;
   try {
     const config = TOML.parse(readFileSync(filePath, 'utf8'));
-    const server = config.mcp_servers?.[INTEGRATION_NAME];
-    return expectedCommand
-      ? isExpectedMcpServer(server, expectedCommand)
-      : isContextModeMcpCommand(server?.command);
+    return config.mcp_servers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
   } catch {
     return false;
   }
 }
 
-function hasCodexHookCoverage(filePath, commandTarget = null) {
+function hasCodexHookCoverage(filePath) {
   if (!existsSync(filePath)) return false;
   try {
     const config = readJson(filePath, {});
-    const expectedCommands = commandTarget ? codexHookCommands(commandTarget) : null;
-    return Object.keys(codexHookCommands()).every(phase =>
+    return Object.entries(CODEX_HOOK_COMMANDS).every(([phase, command]) =>
       Array.isArray(config.hooks?.[phase])
-      && config.hooks[phase].some(entry =>
-        hasCanonicalCodexMatcher(entry, phase)
-        && Array.isArray(entry?.hooks)
-        && entry.hooks.some(hook => expectedCommands
-          ? hook?.command === expectedCommands[phase]
-          : isContextModeCommand(hook?.command))
-      )
+      && config.hooks[phase].some(entry => isCanonicalCodexHookEntry(entry, phase, command))
     );
   } catch {
     return false;
   }
 }
 
-function hasCursorHookCoverage(filePath, commandTarget = null) {
+function hasCursorHookCoverage(filePath) {
   if (!existsSync(filePath)) return false;
   try {
     const config = readJson(filePath, {});
-    const expectedCommands = commandTarget ? cursorHookCommands(commandTarget) : null;
-    return cursorHookCommands().every(({ event }) =>
+    return CURSOR_HOOK_COMMANDS.every(({ event, command }) =>
       Array.isArray(config.hooks?.[event])
-      && config.hooks[event].some(entry => entry?.event === event && (expectedCommands
-        ? entry?.command === expectedCommands.find(command => command.event === event)?.command
-        : isContextModeCommand(entry?.command)))
+      && config.hooks[event].some(entry => entry?.command === command && entry?.event === event)
     );
   } catch {
     return false;
@@ -631,12 +502,12 @@ function hasAnyContextModeConfig(home) {
     || hasJsonMcpServer(join(home, '.claude.json'));
 }
 
-function hasCompleteContextModeConfig(home, commandTarget = BINARY_NAME) {
-  return hasCodexMcpServer(join(home, '.codex', 'config.toml'), commandTarget)
-    && hasCodexHookCoverage(join(home, '.codex', 'hooks.json'), commandTarget)
-    && hasJsonMcpServer(join(home, '.cursor', 'mcp.json'), commandTarget)
-    && hasCursorHookCoverage(join(home, '.cursor', 'hooks.json'), commandTarget)
-    && hasJsonMcpServer(join(home, '.claude.json'), commandTarget);
+function hasCompleteContextModeConfig(home) {
+  return hasCodexMcpServer(join(home, '.codex', 'config.toml'))
+    && hasCodexHookCoverage(join(home, '.codex', 'hooks.json'))
+    && hasJsonMcpServer(join(home, '.cursor', 'mcp.json'))
+    && hasCursorHookCoverage(join(home, '.cursor', 'hooks.json'))
+    && hasJsonMcpServer(join(home, '.claude.json'));
 }
 
 export function isContextModeRequested(args = {}, env = process.env) {
@@ -660,10 +531,6 @@ export function detectContextModeBinary(options = {}) {
     };
   }
 
-  return describeContextModeBinary(binaryPath, env, 'path');
-}
-
-function describeContextModeBinary(binaryPath, env = process.env, source = 'path') {
   const versionEnv = {
     ...process.env,
     ...env,
@@ -690,85 +557,11 @@ function describeContextModeBinary(binaryPath, env = process.env, source = 'path
   return {
     present: true,
     path: binaryPath,
-    source,
-    commandTarget: source === 'path' ? BINARY_NAME : binaryPath,
     version: versionOutput || 'unknown',
     reason: null,
   };
 }
 
-export function resolveContextModeExecutable(options = {}) {
-  const env = options.env || process.env;
-  const home = options.home || env.HOME || process.env.HOME;
-  const pathBinary = findExecutable(BINARY_NAME, env);
-  if (pathBinary) return describeContextModeBinary(pathBinary, env, 'path');
-
-  const knownBinary = findExecutableInDirs(BINARY_NAME, knownExecutableDirs(home, env, options));
-  if (knownBinary) return describeContextModeBinary(knownBinary, env, 'known-prefix');
-
-  return {
-    present: false,
-    path: null,
-    source: null,
-    commandTarget: null,
-    version: null,
-    reason: `${BINARY_NAME} binary not found on PATH or known package-manager prefixes`,
-  };
-}
-
-export function ensureContextModeBinary(options = {}) {
-  const env = options.env || process.env;
-  const dryRun = options.dryRun === true;
-  const home = options.home || env.HOME || process.env.HOME;
-  const warnings = [];
-  const resolved = resolveContextModeExecutable({ ...options, env, home });
-  if (resolved.present) {
-    return { installed: false, plannedInstall: false, binary: resolved, warnings, install: null };
-  }
-
-  const installPlan = buildGlobalPackageInstall(PACKAGE_SPEC, options.packageManager ? { packageManager: options.packageManager } : {});
-  if (dryRun) {
-    return {
-      installed: false,
-      plannedInstall: true,
-      binary: resolved,
-      warnings,
-      install: { ...installPlan, commandLine: formatCommand(installPlan) },
-    };
-  }
-
-  if (env.AW_CONTEXT_MODE_DISABLE_PACKAGE_INSTALL === '1') {
-    warnings.push(`context-mode package install disabled; planned command: ${formatCommand(installPlan)}`);
-    return {
-      installed: false,
-      plannedInstall: false,
-      binary: resolved,
-      warnings,
-      install: { ...installPlan, ok: false, commandLine: formatCommand(installPlan) },
-    };
-  }
-
-  const installer = options.installPackage || installGlobalPackage;
-  const install = installer(PACKAGE_SPEC, {
-    env,
-    cwd: options.cwd,
-    packageManager: options.packageManager,
-    stdio: options.stdio,
-  });
-  if (!install?.ok) {
-    warnings.push(`context-mode package install failed: ${install?.error?.message || install?.stderr || install?.commandLine || 'unknown error'}`);
-    return { installed: false, plannedInstall: false, binary: resolved, warnings, install };
-  }
-
-  const afterInstall = resolveContextModeExecutable({ ...options, env, home });
-  if (!afterInstall.present) {
-    warnings.push(`context-mode installed but binary could not be resolved: ${afterInstall.reason}`);
-    return { installed: true, plannedInstall: false, binary: afterInstall, warnings, install };
-  }
-
-  return { installed: true, plannedInstall: false, binary: afterInstall, warnings, install };
-}
-
 export function ensureContextModeIntegration(home, options = {}) {
   const env = options.env || process.env;
   const dryRun = options.dryRun === true;
@@ -776,31 +569,24 @@ export function ensureContextModeIntegration(home, options = {}) {
   const changedFiles = [];
   const configuredHarnesses = [];
   const installState = readInstallState(home);
-  const binaryResult = ensureContextModeBinary({ ...options, env, home, dryRun });
-  warnings.push(...binaryResult.warnings);
-  const binary = binaryResult.binary;
+  const binary = detectContextModeBinary({ env });
 
   if (!binary.present) {
     return {
       changedFiles,
-      warnings: warnings.length > 0 ? warnings : [`context-mode binary is required before config mutation: ${binary.reason}`],
+      warnings: [`context-mode binary is required before config mutation: ${binary.reason}`],
       configuredHarnesses,
-      complete: false,
       binary,
       dryRun,
-      installedPackage: binaryResult.installed,
-      plannedInstall: binaryResult.plannedInstall,
-      install: binaryResult.install,
     };
   }
 
-  const commandTarget = commandTargetForBinary(binary);
   const updates = [
-    ['Codex MCP', join(home, '.codex', 'config.toml'), () => mergeCodexToml(join(home, '.codex', 'config.toml'), warnings, installState, MCP_TARGETS.codex, commandTarget, dryRun)],
-    ['Codex hooks', join(home, '.codex', 'hooks.json'), () => mergeCodexHooks(join(home, '.codex', 'hooks.json'), commandTarget, dryRun)],
-    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => mergeJsonMcpServer(join(home, '.cursor', 'mcp.json'), installState, MCP_TARGETS.cursor, commandTarget, dryRun)],
-    ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => mergeCursorHooks(join(home, '.cursor', 'hooks.json'), commandTarget, dryRun)],
-    ['Claude MCP', join(home, '.claude.json'), () => mergeJsonMcpServer(join(home, '.claude.json'), installState, MCP_TARGETS.claude, commandTarget, dryRun)],
+    ['Codex MCP', join(home, '.codex', 'config.toml'), () => mergeCodexToml(join(home, '.codex', 'config.toml'), warnings, installState, MCP_TARGETS.codex, dryRun)],
+    ['Codex hooks', join(home, '.codex', 'hooks.json'), () => mergeCodexHooks(join(home, '.codex', 'hooks.json'), dryRun)],
+    ['Cursor MCP', join(home, '.cursor', 'mcp.json'), () => mergeJsonMcpServer(join(home, '.cursor', 'mcp.json'), installState, MCP_TARGETS.cursor, dryRun)],
+    ['Cursor hooks', join(home, '.cursor', 'hooks.json'), () => mergeCursorHooks(join(home, '.cursor', 'hooks.json'), dryRun)],
+    ['Claude MCP', join(home, '.claude.json'), () => mergeJsonMcpServer(join(home, '.claude.json'), installState, MCP_TARGETS.claude, dryRun)],
   ];
 
   for (const [label, filePath, update] of updates) {
@@ -814,21 +600,12 @@ export function ensureContextModeIntegration(home, options = {}) {
     changedFiles.push(statePath);
   }
 
-  const complete = hasCompleteContextModeConfig(home, commandTarget);
-  if (!dryRun && !complete) {
-    warnings.push(`context-mode config is partially configured; fix the warnings above and rerun aw integrations add ${INTEGRATION_NAME}`);
-  }
-
   return {
     changedFiles: unique(changedFiles),
     warnings,
     configuredHarnesses,
-    complete,
     binary,
     dryRun,
-    installedPackage: binaryResult.installed,
-    plannedInstall: binaryResult.plannedInstall,
-    install: binaryResult.install,
   };
 }
 
@@ -863,15 +640,15 @@ export function removeContextModeIntegration(home, options = {}) {
 
 export function getContextModeIntegrationSummary(home, options = {}) {
   const env = options.env || process.env;
-  const binary = resolveContextModeExecutable({ ...options, env, home });
+  const binary = detectContextModeBinary({ env });
   const hasAnyConfig = hasAnyContextModeConfig(home);
-  const configured = binary.present && hasCompleteContextModeConfig(home, commandTargetForBinary(binary));
+  const configured = binary.present && hasCompleteContextModeConfig(home);
   const state = configured ? 'configured' : hasAnyConfig ? 'broken' : 'absent';
   const summary = configured
     ? `context-mode configured (${binary.version || 'version unknown'})`
     : hasAnyConfig
-      ? `context-mode partially configured; run aw integrations add ${INTEGRATION_NAME}`
-      : `context-mode not configured${binary.present ? `; binary discoverable via ${binary.source}` : '; binary not installed'}`;
+      ? `context-mode partially configured; run aw integration add ${INTEGRATION_NAME}`
+      : `context-mode not configured${binary.present ? '' : '; binary not installed'}`;
 
   return {
     name: INTEGRATION_NAME,
@@ -903,7 +680,7 @@ export function getContextModeDoctorStatus(home, options = {}) {
       title: 'Context Mode integration',
       status: 'warn',
       summary: summary.summary,
-      fix: `Run \`aw integrations add ${INTEGRATION_NAME}\` to repair or \`aw integrations remove ${INTEGRATION_NAME}\` to clean it up.`,
+      fix: `Run \`aw integration add ${INTEGRATION_NAME}\` to repair or \`aw integration remove ${INTEGRATION_NAME}\` to clean it up.`,
     }];
   }
 

package/integrations/index.mjs

@@ -0,0 +1,31 @@
+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,
+  }));
+}