Tighten Codex plugin hook migration

Author: ScriptedAlchemy

src/agents/codex.rs

@@ -125,9 +125,8 @@ impl AgentIntegration for CodexIntegration {
             return Ok(UpdatePluginOutcome::Refreshed(refreshed));
         }
 
-        let target = if codex_plugin_manifest_path(&ctx.home).exists()
-            || codex_legacy_config_has_tracedecay(&ctx.home)
-        {
+        let legacy_config_install = codex_legacy_config_has_tracedecay(&ctx.home);
+        let target = if codex_plugin_manifest_path(&ctx.home).exists() || legacy_config_install {
             Some(plugin_dir.clone())
         } else {
             None
@@ -137,6 +136,9 @@ impl AgentIntegration for CodexIntegration {
             return Ok(UpdatePluginOutcome::NotInstalled);
         };
         install_codex_personal_bootstrap(&ctx.home, &ctx.tracedecay_bin)?;
+        if legacy_config_install {
+            sweep_legacy_global_codex_config(&ctx.home);
+        }
         Ok(UpdatePluginOutcome::Refreshed(vec![target]))
     }
 
@@ -193,11 +195,7 @@ impl AgentIntegration for CodexIntegration {
         eprintln!("\n\x1b[1mCodex CLI integration\x1b[0m");
         let local_plugin_dir = codex_repo_plugin_install_dir(&ctx.project_path);
         if local_plugin_dir.join(".codex-plugin/plugin.json").exists() {
-            doctor_check_plugin_dir(
-                dc,
-                &local_plugin_dir,
-                Some(&ctx.home.join(".codex/config.toml")),
-            );
+            doctor_check_plugin_dir(dc, &local_plugin_dir, None);
             doctor_check_marketplace_entry(
                 dc,
                 &codex_repo_marketplace_path(&ctx.project_path),
@@ -483,8 +481,9 @@ fn write_codex_plugin_files(
 ) -> Result<()> {
     for (relative, contents) in codex_embedded_plugin_files() {
         let rendered = match relative {
-            ".codex-plugin/plugin.json" => codex_plugin_manifest(contents)?,
+            ".codex-plugin/plugin.json" => codex_plugin_manifest(contents, scope)?,
             ".mcp.json" => codex_plugin_mcp(contents, tracedecay_bin, scope)?,
+            "hooks/hooks.json" if scope == InstallScope::ProjectLocal => continue,
             "hooks/hooks.json" => codex_plugin_hooks(contents, tracedecay_bin)?,
             _ => contents.to_string(),
         };
@@ -493,8 +492,17 @@ fn write_codex_plugin_files(
     Ok(())
 }
 
-fn codex_plugin_manifest(raw: &str) -> Result<String> {
-    super::plugin_bundle::stamp_manifest_version(raw)
+fn codex_plugin_manifest(raw: &str, scope: InstallScope) -> Result<String> {
+    let stamped = super::plugin_bundle::stamp_manifest_version(raw)?;
+    if scope != InstallScope::ProjectLocal {
+        return Ok(stamped);
+    }
+
+    let mut manifest: serde_json::Value = serde_json::from_str(&stamped)?;
+    if let Some(object) = manifest.as_object_mut() {
+        object.remove("hooks");
+    }
+    Ok(format!("{}\n", serde_json::to_string_pretty(&manifest)?))
 }
 
 fn codex_plugin_mcp(raw: &str, tracedecay_bin: &str, scope: InstallScope) -> Result<String> {
@@ -1311,7 +1319,9 @@ fn doctor_check_plugin_dir(dc: &mut DoctorCounters, plugin_dir: &Path, config_pa
             mcp_path.display()
         ));
     }
-    doctor_check_hooks(dc, &plugin_dir.join("hooks/hooks.json"), config_path);
+    if let Some(config_path) = config_path {
+        doctor_check_hooks(dc, &plugin_dir.join("hooks/hooks.json"), Some(config_path));
+    }
 }
 
 /// Check hooks.json registers the tracedecay lifecycle hooks, and report Codex

tests/agent_suite/agent_test.rs

@@ -389,22 +389,29 @@ fn assert_codex_plugin_bundle(
     plugin_dir: &Path,
     expected_command: &str,
     expected_args: serde_json::Value,
-    expected_global_env: bool,
+    expected_global_bundle: bool,
 ) {
     let manifest = read_json(&plugin_dir.join(".codex-plugin/plugin.json"));
     assert_eq!(manifest["name"], "tracedecay");
     assert_eq!(manifest["version"], env!("CARGO_PKG_VERSION"));
     assert_eq!(manifest["license"], "MIT");
     assert_eq!(manifest["skills"], "./skills/");
     assert_eq!(manifest["mcpServers"], "./.mcp.json");
-    assert_eq!(manifest["hooks"], "./hooks/hooks.json");
+    if expected_global_bundle {
+        assert_eq!(manifest["hooks"], "./hooks/hooks.json");
+    } else {
+        assert!(
+            manifest.get("hooks").is_none(),
+            "repo-local Codex plugin should not declare lifecycle hooks"
+        );
+    }
 
     let mcp = read_json(&plugin_dir.join(".mcp.json"));
     let server = &mcp["mcpServers"]["tracedecay"];
     assert_eq!(server["type"], "stdio");
     assert_eq!(server["command"], expected_command);
     assert_eq!(server["args"], expected_args);
-    if expected_global_env {
+    if expected_global_bundle {
         assert_eq!(server["env"]["TRACEDECAY_ENABLE_GLOBAL_DB"], "1");
     } else {
         assert!(
@@ -413,14 +420,22 @@ fn assert_codex_plugin_bundle(
         );
     }
 
-    let hooks = read_json(&plugin_dir.join("hooks/hooks.json"));
-    assert_codex_hooks_registered(&hooks);
-    assert_command_contains_expected_bin(
-        &hooks,
-        "SessionStart",
-        "hook-codex-session-start",
-        expected_command,
-    );
+    let hooks_path = plugin_dir.join("hooks/hooks.json");
+    if expected_global_bundle {
+        let hooks = read_json(&hooks_path);
+        assert_codex_hooks_registered(&hooks);
+        assert_command_contains_expected_bin(
+            &hooks,
+            "SessionStart",
+            "hook-codex-session-start",
+            expected_command,
+        );
+    } else {
+        assert!(
+            !hooks_path.exists(),
+            "repo-local Codex plugin should not ship lifecycle hooks"
+        );
+    }
 
     let skill = std::fs::read_to_string(plugin_dir.join("skills/exploring-code/SKILL.md"))
         .expect("Codex plugin should ship tracedecay steering skills");
@@ -3463,7 +3478,7 @@ fn test_codex_local_install_creates_repo_plugin_bundle_and_marketplace() {
     );
     assert!(
         !project.path().join(".codex/hooks.json").exists(),
-        "local Codex install should bundle hooks in the repo plugin"
+        "local Codex install should not write project Codex hooks"
     );
     assert!(
         !project.path().join("AGENTS.md").exists(),
@@ -3628,22 +3643,17 @@ fn test_codex_global_install_bundles_hooks_in_plugin() {
 }
 
 #[test]
-fn test_codex_local_install_bundles_hooks_in_plugin() {
+fn test_codex_local_install_does_not_bundle_hooks() {
     let home = TempDir::new().unwrap();
     let project = TempDir::new().unwrap();
 
     assert_local_install_success("codex", project.path(), home.path());
 
     let hooks_path = codex_project_plugin_install_dir(project.path()).join("hooks/hooks.json");
     assert!(
-        hooks_path.exists(),
-        "local Codex install should bundle hooks in the repo plugin"
+        !hooks_path.exists(),
+        "local Codex install should not bundle project-local hooks"
     );
-    let hooks = read_json(&hooks_path);
-    assert_codex_hooks_registered(&hooks);
-    // Local install must use the resolved absolute tracedecay binary path.
-    assert_command_contains_bin(&hooks, "SessionStart", "hook-codex-session-start");
-
     assert!(
         !home.path().join(".codex/hooks.json").exists(),
         "local install must not write the global Codex hooks config"
@@ -3654,11 +3664,6 @@ fn test_codex_local_install_bundles_hooks_in_plugin() {
     );
 }
 
-fn assert_command_contains_bin(hooks: &serde_json::Value, event: &str, needle: &str) {
-    let expected = expected_tracedecay_bin();
-    assert_command_contains_expected_bin(hooks, event, needle, &expected);
-}
-
 fn assert_command_contains_expected_bin(
     hooks: &serde_json::Value,
     event: &str,

tests/agent_suite/update_plugin_test.rs

@@ -599,8 +599,6 @@ fn codex_update_plugin_migrates_legacy_config_only_install_to_plugin() {
         "[mcp_servers.tracedecay]\ncommand = \"/old/bin/tracedecay\"\nargs = [\"serve\"]\n",
     )
     .unwrap();
-    let before = bytes(&codex_dir.join("config.toml"));
-
     let codex = get_integration("codex").unwrap();
     let outcome = codex
         .update_plugin(&ctx_with_project(home.path(), NEW_BIN, &project_root))
@@ -609,7 +607,10 @@ fn codex_update_plugin_migrates_legacy_config_only_install_to_plugin() {
         panic!("expected codex update_plugin to migrate legacy config to plugin");
     };
     assert_eq!(paths, vec![home.path().join("plugins/tracedecay")]);
-    assert_eq!(bytes(&codex_dir.join("config.toml")), before);
+    assert!(
+        !codex_dir.join("config.toml").exists(),
+        "Codex update-plugin should remove the migrated legacy config-managed install"
+    );
     assert_codex_bundle_contains_bin(&home.path().join("plugins/tracedecay"), NEW_BIN);
     assert_codex_marketplace_entry(&codex_marketplace_path(home.path()), "./plugins/tracedecay");
 }