README.md: the Sponsorship for Personal Use section now states the one policy
(feature requests for Windows, Linux and macOS come from current GitHub sponsors
at $5/month and above, individual commercial use licence holders and approved
contributors; other [FEAT] issues are closed automatically; bug reports are open
to everyone). The Community paragraph asks reporters to choose the platform.
Statements about the licence are untouched. One OWNER marker asks what sponsors
get now that the private macOS repository is retired.
Not verified beyond reading the rendered diff.
What: CUTOVER-PLAN.md is rebased onto wip-main (6067938e, the cutover stack and the one flake) and updated. R1: the KDE/macOS history is published, the owner runs every push and tag command (agents only prepare them); the gitleaks result (2832 commits, default rules, no leaks) and its limits are recorded. R6: the sponsor-only FEAT texts are being rewritten by the agent sponsor-texts (in progress, not touched here). R8: master is already frozen, the freeze step is removed. R9: the first CI is hosted Linux and hosted macOS only, with checkSets.cheap as the PR gate; the Windows e2e, VM tiers and canary are a later self-hosted phase (evaluation ISO expires every 90 days). R10: PR only, no feature/hotfix push triggers. R12: actions/cache with per-platform keys, no Cachix. The FLAKE_* placeholders in the workflow drafts are replaced by the real names (checkSets.<set>, windows-komorebi*, native komorebi*, legacyPackages.<system>.vm.<name>). New open item N1: the nextest decision (windows-nextest removed, macos-nextest runs none). The final list of open items is R2, R3, R4, R5 published names, R7, R11, N1 and the token rotation.
How verified: sources read (docs/dev/flake.md, docs/dev/flake-checks.md, nix/checks.nix at wip-main), nothing executed. The gitleaks result, the version and the macos-nextest statement are as told by the coordinator and were not re-run or re-read.
The fullscreen e2e scenario fails 'does not take the window out of fullscreen' and 'not on
any other window' on the original Windows baseline and on every candidate since, so the
behaviour is inherited and not caused by the consolidation or the cutover. It was found in
the gates but not recorded in the known issues; this adds the entry (evidence, platform,
why it may or may not be a bug, no fix proposed).
Verified: documentation only; no build or test was run.
docs/dev/flake-checks.md records why the evaluation of the checks needed more than
the host has (about 0.55 GB per VM suite and 0.4 GB per NixOS system of the module
check, nothing shared), the sets and what is in each, how they are exposed
(checkSets, checkMembers, defaultCheckSets in nix/checks.nix), the alternatives
rejected, what was measured with the sets (nix flake check --no-build 4.54 GB / 33 s
on one system, 6.55 GB / 40 s --all-systems; each set alone from 0.2 GB for the cheap
ones to 11.6 GB for linux-nixos-eval), and why windows-nextest and macos-nextest ran
no test.
build-and-test.md gets the commands for one set, the default and one member and
loses windows-nextest; flake.md, docs/linux/CONTRIBUTING.md, docs/linux/dev/vm-tests.md,
the comment of nix/linux/tests/vm/default.nix and the CI step of CUTOVER-PLAN.md name
the new places (checkSets, checkMembers, legacyPackages.<system>.vm.NAME) instead of the
placeholder heavyChecks and checks.<system>.vm-NAME. Not run: the docs build.
overlays.linux and overlays.forVmTests (which applies the first as well) ran
mkPkgs, a new `import nixpkgs` with the rust overlay, and the whole crane
mkKomorebiPackages once for every NixOS system an evaluation instantiated: every
node of every VM suite and every module scenario, twice each. lib.mkPkgs now
hands out one instance per system and the linux module builds the packages of
each Linux system once (buildFor).
The derivations are the same (drvPath of linux-clippy, vm-kwin and linux-run-kde
equal to those before). Measured on a scratch copy of the same change: the
stand-alone expression of 4 suites 2.15 -> 1.50 GB, 8 real suites 5.18 -> 4.79 GB,
linux-nixos-module-eval 10.3 -> 8.5 GB, plasma guests 9.0 -> 8.7 GB. It does not
make the heavy sets cheap: see docs/dev/flake-checks.md.
The Windows crates are built with doCheck = false (individualCrateArgs of
nix/windows/build.nix) and the tests of a Windows program cannot run on a Linux
builder, so crane's cargoNextest derivation only ran `cargo nextest --version`:
a check named nextest that ran nothing. It is removed from the checks (22 names
left on x86_64-linux) and the windows-test set has the e2e Python tests only.
windows-clippy (--all-targets) still compiles the tests; the Windows CI runs
them (`cargo test`, .github/workflows/windows.yaml). The name is dropped from
docs/dev/flake.md and build-and-test.md, with a comment where it was.
macos-nextest has the same shape (doCheck = false in nix/macos/build.nix): it is
left as it is, since the Intel/Apple names stay stable until the Mac run decides.
checks.<system> is now the members of the sets named in one list,
defaultCheckSets in nix/checks.nix (fmt, deny, windows-lint, windows-test,
linux-lint, linux-test, linux-options, macos-lint, macos-test, macos-options),
instead of "every set but the heavy ones", so choosing what `nix flake check`
runs is a one-line edit. The heavy sets (linux-demo, linux-nixos-eval, vm-fast,
vm-slow) stay reachable as `nix build .#checkSets.<set>` and their members as
.#checkMembers.<set>.<name>. Two sets are added to checkSets: cheap (what
checks has, one derivation) and all (every check).
The members of checks are the same as before this revision on every system
(x86_64-linux: 23 names).
Every platform module now defines its checks as allChecks.<name> and the new
nix/checks.nix says which set each is in (fmt, deny, windows-lint, windows-test,
linux-lint, linux-test, linux-options, macos-lint, macos-test, macos-options,
linux-demo, linux-nixos-eval, vm-fast, vm-slow; the vm tiers come from the
suites). A check in no set, or in two, fails the evaluation. checks.<system>
holds the members of the sets that are not heavy, the same split flake-one made
(vm-*, the Plasma guests, the module scenarios and run-kde left out), and the
placeholder legacyPackages.<system>.heavyChecks is gone: every set is one
linkFarm derivation, legacyPackages.<system>.checkSets.<set>, and its members
are legacyPackages.<system>.checkMembers.<set>.<name>. legacyPackages.<system>.vm
is unchanged.
The linux module is mostly reindented (the split wrapper is gone); no check
changed. Verified: see the revision that composes the sets.
treefmt and pre-commit, which the treefmt-nix and git-hooks-nix modules add to checks themselves, are allChecks of nix/common.nix now (those modules' own entries are switched off, treefmt.flakeCheck and pre-commit.check.enable), so that they are members of the set fmt.
Only the commands and paths that named an attribute or file of the old flakes: the kde source
filter list (nix/linux/root-crates.json), the Windows drift check (windows-default), the KWin
effect install checks (linux-*-install), the module evaluation check on a Mac and the VM suites
(legacyPackages.<system>.vm.NAME, which are also the heavyChecks for now), and the Windows e2e
agent package (windows-komorebi-e2e-agent). docs/dev/flake.md has the full table. The history
in docs/dev/unified-binaries.md keeps the names of the time it describes. On the rebase onto
wip-cutover-all the coordinator edits of ARCHITECTURE-UNIFIED.md were kept and these two lines
applied on top.
Verified: not run (documentation).
docs/dev/flake.md (new): the layout of the one flake, the naming rule, the table of every old
attribute (root flake, kfde-, kfm- and the nested flakes) and its new name, the inputs and
why there are two nixpkgs (x86_64-darwin only), how the source of each platform is cut and why
the stubs are needed, the check groups (the NixOS/VM checks are heavyChecks until the structure
of the check sets is decided), the dev shells, what to run after an update.
docs/dev/build-and-test.md: the nix commands use windows-*, linux-*, macos-* names, the final
directories and legacyPackages.<s>.vm.NAME for a VM suite.
Verified: not run as prose; the attribute names were evaluated by nix flake check --no-build
--all-systems and the Windows ones built (see the flake revision).
fast-check classifies the paths of the final directories (komorebi-linux, komorebi-macos,
komorebi-hotkeys, nix/{windows,linux,macos}, docs and schemas per platform), runs the Linux
check from the repository root and evaluates one check and one package per platform in the
root flake; kde-closure-check reads nix/linux/root-crates.json and compares it with the cargo
tree of the Linux packages (the listed crates besides komorebi-linux, komorebi-hotkeys and
komorebi-daemon); mac-check.sh drops the nested-workspace branch; e2e-needed treats nix/windows,
nix/workspace-src.nix, nix/lib.nix and nix/common.nix as fixed inputs of the Windows binaries
and the Linux and macOS trees as outside them; build-ref.sh builds `windows-NAME` for a REF with
the one-flake layout and keeps the old names for an older REF with its own flake. The justfile
names linux-nix-options-validation and runs a VM suite as legacyPackages.<system>.vm.NAME
(the vm-* checks are heavyChecks for now). scripts/linux/{run-kde,vm-mac,sync-e2e-core,
scenario-status} find the repository root and the VM library from scripts/linux/ and nix/linux/
(on the rebase onto wip-cutover-all the coordinator versions of run-kde, vm-mac and
scenario-status were kept: same change).
Not touched: scripts/linux/compare-gen.py, a migration comparison between the three old trees
that still looks for komorebi-for-mac/ (obsolete; open).
Verified: bash -n on the changed scripts; tools/kde-closure-check passes (14 root crates);
tools/fast-check --list classifies this revision as nix-only. fast-check commands for the
platforms were not run.
komorebi-for-kde/flake.nix, komorebi-for-kde/flake.lock, komorebi-for-mac/flake.nix and
komorebi-for-mac/flake.lock: the root flake builds both platforms now, from one source and one
lock. The directories komorebi-for-kde/ and komorebi-for-mac/ are gone with them.
Verified: nix flake check --no-build --all-systems passes without them (it did not read them
after the previous revision either).
One flake.nix and one flake.lock replace the root flake that re-exported two nested flakes.
The inputs are one nixpkgs (the revision the KDE flake was locked to, f05535a0: the VM suites
run against its Plasma and KWin 6.8.2), one crane, rust-overlay (19ecdd08, rustc 1.99.1),
flake-parts, treefmt-nix and git-hooks-nix, all the KDE flake revisions, plus asc. A second
nixpkgs, nixpkgs-x86_64-darwin (16c7794d, the macOS flake pin), serves the x86_64-darwin
outputs only: evaluating that system with the unified pin throws (nixpkgs 26.11 dropped it).
Layout: nix/common.nix (systems, pkgs, treefmt, pre-commit, dev shells default and native,
default overlay), nix/lib.nix, nix/workspace-src.nix (one source per platform from the one Cargo
workspace: the platform members, its files of the shared crates told apart by name, the data
files, and stubs for the other members, which cargo needs), nix/{windows,linux,macos}/
{build,flake-module}.nix. The dependency derivations use a manifests-only dummy source, a plain
path, so crane reads nothing built at evaluation and the Darwin outputs evaluate on Linux.
Names: unprefixed outputs are the native build (Linux: KDE; Darwin: macOS); Windows cross
outputs are windows-*; checks are windows-*, linux-*, macos-* and vm-NAME; table in docs/dev/flake.md
(next revision). One deny.toml, one format-all and one version (workspace) are used by all.
PLACEHOLDER for the agent that owns the check sets: the checks that evaluate a NixOS system
or a VM (vm-*, linux-nixos-module-eval, linux-plasma-guests-eval, linux-run-kde*) are
legacyPackages.<system>.heavyChecks.<name>, not checks, because evaluating them needs more
memory than nix flake check --all-systems can use. The Plasma guests got a stub root file system
and boot loader (mkDefault, replaced by their vmVariant) so that nix flake check can evaluate
their toplevel.
Verified: nix flake check --no-build --all-systems passes (42 s, rc 0); nix flake check
--no-build passes. Not verified: any build (next revisions record them).
The pure moves put the KDE and macOS nix files under nix/linux and nix/macos but left the
relative paths they read: the JSON schema (now schemas/linux and schemas/macos), the example
configurations and key binding samples (docs/linux, docs/macos), the key binding fixtures
(komorebi-hotkeys at the top level), the wsl2 probe script (scripts/linux). Each path now
names the file in the final directory, one more directory up because the files are one level
deeper.
Not touched: flake.nix and the nested flakes (next revisions), which still name the old paths.
Verified: not verified (nothing evaluates until the flake is rewritten; the new flake checks
these paths).
What: CUTOVER-PLAN.md follows two owner decisions. R6: one sponsor-only [FEAT] policy and one licence apply to all three platforms; section 2.2a is the concrete list of texts to rewrite (feature-check.yaml message, ISSUE_TEMPLATE feature_request, bug_report and config, README and docs index sponsorship sections, the macOS README paragraph about a private repository, licence consistency), found with git grep. R5: no root schema*.json copies and no freshness test; section 2.2b states the consequence (the old master/ raw URLs, including the one komorebic quickstart wrote into users' applications.json, stop resolving), the repository tasks, and the wording for the README and the release notes. The per-platform published file names stay an open release question with a recommendation.
How verified: sources read, nothing executed; the lists come from git grep on the tip 59b01fdb. Earlier revisions are not rewritten.
The unified line starts the 0.2.0 development cycle and is not released yet, so the one
workspace version (every package takes it through version.workspace = true) is the
pre-release 0.2.0-dev instead of 0.2.0. The release revision sets it to 0.2.0.
Cargo.lock only changes the version of the workspace's own packages. The schema
descriptions and the macOS schema links keep naming v0.2.0: they document the schema of
the release this line leads to. The update widget of the bar compares version strings, so
a dev build never offers the 0.1.x releases as an update.
Verified: cargo metadata --offline succeeds; cargo test -p komorebi --test linux_version
passes; komorebic --version prints 0.2.0-dev. The other gates were not re-run for this
one-line change.
What: CUTOVER-PLAN.md follows three owner decisions. (1) No private sponsors repository: the mirror option and sponsor wording are removed, R1 is answered, only the confirmation of the push stays a gate (L3). (2) Schemas are per-platform files under schemas/: R5 states the fact and keeps two sub-questions (root schema*.json copies for old master/ URLs; published file names). (3) The workspace is 0.2.0-dev: section 4 and 5 split the DEV-LINE LANDING (L0-L6: komomono to master, no tag, no artefacts, CI on, nightly publish off) from the RELEASE (E0-E8: version 0.2.0, tag, artefacts, announcement); the go/no-go lists are split the same way, and the macOS hand-check (R2) gates the release only.
R6 (FEAT policy, licence) stays open with the changed premise. R3, R4, R7-R12 are unchanged.
How verified: sources read, nothing executed; the version 0.2.0-dev is as told by the coordinator and not re-read from the tree.
What: docs/dev/CUTOVER-PLAN.md, a plan (not an execution) for landing the consolidated repository as LGUG2Z/komorebi and releasing 0.2.0. It covers branch and history mechanics (fast-forward master, the divergence with komomono on origin, PRs, forks, Scoop/WinGet/nixpkgs users, protection, the old-hashes check), what happens to komorebi-for-kde and komorebi-for-mac, the one CI (jobs, runners, triggers, e2e and VM tiers, caching, dependabot, secrets, with draft workflow files in an appendix), the 0.2.0 release (tags, artefact matrix, notes, schemas, docs, Homebrew), the order of the irreversible steps with go/no-go lists and the exact git and jj commands for the user, and twelve open decisions with recommendations.
Why: the cutover stack (wip-cutover, wip-cutover-docs) leaves the publication, CI and release decisions open (MIGRATION-SUMMARY.md section 7); several of them are irreversible (publishing the private KDE history, a published tag) and need the owner's answers first.
How verified: sources read, nothing executed. Facts come from the repository at 2185556efba6, the three old clones, the plan, decisions and progress logs, and read-only gh api/list calls; every inference is marked in the text, and what could not be determined is listed at the end of section 6. The flake outputs are placeholders until the flake-one stack lands. No file under .github/ was created.
docs/installation.md (the Windows build-from-source guide, published on the site) installed the
daemon with `cargo install --path komorebi`. The `komorebi` binary is built by the package in
komorebi-daemon/ (komorebi-windows is the library behind it, and has no binary), so the command
names `--path komorebi-daemon`. This was already wrong when the daemon became its own package; the
directory rename made it visible.
Verified: komorebi-daemon/Cargo.toml has `name = "komorebi"` and a main.rs; the command itself was
not run (Windows only).
Comment-only edits (no code changed): the module docs of komorebi-linux/src/kwin/mod.rs and
hotkeys.rs pointed at docs/dev/PLATFORM.md and docs/dev/DESIGN.md (now docs/linux/dev/...) and at
nix/tests/vm/suites/kwin-events (now nix/linux/...); the comment in komorebic/Cargo.toml named the
deleted shim komorebi-client-linux and now names the keys that exist (komorebi-linux, komorebi-macos).
Left alone on purpose: the same stale doc paths in comments under nix/ (not mine to edit),
fixture names (kfde-tiled), URLs, and the runtime default PathBuf::from("docs/cli") of docgen
(behaviour).
Not verified by a build: only comments changed. These files are inputs of the KDE nix derivations,
so they will rebuild.
seam, core-model, settings, rule-matching, bar-unification, e2e-to-unit and known-issues are
measurements and decision logs written for the old directories. They keep their history; each
gets a "Paths (cutover stack)" note under the title that maps the old names (komorebi/,
komorebi-for-kde/komorebi/, komorebi-for-mac/komorebi/, nix/, docs/, schema files) to the new
ones and says the 0.1.x numbers are history. The seam.md tree table, the test file paths in
e2e-to-unit.md and known-issues.md (files that exist and are named as current) and the
bar-e2e.md schema path now name the files where they are.
Not rewritten: the line numbers, measurements and "at the time" statements. Not touched:
backend-switch.md (no old paths), build-and-test.md and flake.md (flake-one).
Verified: the files named as current exist (komorebi-linux/tests/*.rs); relative links resolve.
macos-hand-check-plan.md: a note at the top says the text was changed for the cutover stack
and not run; the build command also names komorebi-client and komorebi-macos; the line
about never mixing -p komorebic-macos with -p komorebic is replaced by a line saying the
shims are gone; the example config is docs/macos/komorebi.example.json, the schemas are
schemas/macos/schema.json and schemas/macos/schema.bar.json, and the expected version is
`komorebi 0.2.0` from crates/komorebi-version.
macos-handcheck.md (the older list): a paragraph at the top maps the old names to the
current ones and points at the plan; the Mini run and the bar file path get a "now" note.
The runbook has no flake attributes, so none are left for flake-one. Not run: nothing in
this revision was executed, on a Mac or elsewhere; the package names were checked against
the workspace manifests (komorebi is komorebi-daemon, komorebi-macos is the library).
ARCHITECTURE-UNIFIED.md: the status line, section 1 (a table of where each platform is now),
the package paragraph (shims gone, version crate), the oracle paths (schemas/*, docs/*/cli),
section 6 (now "done / still open" instead of "what is still the old layout"), the tier-0 row,
and the helper tools paragraph (tools/ is committed now).
MIGRATION-SUMMARY.md: status line, the three-trees paragraph, the oracle paths, the known
issues paragraph, and section 7, which was "Cutover list (not done)" and is now a table of what
the cutover stack did and what is open; item 7 of "How to continue".
unified-binaries.md: the status banner (with a map from the old directory names to the new
ones), the Mac Mini commands (the shim line removed, schema.bar.json under schemas/macos,
`komorebi 0.2.0`), and "What is left for the cutover" is now a done / still open list.
Still open, as stated in the three: the one flake (flake-one is writing it), CI and release
workflows (the old ones are archived in docs/dev/old-ci), the site and repository URLs,
COMPARE.md. The 0.1.42 / 0.1.0 / 0.1.1 numbers and the old directory names that stay in
narrative sections are history and are marked as such. Not touched: build-and-test.md and
flake.md (owned by flake-one).
Verified: the relative links of the three files resolve. The statements about what the stack
did are taken from the revision descriptions of wip-cutover, not re-measured.
mkdocs builds docs_dir: docs, which now also holds docs/linux, docs/macos (each with its own
index.md, README.md and cli/ pages) and docs/dev. Without a change they were all built into
the Windows site (692 files instead of the Windows ones) and 250 warnings appeared for their
links to sources outside docs/. exclude_docs lists /linux/, /macos/ and /dev/; the nav is
not touched.
Verified: mkdocs 1.6.1 with material 9.7.6 and mkdocs-macros 1.3.9 (a nix python env):
`mkdocs build --strict` passes with the change; the file set of the site is exactly the one
of the build without the change minus linux/, macos/ and dev/, and the other files are
byte-identical (search index and sitemap differ because they listed the extra pages).
README.md: the note "komorebi for Mac lives here" (a link to the old repository) is replaced
by a "Platforms" section: the three platforms with their daemon library, documentation
(docs/linux/README.md, docs/macos/README.md) and schemas directory, and a sentence that
where the repository is published and where the releases and sites live is not decided
yet. The SocketMessage link pointed at komorebi/src/core/mod.rs#L37 of the old upstream
repository; it is now a relative link to crates/komorebi-protocol/src/message.rs, where the
enum lives. CONTRIBUTING.md: a first line links the contribution guides of the Linux and
macOS ports.
The link to the old komorebi-for-mac repository is kept as history; nothing else of the
README (it is the Windows README) was changed.
Verified: the relative links resolve (link checker over the repository markdown).
The scripts were written for a KDE-only repository root (komorebi-for-kde/, scripts/ one
level below it). They now live in scripts/linux/ of the consolidated repository:
- run-kde looks for the repository two directories above itself (flake.nix at the root) and
no longer knows the komorebi-for-kde/ subdirectory; its comments name nix/linux and docs/linux
- vm-mac cd`s two levels up, usage and comments name scripts/linux/vm-mac
- sync-e2e-core and scenario-status read nix/linux/tests/vm/lib, and usage lines name the new
paths (scenario-status resolves the library with parents[2])
- wsl2-probe.sh names docs/linux/dev/wsl2-probe.md and prints "komorebi (KDE Plasma)" instead of
komorebi-for-kde in its report header
- compare-gen.py is stale by design: the docstring now says so a second time (layout) and
names the new path of COMPARE.md; the logic is not repaired
Flake attribute names the scripts call (nix run .#run-kde, .#wsl2-probe, legacyPackages.*.vm.NAME
in vm-mac) are left for the one-flake revision.
Verified: bash -n and shellcheck -S warning pass on the four shell scripts; the two Python
scripts parse (ast); `bash run-kde --dry-run` run from /tmp prints KOMOREBI_REPO as this
checkout; `sync-e2e-core --check e2e/lib` prints "in step"; `scenario-status --help` runs.
Not run: the VM, vm-mac, wsl2-probe.
The KDE docs were moved from komorebi-for-kde/ to docs/linux/ and the sources, nix files,
scripts and schemas to komorebi-linux/, nix/linux/, scripts/linux/ and schemas/linux/, so
every relative link that left docs/ (to sources, nix files, scripts, schemas, .envrc,
rust-toolchain.toml, the old CI file) was broken, and the text named the old paths.
Links were rewritten mechanically by resolving each broken target against the old
location and mapping it to the new one; link texts and code-span paths were updated to
the new paths (komorebi/src -> komorebi-linux/src, nix/ -> nix/linux/, scripts/ ->
scripts/linux/, docs/ -> docs/linux/, schema.json -> schemas/linux/schema.json). The
crate list of the README names komorebi-linux, komorebi-daemon and komorebi-version;
`cargo install --path komorebi` becomes komorebi-daemon; the comparison paragraph of
CONTRIBUTING.md says compare-gen.py is stale (it looks for the old sibling trees).
URLs of the old GitHub repositories are left as they are (a release decision).
COMPARE.md is left as it is (already marked stale).
Verified: a link checker over every markdown file (outside cli/, nix/, tools/, old-ci)
reports no broken link in docs/linux. Nothing was built.
The macOS installation guide built the daemon with `cargo install --path komorebi`. The
`komorebi` binary is now the package in komorebi-daemon (komorebi-macos is the library
behind it), so the command names `--path komorebi-daemon`.
Verified: the directory exists and its package is named komorebi; the command itself was
not run (macOS only).
komorebi-for-kde/README.md, CONTRIBUTING.md -> docs/linux/
komorebi-for-mac/README.md, CONTRIBUTING.md -> docs/macos/
komorebi-for-kde/.github/* -> docs/dev/old-ci/linux/
komorebi-for-mac/.github/*, mkdocs.yml, check_schema_docs.py, dependencies.json,
formula.template.rb -> docs/dev/old-ci/macos/
The CI workflows, dependabot files, issue templates, the macOS Homebrew formula template and
docs-site configuration of the two old repositories are kept for the CI and release plan
that follows (one workflow set, one release); under docs/ GitHub ignores them, as it did
under the subdirectories, so no KDE or macOS workflow runs on this branch. Renames only (19
files); the Windows .github and files at the root are untouched.
komorebi-for-kde and komorebi-for-mac each had a rustfmt.toml (the root one minus
newline_style), a rust-toolchain.toml and .envrc (identical to the root's), a .gitignore and
a LICENSE.md; they are deleted, and the root .gitignore gains the KDE entries (/.vm,
__pycache__/, *.pyc). tools/format-all now has one group: every .rs file of the repository,
file by file with skip_children, with the root rustfmt.toml and the dev shell's nightly
(the --tree option is gone).
Verified: tools/format-all --check passes on the whole tree (the formatting of the six
files edited in the path-fix revision was applied to that revision).
The root justfile now has the recipes of all three: the Windows ones (PowerShell loops
through [windows] recipes, as before) and unix variants of install, build and schemapub,
the KDE ones (lint, check-js, the VM recipes, run-kde, wsl2-probe, nixgen-linux), the
macOS nixgen, and jsonschema/docgen-local that write schemas/<platform> and
docs/<platform>/cli for the platform they run on. Package names are the unified ones (one
komorebic, komorebi, komorebi-bar everywhere) and all paths are the final directories.
komorebi-for-kde/justfile and komorebi-for-mac/justfile are deleted. The KDE
`just check` recipe (cargo test --workspace) is dropped: on Linux it builds the Windows crates;
the commands in docs/dev/build-and-test.md replace it.
Verified: just --list parses; just --dry-run jsonschema prints the right commands on Linux.
The recipes themselves were not run.
The root deny.toml now covers every platform: the graph targets are the three Windows
targets plus x86_64 and aarch64 Linux and aarch64 macOS; the advisory ignores gain the
KDE ones (zbus family, RUSTSEC-2026-0370..0372) and the macOS ones (git2 through shadow-rs,
RUSTSEC-2026-0183/0184; quick-xml, RUSTSEC-2026-0194/0195); the licence allow list was
already a superset of both trees' lists; clarify entries are added for komorebi-linux,
komorebi-macos, komorebi-hotkeys and komorebi-version; quickxml_to_serde joins the allowed
git sources. komorebi-for-kde/deny.toml and komorebi-for-mac/deny.toml are deleted.
The reasons of ignores that exist in more than one file keep the root text.
Not verified: cargo deny was not run here (it is not installed; the nix check of the root
flake runs it in the flake revision of this stack).
The include_str! and test paths of komorebic (Linux and macOS modules and tests),
komorebi-bar (macOS), komorebi-linux, komorebi-macos, komorebic-core, komorebi-config and
komorebi-bar-core named the old trees (komorebi-for-kde/docs, komorebi-for-mac/docs, the
schema.json files at the roots of the trees, komorebic/fixtures of the macOS tree). They
now read docs/linux, docs/macos, schemas/{windows,linux,macos} and the byte-identical
komorebic/fixtures at the root; the macOS pan tests point at the root fixtures, and
komorebi-linux's config_parity test takes the example config from docs/linux. Comments
that named the old paths were updated with them.
Not touched: markdown docs, justfiles, scripts, tools and nix files that name the old
paths (next revisions of the stack).
Verified: Windows clippy --locked --all-targets -D warnings (default members) passes; on
Linux cargo test -p komorebi -p komorebic -p komorebi-client -p komorebi-linux -p
komorebi-hotkeys -p komorebi-config -p komorebi-bar-core -p komorebic-core -p
komorebi-protocol (one test thread) passes, 96 test binaries ok after config_parity was
fixed; macOS cargo check --target aarch64-apple-darwin (fake CC) passes. Nix not run.
schema.json, schema.asc.json, schema.bar.json -> schemas/windows/
komorebi-for-kde/schema.json, schema.asc.json -> schemas/linux/
komorebi-for-mac/schema.json, schema.asc.json, schema.bar.json -> schemas/macos/
The generated schemas of the three platforms are checked in side by side instead of at the
root and in two subtrees. Renames only; the tests, the justfile, the nix checks and the
docs that read them by path are updated in the path-fixing revision of this stack.
komorebi-for-kde/scripts/ -> scripts/linux/
komorebi-for-kde/spikes/ -> spikes/
Renames only. The scripts' own references to the old directories (and to komorebi/src of
the old trees) are fixed in the path-fixing revision of this stack.
komorebi-for-kde/nix/ -> nix/linux/
komorebi-for-mac/nix/ -> nix/macos/
The nix expressions of the platforms (modules, option files, VM test suites, kwin effects,
the darwin module) sit next to the existing nix/workspace-src.nix. Renames only (252
files); the flakes that import them are replaced by one root flake later in this stack, so
nix does not evaluate at this revision.
komorebi-for-kde/docs/ -> docs/linux/
komorebi-for-mac/docs/ -> docs/macos/
The Windows docs stay where they are (docs/). Renames only, so links and include paths
that named the old directories are broken at this revision; they are fixed in the revision
that fixes the paths of the whole layout move.
The workspace members and the path dependencies of komorebi-client, komorebic,
komorebi-daemon, komorebi-linux, komorebi-macos and komorebi-hotkeys name the directories
of the previous revision (komorebi-windows, komorebi-linux, komorebi-macos,
komorebi-hotkeys at the top level); the dependencies of the moved crates on the shared
crates are one directory shorter. cargo metadata --offline succeeds with an unchanged
Cargo.lock. Source files that include files by relative path are fixed later in this
stack.
komorebi/ -> komorebi-windows/
komorebi-for-kde/komorebi/ -> komorebi-linux/
komorebi-for-mac/komorebi/ -> komorebi-macos/
komorebi-for-kde/komorebi-hotkeys/ -> komorebi-hotkeys/
The directories now carry the names of their packages (komorebi-windows, komorebi-linux,
komorebi-macos). Renames only: every file is a 100% rename (270 files); nothing is edited,
so the workspace does not build at this revision. The next revision fixes the paths.
komorebic-linux, komorebi-client-linux, komorebic-macos, komorebi-client-macos and
komorebi-bar-macos were #[path] includes of the unified komorebic, komorebi-client and
komorebi-bar modules, kept only so the old package names kept building. The unified
packages are the only ones now, so the five directories and their workspace members are
gone (Cargo.lock loses their dependency entries).
Things that named the old packages follow: the clarify entries of the two per-tree
deny.toml files, tools/fast-check, tools/mac-check.sh and tools/kde-closure-check (it now
walks komorebic and komorebi-client), and the doc comment of komorebic/src/main.rs.
komorebi-for-kde/nix/root-crates.json gains komorebic, komorebi-client and
crates/komorebi-version, because those are root crates the KDE build depends on now.
komorebi-for-mac/komorebi/src/pan.rs read its transcripts from the deleted
komorebic/fixtures; they are byte-identical to the root komorebic/fixtures, so the three
paths point there.
Not touched here (done in the flake and justfile revisions of this stack): the nix
flakes and justfiles of the trees, which still name the removed packages, and docs/dev.
Verified: Windows cargo clippy --locked --all-targets -D warnings (default members) passes;
KDE cargo test -p komorebi -p komorebic -p komorebi-client -p komorebi-linux passes; macOS
cargo check --target aarch64-apple-darwin (fake CC) of komorebi, komorebi-macos, komorebic,
komorebi-client, komorebi-bar passes; tools/kde-closure-check passes. The nix flakes were
not run.
version-linux (komorebi-for-kde/version, shadow-rs 2) and version-macos
(komorebi-for-mac/version, shadow-rs 1) had the same build.rs and the same lib.rs. They
are now one package, crates/komorebi-version (lib name version, shadow-rs from the
workspace), and the KDE and macOS daemons, their command lines and the unified komorebic
depend on it under the key version. The extern crate lines of komorebic/src/main.rs that
renamed the two crates are gone, and the two deny.toml clarify entries name the new
package.
komorebi-daemon/tests/linux_version.rs read the version out of the old crate's Cargo.toml
text, which no longer has a number (it is inherited); it now expects the package version,
which is the workspace version.
Verified: cargo test -p komorebi -p komorebic -p komorebi-client -p komorebi-linux (KDE
side, native Linux) all pass, including the version test; cargo check --target
aarch64-apple-darwin of the macOS packages with the fake C compiler passes. Windows and
nix were not run for this revision (Windows does not use the crate; nix runs at the end of
the stack).
The doc comments that become the description of schema.json and schema.bar.json said
v0.1.42 (Windows), and the macOS views of the schemas said v0.1.0 and linked
komorebi.0.1.0.schema.json. They now say v0.2.0 (the unified release) and link the
0.2.0 file. The macOS site domain in those links is not touched: where the schemas are
published is a release decision.
The checked-in schema.json and schema.bar.json of the Windows tree and of
komorebi-for-mac were edited to match, and the size and hash pins of
crates/komorebi-bar-core/tests/schema_oracle.rs were updated for the two bar schemas
(Windows 248,539 bytes, FNV-1a aaa0fabfb45967b7; macOS 116,925 bytes, a042f6ac063a0cfd).
The KDE schemas carry no version text.
Verified: cargo test -p komorebi-config -p komorebi-bar-core -p komorebi-protocol and
-p komorebi-linux --test schemas pass. The komorebi-config doctest fails to link in
the nix dev shell (it cross-compiles to windows-msvc); that is not caused by this change.
Every package of the workspace now takes its version from [workspace.package]
(version.workspace = true) instead of its own number. The numbers before were
0.1.42 (Windows libraries and packages), 0.1.0 (KDE, the macOS version crate,
komorebi-shortcuts and the e2e guest crates) and 0.1.1 (macOS libraries); the
unified release is 0.2.0 for all of them.
Cargo.lock only changes the version of the workspace's own packages.
Not changed here: the version text in schema doc comments and the generated
schemas (next revision), and the shim packages, which are deleted later and
only pick up the number meanwhile.
Verified: cargo metadata --offline --locked succeeds.
The bar scenario counted komorebi-bar.exe processes through 'tasklist /fi "imagename eq komorebi-bar.exe" /fo csv /nh' run via the guest agent, which exits with status 1 there (quoting of the filter), so the process checks failed even though the bar was running and drawing (wgpu). 'tasklist /fo csv /nh' lists the process and the existing filter on lines starting with komorebi-bar.exe keeps the result the same. Found by the candidate 8 Windows gate (gate-cand8.md, bar-fix8.diff: with it the scenario ran 23/0). The file is also reflowed by ruff format (the CONFIG dict), which is formatting only. Verified: ruff format and ruff check on the file; the e2e run in the gate with the one-line change.
Candidate 9 (final): wip-cand9draft (wip-u-cmd2 with the router gate_message hook and 12 more shared arms, wip-u-mac-wm2, wip-u-docs2) merged with wip-u-kdenix (KDE deny --config order, intra-doc links, two KDE manifests formatted with taplo, KDE fmt check through tools/format-all with the flake's own nightly). Conflicts, if any, are resolved here.
Candidate 9 (draft): wip-u-cmd2 (router gate_message hook + 12 more arms through komorebi_core::command; stacked on wip-u-wm2) with wip-u-mac-wm2 (shared push_simple_rule, macOS ignore-rule fix, Minimize/Close/DebugWindow methods) and wip-u-docs2 (MIGRATION-SUMMARY.md, macos-hand-check-plan.md), all on wip-cand8. Conflicts, if any, are resolved here.
The kfde fmt check ran `cargo fmt -p ...` and failed with `failed to resolve
mod windows` for komorebic and komorebi-client: rustfmt follows the
cfg_select! branches of the shared entry files into files the KDE source does
not have. It is now a runCommand running tools/format-all --tree kde with the
rustfmt of the flake's own nightly (fmtToolchain, the toolchain craneLibFmt
already used) over komorebi-for-kde/**/*.rs and the linux modules of the
shared crates, file by file with skip_children and komorebi-for-kde/rustfmt.toml.
tools/format-all now takes the rustfmt of the root dev shell first (the same
pinned nightly) before a nightly on PATH, because a different nightly may
format differently or not follow cfg_select.
Verified: with the rustfmt of that very nightly (rust-overlay 19ecdd08,
rustfmt 1.11.0-nightly 2026-10-27, built from the flake's pins)
tools/format-all --check passes for kde, mac and windows on this tree, so the
only failure was the module resolution, not different formatting. The nix
attribute evaluates; not built.
Records the twelve arms moved in wip-u-cmd2 (28 with the earlier 16), the
two host traits added, and the clusters whose text is identical on all
three routers but still per daemon (rules and padding, animation, lock/save/
load, overrides and work-area offsets, queries) as the next candidates.
Docs only; the list of identical arms comes from comparing the three routers
at wip-cand8.
Records, while kfde's gate_message hook and WindowManagerPlatform trait did not exist yet:
macOS gates every message with the same call at the same place as KDE (so the default
gate_message needs no macOS override), the macOS entry points as hooks with their size and
seam note (focus_workspace keeps the pre-existing main-queue dispatch under the lock, no
hook adds one), what was done meanwhile (Minimize, Close, DebugWindow as methods;
push_simple_rule), and that update stays macOS's (D-coord-15).
Verified: documentation only.
macos-handcheck.md grew by appending sections from several authors (A-H, the
review checks H1-H12, deep-dedup rows, bar clicks, settings rows), so the owner
had to merge them by hand. The new runbook orders every item by what could
make the daemon unusable first: prerequisites, startup and the command path
(shared transport, shared SocketMessage, lock order), hiding and restoring
(shared Container/Workspace/Monitor, HideSpot), the window registry and leaks,
the pointer preamble, settings reload, the rest of the walk-through, the bar,
then the known issues that are expected to misbehave. Each item has steps, the
expected result, how to stop or roll back, the revision that introduced it, a
mark where a second display, trackpad or cables are needed, and a time
estimate per block (about 5 hours in all).
It opens with the list of commands that must not be run on a Mac that has a
live komorebi (stop, start, quickstart, autostart, pkill, state-changing
komorebic commands, SIGSTOP on pids not just started), with the reasons read
from the code: a second daemon exits when a process named komorebi exists, and
a daemon deletes the socket in the user data directory on exit. The original
document is kept as the source.
Commands were checked against the checked-in macOS docs/cli page list; nothing
was run on a Mac. Not built.
LGUG2Z