Merge pull request #246 from ScriptedAlchemy/feat/upgrade-refreshes-plugins

feat(upgrade): refresh all configured agent integrations during upgrade

Author: ScriptedAlchemy

src/agent_cmd.rs

@@ -420,24 +420,20 @@ pub(crate) async fn handle_reinstall_command() -> tracedecay::errors::Result<()>
         eprintln!("No installed agents found. Run `tracedecay install` first.");
     } else {
         let agents = user_cfg.installed_agents.clone();
-        let project_path = std::env::current_dir().ok();
         eprintln!(
             "Reinstalling {} agent(s): {}",
             agents.len(),
             agents.join(", ")
         );
-        for id in &agents {
-            let ag = tracedecay::agents::get_integration(id)?;
-            let ctx = tracedecay::agents::InstallContext {
-                home: home.clone(),
-                tracedecay_bin: tracedecay_bin.clone(),
-                tool_permissions: tracedecay::agents::expected_tool_perms(),
-                profile: None,
-                project_root: None,
-                dashboard: true,
-            };
-            ag.install(&ctx)?;
-            ag.post_install(project_path.as_deref()).await;
+        let results = reinstall_agent_integrations(&agents, &home, &tracedecay_bin).await;
+        let failed: Vec<String> = results
+            .iter()
+            .filter_map(|(id, result)| result.as_ref().err().map(|_| id.clone()))
+            .collect();
+        if !failed.is_empty() {
+            return Err(tracedecay::errors::TraceDecayError::Config {
+                message: format!("failed to reinstall agent(s): {}", failed.join(", ")),
+            });
         }
         eprintln!("\x1b[32m✔\x1b[0m All agents reinstalled");
         user_cfg.last_installed_version = env!("CARGO_PKG_VERSION").to_string();
@@ -446,6 +442,56 @@ pub(crate) async fn handle_reinstall_command() -> tracedecay::errors::Result<()>
     Ok(())
 }
 
+/// Re-runs `install()` + `post_install()` for each tracked agent id, returning
+/// only the ids that resolve to a real integration paired with their install
+/// result.
+///
+/// An id that does NOT resolve to an integration (a later release renamed or
+/// removed it, or a typo landed in `installed_agents`) is SKIPPED, not failed:
+/// it is logged as a warning and left out of the returned results entirely.
+/// Gating version-marker advancement on such an id would wedge the reinstall
+/// loop forever — `migrate_installed_agents` only ever adds ids, never prunes,
+/// so a stale id would never resolve and the markers would never advance. Only
+/// genuine `install()` failures are reported as `Err` so they still gate
+/// markers.
+pub(crate) async fn reinstall_agent_integrations(
+    agent_ids: &[String],
+    home: &Path,
+    tracedecay_bin: &str,
+) -> Vec<(String, tracedecay::errors::Result<()>)> {
+    let project_path = std::env::current_dir().ok();
+    let mut results = Vec::new();
+    for id in agent_ids {
+        let ag = match tracedecay::agents::get_integration(id) {
+            Ok(ag) => ag,
+            Err(_) => {
+                eprintln!(
+                    "  \x1b[33mwarning:\x1b[0m skipping unknown tracked agent id \"{id}\" \
+                     (no such integration); it will not gate the version-marker refresh."
+                );
+                continue;
+            }
+        };
+        let ctx = tracedecay::agents::InstallContext {
+            home: home.to_path_buf(),
+            tracedecay_bin: tracedecay_bin.to_string(),
+            tool_permissions: tracedecay::agents::expected_tool_perms(),
+            profile: None,
+            project_root: None,
+            dashboard: true,
+        };
+        let result = match ag.install(&ctx) {
+            Ok(()) => {
+                ag.post_install(project_path.as_deref()).await;
+                Ok(())
+            }
+            Err(e) => Err(e),
+        };
+        results.push((id.clone(), result));
+    }
+    results
+}
+
 pub(crate) async fn handle_uninstall_command(
     agent: Option<String>,
     profile: Option<String>,

src/cli.rs

@@ -312,6 +312,9 @@ pub enum Commands {
         /// Skip the post-update health pass (safe repairs + doctor summary)
         #[arg(long)]
         no_heal: bool,
+        /// Skip refreshing already-configured agent integrations
+        #[arg(long)]
+        no_reinstall: bool,
     },
     /// Refresh generated plugins and the daemon, even when already up to date
     ///
@@ -323,13 +326,19 @@ pub enum Commands {
         /// Skip the post-update health pass (safe repairs + doctor summary)
         #[arg(long)]
         no_heal: bool,
+        /// Skip refreshing already-configured agent integrations
+        #[arg(long)]
+        no_reinstall: bool,
     },
     /// Refresh plugins and daemon after the binary has been updated.
     #[command(name = "post-update", hide = true)]
     PostUpdate {
         /// Skip the post-update health pass (safe repairs + doctor summary)
         #[arg(long)]
         no_heal: bool,
+        /// Skip refreshing already-configured agent integrations
+        #[arg(long)]
+        no_reinstall: bool,
     },
     /// Show or switch the update channel (stable or beta)
     #[command(long_about = CHANNEL_LONG_ABOUT, after_help = CHANNEL_AFTER_HELP)]

src/cli/help.rs

@@ -219,6 +219,11 @@ pub(crate) const UPGRADE_AFTER_HELP: &str = "\
 Examples:
   tracedecay upgrade                             Install the newest release
   tracedecay upgrade --no-heal                   Skip the post-update health pass
+  tracedecay upgrade --no-reinstall              Skip refreshing configured agents
+
+After a real install, upgrade re-runs install for every configured agent
+integration so a separate `tracedecay reinstall` is not needed. --no-reinstall
+skips that refresh; --no-heal (independent) skips only the health pass.
 
 Related: tracedecay update (refresh even when current), tracedecay channel
 (switch stable/beta).";
@@ -227,6 +232,11 @@ pub(crate) const UPDATE_AFTER_HELP: &str = "\
 Examples:
   tracedecay update                              Upgrade if needed, then refresh
   tracedecay update --no-heal                    Skip the post-update health pass
+  tracedecay update --no-reinstall               Skip refreshing configured agents
+
+Update re-runs install for every configured agent integration so a separate
+`tracedecay reinstall` is not needed. --no-reinstall skips that refresh;
+--no-heal (independent) skips only the health pass.
 
 Related: tracedecay upgrade (refresh only after a real install),
 tracedecay update-plugin (plugins only), tracedecay channel.";

src/cli/parse_tests.rs

@@ -220,11 +220,17 @@ fn update_upgrade_and_update_plugin_parse_to_distinct_commands() {
 
     assert!(matches!(
         update.command,
-        Some(Commands::Update { no_heal: false })
+        Some(Commands::Update {
+            no_heal: false,
+            no_reinstall: false
+        })
     ));
     assert!(matches!(
         upgrade.command,
-        Some(Commands::Upgrade { no_heal: false })
+        Some(Commands::Upgrade {
+            no_heal: false,
+            no_reinstall: false
+        })
     ));
     assert!(matches!(
         update_plugin.command,
@@ -243,15 +249,24 @@ fn update_and_post_update_parse_no_heal_flag() {
 
     assert!(matches!(
         update.command,
-        Some(Commands::Update { no_heal: true })
+        Some(Commands::Update {
+            no_heal: true,
+            no_reinstall: false
+        })
     ));
     assert!(matches!(
         post_update.command,
-        Some(Commands::PostUpdate { no_heal: true })
+        Some(Commands::PostUpdate {
+            no_heal: true,
+            no_reinstall: false
+        })
     ));
     assert!(matches!(
         post_update_default.command,
-        Some(Commands::PostUpdate { no_heal: false })
+        Some(Commands::PostUpdate {
+            no_heal: false,
+            no_reinstall: false
+        })
     ));
 }
 
@@ -264,11 +279,60 @@ fn upgrade_parses_no_heal_flag() {
 
     assert!(matches!(
         upgrade.command,
-        Some(Commands::Upgrade { no_heal: true })
+        Some(Commands::Upgrade {
+            no_heal: true,
+            no_reinstall: false
+        })
     ));
     assert!(matches!(
         upgrade_default.command,
-        Some(Commands::Upgrade { no_heal: false })
+        Some(Commands::Upgrade {
+            no_heal: false,
+            no_reinstall: false
+        })
+    ));
+}
+
+#[test]
+fn upgrade_update_and_post_update_parse_no_reinstall_flag() {
+    let upgrade = Cli::try_parse_from(["tracedecay", "upgrade", "--no-reinstall"])
+        .expect("upgrade --no-reinstall should parse");
+    let update = Cli::try_parse_from(["tracedecay", "update", "--no-reinstall"])
+        .expect("update --no-reinstall should parse");
+    let post_update = Cli::try_parse_from(["tracedecay", "post-update", "--no-reinstall"])
+        .expect("post-update --no-reinstall should parse");
+
+    assert!(matches!(
+        upgrade.command,
+        Some(Commands::Upgrade {
+            no_heal: false,
+            no_reinstall: true
+        })
+    ));
+    assert!(matches!(
+        update.command,
+        Some(Commands::Update {
+            no_heal: false,
+            no_reinstall: true
+        })
+    ));
+    assert!(matches!(
+        post_update.command,
+        Some(Commands::PostUpdate {
+            no_heal: false,
+            no_reinstall: true
+        })
+    ));
+
+    // --no-heal and --no-reinstall are independent and may combine.
+    let both = Cli::try_parse_from(["tracedecay", "upgrade", "--no-heal", "--no-reinstall"])
+        .expect("upgrade --no-heal --no-reinstall should parse");
+    assert!(matches!(
+        both.command,
+        Some(Commands::Upgrade {
+            no_heal: true,
+            no_reinstall: true
+        })
     ));
 }
 

src/main.rs

@@ -205,7 +205,7 @@ async fn run(cli: Cli) -> tracedecay::errors::Result<()> {
     };
 
     maybe_run_extract_worker(&command);
-    run_startup_preamble(&command);
+    run_startup_preamble(&command).await;
     dispatch_command(command).await
 }
 
@@ -219,7 +219,7 @@ fn maybe_run_extract_worker(command: &Commands) {
     }
 }
 
-fn run_startup_preamble(command: &Commands) {
+async fn run_startup_preamble(command: &Commands) {
     let skip_startup_maintenance = should_skip_startup_maintenance(command);
     let skip_agent_install_maintenance = should_skip_agent_install_maintenance(command);
 
@@ -257,7 +257,7 @@ fn run_startup_preamble(command: &Commands) {
     // Best-effort check: warn if install needs re-running.
     if !skip_agent_install_maintenance {
         tracedecay::agents::claude::check_install_stale();
-        maybe_run_silent_reinstall(&mut user_config);
+        maybe_run_silent_reinstall(&mut user_config).await;
     }
 }
 
@@ -311,12 +311,12 @@ fn silent_reinstall_action(
     }
 }
 
-fn maybe_run_silent_reinstall(user_config: &mut tracedecay::user_config::UserConfig) {
+async fn maybe_run_silent_reinstall(user_config: &mut tracedecay::user_config::UserConfig) {
     // Silent reinstall: re-run install for every tracked agent so permissions,
     // hooks, and MCP config stay in sync with the new binary.
     let running = env!("CARGO_PKG_VERSION");
     match silent_reinstall_action(user_config, running) {
-        SilentReinstallAction::Reinstall => run_silent_reinstall(user_config, running),
+        SilentReinstallAction::Reinstall => run_silent_reinstall(user_config, running).await,
         SilentReinstallAction::AdvanceMarker => {
             user_config.previous_version = running.to_string();
             user_config.save();
@@ -325,8 +325,13 @@ fn maybe_run_silent_reinstall(user_config: &mut tracedecay::user_config::UserCon
     }
 }
 
-fn run_silent_reinstall(user_config: &mut tracedecay::user_config::UserConfig, running: &str) {
-    if update_cmd::reinstall_tracked_agents(user_config) {
+async fn run_silent_reinstall(
+    user_config: &mut tracedecay::user_config::UserConfig,
+    running: &str,
+) {
+    if let update_cmd::ReinstallOutcome::AllOk =
+        update_cmd::reinstall_tracked_agents(user_config).await
+    {
         user_config.mark_version_installed(running);
         user_config.save();
     }
@@ -561,14 +566,23 @@ async fn dispatch_command(command: Commands) -> tracedecay::errors::Result<()> {
                 print!("{}", tracedecay::daemon::service_status(&socket_path));
             }
         },
-        Commands::Upgrade { no_heal } => {
-            update_cmd::run_upgrade_command(no_heal)?;
+        Commands::Upgrade {
+            no_heal,
+            no_reinstall,
+        } => {
+            update_cmd::run_upgrade_command(no_heal, no_reinstall)?;
         }
-        Commands::Update { no_heal } => {
-            update_cmd::run_update_command(no_heal)?;
+        Commands::Update {
+            no_heal,
+            no_reinstall,
+        } => {
+            update_cmd::run_update_command(no_heal, no_reinstall)?;
         }
-        Commands::PostUpdate { no_heal } => {
-            update_cmd::run_post_update_tasks(no_heal).await?;
+        Commands::PostUpdate {
+            no_heal,
+            no_reinstall,
+        } => {
+            update_cmd::run_post_update_tasks(no_heal, no_reinstall).await?;
         }
         Commands::Channel { channel } => match channel {
             Some(target) => {