@ghl-ai/aw 0.1.37-beta.66 → 0.1.37-beta.68

package/commands/doctor.mjs

@@ -31,7 +31,21 @@ const CLAUDE_WINDOWS_HOOK_COMMAND = '"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd"
 const REPO_CLAUDE_SESSION_START_COMMAND = '"$CLAUDE_PROJECT_DIR"/hooks/aw-session-start';
 const CODEX_HOOK_MATCHER = 'startup|resume';
 const CODEX_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-session-start.sh"';
+const CODEX_PROMPT_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-user-prompt-submit.sh"';
+const CODEX_PRE_TOOL_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-pre-tool-use.sh"';
+const CODEX_POST_TOOL_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-post-tool-use.sh"';
+const CODEX_STOP_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-stop.sh"';
 const CURSOR_HOOK_COMMAND = 'node .cursor/hooks/session-start.js';
+const CURSOR_BEFORE_PROMPT_COMMAND = 'node .cursor/hooks/before-submit-prompt.js';
+
+function hasManagedHookCommand(entry, command) {
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook => hook?.type === 'command' && hook?.command === command);
+}
+
+function formatMissingParts(parts) {
+  return parts.length > 0 ? parts.join(', ') : 'none';
+}
 
 function projectRelinkFix(homeDir, cwd, targetDescription) {
   return cwd !== homeDir
@@ -245,6 +259,110 @@ function hasManagedCursorSessionStart(filePath) {
     );
 }
 
+function getClaudeHomeHookCoverage(homeDir) {
+  const hooksPath = join(homeDir, '.claude', 'hooks', 'hooks.json');
+  if (!existsSync(hooksPath)) {
+    return { ok: false, missingPhases: ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop'] };
+  }
+
+  const hooksConfig = readJson(hooksPath, {});
+  const sessionStartStatus = getClaudeHomeSessionStartStatus(homeDir);
+  const phases = {
+    SessionStart: sessionStartStatus.present && sessionStartStatus.ok && sessionStartStatus.reason !== 'missing',
+    UserPromptSubmit: Array.isArray(hooksConfig?.hooks?.UserPromptSubmit)
+      && hooksConfig.hooks.UserPromptSubmit.some(entry =>
+        Array.isArray(entry?.hooks)
+        && entry.hooks.some(hook => String(hook?.command || '').includes('session-start-rules-context.sh'))
+      ),
+    PreToolUse: Array.isArray(hooksConfig?.hooks?.PreToolUse) && hooksConfig.hooks.PreToolUse.length > 0,
+    PostToolUse: Array.isArray(hooksConfig?.hooks?.PostToolUse) && hooksConfig.hooks.PostToolUse.length > 0,
+    Stop: Array.isArray(hooksConfig?.hooks?.Stop) && hooksConfig.hooks.Stop.length > 0,
+  };
+
+  const missingPhases = Object.entries(phases)
+    .filter(([, present]) => !present)
+    .map(([phase]) => phase);
+
+  return { ok: missingPhases.length === 0, missingPhases };
+}
+
+function getCodexHomeHookCoverage(homeDir) {
+  const hooksPath = join(homeDir, '.codex', 'hooks.json');
+  const hooksConfig = readJson(hooksPath, {});
+  const phases = {
+    SessionStart: Array.isArray(hooksConfig?.hooks?.SessionStart)
+      && hooksConfig.hooks.SessionStart.some(entry =>
+        entry?.matcher === CODEX_HOOK_MATCHER
+        && hasManagedHookCommand(entry, CODEX_HOOK_COMMAND)
+      ),
+    UserPromptSubmit: Array.isArray(hooksConfig?.hooks?.UserPromptSubmit)
+      && hooksConfig.hooks.UserPromptSubmit.some(entry => hasManagedHookCommand(entry, CODEX_PROMPT_HOOK_COMMAND)),
+    PreToolUse: Array.isArray(hooksConfig?.hooks?.PreToolUse)
+      && hooksConfig.hooks.PreToolUse.some(entry => entry?.matcher === '*' && hasManagedHookCommand(entry, CODEX_PRE_TOOL_HOOK_COMMAND)),
+    PostToolUse: Array.isArray(hooksConfig?.hooks?.PostToolUse)
+      && hooksConfig.hooks.PostToolUse.some(entry => entry?.matcher === '*' && hasManagedHookCommand(entry, CODEX_POST_TOOL_HOOK_COMMAND)),
+    Stop: Array.isArray(hooksConfig?.hooks?.Stop)
+      && hooksConfig.hooks.Stop.some(entry => hasManagedHookCommand(entry, CODEX_STOP_HOOK_COMMAND)),
+  };
+
+  const scripts = {
+    SessionStart: existsSync(join(homeDir, '.codex', 'hooks', 'aw-session-start.sh')),
+    UserPromptSubmit: existsSync(join(homeDir, '.codex', 'hooks', 'aw-user-prompt-submit.sh')),
+    PreToolUse: existsSync(join(homeDir, '.codex', 'hooks', 'aw-pre-tool-use.sh')),
+    PostToolUse: existsSync(join(homeDir, '.codex', 'hooks', 'aw-post-tool-use.sh')),
+    Stop: existsSync(join(homeDir, '.codex', 'hooks', 'aw-stop.sh')),
+  };
+
+  const missingPhases = Object.entries(phases)
+    .filter(([, present]) => !present)
+    .map(([phase]) => phase);
+  const missingScripts = Object.entries(scripts)
+    .filter(([, present]) => !present)
+    .map(([phase]) => phase);
+
+  return { ok: missingPhases.length === 0 && missingScripts.length === 0, missingPhases, missingScripts };
+}
+
+function getCursorHomeHookCoverage(homeDir) {
+  const hooksPath = join(homeDir, '.cursor', 'hooks.json');
+  const hooksConfig = readJson(hooksPath, {});
+  const phases = {
+    SessionStart: Array.isArray(hooksConfig?.hooks?.sessionStart) && hooksConfig.hooks.sessionStart.length > 0,
+    UserPromptSubmit: Array.isArray(hooksConfig?.hooks?.beforeSubmitPrompt) && hooksConfig.hooks.beforeSubmitPrompt.length > 0,
+    PreToolUse: Array.isArray(hooksConfig?.hooks?.beforeShellExecution)
+      && hooksConfig.hooks.beforeShellExecution.length > 0
+      && Array.isArray(hooksConfig?.hooks?.beforeMCPExecution)
+      && hooksConfig.hooks.beforeMCPExecution.length > 0,
+    PostToolUse: Array.isArray(hooksConfig?.hooks?.afterShellExecution)
+      && hooksConfig.hooks.afterShellExecution.length > 0
+      && Array.isArray(hooksConfig?.hooks?.afterFileEdit)
+      && hooksConfig.hooks.afterFileEdit.length > 0
+      && Array.isArray(hooksConfig?.hooks?.afterMCPExecution)
+      && hooksConfig.hooks.afterMCPExecution.length > 0,
+    Stop: Array.isArray(hooksConfig?.hooks?.stop) && hooksConfig.hooks.stop.length > 0,
+  };
+
+  const scripts = {
+    SessionStart: existsSync(join(homeDir, '.cursor', 'hooks', 'session-start.js')),
+    UserPromptSubmit: existsSync(join(homeDir, '.cursor', 'hooks', 'before-submit-prompt.js')),
+    PreToolUse: existsSync(join(homeDir, '.cursor', 'hooks', 'before-shell-execution.js'))
+      && existsSync(join(homeDir, '.cursor', 'hooks', 'before-mcp-execution.js')),
+    PostToolUse: existsSync(join(homeDir, '.cursor', 'hooks', 'after-shell-execution.js'))
+      && existsSync(join(homeDir, '.cursor', 'hooks', 'after-file-edit.js'))
+      && existsSync(join(homeDir, '.cursor', 'hooks', 'after-mcp-execution.js')),
+    Stop: existsSync(join(homeDir, '.cursor', 'hooks', 'stop.js')),
+  };
+
+  const missingPhases = Object.entries(phases)
+    .filter(([, present]) => !present)
+    .map(([phase]) => phase);
+  const missingScripts = Object.entries(scripts)
+    .filter(([, present]) => !present)
+    .map(([phase]) => phase);
+
+  return { ok: missingPhases.length === 0 && missingScripts.length === 0, missingPhases, missingScripts };
+}
+
 function getClaudePluginSessionStartStatus(pluginRoot) {
   const hooksConfig = readJson(join(pluginRoot, 'hooks', 'hooks.json'), {});
   if (!Array.isArray(hooksConfig?.hooks?.SessionStart)) {
@@ -556,6 +674,7 @@ function buildDoctorChecks(homeDir, cwd) {
 
   const claudeLegacyHooks = parseLegacyClaudeHookTargets(claudeSettings?.hooks?.SessionStart || []);
   const claudeHomeSessionStartStatus = getClaudeHomeSessionStartStatus(homeDir);
+  const claudeHomeHookCoverage = getClaudeHomeHookCoverage(homeDir);
   if (claudeLegacyHooks.length > 0) {
     const brokenTargets = claudeLegacyHooks.filter(target => !target.path || !existsSync(target.path));
     checks.push(makeCheck(
@@ -583,6 +702,18 @@ function buildDoctorChecks(homeDir, cwd) {
     checks.push(makeCheck('claude-session-start', 'Claude session-start hook', 'pass', 'No stale Claude SessionStart override detected'));
   }
 
+  checks.push(
+    claudeHomeHookCoverage.ok
+      ? makeCheck('claude-home-hooks', 'Claude home hook phases', 'pass', 'Claude home hooks cover SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop')
+      : makeCheck(
+        'claude-home-hooks',
+        'Claude home hook phases',
+        'fail',
+        `Claude home hooks are missing core phases: ${formatMissingParts(claudeHomeHookCoverage.missingPhases)}`,
+        'Run `aw init` to refresh ~/.claude/hooks/hooks.json with the full home-level AW hook phase set.',
+      ),
+  );
+
   const claudeInstallStatePath = join(homeDir, '.claude', 'ecc', 'install-state.json');
   checks.push(existsSync(claudeInstallStatePath)
     ? makeCheck('claude-install-state', 'Claude install state', 'pass', 'Claude install-state file is present')
@@ -675,14 +806,15 @@ function buildDoctorChecks(homeDir, cwd) {
   const codexConfigPath = join(homeDir, '.codex', 'config.toml');
   const codexHooksPath = join(homeDir, '.codex', 'hooks.json');
   const codexRuntimePath = join(homeDir, '.codex', 'hooks', 'aw-session-start.sh');
-  const codexHealthy = startup.codexHooksEnabled && hasManagedCodexSessionStart(codexHooksPath) && startup.codexSessionStartScriptInstalled;
+  const codexHomeHookCoverage = getCodexHomeHookCoverage(homeDir);
+  const codexHealthy = startup.codexHooksEnabled && codexHomeHookCoverage.ok;
   checks.push(codexHealthy
-    ? makeCheck('codex-routing', 'Codex routing', 'pass', 'Codex hooks, config, and runtime script are installed')
+    ? makeCheck('codex-routing', 'Codex routing', 'pass', 'Codex home hooks cover SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop')
     : makeCheck(
       'codex-routing',
       'Codex routing',
       startup.mode === 'disabled' ? 'warn' : 'fail',
-      `Codex routing incomplete (codex_hooks=${parseCodexHooksFile(codexConfigPath)}, hooks.json=${existsSync(codexHooksPath)}, runtime=${existsSync(codexRuntimePath)})`,
+      `Codex routing incomplete (codex_hooks=${parseCodexHooksFile(codexConfigPath)}, missing phases=${formatMissingParts(codexHomeHookCoverage.missingPhases)}, missing scripts=${formatMissingParts(codexHomeHookCoverage.missingScripts)})`,
       'Run `aw routing enable` or `aw init` to restore Codex startup wiring.',
     ),
   );
@@ -766,14 +898,15 @@ function buildDoctorChecks(homeDir, cwd) {
 
   const cursorHooksPath = join(homeDir, '.cursor', 'hooks.json');
   const cursorRuntimePath = join(homeDir, '.cursor', 'hooks', 'session-start.js');
-  const cursorHealthy = hasManagedCursorSessionStart(cursorHooksPath) && startup.cursorSessionStartScriptInstalled;
+  const cursorHomeHookCoverage = getCursorHomeHookCoverage(homeDir);
+  const cursorHealthy = cursorHomeHookCoverage.ok;
   checks.push(cursorHealthy
-    ? makeCheck('cursor-routing', 'Cursor routing', 'pass', 'Cursor sessionStart hook and runtime script are installed')
+    ? makeCheck('cursor-routing', 'Cursor routing', 'pass', 'Cursor home hooks cover sessionStart, beforeSubmitPrompt, pre-tool, post-tool, and stop phases')
     : makeCheck(
       'cursor-routing',
       'Cursor routing',
       startup.mode === 'disabled' ? 'warn' : 'fail',
-      `Cursor routing incomplete (hooks.json=${existsSync(cursorHooksPath)}, runtime=${existsSync(cursorRuntimePath)})`,
+      `Cursor routing incomplete (missing phases=${formatMissingParts(cursorHomeHookCoverage.missingPhases)}, missing scripts=${formatMissingParts(cursorHomeHookCoverage.missingScripts)})`,
       'Run `aw routing enable` or `aw init` to restore Cursor startup wiring.',
     ),
   );

package/commands/init.mjs

@@ -277,6 +277,7 @@ export async function initCommand(args) {
     ensureAwRuntimeHook(HOME);
     syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
+    applyStoredStartupPreferences(HOME);
     const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
     installGlobalHooks();
 

package/integrate.mjs

@@ -106,6 +106,8 @@ function shouldResetHomeInstructionFile(content, file) {
     : [
       '# AGENTS.md — ',
       '# ECC for Codex CLI',
+      '# AW SDLC Repo Instructions',
+      'Use the repo-local AW SDLC files as the source of truth for routing and stage behavior.',
       '<!-- BEGIN ECC -->',
     ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.66",
+  "version": "0.1.37-beta.68",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {

package/startup.mjs

@@ -11,6 +11,14 @@ const CODEX_HOOK_MATCHER = 'startup|resume';
 const CODEX_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-session-start.sh"';
 const CODEX_HOOK_STATUS = 'Loading AW router';
 const CODEX_HOOK_MARKER = '# aw-managed: codex-global-session-start';
+const CODEX_PROMPT_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-user-prompt-submit.sh"';
+const CODEX_PRE_TOOL_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-pre-tool-use.sh"';
+const CODEX_POST_TOOL_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-post-tool-use.sh"';
+const CODEX_STOP_HOOK_COMMAND = 'bash "$HOME/.codex/hooks/aw-stop.sh"';
+const CODEX_PROMPT_HOOK_MARKER = '# aw-managed: codex-global-user-prompt-submit';
+const CODEX_PRE_TOOL_HOOK_MARKER = '# aw-managed: codex-global-pre-tool-use';
+const CODEX_POST_TOOL_HOOK_MARKER = '# aw-managed: codex-global-post-tool-use';
+const CODEX_STOP_HOOK_MARKER = '# aw-managed: codex-global-stop';
 const CURSOR_SESSION_START_COMMAND = 'node .cursor/hooks/session-start.js';
 const CURSOR_SESSION_START_DESCRIPTION = 'Load previous context and detect environment';
 const REPO_CURSOR_SESSION_START_COMMAND = 'bash "$(git rev-parse --show-toplevel)/hooks/aw-session-start"';
@@ -40,6 +48,32 @@ JSON_CONTEXT=$(printf '%s' "\$CONTEXT" | python3 -c 'import json, sys; print(jso
 echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"SessionStart\\",\\"additionalContext\\":\${JSON_CONTEXT}}}"
 `;
 
+const CODEX_PROMPT_HOOK_SCRIPT = `#!/usr/bin/env bash
+${CODEX_PROMPT_HOOK_MARKER}
+set -euo pipefail
+
+TARGET="$HOME/.aw-ecc/scripts/hooks/session-start-rules-context.sh"
+if [[ -f "$TARGET" ]]; then
+  exec bash "$TARGET"
+fi
+
+exit 0
+`;
+
+function buildCodexLifecycleNoopScript(marker, label) {
+  return `#!/usr/bin/env bash
+${marker}
+set -euo pipefail
+
+# Reserved AW ${label} phase for Codex home routing.
+exit 0
+`;
+}
+
+const CODEX_PRE_TOOL_HOOK_SCRIPT = buildCodexLifecycleNoopScript(CODEX_PRE_TOOL_HOOK_MARKER, 'PreToolUse');
+const CODEX_POST_TOOL_HOOK_SCRIPT = buildCodexLifecycleNoopScript(CODEX_POST_TOOL_HOOK_MARKER, 'PostToolUse');
+const CODEX_STOP_HOOK_SCRIPT = buildCodexLifecycleNoopScript(CODEX_STOP_HOOK_MARKER, 'Stop');
+
 function startupPrefsPath(homeDir = homedir()) {
   return join(homeDir, '.aw', STARTUP_PREFS_FILENAME);
 }
@@ -52,6 +86,22 @@ function codexHookScriptPath(homeDir = homedir()) {
   return join(homeDir, '.codex', 'hooks', 'aw-session-start.sh');
 }
 
+function codexPromptHookScriptPath(homeDir = homedir()) {
+  return join(homeDir, '.codex', 'hooks', 'aw-user-prompt-submit.sh');
+}
+
+function codexPreToolHookScriptPath(homeDir = homedir()) {
+  return join(homeDir, '.codex', 'hooks', 'aw-pre-tool-use.sh');
+}
+
+function codexPostToolHookScriptPath(homeDir = homedir()) {
+  return join(homeDir, '.codex', 'hooks', 'aw-post-tool-use.sh');
+}
+
+function codexStopHookScriptPath(homeDir = homedir()) {
+  return join(homeDir, '.codex', 'hooks', 'aw-stop.sh');
+}
+
 function resolveRegistryRoot(homeDir = homedir()) {
   return [
     join(homeDir, '.aw_registry'),
@@ -77,6 +127,27 @@ function writeJson(filePath, value) {
   writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
 
+function ensureManagedFile(filePath, content, updatedFiles) {
+  const current = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  if (!existsSync(filePath) || current !== content) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+    updatedFiles.push(filePath);
+  }
+}
+
+function removeManagedFile(filePath, marker, updatedFiles) {
+  if (!existsSync(filePath)) return;
+  try {
+    const current = readFileSync(filePath, 'utf8');
+    if (!current.includes(marker)) return;
+    rmSync(filePath, { force: true });
+    updatedFiles.push(filePath);
+  } catch {
+    /* best effort */
+  }
+}
+
 function isObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -121,22 +192,43 @@ function isLegacyClaudeSessionStartEntry(entry) {
     );
 }
 
-function isManagedCodexSessionStartEntry(entry) {
-  return entry?.matcher === CODEX_HOOK_MATCHER
-    && Array.isArray(entry?.hooks)
+function hasCommandHook(entry, command) {
+  return Array.isArray(entry?.hooks)
     && entry.hooks.some(hook =>
       hook?.type === 'command'
-      && hook?.command === CODEX_HOOK_COMMAND
+      && hook?.command === command
     );
 }
 
+function isManagedCodexSessionStartEntry(entry) {
+  return entry?.matcher === CODEX_HOOK_MATCHER && hasCommandHook(entry, CODEX_HOOK_COMMAND);
+}
+
 function isLegacyCodexSessionStartEntry(entry) {
   return Array.isArray(entry?.hooks)
-    && entry.hooks.some(hook =>
-      hook?.type === 'command'
-      && typeof hook?.command === 'string'
-      && hook.command.includes('.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh')
-    );
+    && entry.hooks.some(hook => {
+      const command = String(hook?.command || '');
+      return (
+        command.includes('.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh')
+        || (command.includes('.codex/hooks/aw-session-start.sh') && entry?.matcher !== CODEX_HOOK_MATCHER)
+      );
+    });
+}
+
+function isManagedCodexPromptSubmitEntry(entry) {
+  return hasCommandHook(entry, CODEX_PROMPT_HOOK_COMMAND);
+}
+
+function isManagedCodexPreToolUseEntry(entry) {
+  return entry?.matcher === '*' && hasCommandHook(entry, CODEX_PRE_TOOL_HOOK_COMMAND);
+}
+
+function isManagedCodexPostToolUseEntry(entry) {
+  return entry?.matcher === '*' && hasCommandHook(entry, CODEX_POST_TOOL_HOOK_COMMAND);
+}
+
+function isManagedCodexStopEntry(entry) {
+  return hasCommandHook(entry, CODEX_STOP_HOOK_COMMAND);
 }
 
 function disableClaudeStartup(homeDir = homedir()) {
@@ -270,13 +362,11 @@ function enableCodexStartup(homeDir = homedir()) {
     updatedFiles.push(configPath);
   }
 
-  const hookScriptPath = codexHookScriptPath(homeDir);
-  const currentHookScript = existsSync(hookScriptPath) ? readFileSync(hookScriptPath, 'utf8') : '';
-  if (!existsSync(hookScriptPath) || currentHookScript !== CODEX_HOOK_SCRIPT) {
-    mkdirSync(dirname(hookScriptPath), { recursive: true });
-    writeFileSync(hookScriptPath, CODEX_HOOK_SCRIPT);
-    updatedFiles.push(hookScriptPath);
-  }
+  ensureManagedFile(codexHookScriptPath(homeDir), CODEX_HOOK_SCRIPT, updatedFiles);
+  ensureManagedFile(codexPromptHookScriptPath(homeDir), CODEX_PROMPT_HOOK_SCRIPT, updatedFiles);
+  ensureManagedFile(codexPreToolHookScriptPath(homeDir), CODEX_PRE_TOOL_HOOK_SCRIPT, updatedFiles);
+  ensureManagedFile(codexPostToolHookScriptPath(homeDir), CODEX_POST_TOOL_HOOK_SCRIPT, updatedFiles);
+  ensureManagedFile(codexStopHookScriptPath(homeDir), CODEX_STOP_HOOK_SCRIPT, updatedFiles);
 
   const hooksPath = join(homeDir, '.codex', 'hooks.json');
   const config = readJson(hooksPath, {});
@@ -285,24 +375,98 @@ function enableCodexStartup(homeDir = homedir()) {
     config.hooks = {};
   }
 
-  const current = Array.isArray(config.hooks.SessionStart) ? config.hooks.SessionStart : [];
-  const cleaned = current.filter(entry => !isLegacyCodexSessionStartEntry(entry) && !isManagedCodexSessionStartEntry(entry));
-  const hasManagedEntry = current.some(isManagedCodexSessionStartEntry);
-
-  if (!hasManagedEntry || cleaned.length !== current.length) {
-    config.hooks.SessionStart = [
-      ...cleaned,
-      {
-        matcher: CODEX_HOOK_MATCHER,
-        hooks: [
-          {
-            type: 'command',
-            command: CODEX_HOOK_COMMAND,
-            statusMessage: CODEX_HOOK_STATUS,
-          },
-        ],
-      },
-    ];
+  let hooksChanged = false;
+
+  const currentSessionStart = Array.isArray(config.hooks.SessionStart) ? config.hooks.SessionStart : [];
+  const nextSessionStart = [
+    ...currentSessionStart.filter(entry => !isLegacyCodexSessionStartEntry(entry) && !isManagedCodexSessionStartEntry(entry)),
+    {
+      matcher: CODEX_HOOK_MATCHER,
+      hooks: [
+        {
+          type: 'command',
+          command: CODEX_HOOK_COMMAND,
+          statusMessage: CODEX_HOOK_STATUS,
+        },
+      ],
+    },
+  ];
+  if (JSON.stringify(nextSessionStart) !== JSON.stringify(currentSessionStart)) {
+    config.hooks.SessionStart = nextSessionStart;
+    hooksChanged = true;
+  }
+
+  const currentPromptSubmit = Array.isArray(config.hooks.UserPromptSubmit) ? config.hooks.UserPromptSubmit : [];
+  const nextPromptSubmit = [
+    ...currentPromptSubmit.filter(entry => !isManagedCodexPromptSubmitEntry(entry)),
+    {
+      hooks: [
+        {
+          type: 'command',
+          command: CODEX_PROMPT_HOOK_COMMAND,
+        },
+      ],
+    },
+  ];
+  if (JSON.stringify(nextPromptSubmit) !== JSON.stringify(currentPromptSubmit)) {
+    config.hooks.UserPromptSubmit = nextPromptSubmit;
+    hooksChanged = true;
+  }
+
+  const currentPreToolUse = Array.isArray(config.hooks.PreToolUse) ? config.hooks.PreToolUse : [];
+  const nextPreToolUse = [
+    ...currentPreToolUse.filter(entry => !isManagedCodexPreToolUseEntry(entry)),
+    {
+      matcher: '*',
+      hooks: [
+        {
+          type: 'command',
+          command: CODEX_PRE_TOOL_HOOK_COMMAND,
+        },
+      ],
+    },
+  ];
+  if (JSON.stringify(nextPreToolUse) !== JSON.stringify(currentPreToolUse)) {
+    config.hooks.PreToolUse = nextPreToolUse;
+    hooksChanged = true;
+  }
+
+  const currentPostToolUse = Array.isArray(config.hooks.PostToolUse) ? config.hooks.PostToolUse : [];
+  const nextPostToolUse = [
+    ...currentPostToolUse.filter(entry => !isManagedCodexPostToolUseEntry(entry)),
+    {
+      matcher: '*',
+      hooks: [
+        {
+          type: 'command',
+          command: CODEX_POST_TOOL_HOOK_COMMAND,
+        },
+      ],
+    },
+  ];
+  if (JSON.stringify(nextPostToolUse) !== JSON.stringify(currentPostToolUse)) {
+    config.hooks.PostToolUse = nextPostToolUse;
+    hooksChanged = true;
+  }
+
+  const currentStop = Array.isArray(config.hooks.Stop) ? config.hooks.Stop : [];
+  const nextStop = [
+    ...currentStop.filter(entry => !isManagedCodexStopEntry(entry)),
+    {
+      hooks: [
+        {
+          type: 'command',
+          command: CODEX_STOP_HOOK_COMMAND,
+        },
+      ],
+    },
+  ];
+  if (JSON.stringify(nextStop) !== JSON.stringify(currentStop)) {
+    config.hooks.Stop = nextStop;
+    hooksChanged = true;
+  }
+
+  if (hooksChanged) {
     writeJson(hooksPath, config);
     updatedFiles.push(hooksPath);
   }
@@ -312,38 +476,84 @@ function enableCodexStartup(homeDir = homedir()) {
 
 function disableCodexStartup(homeDir = homedir()) {
   const updatedFiles = [];
-  const hookScriptPath = codexHookScriptPath(homeDir);
-  if (existsSync(hookScriptPath)) {
-    try {
-      const currentHookScript = readFileSync(hookScriptPath, 'utf8');
-      if (currentHookScript.includes(CODEX_HOOK_MARKER)) {
-        rmSync(hookScriptPath, { force: true });
-        updatedFiles.push(hookScriptPath);
-      }
-    } catch {
-      /* best effort */
-    }
-  }
+  removeManagedFile(codexHookScriptPath(homeDir), CODEX_HOOK_MARKER, updatedFiles);
+  removeManagedFile(codexPromptHookScriptPath(homeDir), CODEX_PROMPT_HOOK_MARKER, updatedFiles);
+  removeManagedFile(codexPreToolHookScriptPath(homeDir), CODEX_PRE_TOOL_HOOK_MARKER, updatedFiles);
+  removeManagedFile(codexPostToolHookScriptPath(homeDir), CODEX_POST_TOOL_HOOK_MARKER, updatedFiles);
+  removeManagedFile(codexStopHookScriptPath(homeDir), CODEX_STOP_HOOK_MARKER, updatedFiles);
 
   const hooksPath = join(homeDir, '.codex', 'hooks.json');
   if (!existsSync(hooksPath)) return updatedFiles;
 
   const config = readJson(hooksPath, {});
-  if (!isObject(config.hooks) || !Array.isArray(config.hooks.SessionStart)) {
+  if (!isObject(config.hooks)) {
     return updatedFiles;
   }
 
-  const filtered = config.hooks.SessionStart.filter(entry => !isManagedCodexSessionStartEntry(entry) && !isLegacyCodexSessionStartEntry(entry));
-  if (filtered.length === config.hooks.SessionStart.length) {
-    return updatedFiles;
+  let hooksChanged = false;
+
+  if (Array.isArray(config.hooks.SessionStart)) {
+    const filtered = config.hooks.SessionStart.filter(entry => !isManagedCodexSessionStartEntry(entry) && !isLegacyCodexSessionStartEntry(entry));
+    if (filtered.length !== config.hooks.SessionStart.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks.SessionStart = filtered;
+      } else {
+        delete config.hooks.SessionStart;
+      }
+    }
   }
 
-  if (filtered.length > 0) {
-    config.hooks.SessionStart = filtered;
-  } else {
-    delete config.hooks.SessionStart;
+  if (Array.isArray(config.hooks.UserPromptSubmit)) {
+    const filtered = config.hooks.UserPromptSubmit.filter(entry => !isManagedCodexPromptSubmitEntry(entry));
+    if (filtered.length !== config.hooks.UserPromptSubmit.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks.UserPromptSubmit = filtered;
+      } else {
+        delete config.hooks.UserPromptSubmit;
+      }
+    }
   }
 
+  if (Array.isArray(config.hooks.PreToolUse)) {
+    const filtered = config.hooks.PreToolUse.filter(entry => !isManagedCodexPreToolUseEntry(entry));
+    if (filtered.length !== config.hooks.PreToolUse.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks.PreToolUse = filtered;
+      } else {
+        delete config.hooks.PreToolUse;
+      }
+    }
+  }
+
+  if (Array.isArray(config.hooks.PostToolUse)) {
+    const filtered = config.hooks.PostToolUse.filter(entry => !isManagedCodexPostToolUseEntry(entry));
+    if (filtered.length !== config.hooks.PostToolUse.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks.PostToolUse = filtered;
+      } else {
+        delete config.hooks.PostToolUse;
+      }
+    }
+  }
+
+  if (Array.isArray(config.hooks.Stop)) {
+    const filtered = config.hooks.Stop.filter(entry => !isManagedCodexStopEntry(entry));
+    if (filtered.length !== config.hooks.Stop.length) {
+      hooksChanged = true;
+      if (filtered.length > 0) {
+        config.hooks.Stop = filtered;
+      } else {
+        delete config.hooks.Stop;
+      }
+    }
+  }
+
+  if (!hooksChanged) return updatedFiles;
+
   if (isEmptyObject(config.hooks)) {
     delete config.hooks;
   }