WorkspaceLauncher.ahk

#Requires AutoHotkey v2.0
#SingleInstance Force

; ==============================================================================
; SMART WORKSPACE LAUNCHER (AHK v2)
; ==============================================================================
; A directory-based workspace manager. It treats a folder as a config file.
; Features: Dependency Chaining, Track-by-Exe, Clean Shutdowns, Magic Folders.
; ==============================================================================

; ==============================================================================
; SELF-BUILDING ROUTINE (STRICT)
; ==============================================================================
; This script is designed to run as a standalone executable.
; If running as .ahk, it refuses to start unless the --build flag is present.
if (!A_IsCompiled) {
    HasBuildFlag := false
    HasHelpFlag := false
    if (A_Args.Length > 0) {
        for arg in A_Args {
            if (arg = "--build") {
                HasBuildFlag := true
                break
            }
            if (arg = "-h" || arg = "--help") {
                HasHelpFlag := true
                break
            }
        }
    }

    if (HasHelpFlag) {
        ShowHelp()
        ExitApp
    } else if (HasBuildFlag) {
        BuildScript() ; Compile self
        ExitApp
    } else {
        MsgBox(
            "This script must be compiled to run correctly.`n`nPlease run the script with the argument '--build' to compile it automatically, or compile it manually using Ahk2Exe.",
            "Interpreter Mode Detected", 16)
        ExitApp
    }
}

; ==============================================================================
; CONFIGURATION
; ==============================================================================
DefaultPath := A_ScriptDir "\Workspace"
SessionFile := A_Temp "\Workspace_Session.log"

; ==============================================================================
; INITIALIZATION & ARGUMENTS
; ==============================================================================

; Check Modifier Keys for different modes
IsSaveMode := GetKeyState("Ctrl", "P") && GetKeyState("Shift", "P")
IsCleanupMode := (!IsSaveMode) && GetKeyState("Shift", "P")
IsInteractive := (!IsSaveMode) && GetKeyState("Ctrl", "P")
IsToggleMode := GetKeyState("Alt", "P")

; Parse Command Line Arguments
TargetDir := DefaultPath
UseSaveHere := false
IsSaveAuto := false
UseSaveTimestamp := false
SaveName := ""
SaveConflict := ""
ShowTrayApps := false

if (A_Args.Length > 0) {
    loop A_Args.Length {
        arg := A_Args[A_Index]

        ; Flag Parsing
        if (arg = "-h" || arg = "--help") {
            ShowHelp()
            ExitApp
        }
        else if (arg = "--close" || arg = "-close") {
            IsCleanupMode := true
        }
        else if (arg = "--toggle" || arg = "-show") {
            IsToggleMode := true
        }
        ; Save Workspace Flags
        else if (arg = "--save") {
            IsSaveMode := true
        }
        else if (arg = "--here") {
            UseSaveHere := true
        }
        else if (arg = "--auto") {
            IsSaveAuto := true
        }
        else if (arg = "--timestamp") {
            UseSaveTimestamp := true
        }
        else if RegExMatch(arg, "i)^--name=(.+)", &nMatch) {
            SaveName := nMatch[1]
        }
        else if (arg = "--merge") {
            SaveConflict := "merge"
        }
        else if (arg = "--replace") {
            SaveConflict := "replace"
        }
        else if (arg = "--tray") {
            ShowTrayApps := true
        }
        ; Invalid Flag Detection
        else if SubStr(arg, 1, 1) = "-" {
            ; Allow --build to pass through here silently if handled above,
            ; but warn on other unknown flags.
            if (arg != "--build") {
                MsgBox("Error: Invalid argument '" arg "' detected.`n`nUse -h or --help for full usage information.",
                    "Argument Error", 16)
                ExitApp
            }
        }
        ; Path Argument
        else {
            TargetDir := arg
        }
    }
}

; Determine if GUI dashboard should be shown
IsGUIMode := (!IsSaveMode && !IsCleanupMode && !IsInteractive && !IsToggleMode && A_Args.Length = 0)

; ==============================================================================
; FLOW CONTROLLERS
; ==============================================================================

; --- GUI MODE: Show Dashboard (no args, no modifiers) ---
if (IsGUIMode) {
    ShowMainGUI(DefaultPath, TargetDir, SessionFile)
    ExitApp
}

; --- MODE 0: SAVE WORKSPACE (Ctrl+Shift or --save) ---
if (IsSaveMode) {
    RunSaveMode(TargetDir, DefaultPath, UseSaveHere, UseSaveTimestamp, SaveName, SaveConflict, IsSaveAuto, ShowTrayApps)
    ExitApp
}

; Validate Target Directory
if !DirExist(TargetDir) {
    DirCreate(TargetDir)
    MsgBox("Created new Workspace folder at:`n" TargetDir "`n`nPlease add your shortcuts there and run me again!",
        "Welcome", 64)
    ExitApp
}

; --- MODE 1: TOGGLE VISIBILITY (Alt) ---
if (IsToggleMode) {
    RunToggleMode(IsInteractive)
    ExitApp
}

; --- MODE 2: CLEANUP (Shift) ---
if (IsCleanupMode) {
    RunCleanupMode(TargetDir, IsInteractive)
    ExitApp
}

; --- MODE 3: NORMAL LAUNCH FLOW ---
RunLaunchMode(TargetDir, IsInteractive)
ExitApp

; ==============================================================================
; MAIN GUI DASHBOARD
; ==============================================================================

ShowMainGUI(defaultPath, targetDir, sessionFile) {
    CurrentPath := targetDir

    g := Gui("+Resize +MinSize520x580", "Smart Workspace Launcher")
    g.SetFont("s10", "Segoe UI")
    g.MarginX := 15
    g.MarginY := 10

    ; Set window icon if available
    IconPath := A_ScriptDir "\WorkspaceLauncher.ico"
    if FileExist(IconPath) {
        try SendMessage(0x80, 1, LoadPicture(IconPath, "w32 h32", &iconType), g.Hwnd)  ; WM_SETICON ICON_BIG
    }

    ; --- Workspace Path Section ---
    GrpWorkspace := g.Add("GroupBox", "xm w490 h55 Section vGrpWorkspace", "Workspace")
    PathEdit := g.Add("Edit", "xm+10 ys+22 w390 h23 vPathEdit", CurrentPath)
    BtnBrowse := g.Add("Button", "x+5 yp w85 h25 vBtnBrowse", "Browse")

    ; --- Workspace Contents ListView ---
    GrpContents := g.Add("GroupBox", "xm w490 h240 Section vGrpContents", "Workspace Contents")
    LV := g.Add("ListView", "xm+10 ys+20 w470 h210 vWorkspaceLV -Multi ReadOnly", ["#", "Name", "State", "Mode"])
    LV.ModifyCol(1, 40)
    LV.ModifyCol(2, 230)
    LV.ModifyCol(3, 80)
    LV.ModifyCol(4, 100)

    ; --- Launch Section ---
    GrpLaunch := g.Add("GroupBox", "xm w490 h55 Section vGrpLaunch", "Launch")
    BtnLaunchAll := g.Add("Button", "xm+10 ys+22 w160 h25 vBtnLaunchAll", "🚀 Launch All")
    BtnSelectLaunch := g.Add("Button", "x+10 yp w160 h25 vBtnSelectLaunch", "☑ Select && Launch")

    ; --- Session Section ---
    GrpSession := g.Add("GroupBox", "xm w490 h90 Section vGrpSession", "Session")
    BtnCloseAll := g.Add("Button", "xm+10 ys+22 w150 h25 vBtnCloseAll", "🧹 Close All")
    BtnSelectClose := g.Add("Button", "x+10 yp w150 h25 vBtnSelectClose", "☑ Sel. Close")
    BtnToggle := g.Add("Button", "xm+10 y+5 w150 h25 vBtnToggle", "👁 Toggle Hidden")
    BtnSelectToggle := g.Add("Button", "x+10 yp w150 h25 vBtnSelectToggle", "☑ Sel. Toggle")

    ; --- Tools Section ---
    GrpTools := g.Add("GroupBox", "xm w490 h55 Section vGrpTools", "Tools")
    BtnSave := g.Add("Button", "xm+10 ys+22 w150 h25 vBtnSave", "💾 Save Workspace")
    BtnOpenFolder := g.Add("Button", "x+10 yp w150 h25 vBtnOpenFolder", "📂 Open Folder")
    BtnHelp := g.Add("Button", "x+10 yp w50 h25 vBtnHelp", "❓")

    ; --- Status Bar ---
    SB := g.Add("StatusBar")
    SB.SetParts(250)

    ; === NESTED HELPERS ===

    ; Refresh the workspace ListView contents
    RefreshWorkspaceList() {
        LV.Delete()
        CurrentPath := PathEdit.Value

        if !DirExist(CurrentPath) {
            LV.Add("", "", "Path not found. Use Browse to select a workspace folder.", "", "")
            BtnLaunchAll.Enabled := false
            BtnSelectLaunch.Enabled := false
            SB.SetText("  Workspace: path not found", 2)
            return
        }

        try {
            Items := ScanWorkspace(CurrentPath)
            Items := SortLaunchList(Items)
        } catch {
            Items := []
        }

        if (Items.Length = 0) {
            LV.Add("", "", "No items found. Add shortcuts to your Workspace folder.", "", "")
            BtnLaunchAll.Enabled := false
            BtnSelectLaunch.Enabled := false
            SB.SetText("  Workspace: 0 items", 2)
            return
        }

        for item in Items {
            OrderStr := (item.Order = 9999) ? "—" : String(item.Order)
            NameStr := item.Name

            ; Visual distinction for close modes
            if (item.Mode = "CloseOnLaunch" || item.Mode = "AlwaysClose")
                NameStr := "⛔ " NameStr
            else if (item.Mode = "CloseOnCleanup")
                NameStr := "🔄 " NameStr

            ; Visual distinction for hidden items
            if (item.RunState = "Hide")
                NameStr := "👁 " NameStr

            LV.Add("", OrderStr, NameStr, item.RunState, item.Mode)
        }

        BtnLaunchAll.Enabled := true
        BtnSelectLaunch.Enabled := true
        SB.SetText("  Workspace: " Items.Length " items", 2)
    }

    ; Refresh session button states and status bar
    RefreshSessionStatus() {
        SessionCount := CountSessionApps(sessionFile)
        HasSession := (SessionCount > 0)

        BtnCloseAll.Enabled := HasSession
        BtnSelectClose.Enabled := HasSession
        BtnToggle.Enabled := HasSession
        BtnSelectToggle.Enabled := HasSession

        if (HasSession)
            SB.SetText("  Session: " SessionCount " apps tracked", 1)
        else
            SB.SetText("  No active session", 1)
    }

    ; === EVENT HANDLERS ===

    ; Browse button — pick workspace folder
    BtnBrowse.OnEvent("Click", OnBrowse)
    OnBrowse(*) {
        SelectedDir := DirSelect("*" CurrentPath, 3, "Select Workspace Folder")
        if (SelectedDir != "") {
            PathEdit.Value := SelectedDir
            CurrentPath := SelectedDir
            RefreshWorkspaceList()
        }
    }

    ; Path edit change — refresh preview
    PathEdit.OnEvent("Change", OnPathChange)
    OnPathChange(*) {
        CurrentPath := PathEdit.Value
        RefreshWorkspaceList()
    }

    ; Double-click ListView row — open workspace folder in Explorer
    LV.OnEvent("DoubleClick", OnLVDoubleClick)
    OnLVDoubleClick(ctrl, row) {
        if (row > 0 && DirExist(CurrentPath))
            Run(CurrentPath)
    }

    ; --- Launch buttons ---
    BtnLaunchAll.OnEvent("Click", OnLaunchAll)
    OnLaunchAll(*) {
        g.Destroy()
        RunLaunchMode(CurrentPath, false)
    }

    BtnSelectLaunch.OnEvent("Click", OnSelectLaunch)
    OnSelectLaunch(*) {
        g.Destroy()
        RunLaunchMode(CurrentPath, true)
    }

    ; --- Session buttons ---
    BtnCloseAll.OnEvent("Click", OnCloseAll)
    OnCloseAll(*) {
        g.Destroy()
        RunCleanupMode(CurrentPath, false)
    }

    BtnSelectClose.OnEvent("Click", OnSelectClose)
    OnSelectClose(*) {
        g.Destroy()
        RunCleanupMode(CurrentPath, true)
    }

    BtnToggle.OnEvent("Click", OnToggle)
    OnToggle(*) {
        g.Destroy()
        RunToggleMode(false)
    }

    BtnSelectToggle.OnEvent("Click", OnSelectToggle)
    OnSelectToggle(*) {
        g.Destroy()
        RunToggleMode(true)
    }

    ; --- Tools buttons ---
    BtnSave.OnEvent("Click", OnSave)
    OnSave(*) {
        g.Destroy()
        RunSaveMode(CurrentPath, defaultPath)
    }

    BtnOpenFolder.OnEvent("Click", OnOpenFolder)
    OnOpenFolder(*) {
        if DirExist(CurrentPath)
            Run(CurrentPath)
        else
            MsgBox("Folder not found: " CurrentPath, "Open Folder", 48)
    }

    BtnHelp.OnEvent("Click", OnHelp)
    OnHelp(*) {
        ShowHelp()
    }

    ; === RESIZE HANDLER ===
    InitW := 520
    InitLVH := 210

    g.OnEvent("Size", OnMainGuiResize)
    OnMainGuiResize(thisGui, minMax, w, h) {
        if (minMax = -1)
            return

        ; Suppress painting while we batch-move controls (prevents ghost artifacts)
        SendMessage(0x000B, 0, 0, thisGui.Hwnd)  ; WM_SETREDRAW = false

        mx := 15   ; MarginX
        cx := 25   ; Control inner X (mx + 10)
        dw := w - InitW
        newGrpW := 490 + dw
        newCtrlW := 470 + dw
        newPathW := newCtrlW - 100

        dh := h - 580
        if (dh < 0)
            dh := 0
        newLVH := InitLVH + dh

        ; Resize GroupBoxes horizontally
        GrpWorkspace.Move(, , newGrpW)
        GrpContents.Move(, , newGrpW, 240 + dh)
        GrpLaunch.Move(, , newGrpW)
        GrpSession.Move(, , newGrpW)
        GrpTools.Move(, , newGrpW)

        ; Resize path edit + reposition Browse button to follow it
        PathEdit.Move(, , newPathW)
        BtnBrowse.Move(cx + newPathW + 5)

        ; Resize ListView
        LV.Move(, , newCtrlW, newLVH)

        ; Reposition groups below the contents section
        GrpContents.GetPos(, &contentsY, , &contentsH)
        newY := contentsY + contentsH + 5

        GrpLaunch.Move(, newY)
        BtnLaunchAll.Move(, newY + 22)
        BtnSelectLaunch.Move(, newY + 22)

        GrpSession.Move(, newY + 60)
        BtnCloseAll.Move(, newY + 82)
        BtnSelectClose.Move(, newY + 82)
        BtnToggle.Move(, newY + 112)
        BtnSelectToggle.Move(, newY + 112)

        GrpTools.Move(, newY + 155)
        BtnSave.Move(, newY + 177)
        BtnOpenFolder.Move(, newY + 177)
        BtnHelp.Move(, newY + 177)

        ; Re-enable painting and force a full repaint with background erase
        SendMessage(0x000B, 1, 0, thisGui.Hwnd)  ; WM_SETREDRAW = true
        DllCall("RedrawWindow", "Ptr", thisGui.Hwnd, "Ptr", 0, "Ptr", 0, "UInt", 0x0185)
        ; 0x0185 = RDW_ERASE(4) | RDW_INVALIDATE(1) | RDW_UPDATENOW(0x100) | RDW_ALLCHILDREN(0x80)
    }

    ; === WINDOW CLOSE ===
    g.OnEvent("Close", (*) => g.Destroy())

    ; === INITIAL POPULATION ===
    RefreshWorkspaceList()
    RefreshSessionStatus()

    ; Show and wait
    g.Show("w520")
    WinWaitClose(g)
}

; ==============================================================================
; EXTRACTED MODE FUNCTIONS
; ==============================================================================

; Wraps MODE 3 (Normal Launch) logic into a callable function.
RunLaunchMode(targetDir, interactive := false) {
    LaunchList := ScanWorkspace(targetDir)
    LaunchList := SortLaunchList(LaunchList)
    RunningApps := PruneSessionLog()

    if (interactive) {
        if !ShowSelectionGUI(LaunchList)
            return
    }

    ShowProgress("Starting Workspace...", 0)

    loop LaunchList.Length {
        Item := LaunchList[A_Index]
        Percent := (A_Index / LaunchList.Length) * 100

        if (Item.Mode = "CloseOnCleanup")
            continue

        if (Item.Mode = "CloseOnLaunch" || Item.Mode = "AlwaysClose") {
            ShowProgress("Closing: " Item.Name, Percent)
            TerminateApp(Item)
        } else {
            ShowProgress("Processing: " Item.Name, Percent)
            LaunchItem(Item, RunningApps)
        }
    }

    ShowProgress("Done!", 100)
    Sleep(1000)
    ShowProgress("", 0, true)
}

; Wraps MODE 2 (Cleanup/Close) logic into a callable function.
RunCleanupMode(targetDir, interactive := false) {
    if (interactive) {
        ShowProgress("Scanning active session...", 0)
        CleanUpSession(true)
    } else {
        ShowProgress("Cleaning up Workspace...", 0)
        CleanUpSession(false)
    }

    ShowProgress("Processing [Cleanup/Always] items...", 90)
    KillList := ScanWorkspace(targetDir)
    for item in KillList {
        if (item.Mode = "AlwaysClose" || item.Mode = "CloseOnCleanup")
            TerminateApp(item)
    }

    ShowProgress("Workspace Closed", 100)
    Sleep(1000)
}

; Wraps MODE 1 (Toggle Visibility) logic into a callable function.
RunToggleMode(interactive := false) {
    if (interactive) {
        ShowProgress("Loading Toggle Menu...", 0)
        ToggleSessionVisibility(true)
    } else {
        ShowProgress("Toggling Hidden Apps...", 0)
        ToggleSessionVisibility(false)
    }

    ShowProgress("Done", 100)
    Sleep(500)
}

; Wraps MODE 0 (Save Workspace) logic into a callable function.
; GUI calls use defaults (targetDir + defaultPath only).
; CLI calls pass all save-related flags.
RunSaveMode(targetDir, defaultPath, useSaveHere := false, useSaveTimestamp := false, saveName := "", saveConflict := "", isSaveAuto := false, showTrayApps := false) {
    SaveDir := ResolveSaveDirectory(targetDir, defaultPath, useSaveHere, useSaveTimestamp, saveName, saveConflict)
    if (SaveDir = "")
        return

    DetectedApps := EnumerateWindows()
    TrayApps := EnumerateTrayApps(DetectedApps)

    if (isSaveAuto) {
        FinalApps := []
        for app in DetectedApps
            FinalApps.Push(app)
        if (showTrayApps) {
            for app in TrayApps
                FinalApps.Push(app)
        }
    } else {
        FinalApps := ShowSaveGUI(DetectedApps, TrayApps, showTrayApps, SaveDir)
    }

    if (FinalApps.Length > 0) {
        CreateWorkspaceShortcuts(SaveDir, FinalApps)
        MsgBox("Workspace saved!`n`n" FinalApps.Length " shortcut(s) created in:`n" SaveDir, "Save Workspace", 64)
    } else {
        MsgBox("No apps selected. No shortcuts were created.", "Save Workspace", 48)
    }
}

; ==============================================================================
; SESSION HELPER — READ-ONLY APP COUNTER
; ==============================================================================

; Counts alive tracked apps from the session log for the GUI status bar.
; Unlike PruneSessionLog(), this does NOT modify the log file.
CountSessionApps(sessionFile) {
    if !ValidateLogFile()
        return 0
    Count := 0
    try {
        LogContent := FileRead(sessionFile)
        Lines := StrSplit(LogContent, "`n", "`r")
        for Line in Lines {
            if (Line = "" || InStr(Line, "SESSION_ID|"))
                continue
            Parts := StrSplit(Line, "|")
            if (Parts.Length < 3)
                continue
            Type := Parts[1], ID := Parts[2], TargetExe := Parts[3]
            if (Type = "PID" && ProcessExist(ID))
                Count++
            else if (Type = "HWND" && WinExist("ahk_id " ID))
                Count++
            else if (Type = "EXE" && ProcessExist(TargetExe))
                Count++
        }
    }
    return Count
}

; ==============================================================================
; LAUNCH LOGIC
; ==============================================================================

LaunchItem(item, runningAppsMap) {

    ; Enable hidden window detection to find processes/windows that start hidden
    DetectHiddenWindows(true)

    ; === 1. CHECK SINGLE INSTANCE ===
    ; Skips launch if app is already running (Idempotent behavior)
    CheckKey := (item.MatchTarget != "") ? item.MatchTarget : item.TargetExe

    if (!item.AllowDuplicates && runningAppsMap.Has(CheckKey)) {
        ExistingPID := runningAppsMap[CheckKey]
        if (item.TrackByExe) {
            if ProcessExist(CheckKey)
                return
        }
        else if ProcessExist(ExistingPID) || WinExist("ahk_id " ExistingPID) {
            return
        }
    }

    ; === 2. WAIT DEPENDENCY ===
    ; Waits for previous order numbers or specific apps
    if (item.WaitDep > 0) {
        ShowProgress("Waiting for item [" item.WaitDep "]...", 50)
        Sleep(500)
    }

    ; === 3. PREPARE RUN OPTIONS ===
    ; Only apply Min/Max/Hide at launch if we aren't waiting for the window later.
    ; This prevents applying states to splash screens or helper processes.
    RunOpt := ""
    if (item.WaitWindow == 0 && !item.TrackByExe && item.MatchTarget == "") {
        if (item.RunState = "Min")
            RunOpt := "Min"
        else if (item.RunState = "Max")
            RunOpt := "Max"
        else if (item.RunState = "Hide")
            RunOpt := "Hide"
    }

    try {
        PID := 0
        LaunchTarget := item.Path
        IsFolder := DirExist(item.TargetExe)
        MatchedID := 0
        MatchType := ""

        ; ==============================================================
        ; CASE A: TRACK BY EXE (Broad Tracking)
        ; ==============================================================
        ; For apps that spawn many processes. We track the process Name, not ID.
        if (item.TrackByExe) {
            TargetName := (item.MatchTarget != "") ? item.MatchTarget : item.TargetExe
            SplitPath(TargetName, &TargetName)

            if (item.IsAdmin)
                Run('*RunAs "' LaunchTarget '"', , RunOpt)
            else
                Run('"' LaunchTarget '"', , RunOpt)

            if ProcessWait(TargetName, 5) {
                MatchedID := 0
                MatchType := "EXE"
                IsHiddenLaunch := (item.RunState == "Hide")

                ; Log just the Exe Name
                LogSession("EXE", 0, TargetName, item.ForceKill, IsHiddenLaunch)

                ; Apply state to ALL visible windows of this executable
                if (item.RunState != "Normal") {
                    if (item.WaitWindow > 0)
                        Sleep(item.WaitWindow)

                    ApplyStateToVisibleWindows("ahk_exe " TargetName, item.RunState, item.Monitor)
                }
            } else {
                MsgBox("Warning: Process '" TargetName "' did not appear.", "Launch Warning", 48)
            }

            if (item.Delay > 0)
                Sleep(item.Delay)
            return
        }

        ; ==============================================================
        ; CASE B: MATCH / HWND / STANDARD
        ; ==============================================================

        ; Scenario: User specified [Match=App.exe] (e.g. for wrapper scripts)
        if (item.MatchTarget != "") {
            TargetName := item.MatchTarget

            ; Snapshot PIDs and HWNDs before launch
            OldPIDs := Map(), OldHWNDs := Map()
            for proc in ComObjGet("winmgmts:").ExecQuery("Select ProcessId from Win32_Process Where Name = '" TargetName "'"
            )
                OldPIDs[proc.ProcessId] := true
            try {
                for id in WinGetList("ahk_exe " TargetName)
                    OldHWNDs[id] := true
            }

            Run('"' LaunchTarget '"', , RunOpt)

            ; Wait loop for NEW PID or NEW Window Handle
            loop 40 {
                Sleep 100
                for proc in ComObjGet("winmgmts:").ExecQuery("Select ProcessId from Win32_Process Where Name = '" TargetName "'"
                ) {
                    if !OldPIDs.Has(proc.ProcessId) {
                        MatchedID := proc.ProcessId
                        MatchType := "PID"
                        break 2
                    }
                }
                try {
                    for id in WinGetList("ahk_exe " TargetName) {
                        if !OldHWNDs.Has(id) {
                            MatchedID := id
                            MatchType := "HWND"
                            break 2
                        }
                    }
                }
            }
        }
        ; Scenario: Electron Apps or Folders (Need HWND tracking)
        else if (item.ForceHWND || IsFolder) {
            OldWins := Map()
            Filter := (IsFolder) ? "ahk_class CabinetWClass" : ""
            for id in WinGetList(Filter)
                OldWins[id] := true

            if (item.IsAdmin)
                Run('*RunAs "' LaunchTarget '"', , RunOpt)
            else
                Run('"' LaunchTarget '"', , RunOpt)

            ; Wait for new window handle
            loop 40 {
                Sleep 100
                for id in WinGetList(Filter) {
                    if !OldWins.Has(id) {
                        MatchedID := id
                        MatchType := "HWND"
                        break 2
                    }
                }
            }
        }
        ; Scenario: Standard App Launch
        else {
            if (item.IsAdmin)
                Run('*RunAs "' LaunchTarget '"', , RunOpt, &PID)
            else
                Run('"' LaunchTarget '"', , RunOpt, &PID)

            if (PID) {
                MatchedID := PID
                MatchType := "PID"
            }
        }

        ; Failure Detection (Warn user if nothing happened)
        if (MatchedID == 0 && item.MatchTarget == "") {
            MsgBox("Warning: Launched '" item.Name "' but could not detect a new process or window.",
                "Launch Detection Failed", 48)
        }

        ; ==============================================================
        ; POST-LAUNCH PROCESSING (State & Logging)
        ; ==============================================================

        if (MatchedID) {
            TargetTitle := (MatchType = "PID") ? "ahk_pid " MatchedID : "ahk_id " MatchedID
            IsHiddenLaunch := (item.RunState == "Hide")
            LogSession(MatchType, MatchedID, (item.MatchTarget != "" ? item.MatchTarget : item.TargetExe), item.ForceKill,
            IsHiddenLaunch)

            NeedsManualState := (item.WaitWindow > 0 || item.MatchTarget != "" || item.ForceHWND)

            ; Apply Window State (Min/Max/Hide)
            if (NeedsManualState && item.RunState != "Normal") {
                DetectHiddenWindows(false) ; Fix: Only target visible windows
                if WinWait(TargetTitle, , 10) {
                    if (item.WaitWindow > 0) {
                        ShowProgress("Waiting for window...", 50)
                        Sleep(item.WaitWindow)
                    }

                    if WinExist(TargetTitle) {
                        ApplyStateSafe(TargetTitle, item.RunState, item.Monitor)
                    }
                }
                DetectHiddenWindows(true)
            }

            if (item.Wait) {
                DetectHiddenWindows(false)
                WinWait(TargetTitle, , 10)
                DetectHiddenWindows(true)
            }

            ; Handle Monitor Move for HWND based items
            if (item.Monitor == 2 && MatchType == "HWND") {
                DetectHiddenWindows(false)
                if WinWait(TargetTitle, , 5)
                    MoveWindowToMon2(TargetTitle, item.RunState)
                DetectHiddenWindows(true)
            }
        }
        ; Fallback: If [Match] was used but no new PID found (e.g., new tab in existing Chrome)
        else if (item.MatchTarget != "") {
            TargetTitle := "ahk_exe " item.MatchTarget
            DetectHiddenWindows(false)
            if WinExist(TargetTitle) {
                ApplyStateToVisibleWindows(TargetTitle, item.RunState, item.Monitor)
            }
            DetectHiddenWindows(true)
        }

        if (item.Delay > 0) {
            ShowProgress("Sleeping " item.Delay "ms...", 50)
            Sleep(item.Delay)
        }

    } catch as err {
        MsgBox("CRITICAL FAILURE: Could not launch '" item.Name "'`n`nError: " err.Message, "Launch Error", 16)
    }
}

; ==============================================================================
; HELPER FUNCTIONS (Window Manipulation)
; ==============================================================================

; Applies Min/Max/Hide only to windows that are currently visible.
; This prevents "Phantom Window" issues in apps like OneNote or Electron.
ApplyStateToVisibleWindows(winTitle, runState, monitor) {
    ids := WinGetList(winTitle)
    for id in ids {
        if IsWindowVisible(id) {
            ApplyStateSafe("ahk_id " id, runState, monitor)
        }
    }
}

; Moves/Resizes windows based on tags
ApplyStateSafe(target, runState, monitor) {
    if (monitor == 2)
        MoveWindowToMon2(target, runState)

    if (runState = "Max")
        WinMaximize(target)
    else if (runState = "Min")
        WinMinimize(target)
    else if (runState = "Hide")
        WinHide(target)
}

; Checks if a window has the WS_VISIBLE style
IsWindowVisible(id) {
    style := WinGetStyle("ahk_id " id)
    return (style & 0x10000000)
}

; Calculate approximate Boot Time to identify session ID
GetSystemSessionID() {
    ; Returns a string representing the boot timestamp (e.g. 20231027123000)
    ; This allows us to detect if the PC has rebooted since the log was written.
    return DateAdd(A_Now, -A_TickCount // 1000, "Seconds")
}

; Safety check to prevent killing critical Windows processes
IsSystemProcess(pid_or_name) {
    SafeList := "svchost.exe,csrss.exe,wininit.exe,winlogon.exe,services.exe,lsass.exe,smss.exe,system,registry,dwm.exe,explorer.exe"
    
    ProcessName := ""
    if IsNumber(pid_or_name) {
        try {
            ProcessName := ProcessGetName(pid_or_name)
        } catch {
            return false ; PID might be dead already, safe to ignore
        }
    } else {
        ProcessName := pid_or_name
    }
    
    return InStr("," SafeList ",", "," ProcessName ",")
}

; ==============================================================================
; SESSION MANAGEMENT
; ==============================================================================

; Validates if the log file belongs to the current OS session.
; If the PC rebooted, the log is stale and dangerous -> Delete it.
ValidateLogFile() {
    if !FileExist(SessionFile)
        return false
        
    try {
        FileObj := FileOpen(SessionFile, "r")
        Header := FileObj.ReadLine()
        FileObj.Close()
        
        ; Check Header format: SESSION_ID|YYYYMMDD...
        if !InStr(Header, "SESSION_ID|") {
            FileDelete(SessionFile) ; Legacy or corrupt log
            return false
        }
        
        SavedSession := StrSplit(Header, "|")[2]
        CurrentSession := GetSystemSessionID()
        
        ; Calculate time difference in seconds
        Diff := DateDiff(CurrentSession, SavedSession, "Seconds")
        
        ; If difference is > 120 seconds, it's a different boot session (allow small drift)
        if (Abs(Diff) > 120) {
            FileDelete(SessionFile)
            return false
        }
        return true
    } catch {
        return false
    }
}

LogSession(type, id, targetExe, forceKill, isHidden) {
    ; Create file with Session Header if it doesn't exist
    if !FileExist(SessionFile) {
        FileAppend("SESSION_ID|" GetSystemSessionID() "`n", SessionFile)
    }
    FileAppend(type "|" id "|" targetExe "|" (forceKill ? "1" : "0") "|" (isHidden ? "1" : "0") "`n", SessionFile)
}

; Toggles visibility of apps in the session log
ToggleSessionVisibility(interactive := false) {
    if !ValidateLogFile() {
        MsgBox("No active session log found (or session expired).", "Toggle", 48)
        return
    }

    DetectHiddenWindows(true)
    LogContent := FileRead(SessionFile)
    Lines := StrSplit(LogContent, "`n", "`r")
    ActiveItems := []

    ; Parse the log to find running apps
    loop Lines.Length {
        Line := Lines[A_Index]
        if (Line = "" || InStr(Line, "SESSION_ID|")) {
            continue
        }

        Parts := StrSplit(Line, "|")
        if (Parts.Length < 3) {
            continue
        }

        Item := {}
        Item.Type := Parts[1]
        Item.ID := Parts[2]
        Item.TargetExe := Parts[3]
        Item.IsHiddenLaunch := (Parts.Length >= 5 && Parts[5] = "1")
        SplitPath(Item.TargetExe, &Name)
        Item.Name := Name

        if (Item.Type = "EXE")
            Item.Target := "ahk_exe " Item.TargetExe
        else
            Item.Target := (Item.Type = "PID") ? "ahk_pid " Item.ID : "ahk_id " Item.ID

        if WinExist(Item.Target) {
            Style := WinGetStyle(Item.Target)
            Item.IsVisible := (Style & 0x10000000)
            ActiveItems.Push(Item)
        }
    }

    if (ActiveItems.Length = 0) {
        MsgBox("No tracked apps are currently running.", "Toggle", 64)
        return
    }

    FinalList := []

    ; Interactive Mode: Show Checkbox GUI
    if (interactive) {
        g := Gui()
        g.Title := "Toggle Visibility"
        g.Add("Text", , "Select items to toggle:")
        CheckBoxes := []
        for item in ActiveItems {
            StateStr := item.IsVisible ? "Visible" : "HIDDEN"
            cb := g.Add("Checkbox", "vCB" A_Index, item.Name " (" StateStr ")")
            CheckBoxes.Push({ Ctrl: cb, Item: item })
        }
        ; Note: Processing happens inside the event to prevent window destruction race conditions
        g.Add("Button", "Default w80", "Toggle").OnEvent("Click", ProcessToggleSelection)
        ProcessToggleSelection(*) {
            for obj in CheckBoxes {
                if (obj.Ctrl.Value)
                    FinalList.Push(obj.Item)
            }
            g.Destroy()
        }
        g.OnEvent("Close", (*) => ExitApp())
        g.Show()
        WinWaitClose(g)
    } else {
        ; Auto Mode: Only toggle items launched with [Hide]
        for item in ActiveItems {
            if (item.IsHiddenLaunch)
                FinalList.Push(item)
        }
    }

    ; Apply Toggle
    for item in FinalList {
        if WinExist(item.Target) {
            if (item.IsVisible) {
                WinHide(item.Target)
            } else {
                if (item.Type = "EXE" || item.Type = "PID") {
                    ids := WinGetList(item.Target)
                    for id in ids {
                        if (WinGetTitle(id) = "")
                            continue
                        WinGetPos(, , &W, &H, id)
                        if (W < 10 || H < 10)
                            continue
                        WinShow(id)
                        WinActivate(id)
                    }
                } else {
                    WinShow(item.Target)
                    WinActivate(item.Target)
                }
            }
        }
    }
}

; Removes dead PIDs/IDs from the log file on startup
PruneSessionLog() {
    LiveMap := Map()
    NewLogContent := ""
    
    ; Safety Check: Verify Session ID before pruning
    if !ValidateLogFile()
        return LiveMap ; Return empty map if log was invalid/deleted
    
    LogContent := FileRead(SessionFile)
    Lines := StrSplit(LogContent, "`n", "`r")
    
    for Line in Lines {
        if (Line = "") {
            continue
        }
        
        ; Keep Header
        if (InStr(Line, "SESSION_ID|")) {
            NewLogContent .= Line "`n"
            continue
        }

        Parts := StrSplit(Line, "|")
        if (Parts.Length < 3) {
            continue
        }

        Type := Parts[1], ID := Parts[2], TargetExe := Parts[3]

        IsAlive := false
        if (Type = "PID") {
            if ProcessExist(ID)
                IsAlive := true
        } else if (Type = "HWND") {
            if WinExist("ahk_id " ID)
                IsAlive := true
        } else if (Type = "EXE") {
            if ProcessExist(TargetExe)
                IsAlive := true
        }

        if (IsAlive) {
            if !LiveMap.Has(TargetExe)
                LiveMap[TargetExe] := (Type = "EXE" ? 0 : ID)
            NewLogContent .= Line "`n"
        }
    }
    try {
        FileDelete(SessionFile)
        FileAppend(NewLogContent, SessionFile)
    }
    return LiveMap
}

; Closes apps listed in the session log
CleanUpSession(interactive := false) {
    if !ValidateLogFile() {
        MsgBox("No active session log found (or session expired).", "Cleanup", 48)
        return
    }
    LogContent := FileRead(SessionFile)
    Lines := StrSplit(LogContent, "`n", "`r")
    ActiveItems := []

    ; Parse Log
    loop Lines.Length {
        Line := Lines[A_Index]
        if (Line = "" || InStr(Line, "SESSION_ID|")) {
            continue
        }
        Parts := StrSplit(Line, "|")
        if (Parts.Length < 3) {
            continue
        }
        Item := {}
        Item.Type := Parts[1]
        Item.ID := Parts[2]
        Item.TargetExe := Parts[3]
        Item.ForceKill := (Parts.Length >= 4 && Parts[4] = "1")
        SplitPath(Item.TargetExe, &Name)
        Item.Name := Name
        Item.OriginalLine := Line

        IsAlive := false
        if (Item.Type = "PID" && ProcessExist(Item.ID))
            IsAlive := true
        else if (Item.Type = "HWND" && WinExist("ahk_id " Item.ID))
            IsAlive := true
        else if (Item.Type = "EXE" && ProcessExist(Item.TargetExe))
            IsAlive := true

        if (IsAlive)
            ActiveItems.Push(Item)
    }

    if (ActiveItems.Length = 0) {
        FileDelete(SessionFile)
        return
    }

    FinalList := ActiveItems

    ; Interactive Selection GUI
    if (interactive) {
        g := Gui()
        g.Title := "Selective Cleanup"
        g.Add("Text", , "Uncheck items to KEEP running:")
        CheckBoxes := []
        for item in ActiveItems {
            cb := g.Add("Checkbox", "vCB" A_Index " Checked", item.Name " (" item.Type ")")
            CheckBoxes.Push({ Ctrl: cb, Item: item })
        }
        g.Add("Button", "Default w80", "Kill Selected").OnEvent("Click", ProcessKillSelection)
        ProcessKillSelection(*) {
            FinalList := []
            for obj in CheckBoxes {
                if (obj.Ctrl.Value)
                    FinalList.Push(obj.Item)
            }
            g.Destroy()
        }
        g.OnEvent("Close", (*) => ExitApp())
        g.Show()
        WinWaitClose(g)
    }

    ; Build Map of things to kill
    KillMap := Map()
    for item in FinalList {
        if (item.Type != "EXE")
            KillMap[item.ID] := true
        else
            KillMap[item.TargetExe] := true
    }

    ; Execute Cleanup
    for item in FinalList {
        ; Safety Check: System Processes
        if IsSystemProcess(item.TargetExe) || (item.Type="PID" && IsSystemProcess(item.ID))
            continue

        if (item.Type = "EXE") {
            if (item.ForceKill) {
                while ProcessExist(item.TargetExe)
                    ProcessClose(item.TargetExe)
            } else {
                ids := WinGetList("ahk_exe " item.TargetExe)
                for id in ids
                    WinClose("ahk_id " id)
            }
        }
        else if (item.Type = "PID") {
            if ProcessExist(item.ID) {
                if (item.ForceKill)
                    ProcessClose(item.ID)
                else if WinExist("ahk_pid " item.ID)
                    WinClose("ahk_pid " item.ID)
            }
        }
        else if (item.Type = "HWND") {
            if WinExist("ahk_id " item.ID)
                WinClose("ahk_id " item.ID)
        }
    }

    ; Rebuild Log with survivors (if interactive mode used)
    if (interactive) {
        RemainingLines := ""
        for item in ActiveItems {
            if (item.Type = "EXE") {
                if !KillMap.Has(item.TargetExe)
                    RemainingLines .= item.OriginalLine "`n"
            } else {
                if !KillMap.Has(item.ID)
                    RemainingLines .= item.OriginalLine "`n"
            }
        }
        ; Re-Add Header
        HeaderLine := "SESSION_ID|" GetSystemSessionID() "`n"
        FileDelete(SessionFile)
        if (RemainingLines != "")
            FileAppend(HeaderLine RemainingLines, SessionFile)
    } else {
        FileDelete(SessionFile)
    }
}

TerminateApp(item) {
    ExeName := item.Name
    
    ; Handle Shortcuts specifically to check for folders
    if (item.Ext = "lnk") {
        if DirExist(item.TargetExe) {
            SplitPath(item.TargetExe, &FolderName)
            ; Match Explorer windows with this folder title
            ids := WinGetList("ahk_class CabinetWClass")
            for id in ids {
                Title := WinGetTitle("ahk_id " id)
                if (Title = FolderName)
                    WinClose("ahk_id " id)
            }
            return
        }
        SplitPath(item.TargetExe, &ExeName)
    }
    
    if (ExeName = "explorer.exe")
        return
    if IsSystemProcess(ExeName)
        return
        
    if ProcessExist(ExeName) {
        if (item.ForceKill) {
            while ProcessExist(ExeName)
                ProcessClose(ExeName)
        } else {
            if WinExist("ahk_exe " ExeName)
                WinClose("ahk_exe " ExeName)
        }
    }
}

MoveWindowToMon2(winTitle, runState) {
    try {
        WinMove(1920, 0, , , winTitle)
        if (runState = "Max")
            WinMaximize(winTitle)
    }
}

; ==============================================================================
; HELP / USAGE
; ==============================================================================

ShowHelp() {
    HelpText := "
    (
SMART WORKSPACE LAUNCHER — Help
================================

USAGE:
  WorkspaceLauncher.exe [path] [flags]

DESCRIPTION:
  A directory-based workspace manager that treats a folder as a config.
  Place shortcuts (.lnk) in a workspace folder with special naming
  conventions, then run this tool to launch, close, or toggle them.

ARGUMENTS:
  [path]              Path to the workspace folder (default: .\Workspace)

GENERAL FLAGS:
  -h, --help          Show this help message and exit
  --build             Compile the .ahk script into an .exe (dev only)

LAUNCH MODE FLAGS:
  --close, -close     Close/kill all tracked apps (same as hold Shift)
  --toggle, -show     Toggle visibility of hidden apps (same as hold Alt)

SAVE WORKSPACE FLAGS:
  --save              Save currently running apps as workspace shortcuts
  --here              Save into the default Workspace folder
  --auto              Skip the GUI, save all detected apps automatically
  --timestamp         Create a timestamped subfolder for the save
  --name=NAME         Create a named subfolder for the save
  --merge             If target has shortcuts, merge without asking
  --replace           If target has shortcuts, delete existing first
  --tray              Show/include background/tray apps (expands tray
                      section in GUI; includes tray apps with --auto)

MODIFIER KEY COMBOS (hold while double-clicking the exe):
  (None)              Launch all items in the workspace folder
  Shift               Cleanup/Close mode (same as --close)
  Ctrl                Interactive — pick which items to launch
  Alt                 Toggle hidden apps (same as --toggle)
  Ctrl+Alt            Selective Toggle — GUI to show/hide any session app
  Ctrl+Shift          Save Workspace mode (same as --save)

FILENAME TAGS (case-insensitive, supports [], {}, or <>):
  [N]                 Launch order number (e.g. [1], [2], [10])
  [Admin]             Run as administrator
  [Wait]              Wait for app window before continuing
  [Wait=N]            Wait for item with order N to finish first
  [WaitWindow]        Wait for window to appear (default 2000ms)
    aliases: [WaitWin]
  [WaitWin=T]         Custom wait (T: ms, s=seconds, m=minutes)
  [Delay=T]           Pause after launching (T: ms, s=seconds, m=minutes)
  [Min]               Launch minimized        (alias: [Minimized])
  [Max]               Launch maximized        (alias: [Maximized])
  [Hide]              Launch hidden            (alias: [Hidden])
  [ForceKill]         Force-kill on cleanup    (aliases: [Kill], [KillForce])
  [Multi]             Allow duplicate instances (aliases: [Dup], [AllowDup])
  [HWND]              Track by window handle   (aliases: [Win], [Window])
  [TrackExe]          Track by exe name        (aliases: [Exe], [ByExe])
  [Match=app.exe]     Match against a different executable name
  [Monitor2]          Move window to second monitor

MAGIC FOLDERS (place shortcuts inside these named subfolders):
  Minimized/          Launch contents minimized
  Maximized/          Launch contents maximized
  Hidden/             Launch contents hidden
  Monitor2/           Move contents to second monitor
  CloseOnLaunch/      Close these apps when workspace launches
  AlwaysClose/        Close on both launch and cleanup
  CloseOnCleanup/     Close only during cleanup (not on launch)
  Ignore/             Skip contents entirely

EXAMPLES:
  WorkspaceLauncher.exe                        Launch default workspace
  WorkspaceLauncher.exe "D:\Workspaces\Gaming" Launch specific folder
  WorkspaceLauncher.exe --close                Close all tracked apps
  WorkspaceLauncher.exe --toggle               Show/hide hidden apps
  WorkspaceLauncher.exe --save                 Save workspace (GUI)
  WorkspaceLauncher.exe --save --here --auto   Auto-save current apps
  WorkspaceLauncher.exe --save --name=Work     Save to .\Workspace\Work
  WorkspaceLauncher.exe --save --tray          Save with tray apps shown
  WorkspaceLauncher.exe --save "D:\WS" --timestamp --replace
    )"

    g := Gui("+Resize +MinSize400x300", "WorkspaceLauncher — Help")
    g.SetFont("s10", "Consolas")
    g.MarginX := 10
    g.MarginY := 10
    g.Add("Edit", "vHelpBox ReadOnly -WantReturn w700 h500 VScroll", HelpText)
    g.OnEvent("Size", HelpGuiResize)
    g.OnEvent("Close", (*) => g.Destroy())
    g.Show("AutoSize")
    WinWaitClose(g)

    HelpGuiResize(thisGui, minMax, w, h) {
        if (minMax = -1)
            return
        thisGui["HelpBox"].Move(, , w - 20, h - 20)
    }
}

; ==============================================================================
; BUILD FUNCTION (Compile Self)
; ==============================================================================
BuildScript() {
    CompilerPath := ""

    ; 1. Try relative path
    if FileExist(A_ScriptDir "\Compiler\Ahk2Exe.exe")
        CompilerPath := A_ScriptDir "\Compiler\Ahk2Exe.exe"

    ; 2. Try Registry
    if !CompilerPath {
        try {
            InstallDir := RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\AutoHotkey", "InstallDir")
            if FileExist(InstallDir "\Compiler\Ahk2Exe.exe")
                CompilerPath := InstallDir "\Compiler\Ahk2Exe.exe"
        }
    }

    ; 3. Standard Defaults
    if !CompilerPath && FileExist("C:\Program Files\AutoHotkey\Compiler\Ahk2Exe.exe")
        CompilerPath := "C:\Program Files\AutoHotkey\Compiler\Ahk2Exe.exe"

    ; 4. Ask User (Interactive)
    if !CompilerPath {
        Result := MsgBox("Ahk2Exe (Compiler) was not found automatically.`n`nWould you like to browse for it?",
            "Compiler Missing", 52)
        if (Result = "Yes") {
            SelectedFile := FileSelect(3, "C:\Program Files\AutoHotkey", "Select Ahk2Exe.exe", "Executables (*.exe)")
            if (SelectedFile != "")
                CompilerPath := SelectedFile
        }
    }

    if !CompilerPath {
        MsgBox("Build Failed: Compiler not found or selected.", "Build Error", 16)
        return
    }

    ScriptPath := A_ScriptFullPath
    ExeName := SubStr(A_ScriptName, 1, InStr(A_ScriptName, ".", , -1) - 1) ".exe"
    ExePath := A_ScriptDir "\" ExeName
    IconPath := A_ScriptDir "\" SubStr(A_ScriptName, 1, InStr(A_ScriptName, ".", , -1) - 1) ".ico"

    Cmd := '"' CompilerPath '" /in "' ScriptPath '" /out "' ExePath '"'
    if FileExist(IconPath)
        Cmd .= ' /icon "' IconPath '"'

    try {
        RunWait(Cmd)
        MsgBox("Build Successful!`nCreated: " ExePath, "Build", 64)
    } catch as e {
        MsgBox("Build Failed: " e.Message, "Build Error", 16)
    }
}

; ==============================================================================
; CLASS DEFINITIONS
; ==============================================================================

class WorkspaceItem {
    Path := "", Name := "", Ext := "", TargetExe := "", Args := ""
    Order := 9999, RunState := "Normal", Monitor := 1
    IsAdmin := false, Wait := false, WaitDep := 0, Delay := 0
    ForceKill := false, AllowDuplicates := false, Mode := "Launch"
    MatchTarget := "", WaitWindow := 0, ForceHWND := false, TrackByExe := false

    __New(filePath, magicFolderType) {
        this.Path := filePath
        SplitPath(filePath, &name, &dir, &ext, &nameNoExt)
        this.Name := name
        this.Ext := StrLower(ext)

        ; Parse Shortcut Properties (Extract Arguments & State)
        if (this.Ext = "lnk") {
            try {
                FileGetShortcut(filePath, &target, , &args, , , , &runState)
                this.TargetExe := target
                this.Args := args
                if (runState = 7)
                    this.RunState := "Min"
                else if (runState = 3)
                    this.RunState := "Max"
                else if (runState = 0)
                    this.RunState := "Hide"
            } catch {
                this.TargetExe := filePath
            }
        } else {
            this.TargetExe := filePath
        }

        ; --- MAGIC FOLDER LOGIC (Strict Names) ---
        
        if (magicFolderType = "minimized")
            this.RunState := "Min"
        else if (magicFolderType = "maximized")
            this.RunState := "Max"
        else if (magicFolderType = "hidden")
            this.RunState := "Hide"

        if (magicFolderType = "monitor2")
            this.Monitor := 2

        if (magicFolderType = "closeonlaunch")
            this.Mode := "CloseOnLaunch"
        else if (magicFolderType = "alwaysclose")
            this.Mode := "AlwaysClose"
        else if (magicFolderType = "closeoncleanup")
            this.Mode := "CloseOnCleanup"

        this.ParseTags(nameNoExt)
    }

    ; Regex Tag Parsing (Filename Meta-Data)
    ParseTags(filename) {
        loop {
            if RegExMatch(filename, "i)[\[\{<](.*?)[\]\}>]", &match, 1) {
                content := match[1]
                filename := StrReplace(filename, match[0], "", , , 1)
                content := StrLower(Trim(content))

                ; [Order Number]
                if IsNumber(content) {
                    this.Order := Integer(content)
                    continue
                }

                ; [Flags]
                if (content = "admin")
                    this.IsAdmin := true
                else if (content = "wait")
                    this.Wait := true
                else if (content = "forcekill" || content = "killforce" || content = "kill")
                    this.ForceKill := true
                else if (content = "multi" || content = "dup" || content = "allowdup")
                    this.AllowDuplicates := true

                ; [Tracking Mode]
                else if (content = "hwnd" || content = "win" || content = "window")
                    this.ForceHWND := true
                else if (content = "trackexe" || content = "byexe" || content = "exe")
                    this.TrackByExe := true

                ; [WaitWindow] with optional time
                else if (content = "waitwindow" || content = "waitwin")
                    this.WaitWindow := 2000
                else if RegExMatch(content, "^wait(?:win|window)=([\d\.]+)(s|m|ms)?", &wMatch) {
                    val := wMatch[1]
                    unit := wMatch[2]
                    if (unit = "s")
                        this.WaitWindow := val * 1000
                    else if (unit = "m")
                        this.WaitWindow := val * 60000
                    else
                        this.WaitWindow := val
                }

                ; [State] Overrides
                else if (content = "min" || content = "minimized")
                    this.RunState := "Min"
                else if (content = "max" || content = "maximized")
                    this.RunState := "Max"
                else if (content = "hide" || content = "hidden")
                    this.RunState := "Hide"

                ; [Match] and [Delay] values
                else if RegExMatch(content, "^match=(.+)", &mMatch) {
                    this.MatchTarget := mMatch[1]
                    if !InStr(this.MatchTarget, ".")
                        this.MatchTarget .= ".exe"
                }
                else if RegExMatch(content, "^wait=(\d+)", &wMatch)
                    this.WaitDep := Integer(wMatch[1])
                else if RegExMatch(content, "^delay=([\d\.]+)(s|m|ms)?", &dMatch) {
                    val := dMatch[1]
                    unit := dMatch[2]
                    if (unit = "s")
                        this.Delay := val * 1000
                    else if (unit = "m")
                        this.Delay := val * 60000
                    else
                        this.Delay := val
                }
            } else {
                break
            }
        }
    }
}

; Recursive File Scanner
ScanWorkspace(dirPath) {
    List := []
    loop files, dirPath "\*", "R" {
        if InStr(A_LoopFileAttrib, "H") || InStr(A_LoopFileAttrib, "S")
            continue

        ParentDir := A_LoopFileDir
        FolderOptions := ""
        if (ParentDir != dirPath) {
            SplitPath(ParentDir, &FolderName)
            FolderOptions := StrLower(FolderName)
        }

        if (FolderOptions = "ignore")
            continue

        List.Push(WorkspaceItem(A_LoopFilePath, FolderOptions))
    }
    return List
}

; Simple Bubble Sort (Order > Name)
SortLaunchList(list) {
    loop list.Length {
        i := A_Index
        loop list.Length - i {
            j := A_Index
            ItemA := list[j]
            ItemB := list[j + 1]
            Swap := false
            if (ItemA.Order > ItemB.Order)
                Swap := true
            else if (ItemA.Order == ItemB.Order) {
                if StrCompare(ItemA.Name, ItemB.Name, "Logical") > 0
                    Swap := true
            }
            if (Swap) {
                list[j] := ItemB
                list[j + 1] := ItemA
            }
        }
    }
    return list
}

; Interactive Checklist GUI
ShowSelectionGUI(list) {
    g := Gui()
    g.Title := "Launch Selection"
    g.Add("Text", , "Select items:")
    CheckBoxes := []
    for item in list {
        Label := "[" item.Order "] " item.Name
        if (item.Mode = "CloseOnLaunch" || item.Mode = "AlwaysClose")
            Label .= " (CLOSE)"
        else if (item.Mode = "CloseOnCleanup")
            Label .= " (CLEANUP)"

        cb := g.Add("Checkbox", "vCB" A_Index " Checked", Label)
        CheckBoxes.Push({ Ctrl: cb, Item: item })
    }
    g.Add("Button", "Default w80", "Launch").OnEvent("Click", ProcessLaunch)
    ProcessLaunch(*) {
        list.Length := 0
        for obj in CheckBoxes {
            if (obj.Ctrl.Value)
                list.Push(obj.Item)
        }
        g.Destroy()
    }
    g.OnEvent("Close", (*) => ExitApp())
    g.Show()
    WinWaitClose(g)
    return true
}

ShowProgress(text, val, hide := false) {
    static pGui := ""
    static pText := ""
    static pBar := ""
    if (hide) {
        if IsObject(pGui)
            pGui.Destroy()
        pGui := ""
        return
    }
    if !IsObject(pGui) {
        pGui := Gui("+AlwaysOnTop -Caption +ToolWindow")
        pGui.BackColor := "222222"
        pGui.SetFont("s10 cWhite", "Segoe UI")
        pText := pGui.Add("Text", "w300 Center", text)
        pBar := pGui.Add("Progress", "w300 h10 c0078D7 Background444444", val)
        pGui.Show("x" (A_ScreenWidth - 320) " y" (A_ScreenHeight - 100) " NoActivate")
    } else {
        pText.Value := text
        pBar.Value := val
    }
}

; ==============================================================================
; SAVE WORKSPACE — CLASS DEFINITION
; ==============================================================================

class SaveItem {
    Name := ""          ; Display name (from window title or exe)
    ExePath := ""       ; Full path to the executable
    ProcessName := ""   ; e.g., "code.exe"
    Tags := ""          ; Auto-detected tag string e.g., "[Max] [TrackExe]"
    Selected := true    ; For GUI checkbox
    Order := 0          ; Sequential order number
    HWND := 0           ; Window handle for reference
    IsFolder := false   ; True if this is an Explorer folder window
    FolderPath := ""    ; Full folder path (e.g., "C:\Users\Admin\Downloads")
    IsTrayApp := false  ; True if detected as tray/background process
    Args := ""          ; Command-line arguments (populated from Start Menu shortcut)
    WorkDir := ""       ; Working directory override (populated from Start Menu shortcut)
}

; ==============================================================================
; SAVE WORKSPACE — KNOWN APP INTELLIGENCE
; ==============================================================================

; Electron/multi-process apps that benefit from [TrackExe]
GetElectronApps() {
    apps := Map()
    apps["code.exe"] := true         ; VS Code
    apps["discord.exe"] := true      ; Discord
    apps["slack.exe"] := true        ; Slack
    apps["teams.exe"] := true        ; Teams
    apps["spotify.exe"] := true      ; Spotify
    apps["obsidian.exe"] := true     ; Obsidian
    apps["notion.exe"] := true       ; Notion
    apps["whatsapp.exe"] := true     ; WhatsApp Desktop
    apps["telegram.exe"] := true     ; Telegram
    apps["signal.exe"] := true       ; Signal
    apps["figma.exe"] := true        ; Figma
    apps["postman.exe"] := true      ; Postman
    apps["1password.exe"] := true    ; 1Password
    return apps
}

; Background/system processes to exclude from tray app detection
GetBackgroundExclusions() {
    excl := Map()
    excl["SearchHost.exe"] := true
    excl["StartMenuExperienceHost.exe"] := true
    excl["ShellExperienceHost.exe"] := true
    excl["RuntimeBroker.exe"] := true
    excl["backgroundTaskHost.exe"] := true
    excl["SecurityHealthSystray.exe"] := true
    excl["TextInputHost.exe"] := true
    excl["WidgetService.exe"] := true
    excl["Widgets.exe"] := true
    excl["SystemSettings.exe"] := true
    excl["conhost.exe"] := true
    excl["dllhost.exe"] := true
    excl["WmiPrvSE.exe"] := true
    excl["fontdrvhost.exe"] := true
    excl["sihost.exe"] := true
    excl["taskhostw.exe"] := true
    excl["ctfmon.exe"] := true
    excl["CompPkgSrv.exe"] := true
    excl["LockApp.exe"] := true
    excl["SearchIndexer.exe"] := true
    excl["SearchProtocolHost.exe"] := true
    excl["SearchFilterHost.exe"] := true
    excl["MsMpEng.exe"] := true
    excl["NisSrv.exe"] := true
    excl["SecurityHealthService.exe"] := true
    excl["SgrmBroker.exe"] := true
    excl["spoolsv.exe"] := true
    excl["wlanext.exe"] := true
    excl["unsecapp.exe"] := true
    excl["audiodg.exe"] := true
    excl["WindowsTerminal.exe"] := true
    excl["msedgewebview2.exe"] := true
    excl["PhoneExperienceHost.exe"] := true
    excl["UserOOBEBroker.exe"] := true
    excl["MusNotifyIcon.exe"] := true
    excl["MoUsoCoreWorker.exe"] := true
    excl["TiWorker.exe"] := true
    excl["WUDFHost.exe"] := true
    excl["dasHost.exe"] := true
    excl["TabTip.exe"] := true
    excl["ApplicationFrameHost.exe"] := true
    return excl
}

; Processes that may have visible windows but are OS UI components, not user apps.
; These pass Alt+Tab filtering but should NOT be captured as workspace items.
GetWindowProcessExclusions() {
    excl := Map()
    excl["TextInputHost.exe"] := true           ; Windows Input Experience (full-screen overlay)
    excl["ShellHost.exe"] := true               ; Shell hosting (DesktopWindowXamlSource)
    excl["SearchHost.exe"] := true              ; Windows Search UI
    excl["StartMenuExperienceHost.exe"] := true ; Start Menu
    excl["ShellExperienceHost.exe"] := true     ; Shell Experience (Action Center, etc.)
    excl["LockApp.exe"] := true                 ; Lock screen
    excl["SystemSettings.exe"] := true          ; Windows Settings (transient)
    excl["ApplicationFrameHost.exe"] := true    ; UWP frame host (handled separately for real UWP apps)
    return excl
}

; Generic host processes — interpreters/runtimes that host other applications.
; Windows using these need Start Menu shortcut lookup to identify the actual app.
GetGenericHostProcesses() {
    hosts := Map()
    hosts["pythonw.exe"] := true     ; Python (no console)
    hosts["python.exe"] := true      ; Python (with console)
    hosts["python3.exe"] := true     ; Python 3
    hosts["javaw.exe"] := true       ; Java (no console)
    hosts["java.exe"] := true        ; Java (with console)
    hosts["node.exe"] := true        ; Node.js
    hosts["ruby.exe"] := true        ; Ruby
    hosts["rubyw.exe"] := true       ; Ruby (no console)
    hosts["wish.exe"] := true        ; Tcl/Tk
    hosts["perl.exe"] := true        ; Perl
    hosts["wscript.exe"] := true     ; Windows Script Host (GUI)
    return hosts
}

; Search Start Menu shortcuts for one matching a window title.
; Used when a generic host process (e.g., pythonw.exe) is detected — the real app
; identity is determined by matching the window title against Start Menu shortcut names.
; Returns an object {Name, Target, Args, WorkDir, Icon} or "" if no match found.
FindStartMenuShortcut(windowTitle) {
    static shortcutCache := ""

    ; Build cache on first call — scans both per-user and system-wide Start Menu
    if (shortcutCache = "") {
        shortcutCache := []
        StartMenuDirs := [
            A_AppData "\Microsoft\Windows\Start Menu\Programs",
            EnvGet("ProgramData") "\Microsoft\Windows\Start Menu\Programs"
        ]

        for dir in StartMenuDirs {
            if !DirExist(dir)
                continue
            loop files, dir "\*.lnk", "R" {
                try {
                    lnkPath := A_LoopFilePath
                    SplitPath(A_LoopFileName, , , , &nameNoExt)

                    target := ""
                    workDir := ""
                    args := ""
                    desc := ""
                    icon := ""
                    FileGetShortcut(lnkPath, &target, &workDir, &args, &desc, &icon)

                    if (target = "")
                        continue

                    shortcutCache.Push({
                        Name: nameNoExt,
                        Target: target,
                        Args: args,
                        WorkDir: workDir,
                        Icon: icon
                    })
                }
            }
        }
    }

    ; Find best match: shortcut name appears in the window title (case-insensitive)
    titleLower := StrLower(windowTitle)
    BestMatch := ""
    BestScore := 0

    for sc in shortcutCache {
        scNameLower := StrLower(sc.Name)

        ; Skip very short names (< 3 chars) to avoid false positives
        if (StrLen(sc.Name) < 3)
            continue

        score := 0
        if (InStr(titleLower, scNameLower))
            score := StrLen(sc.Name)  ; Longer name match = higher confidence

        if (score > BestScore) {
            BestScore := score
            BestMatch := sc
        }
    }

    return BestMatch
}

; ==============================================================================
; SAVE WORKSPACE — DIRECTORY RESOLUTION (Step 3)
; ==============================================================================

ResolveSaveDirectory(targetDir, defaultPath, useSaveHere, useSaveTimestamp, saveName, saveConflict) {
    ; 1. Determine base directory
    if (useSaveHere) {
        baseDir := defaultPath
    } else if (targetDir != defaultPath) {
        ; User passed a specific path argument
        baseDir := targetDir
    } else {
        ; Show folder picker
        baseDir := DirSelect("*" A_ScriptDir, 3, "Select folder to save workspace shortcuts:")
        if (baseDir = "")
            return ""
    }

    ; 2. Apply subfolder naming
    if (useSaveTimestamp) {
        finalDir := baseDir "\" FormatTime(A_Now, "yyyyMMdd_HHmmss")
    } else if (saveName != "") {
        finalDir := baseDir "\" saveName
    } else {
        finalDir := baseDir
    }

    ; 3. Create directory if needed
    if !DirExist(finalDir)
        DirCreate(finalDir)

    ; 4. Conflict check (only if finalDir already has .lnk files)
    HasLinks := false
    loop files, finalDir "\*.lnk" {
        HasLinks := true
        break
    }

    if (HasLinks) {
        if (saveConflict = "merge") {
            ; Silently merge — do nothing, proceed
            return finalDir
        } else if (saveConflict = "replace") {
            ; Delete existing .lnk files
            loop files, finalDir "\*.lnk"
                FileDelete(A_LoopFilePath)
            return finalDir
        } else {
            ; Prompt user
            Result := MsgBox("The folder already contains shortcut files:`n" finalDir "`n`nMerge: Add new shortcuts alongside existing ones`nReplace: Delete all existing shortcuts first`nCancel: Abort save",
                "Folder Not Empty", 0x3 + 0x30)  ; YesNoCancel + Warning icon
            if (Result = "Yes") {
                ; Merge
                return finalDir
            } else if (Result = "No") {
                ; Replace
                loop files, finalDir "\*.lnk"
                    FileDelete(A_LoopFilePath)
                return finalDir
            } else {
                ; Cancel
                return ""
            }
        }
    }

    return finalDir
}

; ==============================================================================
; SAVE WORKSPACE — WINDOW ENUMERATION (Step 4)
; ==============================================================================

EnumerateWindows() {
    ; IMPORTANT: Only enumerate VISIBLE windows. DetectHiddenWindows(true) would
    ; capture ~90+ invisible helper windows (IME, DDE, COM, etc.) from apps like
    ; Discord, OBS, ShareX, etc. — those belong in the Tray/Background section.
    DetectHiddenWindows(false)
    ElectronApps := GetElectronApps()
    WindowExclusions := GetWindowProcessExclusions()
    GenericHosts := GetGenericHostProcesses()
    Results := []
    SeenExes := Map()

    ; Build Explorer path map via Shell COM
    ExplorerPaths := Map()
    try {
        shell := ComObject("Shell.Application")
        windows := shell.Windows()
        loop windows.Count {
            try {
                win := windows.Item(A_Index - 1)
                winHwnd := win.HWND
                folderPath := win.Document.Folder.Self.Path
                if (folderPath != "")
                    ExplorerPaths[winHwnd] := folderPath
            }
        }
    }

    ; Get self process name to exclude
    SelfPID := ProcessExist()
    SelfName := ""
    try SelfName := ProcessGetName(SelfPID)

    ; Get all visible window IDs
    AllWindows := WinGetList()

    for id in AllWindows {
        try {
            ; a. Get title — skip if empty
            Title := WinGetTitle("ahk_id " id)
            if (Title = "")
                continue

            ; b. Alt+Tab filter: Skip tool windows and owned popup windows.
            ;    This mirrors what Windows shows in Alt+Tab — only "real" app windows.
            ExStyle := WinGetExStyle("ahk_id " id)
            if (ExStyle & 0x00000080) ; WS_EX_TOOLWINDOW — never in Alt+Tab
                continue
            if !(ExStyle & 0x00040000) { ; Not WS_EX_APPWINDOW
                ; Check if window has an owner — owned windows don't appear in Alt+Tab
                ; unless they have WS_EX_APPWINDOW (checked above)
                try {
                    Owner := DllCall("GetWindow", "Ptr", id, "UInt", 4, "Ptr") ; GW_OWNER = 4
                    if (Owner != 0)
                        continue
                }
            }

            ; c. Get size — skip if < 10x10 pixels (catches message-only windows)
            WinGetPos(&X, &Y, &W, &H, "ahk_id " id)
            if (W < 10 || H < 10)
                continue

            ; d. Get PID → get process name + window class
            PID := WinGetPID("ahk_id " id)
            ProcessName := ""
            try ProcessName := ProcessGetName(PID)
            if (ProcessName = "")
                continue
            WinClass := WinGetClass("ahk_id " id)

            ; e. Detect Explorer folder windows FIRST (before system process filter,
            ;    since explorer.exe is in the system process safelist)
            if (WinClass = "CabinetWClass" && ProcessName = "explorer.exe") {
                ; Look up HWND in the Explorer path map
                if ExplorerPaths.Has(id) {
                    FolderPath := ExplorerPaths[id]
                    SplitPath(FolderPath, &FolderName)

                    item := SaveItem()
                    item.Name := FolderName
                    item.ExePath := FolderPath
                    item.ProcessName := "explorer.exe"
                    item.IsFolder := true
                    item.FolderPath := FolderPath
                    item.HWND := id
                    item.Selected := true

                    ; Detect state for folder window
                    style := WinGetStyle("ahk_id " id)
                    if (style & 0x20000000)
                        item.Tags := "[Min]"
                    else if (style & 0x01000000)
                        item.Tags := "[Max]"
                    else
                        item.Tags := ""

                    ; Detect monitor
                    if (X >= A_ScreenWidth)
                        item.Tags .= (item.Tags != "" ? " " : "") "[Monitor2]"

                    Results.Push(item)
                }
                continue
            }

            ; Skip explorer.exe windows that aren't folder windows (e.g., desktop)
            if (ProcessName = "explorer.exe")
                continue

            ; f. Skip system processes (after Explorer folder check)
            if IsSystemProcess(ProcessName)
                continue

            ; g. Skip self
            if (ProcessName = SelfName)
                continue

            ; h. Skip known non-app window processes (OS UI components)
            if WindowExclusions.Has(ProcessName)
                continue

            ; i. Skip known ghost/framework windows
            if (ProcessName = "ApplicationFrameHost.exe" && WinClass != "ApplicationFrameWindow")
                continue

            ; j. Detect state (only Min/Max since we only see visible windows)
            style := WinGetStyle("ahk_id " id)
            StateTag := ""
            if (style & 0x20000000)
                StateTag := "[Min]"
            else if (style & 0x01000000)
                StateTag := "[Max]"
            ; Note: No [Hide] detection here — hidden windows are handled by EnumerateTrayApps

            ; k. Detect monitor
            MonitorTag := ""
            if (X >= A_ScreenWidth)
                MonitorTag := "[Monitor2]"

            ; l. Detect exe path
            ExePath := ""
            try ExePath := ProcessGetPath(PID)
            if (ExePath = "")
                continue

            ; l2. Generic host process resolution — look up actual app via Start Menu
            ProcNameLower := StrLower(ProcessName)
            IsGenericHost := GenericHosts.Has(ProcNameLower)
            ResolvedName := ""
            ResolvedTarget := ""
            ResolvedArgs := ""
            ResolvedWorkDir := ""

            if (IsGenericHost) {
                match := FindStartMenuShortcut(Title)
                if (match != "") {
                    ResolvedName := match.Name
                    ResolvedTarget := match.Target
                    ResolvedArgs := match.Args
                    ResolvedWorkDir := match.WorkDir
                }
            }

            ; m. Build detected tags string
            Tags := ""
            if (StateTag != "")
                Tags := StateTag
            if (MonitorTag != "") {
                if (Tags != "")
                    Tags .= " "
                Tags .= MonitorTag
            }
            ; Check if Electron app → suggest [TrackExe]
            if ElectronApps.Has(ProcNameLower) {
                if (Tags != "")
                    Tags .= " "
                Tags .= "[TrackExe]"
            }
            ; For generic hosts, always add [Match=<process>] so WorkspaceLauncher
            ; can match the window at launch time regardless of resolved shortcut target
            if (IsGenericHost) {
                if (Tags != "")
                    Tags .= " "
                Tags .= "[Match=" ProcessName "]"
            }

            ; n. Deduplicate: group by exe name, keep most meaningful title
            ;    Explorer windows (folders) are NOT deduplicated (handled above)
            ;    Generic host processes dedup by resolved app name, not process name
            DedupKey := ProcNameLower
            if (IsGenericHost && ResolvedName != "")
                DedupKey := "generic:" StrLower(ResolvedName)
            else if (IsGenericHost)
                DedupKey := "generic:" StrLower(Title)  ; Unresolved: each unique title is separate

            if SeenExes.Has(DedupKey) {
                ; Already have this exe — keep the one with the longer/more meaningful title
                ExistingIdx := SeenExes[DedupKey]
                ExistingItem := Results[ExistingIdx]
                CurrentName := (IsGenericHost && ResolvedName != "") ? ResolvedName : Title
                if (StrLen(CurrentName) > StrLen(ExistingItem.Name)) {
                    ExistingItem.Name := CurrentName
                    ExistingItem.Tags := Tags
                    ExistingItem.HWND := id
                }
                continue
            }

            ; Build display name
            if (IsGenericHost && ResolvedName != "") {
                ; Use the resolved app name from Start Menu shortcut
                DisplayName := ResolvedName
            } else {
                ; Normal path: clean up title suffixes
                DisplayName := Title
                DisplayName := RegExReplace(DisplayName, "\s*[-–—]\s*[^-–—]+$", "")
                if (DisplayName = "")
                    DisplayName := RegExReplace(ProcessName, "\.exe$", "")
            }

            item := SaveItem()
            item.Name := DisplayName
            item.ExePath := (ResolvedTarget != "") ? ResolvedTarget : ExePath
            item.ProcessName := ProcessName
            item.Tags := Tags
            item.Selected := true
            item.HWND := id
            item.Args := ResolvedArgs
            item.WorkDir := ResolvedWorkDir

            Results.Push(item)
            SeenExes[DedupKey] := Results.Length
        }
    }

    if (Results.Length = 0) {
        ; No windows detected — will be handled by caller
    }

    return Results
}

; ==============================================================================
; SAVE WORKSPACE — TRAY APP ENUMERATION (Step 4b)
; ==============================================================================

EnumerateTrayApps(alreadyDetectedApps) {
    Results := []
    BackgroundExclusions := GetBackgroundExclusions()

    ; 1. Build a set of already-detected exe names
    DetectedExes := Map()
    for app in alreadyDetectedApps {
        DetectedExes[StrLower(app.ProcessName)] := true
    }

    ; 2. Query running processes via WMI
    SeenTrayExes := Map()
    try {
        for proc in ComObjGet("winmgmts:").ExecQuery(
            "Select Name, ProcessId, ExecutablePath from Win32_Process") {

            ProcName := ""
            try ProcName := proc.Name
            if (ProcName = "")
                continue

            ProcNameLower := StrLower(ProcName)

            ; a. Skip already-detected
            if DetectedExes.Has(ProcNameLower)
                continue

            ; b. Skip system processes
            if IsSystemProcess(ProcName)
                continue

            ; c. Skip self
            SelfPID := ProcessExist()
            try {
                SelfName := ProcessGetName(SelfPID)
                if (ProcNameLower = StrLower(SelfName))
                    continue
            }

            ; d. Skip known background services
            if BackgroundExclusions.Has(ProcName)
                continue

            ; e. Skip processes with no ExecutablePath
            ExePath := ""
            try ExePath := proc.ExecutablePath
            if (ExePath = "")
                continue

            ; g. Deduplicate by exe name
            if SeenTrayExes.Has(ProcNameLower)
                continue
            SeenTrayExes[ProcNameLower] := true

            ; f. Create SaveItem
            FriendlyName := RegExReplace(ProcName, "\.exe$", "")

            item := SaveItem()
            item.Name := FriendlyName
            item.ExePath := ExePath
            item.ProcessName := ProcName
            item.Tags := "[Hide]"
            item.IsTrayApp := true
            item.Selected := false  ; Unchecked by default in GUI

            Results.Push(item)
        }
    }

    return Results
}

; ==============================================================================
; SAVE WORKSPACE — SELECTION GUI (Step 5)
; ==============================================================================

ShowSaveGUI(windowApps, trayApps, showTrayExpanded, saveDir) {
    FinalApps := []

    if (windowApps.Length = 0 && trayApps.Length = 0) {
        MsgBox("No running applications were detected.", "Save Workspace", 48)
        return FinalApps
    }

    ; --- Build unified item list with section markers ---
    AllItems := []        ; Array of SaveItem references (window apps first, then tray)
    RowToItem := Map()    ; ListView row → SaveItem

    g := Gui("+Resize -MaximizeBox +MinSize480x400")
    g.Title := "Save Workspace"
    g.SetFont("s10", "Segoe UI")
    g.MarginX := 15
    g.MarginY := 10

    g.Add("Text", "w550", "Select applications to save as workspace shortcuts:")

    ; --- ListView with checkboxes ---
    LV := g.Add("ListView", "w550 h320 Checked vAppList -Multi", ["Application", "Tags", "Section"])
    LV.ModifyCol(1, 240)
    LV.ModifyCol(2, 200)
    LV.ModifyCol(3, 80)

    ; Populate window apps (checked by default)
    for app in windowApps {
        Label := app.Name
        if (app.IsFolder)
            Label := "📁 " app.Name

        rowNum := LV.Add(app.Selected ? "Check" : "", Label, app.Tags, "Window")
        AllItems.Push(app)
        RowToItem[rowNum] := AllItems.Length
    }

    ; Add separator row for tray section
    TrayStartRow := 0
    TrayExpanded := showTrayExpanded
    if (trayApps.Length > 0) {
        if (showTrayExpanded) {
            ; --tray flag: show tray apps immediately
            TrayStartRow := LV.Add("", "▼ Background/Tray Apps (" trayApps.Length ") ──", "", "───")
        } else {
            ; Default: collapsed — double-click to expand
            TrayStartRow := LV.Add("", "▶ Background/Tray Apps (" trayApps.Length ") — double-click to show", "", "───")
        }
        AllItems.Push("")  ; placeholder for separator
        RowToItem[TrayStartRow] := 0  ; not selectable

        ; Remove checkbox from separator row by setting state image index to 0
        LVITEM := Buffer(48, 0)
        NumPut("UInt", 0, LVITEM, 12)       ; state = 0 (no checkbox image)
        NumPut("UInt", 0xF000, LVITEM, 16)  ; stateMask = LVIS_STATEIMAGEMASK
        SendMessage(0x102B, TrayStartRow - 1, LVITEM.Ptr, LV.Hwnd)  ; LVM_SETITEMSTATE

        if (showTrayExpanded) {
            ; Populate tray apps immediately
            for app in trayApps {
                rowNum := LV.Add(app.Selected ? "Check" : "", app.Name, app.Tags, "Tray")
                AllItems.Push(app)
                RowToItem[rowNum] := AllItems.Length
            }
        }
    }

    ; Double-click handler: expand tray section on separator click
    LV.OnEvent("DoubleClick", OnDoubleClick)
    OnDoubleClick(ctrl, row) {
        if (row = TrayStartRow && !TrayExpanded && trayApps.Length > 0) {
            TrayExpanded := true
            LV.Modify(TrayStartRow, , "▼ Background/Tray Apps (" trayApps.Length ") ──", "", "───")
            ; Add tray app rows below separator
            for app in trayApps {
                rowNum := LV.Add(app.Selected ? "Check" : "", app.Name, app.Tags, "Tray")
                AllItems.Push(app)
                RowToItem[rowNum] := AllItems.Length
            }
        }
    }

    ; --- Tag Editor (below ListView) ---
    TagLabel := g.Add("Text", "xm w550", "Edit tags for selected item:")
    TagEdit := g.Add("Edit", "xm w550 h25 vTagEdit")
    TagEdit.Enabled := false
    SelectedRow := 0  ; Track which row is being edited

    ; When user clicks a row, load its tags into the editor
    LV.OnEvent("ItemFocus", OnRowSelect)
    OnRowSelect(ctrl, row) {
        ; Save previous row's tags first
        if (SelectedRow > 0 && RowToItem.Has(SelectedRow) && RowToItem[SelectedRow] > 0) {
            LV.Modify(SelectedRow, , , TagEdit.Value)
        }

        SelectedRow := row
        if (RowToItem.Has(row) && RowToItem[row] > 0) {
            TagEdit.Value := LV.GetText(row, 2)
            TagEdit.Enabled := true
        } else {
            TagEdit.Value := ""
            TagEdit.Enabled := false
        }
    }

    ; --- Target path display ---
    TargetLabel := g.Add("Text", "xm w550", "Target: " saveDir)

    ; --- Buttons ---
    BtnSave := g.Add("Button", "xm Default w100 Section", "Save")
    BtnCancel := g.Add("Button", "w100 ys", "Cancel")

    ; Save: commit current edit, collect checked items
    BtnSave.OnEvent("Click", DoSave)
    DoSave(*) {
        ; Commit any pending tag edit
        if (SelectedRow > 0 && RowToItem.Has(SelectedRow) && RowToItem[SelectedRow] > 0) {
            LV.Modify(SelectedRow, , , TagEdit.Value)
        }

        ; Collect all checked rows
        loop LV.GetCount() {
            row := A_Index
            if !RowToItem.Has(row)
                continue
            idx := RowToItem[row]
            if (idx <= 0)
                continue

            ; Check if row is checked (bit 0x2000 in options)
            opts := SendMessage(0x102C, row - 1, 0xF000, LV.Hwnd)  ; LVM_GETITEMSTATE, LVIS_STATEIMAGEMASK
            isChecked := ((opts >> 12) - 1) > 0

            if (isChecked) {
                item := AllItems[idx]
                item.Tags := LV.GetText(row, 2)
                item.Selected := true
                FinalApps.Push(item)
            }
        }
        g.Destroy()
    }

    ; Cancel
    BtnCancel.OnEvent("Click", (*) => g.Destroy())
    g.OnEvent("Close", (*) => g.Destroy())

    ; Handle resize — stretch ListView vertically, reposition all bottom controls
    g.OnEvent("Size", OnGuiResize)
    OnGuiResize(thisGui, minMax, w, h) {
        if (minMax = -1)
            return
        mx := 15  ; MarginX
        newW := w - (mx * 2)
        ; Reserve space for bottom controls
        bottomH := 130
        lvH := h - bottomH - 50
        if (lvH < 80)
            lvH := 80

        ; Calculate Y positions for bottom controls
        lvBottom := 50 + lvH
        yTagLabel := lvBottom + 5
        yTagEdit := yTagLabel + 22
        yTarget := yTagEdit + 32
        yButtons := yTarget + 25

        ; Use DeferWindowPos for atomic batch-move (prevents ghost artifacts)
        SWP := 0x0014  ; SWP_NOZORDER | SWP_NOACTIVATE
        hdwp := DllCall("BeginDeferWindowPos", "Int", 6, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", LV.Hwnd, "Ptr", 0, "Int", mx, "Int", 50, "Int", newW, "Int", lvH, "UInt", SWP, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", TagLabel.Hwnd, "Ptr", 0, "Int", mx, "Int", yTagLabel, "Int", newW, "Int", 20, "UInt", SWP, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", TagEdit.Hwnd, "Ptr", 0, "Int", mx, "Int", yTagEdit, "Int", newW, "Int", 25, "UInt", SWP, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", TargetLabel.Hwnd, "Ptr", 0, "Int", mx, "Int", yTarget, "Int", newW, "Int", 20, "UInt", SWP, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", BtnSave.Hwnd, "Ptr", 0, "Int", mx, "Int", yButtons, "Int", 100, "Int", 30, "UInt", SWP, "Ptr")
        hdwp := DllCall("DeferWindowPos", "Ptr", hdwp, "Ptr", BtnCancel.Hwnd, "Ptr", 0, "Int", mx + 115, "Int", yButtons, "Int", 100, "Int", 30, "UInt", SWP, "Ptr")
        DllCall("EndDeferWindowPos", "Ptr", hdwp)

        ; Update column widths after LV resize
        LV.ModifyCol(1, newW * 0.44)
        LV.ModifyCol(2, newW * 0.37)
        LV.ModifyCol(3, newW * 0.15)

        ; Force full repaint with background erase to clear ghost text
        DllCall("RedrawWindow", "Ptr", thisGui.Hwnd, "Ptr", 0, "Ptr", 0, "UInt", 0x0185)
        ; 0x0185 = RDW_ERASE(4) | RDW_INVALIDATE(1) | RDW_UPDATENOW(0x100) | RDW_ALLCHILDREN(0x80)
    }

    g.Show("w800")
    WinWaitClose(g)

    return FinalApps
}

; ==============================================================================
; SAVE WORKSPACE — SHORTCUT CREATION (Step 6)
; ==============================================================================

CreateWorkspaceShortcuts(saveDir, appList) {
    ; 1. Assign sequential order numbers
    OrderNum := 1
    for app in appList {
        app.Order := OrderNum
        OrderNum++
    }

    ; 2. Create shortcuts
    for app in appList {
        ; Build tags string (clean up whitespace)
        TagStr := Trim(app.Tags)

        ; Build filename: "[N] AppName Tags.lnk"
        FileName := "[" app.Order "] " app.Name
        if (TagStr != "")
            FileName .= " " TagStr
        FileName .= ".lnk"

        ; Sanitize filename (remove invalid characters)
        FileName := RegExReplace(FileName, '[<>:"/\\|?*]', "_")

        ; Determine shortcut RunState from tags
        RunState := 1  ; Normal
        if InStr(TagStr, "[Min]")
            RunState := 7
        else if InStr(TagStr, "[Max]")
            RunState := 3
        else if InStr(TagStr, "[Hide]")
            RunState := 0

        ; Handle name collisions
        FullPath := saveDir "\" FileName
        if FileExist(FullPath) {
            Suffix := 2
            loop {
                NewName := RegExReplace(FileName, "\.lnk$", " (" Suffix ").lnk")
                FullPath := saveDir "\" NewName
                if !FileExist(FullPath)
                    break
                Suffix++
            }
        }

        ; Create shortcut
        try {
            if (app.IsFolder) {
                ; Create folder shortcut
                FileCreateShortcut(app.FolderPath, FullPath)
            } else {
                ; Normal app shortcut — use saved WorkDir/Args from Start Menu if available
                WorkDir := app.WorkDir
                if (WorkDir = "")
                    SplitPath(app.ExePath, , &WorkDir)
                FileCreateShortcut(app.ExePath, FullPath, WorkDir, app.Args, , , , , RunState)
            }
        } catch as err {
            ; Silently skip failed shortcuts (e.g., admin-protected paths)
        }
    }
}