Skip to content

Fix/audit 2026 11 - #6

Merged
jcrussell merged 36 commits into
mainfrom
fix/audit-2026-11
Nov 7, 2026
Merged

jcrussell merged 36 commits into
mainfrom
fix/audit-2026-11

Conversation

@jcrussell

Copy link
Copy Markdown
Owner

What and why

Fixes from a November audit of upstream issues and PRs, the codebase and security (beads labelled audit-2026-11). Every finding was adversarially reviewed before it was filed, and every fix was reviewed independently. One bead per commit (30 commits):

  • Tabbed/stacked focus.
  • Floats and neighbours.
  • Hover focus.
    • It no longer pulls keyboard focus back under the pointer.
    • It skips the desktop-icons window.
    • A window that becomes a desktop window is untracked.
  • Data loss.
    • The original values of the GNOME keys Forge overrides are persisted, so a crash or logout no longer leaves Super+L, maximize and edge-tiling disabled.
    • A malformed windows.json is backed up rather than overwritten, and bad rule entries are ignored instead of breaking every render.
  • Tree.
    • Containers keep their survivors' proportions when a window closes.
    • Stacked/tabbed groups aren't silently un-grouped.
    • Decoration actors no longer leak.
    • Auto-split honours a direction chosen with Super+V/Z.
    • Tab icons update when an app's class arrives late.
  • Timing.
    • The drag freeze holds when the drag starts on an unfocused window or a force render arrives mid-drag.
    • Duplicate events are coalesced.
    • The open animation survives an early render.
  • Misc.
    • Drag-tile works with NumLock or CapsLock on.
    • A read-only stylesheet can be updated.
    • The prefs window floats again.
  • Security. The build no longer lets a git author name or email inject JS into lib/prefs/metadata.js.
  • Test infrastructure.
    • The idle_add mock no longer silently drops renders, and the render-step order is now tested.
    • The e2e fill checks fail when windows overlap.

Fit

Behaviour follows i3 where it has an equivalent: a group remembers its shown member, stack order is fixed, and closing a window keeps the other sizes in proportion. Upstream PRs forge-ext#569, forge-ext#578, forge-ext#589 and forge-ext#590 were ported where the defect still exists here. Each commit message notes any GNOME-version or Wayland caveat.

Root cause and mechanism

Each commit names the root cause and the layer it's fixed at.

Tests

  • A regression test for every fix, each confirmed failing without its change.
  • Every commit passes the suite on its own.
  • Full e2e suite passes locally on GNOME 45, 48 and 49.
  • The new tab-bar stacking e2e test also fails on the pre-fix code.
  • Needs a manual check: the prefs window title on a real session (forge-cxxo). The e2e image can't open prefs windows (forge-movq).

Checklist

  • npm test, npm run lint, npm run lint:src, npm run typecheck pass
  • New tests fail without the change
  • One concern per commit; messages say what and why
  • Docs updated where behaviour changed
  • AI-assisted (tool: Claude Code). Fine, just say so

🤖 Generated with Claude Code

jcrussell and others added 30 commits November 5, 2026 21:57
…step order

The GLib.idle_add mock ran the callback synchronously and then returned a
random id. renderTree's callback clears _renderTreeSrcId itself, so the id
returned afterwards overwrote that reset and every later renderTree() in a
fixture silently did nothing (the same applied to the reload and
window-home reconcile idles). The mock now returns 0, matching the state
real GLib leaves once the source has fired.

Separately, nothing guarded the renderTree pipeline: deleting
processFloats, _reconcileFullscreenFloatDemotion or handleMaximizeOnSingle
from the idle callback left the suite green. A new unit test asserts every
step runs once and in order (demotion after processFloats per forge-zo4),
and that repeated renderTree calls each render.

Closes forge-3y3i.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
allowDragDropTile compared the pointer modifier state for exact equality,
but that state is the effective xkb mask and includes locked modifiers on
both Wayland and X11. With Num Lock (MOD2_MASK, 16) or Caps Lock
(LOCK_MASK, 2) on, the Super/Alt/Ctrl/Shift settings of
mod-mask-mouse-tile never matched, so drag-drop tiling never triggered.
The lock bits are now masked out before the comparison.

Closes forge-gqol.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
assert_windows_fill_workspace and wait_for_layout_settled summed raw
window areas, so two overlapping full-width windows scored ~2.0 and
passed, and area off the workspace counted towards the fill. The
rebalance and resize tests that rely on them could not catch an overlap
or stale-rect regression.

Both now go through framework/geometry.layout_fill_error, which clips
each frame rect to the workspace, fails on any pair overlapping by more
than Tolerance.OVERLAP, and then applies the fill ratio. Frame rects of
gapped tiles do not overlap at all, so real tiled layouts still pass.
A shell-free self-test covers gapped 1-3 tile layouts, two overlapping
full-width windows, off-workspace area and an uncovered half.

Closes forge-noi2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… window

Pressing on an unfocused tiled window and dragging it focuses it first; the
focus handler queues a "focus-update" event that runs ~220 ms later, after
grab-op-begin has frozen rendering. The callback unfroze unconditionally, so
any later render mid-drag laid out the tree without the dragged window
(neighbours filled its slot), and in a stacked container updateStackedFocus
re-stacked it and queued a "render-focus-stack" reflow.

The callback now leaves the freeze in place while a grab is live. Outside a
grab it still unfreezes, as the safety net for a stranded freeze.

Closes forge-09kp.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… render

renderTree held the re-freeze a force render owes in its per-call closure.
(a) A force render mid-drag (a window opening or closing) while a render
scheduled before grab-op-begin was still pending unfroze and scheduled
nothing; the pending idle owed nothing, so the rest of the drag ran unfrozen
and neighbours reflowed into the dragged window's slot. (b) A force render
mid-drag followed by grab-op-end in the same main-loop iteration re-froze
after the grab had ended, leaving later non-force renders decoration-only
until the next focus-update unfroze.

The owed re-freeze now lives on the instance: whichever idle renders next
honours it, and freezeRender()/unfreezeRender() settle it, so grab-op-end
cancels it.

Closes forge-ds8f.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
queueEvent drains one event per 220 ms and never coalesced, so holding
Super+J/K (autorepeat ~30/s) queued a "focus-update" (plus "raise-float" or
"render-focus-stack") per repeat and replayed them for seconds afterwards:
redundant border/restack work, pointer jumps with move-pointer-focus, and a
new window's "window-first-frame" waiting behind the whole backlog.

Events whose callbacks read live state (focus-update, raise-float,
render-focus-stack) now opt in to coalescing: one is not queued again while
another of the same name is pending. window-first-frame is per window and
still queues every time.

Closes forge-2hbi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…its first frame

Tree apply cleared metaWindow.firstRender for every tiled window it visited,
even when move() skipped the window because its first frame had not painted
yet and so sent no geometry. On Wayland window-created and the wm-class
render always arrive before the first buffer (on X11 often, via the
focus-at-map and create renders), so the real placement after first-frame
saw a non-first window and stripped the open animation (regression of
forge-nh7 / forge-ext#530).

move() now owns the flag: it clears firstRender when it places the window,
including its "already in place" return, and tree apply no longer touches it.

Closes forge-b2f9.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…swap

New windows, floats included, are inserted right after the focused one, so a
split often holds [A, F(float), B]. Tree.next() returned the raw sibling
whatever its mode: Focus-Right from A landed on the float, and Move/Swap-Right
swapped A with it, moving the float onto A's tile and trading their percents.
_swappable accepted a floating partner too, so WindowSwapLastActive swapped the
focused tile with a floating last-active window.

next() now steps over floating siblings, move() treats any same-parent window
neighbour as a swap (it need not be adjacent once a float is skipped), the
monitor-edge no-op check compares against the edge tiled child, and
_swappable rejects floating windows (i3 refuses to swap them as well). With no
float left to trade, swapPairs drops its mode exchange and only normalizes a
dragged node's GRAB_TILE to TILE.

Closes forge-no5x.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…d or pruned

Every container creates a decoration actor in global.window_group, but
removeChild only destroys it for a stacked/tabbed container. cleanTree's
flatten (closing W1 in HSPLIT[W1, VSPLIT[W2, W3]]) and the workspace-monocle
prune remove split containers for good with a raw removeChild, so their
decorations stayed in window_group until Forge was reloaded.

Both paths now hand the removed container to _forgetRemoved, the existing
"left the tree for good" teardown.

Closes forge-tlhk.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
cleanTree's flatten collapsed every container whose only child is a container
and copied the child's layout onto it. Closing W1 in STACKED[W1, HSPLIT[W2, W3]]
turned the stack into a plain HSPLIT, and with auto-exit-tabbed off a
TABBED[W1, CON[W2, W3]] was un-grouped on the next render despite the setting.

The flatten now keeps a stacked/tabbed group whose only child is a split. A
group whose only child is itself a stacked/tabbed group still collapses, so
STACKED[STACKED[..]] keeps showing a single tab bar.

Closes forge-in5v.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…container

Closing a window redistributed its siblings' percents proportionally when the
parent was a monitor, but reset them to equal shares when it was a container:
closing c in a nested VSPLIT sized 50/25/25 gave 50/50, while the same close
at monitor level gives 67/33. A close that collapsed a single-child container
reset the grandparent container's children the same way, and so did a close
that left a container with no tiled window (only minimized ones).

cleanUpParent now redistributes in both places for container parents, as it
does for monitors, matching i3's con_fix_percent. The workspace/monitor
boundary is still never crossed (Bug forge-ext#470). Tree-cleanup's "reset sibling
percents" test pinned the old equal-reset and now expects the kept
proportions.

Closes forge-h5nw.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…-split is on

With auto-split on, opening a window re-split the focused window by its shape,
and split()'s single-child toggle overwrote the direction the user had just
chosen: on a lone wide window, Super+V and then a new window put it beside the
first one instead of below.

A user Split now records the focused window on the node whose direction it set
(auto-split's own Split is marked and records nothing). trackWindow skips the
auto-split while that window is still the only tiled child there, and the
choice is dropped once a tiled window leaves that node. Same approach as
upstream forge-ext#578 (issue forge-ext#409). The layouts doc now says so.

Closes forge-5bdc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Apps that set their class late (Anki, Opera, many Flatpaks) can resolve to a
placeholder app when they map, and to their real app only once the class
lands. refreshApp re-read the app, but _createWindowTab returns early when the
tab exists, so the tab kept the placeholder icon until the window was moved.
_ensureConTab only rebuilt a container's header tab when its representative
window changed, not that window's app.

The node now remembers which app its tab was built from, and both paths swap
the tab's icon when the app has changed. A null app keeps the existing icon,
and a tab that was never built (null app at map time) is still created by
_createWindowTab (forge-2uc0), so the fix holds whether the window tracker
returns null or a fallback app first.

Closes forge-n4ie.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ting

With float-always-on-top-enabled, the float setter pins a floated window
(make_above, marked _forgeSetAbove). _floatsByRole read every is_above() that
was not the transient focus pin as a user "Always on Top" pin, so Forge's own
pin kept the window floating, and pinned, after the reason it was floated
went away: a float rule removed, a skip-tile workspace or monitor turned back
to tiling, a class-less window gaining its class.

_floatsByRole now also skips a pin marked _forgeSetAbove, so processFloats
re-tiles the window and the float setter drops the pin. The marker moves from
the node to the Meta.Window, like _forgeTransientAbove, because a tree reload
(enable, workspaces-reordered) rebuilds every node and would otherwise lose it.

Closes forge-5k24.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
processFloats recentres a transient dialog over its parent whenever it
overlaps another tiled window (forge-2ew), and it runs on every render. A
grab only protects the dialog while it lasts: the grab-op-end render, and
every render after it, snapped a dialog the user had dragged over the
neighbour back over its parent.

_handleGrabOpBegin now marks the grabbed node userPlaced, and processFloats
skips the recentre for such a node, so the forge-2ew placement fix only
corrects where Mutter put the dialog.

Closes forge-spjt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… pointer

The focus-on-hover poll runs every 16 ms and focused the window under the
pointer whenever it was not the focused window. Moving keyboard focus
without moving the pointer (Super+hjkl, Alt+Tab, a newly opened window in
another tile; move-pointer-focus is off by default) was undone within a
frame.

The poll now remembers the window it last saw under the pointer and acts
only when that changes, like Mutter's sloppy focus. pointerLoopInit and
_removeSignals reset it, so a restarted loop starts fresh.

Closes forge-0wvx.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The focus-on-hover poll focused whatever window was under the pointer apart
from notifications and popups. With a desktop-icons extension (DING, on by
default on Ubuntu), resting the pointer in a gap between tiles focused the
desktop window. On Wayland that window is a NORMAL-type "gjs" window, so a
DESKTOP type check alone misses it.

The poll now skips the desktop window, DESKTOP type or the "gjs" window,
like Mutter's sloppy focus skips DESKTOP. The test is Utils.isDesktopWindow,
which cleanTree now also uses to drop that window from the tree. Other windows
Forge does not track (UTILITY palettes, ddterm) still take hover focus.

Closes forge-zqti.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…naged

Forge checked a window's type only when it tracked the window. Types change
after a window maps: Desktop Icons NG maps a NORMAL toplevel, which Forge
tracks, then retypes it DESKTOP (meta_window_set_type, GNOME 49+, or
meta_wayland_client_make_desktop on 46-48), so the desktop window stayed in
the tree, could be tiled once its class landed, and took clicks' focus
(forge-extgh-109). Dialogs also flip NORMAL <-> MODAL_DIALOG through xdg-dialog.

A notify::window-type handler now re-runs _validWindow. A window that is no
longer valid has its signals and borders released (the per-window body of
_removeSignals, extracted as _releaseWindow) and leaves the tree through
windowDestroy, like a closed window. A window whose new type is still valid
re-renders, so processFloats re-evaluates it. A float-always-on-top pin
Forge set on the window is dropped first; otherwise the desktop window would
stay above every normal window with nothing left to unpin it.

GNOME 45 Wayland has no set-type API, so this does not cover DING there.

Closes forge-e85.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…eighbour

Mouse-resizing a window in a tabbed or stacked group went through
_resizeContainerAgainstSibling, which only handles a neighbour that is the
group's direct split sibling and returns null otherwise. The tabbed branch
then skipped the rest of _handleResizing, so in a layout like
HSPLIT[L, VSPLIT[TABBED[A, B], Y]] dragging A's left edge moved the border
during the drag and snapped back on release (forge-extgh-561).

When _resizeContainerAgainstSibling changes nothing, the branch now falls
through to the general cross-parent path. _resizePairFor already looks past
tabbed and stacked groups, so it finds L and resizes the column holding the
group, as it does for a plain window in that slot.

Closes forge-zqcm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Forge snapshotted the GNOME values it overrides (native maximize/minimize,
Super+L, edge-tiling, ...) only in memory, while the overrides go to dconf.
An exit that skips disable() (shell crash, X11 restart) left the override
values in dconf, so the next enable() captured []/false as the originals and
every later disable() wrote them back: the native features stayed dead even
after uninstalling Forge.

The originals now persist in a new internal Forge key,
gnome-overrides-snapshot (JSON), written before each override is applied.
enable() reuses an original already in the snapshot instead of recapturing
it, and restores one the user has since opted out of. Every restore
(disable(), the failed-enable path, the runtime tiling-toggle restore)
writes the snapshot value back and drops it from the key. ConfigSync
neither exports nor reacts to the key.

Closes forge-7t96.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…laces it

When ~/.config/forge/config/windows.json fails to parse (e.g. a trailing
comma after a hand edit), the windowProps getter serves the bundled defaults.
The next float toggle, class toggle or prefs Add/Remove then wrote defaults
plus one rule over the user's file, losing every hand-written rule without
a trace (the production logger is compiled out).

The setter now checks the file it is about to replace: if it exists but is
not a valid overrides config, it copies it to windows.json.bak first, and
skips the write if the backup fails. Backing up rather than refusing keeps
prefs Reset and live toggles working as the way out of a broken file.

Closes forge-d90q.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…every render

ConfigManager.windowProps only checked that `overrides` is an array. A
hand-edited entry that is null, or has an array wmClass or a number wmTitle,
made the override matchers throw (null deref, .split on a non-string) from
processFloats, so every render's layout was skipped with no hint to the user.

The getter now keeps only object entries whose wmClass/wmTitle are strings
(or absent), so every matcher and the prefs list see well-formed rules. The
setter also backs the file up to windows.json.bak when it holds such entries,
since a rule write would otherwise drop them for good.

Closes forge-45tv.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…module

`make metadata` spliced `git shortlog -sne --all` output into the JS module
lib/prefs/metadata.js with awk, escaping only `"` in names and nothing in
emails. An author identity like `e",globalThis.PWN=1,"@x` executed in the
prefs process, a name containing `\"` broke prefs with a SyntaxError, and
--all pulled in authors of locally fetched, unmerged PR branches.

The target now parses shortlog with python3 (already a build dependency),
takes the email from inside <...>, and serialises the list with json.dumps;
it reads HEAD only. The review-pr safety screen also checks commit author
and committer identities, since they land unchanged with --author.

Closes forge-fw33.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ackup

forge-9sd made the colour-write path make stylesheet.css writable first,
but patchCss did not. A stylesheet.css copied read-only from a read-only
install (older or upstream Forge, e.g. from the Nix store) made the first
cssTag bump create a read-only .bak, and every later launch then failed at
the .bak overwrite, since a Gio OVERWRITE copy onto a read-only file is
refused. A prefs colour change only fixed stylesheet.css, so patchCss stayed
stuck until the user removed the .bak.

patchCss now makes stylesheet.css and an existing .bak writable before
overwriting them, and copies the .bak with TARGET_DEFAULT_PERMS too. The
Gio.File mock now refuses a copy onto an existing read-only file, as Gio
does.

Closes forge-3pnu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…refocuses

The libadwaita prefs rewrite stopped setting the prefs window title, so
GNOME's own title matched neither the bundled
{wmClass: "org.gnome.Shell.Extensions", wmTitle: "Forge Settings"} float
rule nor the extension's prefsTitle (`Forge <translated Settings> -
<version>`). The prefs window tiled, PrefsOpen could not find an open window
to refocus and opened another, and postProcessWindow never centred it.

A shared PREFS_TITLE constant ("Forge Settings", untranslated) is now set by
fillPreferencesWindow and used as prefsTitle, so both sides use the same
title whatever GNOME would assign, and the rule already copied into users'
windows.json matches again. Since that title is generic, PrefsOpen also
requires the prefs app's wm_class, so it can't grab e.g. a browser tab
titled "Forge Settings - GitHub".

Closes forge-cxxo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Moving focus into a tabbed group (Super+H/J/K/L) landed on its first or
last tab instead of the one showing, switching the visible tab, and a
swap into a group swapped with a hidden tab (or silently did nothing
when that tab was minimized). A group never kept track of the window it
shows: lastTabFocus was written only by a few layout commands and read
only by the reload snapshot.

Every focus path already ends in the stacked/tabbed focus update, so the
two updaters become one, FocusManager.updateGroupFocus, which records
the focused window as lastTabFocus in every tabbed/stacked ancestor (a
window in a split among tabs counts for the outer group too).
Tree._selectFocusWindow, used by directional focus, cyclic focus and
now swap, enters a group at that window while it is still a visible
tile there, else at the entry-side window as before. The layout
toggles and Move record through the same function; a directional swap
also records the window swapped in for the groups the focused one left.
A window that tiles again while focused (float toggle, tiling mode, a
late wm-class) is recorded when processFloats tiles it, since no focus
change follows. A STACKED group's shown window, and one inside a nested
split, also survive a tree reload.

Closes forge-f8ka.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In STACKED[A,B,C] with C focused, Super+K went B, C, B, C and A was
unreachable, and moving a window up a stack snapped it back. The shown
member of a stack was stored by moving the focused window to the end of
the stack (appendChild in the stacked focus update and in Move's settle
callback), but directional focus, move and the title column all walk
that same child order, so each step rewrote the order the next one
walked. The reorder dates from when stacked windows were cascaded;
every member now gets the same rect.

updateGroupFocus now only records the focused window as the group's
shown window (lastTabFocus) and raises it; Move's settle callback no
longer reorders. Toggling a container to STACKED keeps the focused
window shown instead of focusing its last child. Since stack order no
longer says which member is on top, a group whose remembered window is
gone (closed, moved out, minimized) is entered at the member Mutter
stacks highest rather than at an end of the stack. The d5mm regression
test and the e2e fuzz focus probe asserted the reorder; the probe now
checks that the focused window is the shown window of every
tabbed/stacked group around it.

Closes forge-0ym6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In TABBED[W1, HSPLIT[W2, W3]] with W1 showing, reaching W2 by keyboard,
alt-tab or an app focus request brought W2 to the front but left W3
under W1, so W1 showed through. The group focus update raised only the
focused window, and only when its immediate parent was the group, while
clicking the split's tab raises its whole subtree.

updateGroupFocus now raises everything the outermost group's member
shows (Tree.shownWindows: every window of a split, only the shown member
of a nested group), then the focused window on top. The same holds for
STACKED.

Closes forge-0zvq.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In TABBED[W1, HSPLIT[W2, W3]] the split's header tab lit up only from
its own click handler: keyboard or alt-tab focus of W2 or W3 never
highlighted it, and once clicked it stayed highlighted next to W1's tab
after focus moved to W1. hideWindowBorders cleared the active class
only on window tabs, and showWindowBorders set it only when the focused
window's direct parent was the group.

Both now key on the members around the focused window
(Tree.groupMembers, shared with the group focus update): the member
holding it in each tabbed/stacked group is active, every other group
member's tab, CON tabs included, is not.

Closes forge-3e1x.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
With float-always-on-top off, a float covering a tabbed or stacked
container's bar was painted over by that bar as soon as an unrelated
tiled window took focus. updateDecorationLayout restacked every bar
directly below the focused window's actor rather than with its own
container. Mutter's restack also lowers every window actor in turn to
the bottom of window_group, leaving the bars, which are not window
actors, above every window until Forge laid them out again.

Each bar is now anchored just below the topmost window its own
container shows (Tree.shownWindows, so a minimized or floating member
cannot lift it), both in updateDecorationLayout and on
display::restacked next to the focus-border restack.

The unit test covers the anchoring against a mocked window_group; the
e2e test, which compares the real window_group order after a Mutter
restack, has not been run.

Closes forge-zhms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
jcrussell and others added 6 commits November 6, 2026 01:03
"stop Forge's always-on-top pin from keeping a window floating" made the
_forgeSetAbove marker decide whether an above window is a user "Always on
Top" pin, but two paths left the marker wrong.

Turning float-always-on-top-enabled off unpinned every float but kept the
marker, and the float setter cleared it on tiling only while the window was
still above. A window that re-tiled after that (or after a fullscreen
demotion) kept the stale marker, so a later user pin on it was ignored, and
the next float-then-tile removed it. cleanupAlwaysFloat now clears the marker,
and the setter's tile branch clears it whenever it is set, unpinning only if
the window is still above.

Turning the setting on pinned every float without the marker, so those pins
read as user pins and kept the windows floating for good. restoreAlwaysFloat
now marks the pins it makes.

Refs forge-5k24.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…nitor

"step over floating windows in directional focus, move and swap" made next()
skip floats within a parent, but when focus crossed to another monitor,
focus() took that monitor's raw first or last child and resolved only a CON.
A float on the entry edge, common when it opened on an empty monitor, got
focus: with monitor 2 holding [F(float), B], Super+L from monitor 1's edge
focused F instead of B.

A monitor target now goes through _selectFocusWindow like a CON, which skips
floats, minimized and dead windows from the entry side and enters a group at
the window it shows.

Refs forge-no5x.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ean exit

"keep GNOME originals across an exit that skips disable()" kept a snapshot
entry whenever one existed. If the user changed an overridden GNOME setting
while Forge was enabled, for example rebinding minimize in GNOME Settings,
and the session then ended without disable(), the next enable() kept the old
snapshot value and the eventual disable() wrote it back over the user's newer
choice.

_applyOverride now reuses a snapshot entry only while the live value is still
Forge's override value, which is the state such an exit leaves behind, and
otherwise captures the live value as the original. The _reconcileOverridesFor
comment now says why the snapshot write cannot re-enter it.

Refs forge-7t96.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
"stop focus-on-hover pulling keyboard focus back under the pointer" made the
hover poll act when the window under the pointer changed. That also happens
without the pointer moving: a new window opening reflows the tiles, or a
workspace switch puts another window under the pointer, and the poll then
took focus from the window that just got it.

The poll now also remembers the pointer position and acts only when the
pointer moved and the window under it changed. It still records the window
under a still pointer, so a small nudge within that window does not focus it
either. pointerLoopInit and _removeSignals reset the position with the window.

Refs forge-0wvx.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
"test(e2e): fail the layout fill checks when tiled windows overlap" made the fill check fail
on a transient overlap, which a plain area sum let pass. The regression
validation fill test checked right after the third window appeared, so a
first frame that landed before the reflow could fail it. It now waits for the
layout to settle first, as the close-rebalance tests do.

The fill helpers' docstrings now say they are for split layouts only: stacked
and tabbed windows share one rect by design, which reads as overlap.

Refs forge-noi2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
"ignore malformed windows.json rules instead of aborting every render" said
the backup of a file with malformed rules happens on the next rule change. It
can also happen at startup: Forge drops leftover per-window wmId rows and
saves the file, and that write backs it up first.

Refs forge-45tv.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@jcrussell
jcrussell merged commit ccc3a7e into main Nov 7, 2026
16 checks passed
@jcrussell
jcrussell deleted the fix/audit-2026-11 branch November 7, 2026 16:49
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant