fix: address review feedback for terminal path normalization and switch-hook context

Agent-Logs-Url: https://github.com/InterestingSoftware/SproutGit/sessions/55f34c67-940b-41ff-9398-342e241c4971

Author: Copilot

src-tauri/src/hooks.rs

@@ -2085,8 +2085,14 @@ pub async fn run_worktree_switch_hooks(
 
 #[cfg(test)]
 mod tests {
-    use super::{ensure_dependency_triggers_compatible, normalize_hook_script};
+    use super::{
+        build_switch_hook_session_key, ensure_dependency_triggers_compatible,
+        mark_switch_hook_ran_this_session, normalize_hook_script, normalize_switch_auto_run_flags,
+        parse_switch_hook_source, should_skip_switch_hook_once_per_session,
+        validate_switch_once_per_session, HookExecutionContext, RuntimeHook, SWITCH_HOOK_SESSION_RUNS,
+    };
     use std::collections::HashMap;
+    use std::path::PathBuf;
 
     #[test]
     fn normalize_hook_script_allows_multiline_scripts() {
@@ -2136,4 +2142,97 @@ mod tests {
             Err(err) => panic!("manual dependency should be allowed: {err}"),
         }
     }
+
+    #[test]
+    fn parse_switch_hook_source_defaults_to_manual_when_missing_or_blank() {
+        assert!(matches!(parse_switch_hook_source(None), Ok(super::SwitchHookSource::Manual)));
+        assert!(matches!(
+            parse_switch_hook_source(Some("   ")),
+            Ok(super::SwitchHookSource::Manual)
+        ));
+    }
+
+    #[test]
+    fn parse_switch_hook_source_rejects_unknown_value() {
+        match parse_switch_hook_source(Some("invalid")) {
+            Ok(_) => panic!("invalid source should be rejected"),
+            Err(err) => assert!(err.contains("Unsupported switch hook source")),
+        }
+    }
+
+    #[test]
+    fn validate_switch_once_per_session_allows_only_switch_triggers() {
+        match validate_switch_once_per_session("before_worktree_switch", true) {
+            Ok(value) => assert!(value),
+            Err(err) => panic!("switch trigger should allow once-per-session: {err}"),
+        }
+
+        match validate_switch_once_per_session("before_worktree_create", true) {
+            Ok(_) => panic!("non-switch trigger should reject once-per-session"),
+            Err(err) => assert!(err.contains("switchOncePerSession can only be enabled")),
+        }
+    }
+
+    #[test]
+    fn normalize_switch_auto_run_flags_defaults_for_non_switch_triggers() {
+        assert_eq!(
+            normalize_switch_auto_run_flags("before_worktree_create", false, true),
+            (true, false)
+        );
+        assert_eq!(
+            normalize_switch_auto_run_flags("before_worktree_switch", false, true),
+            (false, true)
+        );
+    }
+
+    #[test]
+    fn switch_once_per_session_marks_and_skips_after_first_run() {
+        if let Ok(mut runs) = SWITCH_HOOK_SESSION_RUNS.lock() {
+            runs.clear();
+        } else {
+            panic!("failed to clear switch hook session runs");
+        }
+
+        let context = HookExecutionContext {
+            workspace_path: PathBuf::from("/tmp/workspace"),
+            trigger_worktree_path: Some(PathBuf::from("/tmp/workspace/worktrees/feature-a")),
+            initiating_worktree_path: None,
+            source_ref: None,
+        };
+        let hook = RuntimeHook {
+            id: "hook-1".to_string(),
+            name: "hook".to_string(),
+            scope: "workspace".to_string(),
+            trigger: "before_worktree_switch".to_string(),
+            execution_target: "trigger_worktree".to_string(),
+            execution_mode: "inline".to_string(),
+            shell: "bash".to_string(),
+            script: "echo hi".to_string(),
+            critical: false,
+            switch_once_per_session: true,
+            keep_open_on_completion: false,
+            timeout_seconds: 60,
+            switch_run_on_create: true,
+            switch_run_on_delete: false,
+        };
+
+        assert!(!should_skip_switch_hook_once_per_session(
+            "before_worktree_switch",
+            &hook,
+            &context
+        ));
+        mark_switch_hook_ran_this_session("before_worktree_switch", &hook.id, &context);
+        assert!(should_skip_switch_hook_once_per_session(
+            "before_worktree_switch",
+            &hook,
+            &context
+        ));
+
+        if let Some(key) = build_switch_hook_session_key("before_worktree_switch", &hook.id, &context)
+        {
+            if let Ok(mut runs) = SWITCH_HOOK_SESSION_RUNS.lock() {
+                runs.remove(&key);
+            }
+        }
+    }
 }

src-tauri/src/terminal.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::io::{BufRead, BufReader, Read, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::sync::{Arc, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -9,7 +9,7 @@ use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize}
 use tauri::{AppHandle, Emitter};
 
 use crate::git::helpers::{
-    command_exists, shell_candidates_for_current_os, validate_no_control_chars,
+    command_exists, shell_candidates_for_current_os, strip_win_prefix, validate_no_control_chars,
 };
 
 // ── Shell detection ──────────────────────────────────────────────────────────
@@ -114,6 +114,13 @@ fn validate_shell_for_terminal(shell: &str) -> Result<String, String> {
     Ok(s)
 }
 
+fn normalize_session_cwd(cwd_path: &Path) -> PathBuf {
+    cwd_path
+        .canonicalize()
+        .map(strip_win_prefix)
+        .unwrap_or_else(|_| cwd_path.to_path_buf())
+}
+
 fn validate_spawn_env_vars(
     env_vars: Option<HashMap<String, String>>,
 ) -> Result<HashMap<String, String>, String> {
@@ -351,7 +358,7 @@ pub async fn spawn_terminal(
         master: Mutex::new(pair.master),
         writer: Mutex::new(writer),
         child: Mutex::new(child),
-        initial_cwd: cwd_path.clone(),
+        initial_cwd: normalize_session_cwd(&cwd_path),
     });
 
     {

src/lib/components/TerminalDock.svelte

@@ -6,6 +6,7 @@
     getTerminalShellOptions,
     getWorkspaceTerminalSnapshots,
   } from '$lib/workspace-terminals.svelte';
+  import { pathsEqual } from '$lib/path-utils';
 
   const terminalRouteActive = $derived($page.url.pathname.startsWith('/workspace'));
   const activeWorkspacePath = $derived(getActiveWorkspacePath());
@@ -15,15 +16,15 @@
     terminalRouteActive
       ? workspaceSnapshots.find(
           snapshot =>
-            snapshot.workspacePath === activeWorkspacePath &&
+            pathsEqual(snapshot.workspacePath, activeWorkspacePath) &&
             snapshot.activeTab === 'terminal' &&
             snapshot.initializedPaths.length > 0
         ) ?? null
       : null
   );
 
   function getSnapshotStyles(workspacePath: string, activeWorkspacePath: string | null) {
-    return activeTerminalSnapshot && activeWorkspacePath === workspacePath ? 'flex' : 'none';
+    return activeTerminalSnapshot && pathsEqual(activeWorkspacePath, workspacePath) ? 'flex' : 'none';
   }
 </script>
 
@@ -39,7 +40,7 @@
       {#each workspaceState.initializedPaths as wtPath (wtPath)}
         <div
           class="flex min-h-0 flex-1 flex-col overflow-hidden"
-          style:display={workspaceState.activeTerminalPath === wtPath ? 'flex' : 'none'}
+          style:display={pathsEqual(workspaceState.activeTerminalPath, wtPath) ? 'flex' : 'none'}
         >
           <TerminalContainer
             defaultShell={shellOptions.defaultShell}
@@ -51,4 +52,4 @@
       {/each}
     </div>
   {/each}
-</div>
+</div>

src/lib/terminal-session-cache.svelte.ts

@@ -1,3 +1,5 @@
+import { pathKey } from '$lib/path-utils';
+
 type CachedSession = {
   id: string;
   shell: string;
@@ -38,13 +40,13 @@ function cloneState(state: CachedContainerState): CachedContainerState {
 }
 
 export function getTerminalContainerCache(cwd: string): CachedContainerState {
-  return cloneState(cacheByCwd.get(cwd) ?? EMPTY_STATE);
+  return cloneState(cacheByCwd.get(pathKey(cwd)) ?? EMPTY_STATE);
 }
 
 export function setTerminalContainerCache(cwd: string, nextState: CachedContainerState) {
-  cacheByCwd.set(cwd, cloneState(nextState));
+  cacheByCwd.set(pathKey(cwd), cloneState(nextState));
 }
 
 export function clearTerminalContainerCache(cwd: string) {
-  cacheByCwd.delete(cwd);
-}
+  cacheByCwd.delete(pathKey(cwd));
+}

src/routes/workspace/+page.svelte

@@ -1554,7 +1554,8 @@
     }
 
     // Ensure the shared terminal dock tracks this worktree path.
-    if (!terminalInitializedPaths.has(cwd)) {
+    const hasInitializedPath = [...terminalInitializedPaths].some(path => pathsEqual(path, cwd));
+    if (!hasInitializedPath) {
       terminalInitializedPaths = new Set([...terminalInitializedPaths, cwd]);
     }
 
@@ -1745,6 +1746,7 @@
         worktreeChangeCounts = remainingChangeCounts;
 
         const deletingActiveWorktree = !!activeWorktreePath && pathsEqual(activeWorktreePath, wt.path);
+        const activeWorktreePathBeforeDelete = activeWorktreePath;
         const shouldRunDeleteSwitchHooks = deletingActiveWorktree && !!nextWorktreePath;
         const operationTriggers: WorkspaceHookTrigger[] = shouldRunDeleteSwitchHooks
           ? [
@@ -1777,14 +1779,19 @@
             await runWorktreeSwitchHooks(
               workspace!.workspacePath,
               nextWorktreePath,
-              activeWorktreePath ?? null,
+              activeWorktreePathBeforeDelete ?? null,
               'delete'
             );
           }
 
           clearTerminalStateForPath(wt.path);
           await closeTerminalsForPath(wt.path);
-          await deleteManagedWorktree(workspace!.rootPath, wt.path, true, activeWorktreePath);
+          await deleteManagedWorktree(
+            workspace!.rootPath,
+            wt.path,
+            true,
+            activeWorktreePathBeforeDelete
+          );
           toast.success(`Deleted worktree: ${label}`);
           try {
             await refreshWorkspaceData();