fix(hammerspoon): make ⌥0 consolidation work on macOS 26 (Tahoe)

moveWindowToSpace is a no-op on macOS 26 (returns true, moves nothing),
and allWindows() only enumerates the current Space, so the first cut
found 0 windows and moved nothing. Rebuild on mechanisms that work on
Tahoe: enumerate every Space via an all-Spaces hs.window.filter,
un-full-screen those windows, then removeSpace every user Space except
each screen's focused one (removeSpace migrates a Space's windows onto a
neighbour, funnelling everything onto the survivor).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ChipWolf

.agents/skills/hammerspoon/SKILL.md

@@ -11,7 +11,8 @@ Hammerspoon provides direct macOS Space switching: `⌥1`–`⌥5` (Option, matc
 
 - **Bind number-row Space switches with `hs.eventtap`, not `hs.hotkey.bind`.** The keys are `⌥1`..`⌥5` (Option, matching Komorebi's `alt`+number). Two reasons the tap is needed: (1) on macOS `⌥`+number normally types special characters (`¡™£¢∞`), and the tap returns `true` to swallow the keystroke before the input system inserts the character, so the Space switches and nothing is typed (verified by reading a focused text field after a synthetic `⌥1`); (2) `⌃`+number can't go through `hs.hotkey` at all: macOS reserves `⌃1`..`⌃N` as Carbon hotkeys for "Switch to Desktop" by the number of Mission Control *user* desktops even when the System Settings checkboxes are off, so `RegisterEventHotKey` rejects them (`hs.hotkey:enable()` returns nil, console logs `-9878 ... already registered`). Diagnose hotkey issues with `hs -c 'return #hs.hotkey.getHotkeys()'` plus the Hammerspoon console.
 - **`hs.spaces` reaches full-screen spaces.** `hs.spaces.spacesForScreen(uuid)` lists every Space (user and full screen/tiled, per `hs.spaces.spaceType`) in Mission Control order, and `hs.spaces.gotoSpace(id)` activates one by driving its Mission Control thumbnail, so it can land on full-screen spaces (the native `⌃`+number shortcuts cannot). Map "Space N" by indexing that list by position.
-- **Window consolidation (`⌥0`) is per-screen because `hs.spaces.moveWindowToSpace` cannot cross displays.** It retargets a window's Space only on the *same* screen, so the consolidate action resolves each screen's `activeSpaceOnScreen` and collects that screen's windows onto it. `hs.window.allWindows()` does reach windows on non-focused Spaces (the AX API only enumerates the current Space, but Hammerspoon works around it — verified live: it listed a window on Space 1 while another Space was active), and `hs.spaces.windowSpaces(win)` reports a window's Space(s) so already-placed windows are skipped. Un-full-screen via `win:setFullScreen(false)` first (it collapses the app's dedicated full-screen Space back to a normal window), then wait ~1s before moving so macOS has torn the full-screen Space down. Filter to `win:isStandard()` to skip Notification Centre and other non-app windows.
+- **Window consolidation (`⌥0`) is built on `removeSpace`, NOT `moveWindowToSpace`, because the latter is broken on macOS 26 (Tahoe / Darwin 25).** Verified live on 26.4: `hs.spaces.moveWindowToSpace(id, space)` returns `true` but never moves the window, for both off-Space *and* active-Space windows (so it is not a "window must be visible" constraint, it is simply non-functional). The working approach instead deletes the other Spaces: `hs.spaces.removeSpace(sp)` migrates that Space's windows onto a neighbour, so per screen, removing every `spaceType == "user"` Space except `activeSpaceOnScreen(uuid)` funnels all windows onto the one that remains (sequential `removeSpace` calls serialise fine — each drives Mission Control). Per-screen because Spaces belong to a screen.
+- **`hs.window.allWindows()` only sees the *current* Space; use an all-Spaces `hs.window.filter` to reach off-Space windows.** The AX API behind `allWindows()` does not enumerate other Spaces (the original `⌥0` used it and found 0 windows because the full-screen apps were on other Spaces). `hs.window.filter.new(nil):setCurrentSpace(nil):setDefaultFilter():getWindows()` *does* enumerate every Space and reports `isFullScreen()` correctly, and `win:setFullScreen(false)` works on those off-Space windows. Consolidation un-full-screens via this filter first (collapsing each app's dedicated full-screen Space into a user Space), waits ~1s for the Spaces to tear down, then removes the leftover user Spaces.
 - **Space positions are not stable while "rearrange by most recent use" is on.** With `com.apple.dock` `mru-spaces` unset or true (the macOS default), visiting a full-screen space reorders it in Mission Control, so the index `⌥N` and the menu bar indicator use drifts (the order is stable only while idle). `defaults write com.apple.dock mru-spaces -bool false && killall Dock` gives stable positions; this is applied declaratively by `home/.chezmoiscripts/run_onchange_after_macos_defaults.sh.tmpl` (darwin-guarded, restarts the Dock only when it is running). The indicator (`hs.menubar` badge driven by `hs.spaces.watcher`) recomputes ~0.25s after a change so it reads the settled order, not a mid-transition one; the watcher fires before `activeSpaceOnScreen` settles otherwise.
 - **Auto-reload works.** `hs.pathwatcher` uses FSEvents (path-based), so it survives chezmoi's atomic-rename writes (new inode each apply). By contrast, Finicky's `fsnotify`/kqueue watcher is inode-based and loses the watch on every chezmoi write, so Finicky needs a manual restart (see the `finicky` skill).
 - **`hs.ipc` is enabled** in `init.lua`, so the running config is queryable from the `hs` CLI (`hs -c '...'`), the main way to debug Spaces and hotkeys.

home/dot_hammerspoon/spaces.lua

@@ -90,62 +90,62 @@ local function gotoSpaceIndex(index)
 	end
 end
 
--- Pull every standard window onto each screen's currently-focused Space,
+-- Consolidate every window onto each screen's currently-focused Space,
 -- un-full-screening any full-screen apps first so their dedicated full-screen
 -- spaces collapse back into normal windows.
 --
--- Per screen: hs.spaces.moveWindowToSpace cannot move a window across displays,
--- so each screen collects its own windows onto its own active Space.
+-- Why this is built on removeSpace rather than moveWindowToSpace:
+--   On macOS 26 (Tahoe), hs.spaces.moveWindowToSpace is a no-op: it returns
+--   true but never moves the window (verified on both off-Space and active-Space
+--   windows). So instead of carrying windows to one Space, we delete the other
+--   Spaces: hs.spaces.removeSpace() migrates a removed Space's windows onto an
+--   adjacent Space, so removing every Space except the focused one funnels all
+--   windows onto the one that remains.
 --
--- hs.window.allWindows() reaches windows on Spaces other than the focused one
--- (the macOS Accessibility API only enumerates the current Space, but
--- Hammerspoon works around that), and hs.spaces.windowSpaces(win) reports which
--- Space(s) a window lives on so already-placed windows are left untouched.
+-- Why hs.window.filter and not hs.window.allWindows():
+--   allWindows() (the AX API) only enumerates the *current* Space, so it cannot
+--   see or un-full-screen apps living on other Spaces. An all-Spaces window
+--   filter (setCurrentSpace(nil)) does enumerate every Space, and setFullScreen
+--   works on the windows it returns even when they are off-Space.
 local function consolidateWindows()
-	-- 1) Un-full-screen everything; this dissolves the dedicated full-screen
-	--    spaces back into user spaces.
+	-- 1) Un-full-screen everything; this dissolves each app's dedicated
+	--    full-screen Space back into a user Space. allWindows() can't see
+	--    off-Space windows, so enumerate via an all-Spaces window filter.
+	local filter = hs.window.filter.new(nil):setCurrentSpace(nil):setDefaultFilter()
 	local hadFullscreen = false
-	for _, win in ipairs(hs.window.allWindows()) do
+	for _, win in ipairs(filter:getWindows()) do
 		if win:isFullScreen() then
 			win:setFullScreen(false)
 			hadFullscreen = true
 		end
 	end
 
-	local function gather()
-		-- Resolve each screen's active Space after any full-screen spaces have
-		-- collapsed, since positions can shift.
-		local targetForScreen = {}
+	local function collapse()
+		-- 2) Per screen: keep the focused Space and remove the other user
+		--    Spaces. Each removeSpace migrates that Space's windows onto a
+		--    neighbour, so removing all but the target funnels everything onto
+		--    it. Leftover full-screen Spaces (if an un-full-screen failed) are
+		--    skipped rather than removed.
+		local removed = 0
 		for _, screen in ipairs(hs.screen.allScreens()) do
-			targetForScreen[screen:getUUID()] = hs.spaces.activeSpaceOnScreen(screen:getUUID())
-		end
-
-		local moved = 0
-		for _, win in ipairs(hs.window.allWindows()) do
-			local screen = win:isStandard() and win:screen()
-			local target = screen and targetForScreen[screen:getUUID()]
-			if target then
-				local onTarget = false
-				for _, s in ipairs(hs.spaces.windowSpaces(win) or {}) do
-					if s == target then
-						onTarget = true
-						break
-					end
-				end
-				if not onTarget then
-					hs.spaces.moveWindowToSpace(win:id(), target)
-					moved = moved + 1
+			local uuid = screen:getUUID()
+			local target = hs.spaces.activeSpaceOnScreen(uuid)
+			for _, sp in ipairs(hs.spaces.spacesForScreen(uuid) or {}) do
+				if sp ~= target and hs.spaces.spaceType(sp) == "user" then
+					hs.spaces.removeSpace(sp)
+					removed = removed + 1
 				end
 			end
 		end
-		hs.alert.show(string.format("Consolidated %d window(s)", moved))
+		hs.alert.show(string.format("Consolidated (removed %d Space(s))", removed))
 	end
 
-	-- Give macOS a moment to tear down full-screen spaces before moving windows.
+	-- Give macOS a moment to tear down full-screen spaces before removing the
+	-- now-empty user spaces.
 	if hadFullscreen then
-		hs.timer.doAfter(1.0, gather)
+		hs.timer.doAfter(1.0, collapse)
 	else
-		gather()
+		collapse()
 	end
 end