Unify background hook output into single line (#908)

* feat(output): unify background hook output into single line

Combine contiguous post-switch and post-start hooks into a single
output line when both are present (common in `wt switch --create`).

Old format (2 lines):
  Running post-switch hooks @ ~/repo.feature: user:foo
  Running post-start hooks @ ~/repo.feature: project:bar

New format (1 line):
  Running post-switch: user:foo; post-start: project:bar @ ~/repo.feature

Changes:
- Rename spawn_hook_commands_background → spawn_background_hooks
- Add prepare_background_hooks() to collect hooks before spawning
- Add group_commands_by_hook_type() to group commands by type
- Update handle_switch.rs to batch hooks from both types
- Remove unused spawn_post_start_commands/spawn_post_switch_commands

Co-Authored-By: Claude <noreply@anthropic.com>

* chore: address review feedback

- Update doc comments in global.rs to use new API functions
- Update demo snapshot to use new output format
- Make prepare_background_hooks pub(crate) (internal only)

Co-Authored-By: Claude <noreply@anthropic.com>

* test: add coverage for multiple unnamed hooks of same type

Add test_user_and_project_unnamed_post_start to exercise the unnamed
index tracking code when both user and project have unnamed hooks for
the same hook type (post-start).

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: max-sixty

docs/demos/snapshots/wt-core.snap

@@ -13,7 +13,7 @@ $ wt switch alpha
 
 $ wt switch --create api
 ✓ Created branch api from main and worktree @ <DEMO_DIR>/.demo-wt-core/w/acme.api
-◎ Running post-start hooks: project:dev
+◎ Running post-start: project:dev
 
 $ wt list --full
   Branch   Status        HEAD±    main↕     main…±  Remote⇅  CI  Commit    Age

src/commands/handle_switch.rs

@@ -133,16 +133,26 @@ pub fn handle_switch(
     // Spawn background hooks after success message
     // - post-switch: runs on ALL switches (shows "@ path" when shell won't be there)
     // - post-start: runs only when creating a NEW worktree
+    // Batch hooks into a single message when both types are present
     if !skip_hooks {
         let ctx = CommandContext::new(&repo, config, Some(&branch_info.branch), result.path(), yes);
 
-        // Post-switch runs first (immediate "I'm here" signal)
-        ctx.spawn_post_switch_commands(&extra_vars, hooks_display_path.as_deref())?;
-
-        // Post-start runs only on creation (setup tasks)
+        // Collect hooks from both types, then spawn as a single batch
+        let mut hooks = super::hooks::prepare_background_hooks(
+            &ctx,
+            HookType::PostSwitch,
+            &extra_vars,
+            hooks_display_path.as_deref(),
+        )?;
         if matches!(&result, SwitchResult::Created { .. }) {
-            ctx.spawn_post_start_commands(&extra_vars, hooks_display_path.as_deref())?;
+            hooks.extend(super::hooks::prepare_background_hooks(
+                &ctx,
+                HookType::PostStart,
+                &extra_vars,
+                hooks_display_path.as_deref(),
+            )?);
         }
+        super::hooks::spawn_background_hooks(&ctx, hooks)?;
     }
 
     // Execute user command after post-start hooks have been spawned

src/commands/hook_commands.rs

@@ -29,7 +29,7 @@ use super::context::CommandEnv;
 use super::hooks::execute_hook;
 use super::hooks::{
     HookFailureStrategy, check_name_filter_matched, prepare_hook_commands, run_hook_with_filter,
-    spawn_hook_commands_background,
+    spawn_background_hooks,
 };
 use super::project_config::collect_commands_for_hooks;
 
@@ -141,7 +141,7 @@ pub fn run_hook(
                     user_config,
                     project_config,
                 )?;
-                spawn_hook_commands_background(&ctx, commands, hook_type)
+                spawn_background_hooks(&ctx, commands)
             } else {
                 run_hook_with_filter(
                     &ctx,
@@ -180,7 +180,7 @@ pub fn run_hook(
                     user_config,
                     project_config,
                 )?;
-                spawn_hook_commands_background(&ctx, commands, hook_type)
+                spawn_background_hooks(&ctx, commands)
             } else {
                 run_hook_with_filter(
                     &ctx,
@@ -283,7 +283,7 @@ pub fn run_hook(
                     user_config,
                     project_config,
                 )?;
-                spawn_hook_commands_background(&ctx, commands, hook_type)
+                spawn_background_hooks(&ctx, commands)
             } else {
                 run_hook_with_filter(
                     &ctx,

src/commands/hooks.rs

@@ -148,12 +148,12 @@ fn filter_by_name(
 /// Used for post-start and post-switch hooks during normal worktree operations.
 /// Commands are spawned and immediately detached - we don't wait for them.
 ///
-/// By default, shows a single-line summary of all hooks being run.
+/// By default, shows a single-line summary of all hooks being run, with support
+/// for multiple hook types in a single message (e.g., "Running post-switch: user:foo; post-start: project:bar").
 /// With `-v`, shows verbose per-hook output with command details.
-pub fn spawn_hook_commands_background(
+pub fn spawn_background_hooks(
     ctx: &CommandContext,
     commands: Vec<SourcedCommand>,
-    hook_type: HookType,
 ) -> anyhow::Result<()> {
     if commands.is_empty() {
         return Ok(());
@@ -162,29 +162,39 @@ pub fn spawn_hook_commands_background(
     let verbose = verbosity();
 
     if verbose == 0 {
-        // Single-line summary: "Running post-start hooks @ path: user:bg, project"
-        let names: Vec<String> = commands
-            .iter()
-            .map(|c| cformat!("<bold>{}</>", c.summary_name()))
-            .collect();
+        // Group commands by hook type, preserving insertion order
+        let groups = group_commands_by_hook_type(&commands);
         // All commands in a batch share the same display_path (set by prepare_hook_commands)
         let display_path = commands.first().and_then(|c| c.display_path.as_ref());
 
+        // Format: "Running {type}: {names}[; {type}: {names}]... [@ {path}]"
+        let type_segments: Vec<String> = groups
+            .iter()
+            .map(|(hook_type, cmds)| {
+                let names: Vec<String> = cmds
+                    .iter()
+                    .map(|c| cformat!("<bold>{}</>", c.summary_name()))
+                    .collect();
+                format!("{hook_type}: {}", names.join(", "))
+            })
+            .collect();
+
         let message = match display_path {
             Some(path) => {
                 let path_display = format_path_for_display(path);
                 cformat!(
-                    "Running {hook_type} hooks @ <bold>{path_display}</>: {}",
-                    names.join(", ")
+                    "Running {} @ <bold>{path_display}</>",
+                    type_segments.join("; ")
                 )
             }
-            None => format!("Running {hook_type} hooks: {}", names.join(", ")),
+            None => format!("Running {}", type_segments.join("; ")),
         };
         eprintln!("{}", progress_message(message));
     }
 
-    // Track index for unnamed commands to prevent log collisions
-    let mut unnamed_index = 0usize;
+    // Track index for unnamed commands to prevent log collisions (per hook type)
+    // Use a Vec since HookType doesn't implement Hash
+    let mut unnamed_indices: Vec<(HookType, usize)> = Vec::new();
 
     for cmd in &commands {
         if verbose >= 1 {
@@ -194,13 +204,22 @@ pub fn spawn_hook_commands_background(
         let name = match &cmd.prepared.name {
             Some(n) => n.clone(),
             None => {
-                let idx = unnamed_index;
-                unnamed_index += 1;
+                let idx = if let Some((_, count)) = unnamed_indices
+                    .iter_mut()
+                    .find(|(t, _)| *t == cmd.hook_type)
+                {
+                    let result = *count;
+                    *count += 1;
+                    result
+                } else {
+                    unnamed_indices.push((cmd.hook_type, 1));
+                    0
+                };
                 format!("cmd-{idx}")
             }
         };
-        // Use HookLog for consistent log file naming
-        let hook_log = HookLog::hook(cmd.source, hook_type, &name);
+        // Use HookLog with the command's own hook_type for consistent log file naming
+        let hook_log = HookLog::hook(cmd.source, cmd.hook_type, &name);
 
         if let Err(err) = spawn_detached(
             ctx.repo,
@@ -222,6 +241,25 @@ pub fn spawn_hook_commands_background(
     Ok(())
 }
 
+/// Group commands by hook type, preserving insertion order.
+///
+/// Returns a vector of (HookType, Vec<&SourcedCommand>) tuples.
+/// This preserves the order in which hook types were first encountered
+/// (e.g., post-switch before post-start).
+fn group_commands_by_hook_type(
+    commands: &[SourcedCommand],
+) -> Vec<(HookType, Vec<&SourcedCommand>)> {
+    let mut groups: Vec<(HookType, Vec<&SourcedCommand>)> = Vec::new();
+    for cmd in commands {
+        if let Some((_, vec)) = groups.iter_mut().find(|(t, _)| *t == cmd.hook_type) {
+            vec.push(cmd);
+        } else {
+            groups.push((cmd.hook_type, vec![cmd]));
+        }
+    }
+    groups
+}
+
 /// Check if a name filter was provided but no commands matched.
 /// Returns an error listing available command names if so.
 pub(crate) fn check_name_filter_matched(
@@ -404,12 +442,46 @@ pub fn execute_hook(
     .map_err(worktrunk::git::add_hook_skip_hint)
 }
 
+/// Prepare background hooks with automatic config lookup.
+///
+/// This is a convenience wrapper that:
+/// 1. Loads project config from the repository
+/// 2. Looks up user hooks from the config
+/// 3. Prepares commands ready for spawning
+///
+/// Use this to collect hooks from multiple types, then call `spawn_background_hooks`
+/// once to spawn them all with a unified message.
+pub(crate) fn prepare_background_hooks(
+    ctx: &CommandContext,
+    hook_type: HookType,
+    extra_vars: &[(&str, &str)],
+    display_path: Option<&Path>,
+) -> anyhow::Result<Vec<SourcedCommand>> {
+    let project_config = ctx.repo.load_project_config()?;
+    let user_hooks = ctx.config.hooks(ctx.project_id().as_deref());
+    let (user_config, proj_config) =
+        lookup_hook_configs(&user_hooks, project_config.as_ref(), hook_type);
+
+    prepare_hook_commands(
+        ctx,
+        user_config,
+        proj_config,
+        hook_type,
+        extra_vars,
+        None, // no filter for automatic background hooks
+        display_path,
+    )
+}
+
 /// Spawn hook commands as background processes with automatic config lookup.
 ///
 /// This is a convenience wrapper that:
 /// 1. Loads project config from the repository
 /// 2. Looks up user hooks from the config
 /// 3. Prepares and spawns background commands
+///
+/// For spawning multiple hook types in a single message, use `prepare_background_hooks`
+/// to collect hooks, then `spawn_background_hooks` to spawn them.
 pub fn spawn_hook_background(
     ctx: &CommandContext,
     hook_type: HookType,
@@ -432,7 +504,7 @@ pub fn spawn_hook_background(
         display_path,
     )?;
 
-    spawn_hook_commands_background(ctx, commands, hook_type)
+    spawn_background_hooks(ctx, commands)
 }
 
 #[cfg(test)]

src/commands/worktree/hooks.rs

@@ -1,6 +1,6 @@
 //! Hook execution for worktree operations.
 //!
-//! CommandContext implementations for post-create, post-start, post-switch, and post-remove hooks.
+//! CommandContext implementations for post-create and post-remove hooks.
 
 use std::path::Path;
 
@@ -9,8 +9,7 @@ use worktrunk::path::to_posix_path;
 
 use crate::commands::command_executor::CommandContext;
 use crate::commands::hooks::{
-    HookFailureStrategy, execute_hook, prepare_hook_commands, spawn_hook_background,
-    spawn_hook_commands_background,
+    HookFailureStrategy, execute_hook, prepare_hook_commands, spawn_background_hooks,
 };
 
 impl<'a> CommandContext<'a> {
@@ -32,24 +31,6 @@ impl<'a> CommandContext<'a> {
         )
     }
 
-    /// Spawn post-start commands in parallel as background processes (non-blocking)
-    pub fn spawn_post_start_commands(
-        &self,
-        extra_vars: &[(&str, &str)],
-        display_path: Option<&Path>,
-    ) -> anyhow::Result<()> {
-        spawn_hook_background(self, HookType::PostStart, extra_vars, None, display_path)
-    }
-
-    /// Spawn post-switch commands in parallel as background processes (non-blocking)
-    pub fn spawn_post_switch_commands(
-        &self,
-        extra_vars: &[(&str, &str)],
-        display_path: Option<&Path>,
-    ) -> anyhow::Result<()> {
-        spawn_hook_background(self, HookType::PostSwitch, extra_vars, None, display_path)
-    }
-
     /// Spawn post-remove commands in parallel as background processes (non-blocking)
     ///
     /// Runs after worktree removal. Commands execute from the invoking worktree (where
@@ -108,6 +89,6 @@ impl<'a> CommandContext<'a> {
             display_path,
         )?;
 
-        spawn_hook_commands_background(self, commands, HookType::PostRemove)
+        spawn_background_hooks(self, commands)
     }
 }

src/output/global.rs

@@ -302,11 +302,12 @@ pub fn pre_hook_display_path(hooks_run_at: &std::path::Path) -> Option<&std::pat
 /// # Examples
 ///
 /// ```ignore
-/// // In post-create, post-start, post-switch hooks (creation path):
-/// ctx.spawn_post_start_commands(&extra_vars, post_hook_display_path(&destination))?;
+/// // Prepare and spawn hooks with display path:
+/// let hooks = prepare_background_hooks(&ctx, HookType::PostStart, &extra_vars, post_hook_display_path(&destination))?;
+/// spawn_background_hooks(&ctx, hooks)?;
 ///
 /// // After remove when switching to main:
-/// ctx.spawn_post_switch_commands(&[], post_hook_display_path(main_path))?;
+/// spawn_hook_background(&ctx, HookType::PostSwitch, &[], None, post_hook_display_path(main_path))?;
 /// ```
 pub fn post_hook_display_path(destination: &std::path::Path) -> Option<&std::path::Path> {
     if is_shell_integration_active() {

tests/integration_tests/switch.rs

@@ -1297,6 +1297,32 @@ fn test_switch_post_hook_no_path_with_shell_integration(repo: TestRepo) {
     );
 }
 
+/// When both post-switch and post-start hooks are configured, they should be combined
+/// into a single output line with format: "Running post-switch: {names}; post-start: {names} @ path"
+#[rstest]
+fn test_switch_combined_post_switch_and_post_start_hooks(repo: TestRepo) {
+    // Create project config with both post-switch and post-start hooks
+    let config_dir = repo.root_path().join(".config");
+    fs::create_dir_all(&config_dir).unwrap();
+    fs::write(
+        config_dir.join("wt.toml"),
+        r#"post-switch = "echo switched"
+post-start = "echo started"
+"#,
+    )
+    .unwrap();
+
+    repo.commit("Add config");
+
+    // Run switch --create (triggers both post-switch and post-start)
+    // Should show a single combined line: "Running post-switch: project; post-start: project @ path"
+    snapshot_switch(
+        "switch_combined_hooks",
+        &repo,
+        &["--create", "combined-hooks-test", "--yes"],
+    );
+}
+
 #[rstest]
 fn test_switch_clobber_path_with_extension(repo: TestRepo) {
     // Calculate where the worktree would be created

tests/integration_tests/user_hooks.rs

@@ -927,6 +927,46 @@ vars = "echo 'repo={{ repo }} branch={{ branch }}' > template_vars.txt"
 // Combined User and Project Hooks Tests
 // ============================================================================
 
+/// Test that both user and project unnamed hooks of the same type run and get unique log names.
+/// This exercises the unnamed index tracking when multiple unnamed hooks share the same hook type.
+#[rstest]
+fn test_user_and_project_unnamed_post_start(repo: TestRepo) {
+    // Create project config with unnamed post-start hook
+    repo.write_project_config(r#"post-start = "echo 'PROJECT_POST_START' > project_bg.txt""#);
+    repo.commit("Add project config");
+
+    // Write user config with unnamed hook AND pre-approve project command
+    repo.write_test_config(
+        r#"post-start = "echo 'USER_POST_START' > user_bg.txt"
+
+[projects."../origin"]
+approved-commands = ["echo 'PROJECT_POST_START' > project_bg.txt"]
+"#,
+    );
+
+    snapshot_switch(
+        "user_and_project_unnamed_post_start",
+        &repo,
+        &["--create", "feature"],
+    );
+
+    let worktree_path = repo.root_path().parent().unwrap().join("repo.feature");
+
+    // Wait for both background commands
+    wait_for_file(&worktree_path.join("user_bg.txt"));
+    wait_for_file(&worktree_path.join("project_bg.txt"));
+
+    // Both should have run
+    assert!(
+        worktree_path.join("user_bg.txt").exists(),
+        "User post-start should have run"
+    );
+    assert!(
+        worktree_path.join("project_bg.txt").exists(),
+        "Project post-start should have run"
+    );
+}
+
 #[rstest]
 fn test_user_and_project_post_start_both_run(repo: TestRepo) {
     // Create project config with post-start hook