It is reached only through font-loader, which komorebi-bar looks up system fonts with; it was
already in the lock before the recorder and schemars-nixgen merged.
nix/nixgen has the package and the clippy and nextest checks (in the default check sets), from a
"nixgen" platform of nix/workspace-src.nix that is the tool alone; it is a stub in every other
platform's source, so an edit of it rebuilds none of theirs.
It is a development tool: a bare cargo build leaves it out, publish is off, and no release
ships it. Its manifest uses the workspace dependencies it shares and keeps its own version.
nix/recorder holds the native packages and checks of macOS and Linux (the recorder and the
sources it indexes are the "recorder" platform of nix/workspace-src.nix), the Windows
build has it as one of its members, and the dev shell gets ffmpeg, resvg and GStreamer. The
flake inputs komorebi-mac and komorebi-windows are gone: the sources are in the tree.
The recorder is a member of the repository it indexes: each flavor is built from the
directory of its own daemon (komorebi-macos, komorebi-windows, komorebi-linux) and the shared
crates that log. The statements of the container, workspace and monitor moved into
komorebi-core, so the targets of the real log sample in the fixture are komorebi_core's.
KOMOREBI_SRC and KOMOREBI_COMMIT replace the three KOMOREBI_*_SRC variables, for a build
that is not in a checkout.
N1 is answered: macos-nextest runs in nix on a Mac (383 tests on the Mac Mini), the Windows
unit tests run in the Windows guest through nix run .#windows-nextest (964 tests, 964
passed, one run) with the check windows-nextest-build cross-compiling the 48 test
executables, and the neutral crates' tests run in linux-nextest (1532 tests). The remaining
open point is only whether the first CI also gets a hosted windows-latest cargo test job.
The R6 follow-up (the sponsor-only [FEAT] texts) and 2.2a are marked done.
Verified: documentation only; the numbers are from the agents' reports (win-nextest, and the
Mac Mini run of macos-nextest).
What: CUTOVER-PLAN.md records further owner decisions. R2: macOS is part of 0.2.0-dev; the owner tests it and releases 0.2.0 when ready; the macOS hand-check gates only the release, and the pre-release-later idea is dropped. R3: Starlight is the site for all docs, gh-pages is deprecated: new section 4.9 gives the retirement steps and what happens to mkdocs.yml (exclude_docs stays only while MkDocs builds anything) and the Windows docs source. R4: known failures do not block the dev-line landing. R5: published schema names agreed. R7: the owner handles the old macOS repository, so its banner/mirror/archive steps are removed (the KDE repository steps stay). R11 and every nixpkgs step are removed (no upstream package, the flake is the distribution). New section 4.8: the macOS nightly and its Homebrew formula must come from workflows of the joined repository, starting from docs/dev/old-ci/macos/workflows/*; not in the first CI; one nightly release for the whole repository. N1 (nextest) is marked in progress with the owner's two feasibility questions, not decided. Section 6 now lists what is truly open: the push (owner), the macOS hand-check, the self-hosted Windows runner, N1, and the release-time items.
How verified: sources read, nothing executed; the owner decisions are as relayed by the coordinator.
installation.md: the Nix flake section no longer asks for a GitHub access token
or a private repository; the input is github:LGUG2Z/komorebi and the overlay is
komorebi.overlays.macos (names checked in nix/macos/flake-module.nix; komorebi-full,
komorebi, komorebic and komorebi-bar are the package names it provides). The
nightly Homebrew text stays, now saying nightly builds come from LGUG2Z/komorebi;
the package name and tap are unchanged. Both OWNER markers are removed, the owner
having answered them. docs/macos/README.md had no remaining private-repo text.
Not verified by building; links by repository path only.
Resolves the OWNER marker in the sponsorship section. The owner confirmed that
sponsors get Discord roles, shout-outs, feature requests and, where stated, easter
egg releases, and nothing else; the private macOS repository for sponsors is
gone. Only the marker comment is removed, no wording changes.
Not verified beyond reading the diff.
The Windows crates' unit tests could only run in the (future) hosted Windows
CI. They run in the existing Windows e2e guest: nix run .#windows-nextest
boots the golden image like a scenario (restoring a saved state when
KOMOREBI_E2E_STATE is set), uploads the test executables that the check
windows-nextest-build cross-compiled, runs every test in a process of its own
(nextest.exe is not needed: komorebi's tests share global state, so one
process per test is what nextest does too) and prints a line per executable
and the failures, with OUT/cargo-tests.json for every result.
The driver e2e/platforms/qemu_windows/cargo_tests.py already existed and was
wired to nothing; it now takes the check output (tests.tsv) as well as cargo
messages, creates the saved state itself, prints the panic message of a
failure, and uploads the data files the tests read. Those are found by the
CARGO_MANIFEST_DIR baked into the executables, a path of the Nix build, so
the check also keeps schemas/ and the tests' fixtures and the driver puts them
at that path under C:. Without them 20 tests failed for the missing files.
docs/dev/build-and-test.md and docs/dev/flake-checks.md describe the check,
the app and the neutral crates in linux-nextest.
Verified: nix run .#windows-nextest on the golden image g8 (scale 1.5, state
~/e2e-w0/state-nextest): 964 tests in 37 executables, 964 passed, 0 failed,
202 s with the state restored (first run 163 s more to save the state).
One run only; not soaked. No e2e scenario, the golden image or the existing
e2e-windows behaviour changed.
The tests of the Windows crates cannot run on a Linux builder, and the old
windows-nextest (crane cargoNextest with doCheck = false) ran none. This
check does the part a builder can do: cross-compile every test executable of
the Windows workspace (cargo test --workspace --release --no-run, target
x86_64-pc-windows-msvc through the xwin toolchain) and keep them with a
tests.tsv that lists them (48 executables), so that they are proved to
compile and link, and so that the next revision can run them in the guest.
The stub members of the Windows source (Linux and macOS packages) are
excluded: objc2 does not build for Windows. The check is in the set
windows-test.
Verified: nix build .#checks.x86_64-linux.windows-nextest-build; the output
holds tests/*.exe and tests.tsv. Not run: the executables (see the next
revision).
linux-nextest ran only the tests of the Linux packages (-p komorebi -p
komorebi-linux ...). The tests of komorebi-layouts, komorebi-scrolling,
komorebi-themes and the shared crates/* (backend, collections, config, core,
protocol, settings, transport, komorebic-core) ran in no nix check. They are
platform neutral, so the check now names them too (explicit -p list: with
--workspace the feature unification of komorebi-daemon breaks windows-future
on Linux), and runs with --no-fail-fast so one run lists every failure.
Two of those tests read files that the Linux source did not have: the
schemas of every platform (komorebi-config schemas test) and the macOS CLI
pages (komorebic-core docs_cli), so nix/workspace-src.nix keeps schemas/ and
docs/macos/cli/ in the Linux source.
Verified: nix build .#checks.x86_64-linux.linux-nextest, 1532 tests run, 1532
passed (9.1 s of test time).
The macos-nextest check was built with doCheck = false like the Windows one, so crane printed
'doCheck is not set, nextest tests will not run' and the check ran no test. It now uses
doCheck = true, as linux-nextest does, so the macOS unit tests run in the nix sandbox of a
darwin machine (the owner asked: can nextest run on a Mac with nix-darwin; if so, keep it).
Verified on the Mac Mini (aarch64-darwin, nix, no komorebi daemon started):
nix build .#checks.aarch64-darwin.macos-nextest exits 0 in about 1 minute with the cached
dependencies; nextest reports 'Summary 383 tests run: 383 passed, 1 skipped'. This is the
komorebi-macos library's tests; the cargo test run of the other packages (753 tests in all) was
done outside nix earlier. Not run: the other macOS checks again after this change (it only
touches this one check's arguments).
The owner decided not to rotate the token embedded in the origin URL of ~/komorebi-for-mac
(it is how they develop locally) and asked that it be in nothing that is pushed. The plan
now says that, replaces the 'rotate now' instruction and checklist item 5 accordingly, and
records what was checked: gitleaks with the default rules (which include the GitHub token
formats) found no leak in 7609 commits across every ref of the work clone nor in the files
of any workspace, and the work clone has no remote URL with credentials. The literal value
was not searched (tooling refused to copy a credential into a file); the plan gives the
owner a one-line command that reads the token at run time and prints only a count.
Verified: documentation only; the scans are the ones described above.
bug_report.yml and feature_request.yml get a required platform dropdown (Windows,
Linux (KDE Plasma), macOS) first in the form; the bug report's Windows-only
wording (ghost tiles, systeminfo, whkdrc, komorebic check) is scoped to Windows or
made platform-neutral; the feature request text names all three platforms.
config.yml links the Windows docs site plus the Linux and macOS index pages on
master (repo-relative GitHub links). Existing fields and labels are kept.
Verified: yq parses the three files. Links not fetched (the docs/linux and
docs/macos index files exist in the tree; they resolve on GitHub once pushed).
feature-check.yaml: the comment says feature requests for Windows, Linux and macOS
are open to current $5/month sponsors, individual commercial use licence holders
and approved contributors, and links the README section. It no longer implies
anything about a private repository. The [FEAT]: prefix check and the close and
lock behaviour are unchanged.
Verified: yq parses the file, actionlint reports nothing.
docs/macos/README.md: delete the paragraphs naming LGUG2Z/komorebi-for-mac as the
public release repository and KomoCorp/komorebi-for-mac as a private repository
for certain sponsor tiers with nightly releases (the private repository is retired
and nothing replaces it); add the one policy paragraph to its sponsorship section.
docs/macos/index.md: the same policy paragraph.
docs/macos/installation.md: OWNER markers only, on the Nix flake section that adds
the private repository as an input and on the nightly Homebrew line; text left
as it was because the replacement is the owner's decision.
Not verified beyond reading the diff.
docs/linux/index.md: the Sponsorship for Personal Use copy gains the same policy
paragraph as the README so the three platforms read one wording. Licence
sentences are untouched.
Not verified beyond reading the diff.
docs/index.md: add the same policy paragraph as the README (all three platforms,
the $5/month sponsor tier, licence holders, approved contributors, automatic
closing of other [FEAT] issues). Licence sentences are untouched.
Not verified beyond reading the diff.
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).
LGUG2Z