@ghl-ai/aw 0.1.56 → 0.1.57

package/integrations/context-mode.mjs

@@ -1,64 +1,67 @@
-import { accessSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { accessSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { constants as fsConstants } from 'node:fs';
 import { spawnSync } from 'node:child_process';
-import { delimiter, dirname, join } from 'node:path';
+import { delimiter, dirname, isAbsolute, 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',
 };
 
-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 shellQuote(value) {
+  const text = String(value);
+  if (!isAbsolute(text)) return text;
+  if (process.platform === 'win32') return `"${text.replace(/"/g, '\\"')}"`;
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
 
-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 hookCommand(commandTarget, harness, phase) {
+  return `${shellQuote(commandTarget)} hook ${harness} ${phase}`;
+}
 
-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 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'),
+  };
+}
+
+function codexHookMatcherForPhase(phase) {
+  if (phase === 'SessionStart') return 'startup|resume';
+  if (phase === 'PreToolUse' || phase === 'PostToolUse') return '*';
+  return undefined;
+}
+
+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') },
+  ];
+}
 
 function truthy(value) {
   return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
@@ -142,8 +145,16 @@ function unmarkMcpTargetOwned(installState, target) {
   installState.mcpServers = installState.mcpServers.filter(item => item !== target);
 }
 
+function mcpServerConfig(commandTarget = BINARY_NAME) {
+  return { command: commandTarget };
+}
+
 function isDesiredMcpServer(value) {
-  return JSON.stringify(value) === JSON.stringify(CONTEXT_MODE_MCP_SERVER);
+  return value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && Object.keys(value).length === 1
+    && isContextModeMcpCommand(value.command);
 }
 
 function parseTomlConfig(filePath, warnings) {
@@ -189,8 +200,108 @@ 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) {
-  return String(command || '').startsWith('context-mode hook ');
+  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);
 }
 
 function hasHookCommand(entry, command) {
@@ -199,7 +310,7 @@ function hasHookCommand(entry, command) {
 }
 
 function hasCanonicalCodexMatcher(entry, phase) {
-  const expectedMatcher = CODEX_HOOK_MATCHERS[phase];
+  const expectedMatcher = codexHookMatcherForPhase(phase);
   return expectedMatcher === undefined
     ? entry?.matcher === undefined
     : entry?.matcher === expectedMatcher;
@@ -213,7 +324,7 @@ function buildCodexHookEntry(phase, command) {
   const entry = {
     hooks: [{ type: 'command', command }],
   };
-  const matcher = CODEX_HOOK_MATCHERS[phase];
+  const matcher = codexHookMatcherForPhase(phase);
   if (matcher !== undefined) entry.matcher = matcher;
   return entry;
 }
@@ -225,7 +336,7 @@ function ensureObject(parent, key) {
   return parent[key];
 }
 
-function mergeJsonMcpServer(filePath, installState, target, dryRun = false) {
+function mergeJsonMcpServer(filePath, installState, target, commandTarget = BINARY_NAME, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
@@ -233,12 +344,16 @@ function mergeJsonMcpServer(filePath, installState, target, dryRun = false) {
 
   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) return false;
+  if (existing && JSON.stringify(existing) === JSON.stringify(desired)) {
+    markMcpTargetOwned(installState, target);
+    return false;
+  }
 
-  mcpServers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
+  mcpServers[INTEGRATION_NAME] = desired;
   markMcpTargetOwned(installState, target);
   return writeJsonIfChanged(filePath, config, dryRun);
 }
@@ -267,7 +382,7 @@ function removeJsonMcpServer(filePath, installState, target, warnings, dryRun =
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function mergeCodexToml(filePath, warnings, installState, target, dryRun = false) {
+function mergeCodexToml(filePath, warnings, installState, target, commandTarget = BINARY_NAME, dryRun = false) {
   const config = parseTomlConfig(filePath, warnings);
   if (config === null) return false;
   const existing = config.mcp_servers?.[INTEGRATION_NAME];
@@ -285,10 +400,8 @@ function mergeCodexToml(filePath, warnings, installState, target, dryRun = false
   config.mcp_servers = config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)
     ? config.mcp_servers
     : {};
-  if (!existing) {
-    config.mcp_servers[INTEGRATION_NAME] = cloneJson(CONTEXT_MODE_MCP_SERVER);
-    markMcpTargetOwned(installState, target);
-  }
+  config.mcp_servers[INTEGRATION_NAME] = mcpServerConfig(commandTarget);
+  markMcpTargetOwned(installState, target);
 
   if (JSON.stringify(config) === before) return false;
   return writeTomlIfChanged(filePath, config, dryRun);
@@ -333,7 +446,7 @@ function ensureCodexHook(config, phase, command) {
       continue;
     }
 
-    const nextHooks = entry.hooks.filter(hook => hook?.command !== command);
+    const nextHooks = entry.hooks.filter(hook => !isContextModeCommand(hook?.command));
     if (nextHooks.length === 0) continue;
     nextEntries.push(nextHooks.length === entry.hooks.length ? entry : { ...entry, hooks: nextHooks });
   }
@@ -343,14 +456,14 @@ function ensureCodexHook(config, phase, command) {
   return JSON.stringify(nextEntries) !== before;
 }
 
-function mergeCodexHooks(filePath, dryRun = false) {
+function mergeCodexHooks(filePath, commandTarget = BINARY_NAME, 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(CODEX_HOOK_COMMANDS)) {
+  for (const [phase, command] of Object.entries(codexHookCommands(commandTarget))) {
     changed = ensureCodexHook(config, phase, command) || changed;
   }
   return changed && writeJsonIfChanged(filePath, config, dryRun);
@@ -392,7 +505,7 @@ function ensureCursorHook(config, event, command) {
   config.hooks[event] = entries;
 }
 
-function mergeCursorHooks(filePath, dryRun = false) {
+function mergeCursorHooks(filePath, commandTarget = BINARY_NAME, dryRun = false) {
   const config = readJson(filePath, {});
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error(`Expected JSON object in ${filePath}`);
@@ -413,7 +526,7 @@ function mergeCursorHooks(filePath, dryRun = false) {
     else delete config.hooks[phase];
   }
 
-  for (const { event, command } of CURSOR_HOOK_COMMANDS) {
+  for (const { event, command } of cursorHookCommands(commandTarget)) {
     ensureCursorHook(config, event, command);
   }
 
@@ -449,45 +562,61 @@ function removeCursorHooks(filePath, dryRun = false) {
   return writeJsonIfChanged(filePath, config, dryRun);
 }
 
-function hasJsonMcpServer(filePath) {
+function hasJsonMcpServer(filePath, expectedCommand = null) {
   if (!existsSync(filePath)) return false;
   try {
-    return readJson(filePath, {}).mcpServers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
+    const server = readJson(filePath, {}).mcpServers?.[INTEGRATION_NAME];
+    return expectedCommand
+      ? isExpectedMcpServer(server, expectedCommand)
+      : isContextModeMcpCommand(server?.command);
   } catch {
     return false;
   }
 }
 
-function hasCodexMcpServer(filePath) {
+function hasCodexMcpServer(filePath, expectedCommand = null) {
   if (!existsSync(filePath)) return false;
   try {
     const config = TOML.parse(readFileSync(filePath, 'utf8'));
-    return config.mcp_servers?.[INTEGRATION_NAME]?.command === BINARY_NAME;
+    const server = config.mcp_servers?.[INTEGRATION_NAME];
+    return expectedCommand
+      ? isExpectedMcpServer(server, expectedCommand)
+      : isContextModeMcpCommand(server?.command);
   } catch {
     return false;
   }
 }
 
-function hasCodexHookCoverage(filePath) {
+function hasCodexHookCoverage(filePath, commandTarget = null) {
   if (!existsSync(filePath)) return false;
   try {
     const config = readJson(filePath, {});
-    return Object.entries(CODEX_HOOK_COMMANDS).every(([phase, command]) =>
+    const expectedCommands = commandTarget ? codexHookCommands(commandTarget) : null;
+    return Object.keys(codexHookCommands()).every(phase =>
       Array.isArray(config.hooks?.[phase])
-      && config.hooks[phase].some(entry => isCanonicalCodexHookEntry(entry, phase, command))
+      && config.hooks[phase].some(entry =>
+        hasCanonicalCodexMatcher(entry, phase)
+        && Array.isArray(entry?.hooks)
+        && entry.hooks.some(hook => expectedCommands
+          ? hook?.command === expectedCommands[phase]
+          : isContextModeCommand(hook?.command))
+      )
     );
   } catch {
     return false;
   }
 }
 
-function hasCursorHookCoverage(filePath) {
+function hasCursorHookCoverage(filePath, commandTarget = null) {
   if (!existsSync(filePath)) return false;
   try {
     const config = readJson(filePath, {});
-    return CURSOR_HOOK_COMMANDS.every(({ event, command }) =>
+    const expectedCommands = commandTarget ? cursorHookCommands(commandTarget) : null;
+    return cursorHookCommands().every(({ event }) =>
       Array.isArray(config.hooks?.[event])
-      && config.hooks[event].some(entry => entry?.command === command && entry?.event === event)
+      && config.hooks[event].some(entry => entry?.event === event && (expectedCommands
+        ? entry?.command === expectedCommands.find(command => command.event === event)?.command
+        : isContextModeCommand(entry?.command)))
     );
   } catch {
     return false;
@@ -502,12 +631,12 @@ function hasAnyContextModeConfig(home) {
     || hasJsonMcpServer(join(home, '.claude.json'));
 }
 
-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'));
+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);
 }
 
 export function isContextModeRequested(args = {}, env = process.env) {
@@ -531,6 +660,10 @@ export function detectContextModeBinary(options = {}) {
     };
   }
 
+  return describeContextModeBinary(binaryPath, env, 'path');
+}
+
+function describeContextModeBinary(binaryPath, env = process.env, source = 'path') {
   const versionEnv = {
     ...process.env,
     ...env,
@@ -557,11 +690,85 @@ export function detectContextModeBinary(options = {}) {
   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;
@@ -569,24 +776,31 @@ export function ensureContextModeIntegration(home, options = {}) {
   const changedFiles = [];
   const configuredHarnesses = [];
   const installState = readInstallState(home);
-  const binary = detectContextModeBinary({ env });
+  const binaryResult = ensureContextModeBinary({ ...options, env, home, dryRun });
+  warnings.push(...binaryResult.warnings);
+  const binary = binaryResult.binary;
 
   if (!binary.present) {
     return {
       changedFiles,
-      warnings: [`context-mode binary is required before config mutation: ${binary.reason}`],
+      warnings: warnings.length > 0 ? 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, 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)],
+    ['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)],
   ];
 
   for (const [label, filePath, update] of updates) {
@@ -600,12 +814,21 @@ 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,
   };
 }
 
@@ -640,15 +863,15 @@ export function removeContextModeIntegration(home, options = {}) {
 
 export function getContextModeIntegrationSummary(home, options = {}) {
   const env = options.env || process.env;
-  const binary = detectContextModeBinary({ env });
+  const binary = resolveContextModeExecutable({ ...options, env, home });
   const hasAnyConfig = hasAnyContextModeConfig(home);
-  const configured = binary.present && hasCompleteContextModeConfig(home);
+  const configured = binary.present && hasCompleteContextModeConfig(home, commandTargetForBinary(binary));
   const state = configured ? 'configured' : hasAnyConfig ? 'broken' : 'absent';
   const summary = configured
     ? `context-mode configured (${binary.version || 'version unknown'})`
     : hasAnyConfig
-      ? `context-mode partially configured; run aw integration add ${INTEGRATION_NAME}`
-      : `context-mode not configured${binary.present ? '' : '; binary not installed'}`;
+      ? `context-mode partially configured; run aw integrations add ${INTEGRATION_NAME}`
+      : `context-mode not configured${binary.present ? `; binary discoverable via ${binary.source}` : '; binary not installed'}`;
 
   return {
     name: INTEGRATION_NAME,
@@ -680,7 +903,7 @@ export function getContextModeDoctorStatus(home, options = {}) {
       title: 'Context Mode integration',
       status: 'warn',
       summary: summary.summary,
-      fix: `Run \`aw integration add ${INTEGRATION_NAME}\` to repair or \`aw integration remove ${INTEGRATION_NAME}\` to clean it up.`,
+      fix: `Run \`aw integrations add ${INTEGRATION_NAME}\` to repair or \`aw integrations remove ${INTEGRATION_NAME}\` to clean it up.`,
     }];
   }