Skip to content

Releases

kuma v45.4.0

Choose a tag to compare

@github-actions github-actions released this 14 Nov 05:45
  • The shell rides with its battery notifier. The kumaui pin moves to v0.9.0, the release that grows threshold battery notifications into kuma-shell itself: low at 15%, critical at 5%, warned once per band through the shell's own notification road, re-armed by any non-Discharging status.

  • The image's battery-watch script retires. The shell's notifier is the superset of what /usr/libexec/kuma-battery-watch did, so the script, its niri spawn line, and its 300-second monitor leave the image: one battery state announced by two programs in two styles was the shape the blueman retirement exists to undo. Every login stops respawning a second watcher that says what the shell already says. (#80)

  • The image's git speaks nostr://. The nostr git transport rides in every image now: ngit and its git-remote-nostr launcher, baked from the pinned upstream release (v3.0.5, verbatim musl archive — the emoji-font precedent), verified by hash at build and gated on their own --version before the layer can claim it shipped. git clone nostr://… works on a fresh machine. The doctor reads the pair's versions back rather than trusting the layer's presence: an image that predates the transport grades a warn whose fix is kuma update, instead of git dying later in its own bare transport error. (#79)

  • Doctor grades the wire under the signer. The 45.2.1 lesson's read side, closed: the vault line now grades the conjunction — an open vault answering over no connected relay is a warn that names the dead wire, not an Ok that vouches for it; the local relay's unit gets a liveness check when the declaration arms it (a relay that cannot stay up was silent while every other grade read green); and a unit stuck activating is called a crash loop, with the journal as the fix, instead of being told to start. The dev road stopped swallowing its own failures in the same breath: a bounce that fails is noted loudly at both call sites (the install print says the daemon is pointed at the staged binary — what a swallowed restart actually achieved), an adopt that finds a session bus missing bails instead of staging silently, and the dev override is audited — its ExecStart arguments drift when the image's unit moves, and the audit's fix is re-running kuma dev install. (#77)

  • The fallback lap's ceiling fits its work. The upgrade-fallback job's in-guest fallback compile measured 117–120 minutes against a 150-minute job ceiling that one runner shutdown and one unfinished lap proved was runner-weather roulette: the ceiling is 180 now. (#81)

  • Battery-watch stopped polling. The low/critical notifier woke the machine every 60 seconds — 1,440 wakeups a day on every machine, battery or none — to read two sysfs files. It now watches udev's power_supply events, with a five-minute safety read behind them: the first real battery announced the plug and stayed silent through a whole band of draining, so the monitor's own five-minute lifespan is the floor the threshold can never slip past. A desktop's watch now costs ~288 cheap reads a day instead of 1,440 timer wakeups; a laptop's notice is never more than one cadence behind. The first read on start means a boot at 12% on battery warns immediately. The old poll survives as the fallback for a machine without udevadm. The real-battery proof (discharge past both thresholds, replug, re-warn) is #80's remaining half — nothing in a VM ever discharges.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.4.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.4.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.4.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.4.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.4.0/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.4.0

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from 3a1c09454a74f976763bca53e25f9eff2e9328d5.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v45.3.0

Choose a tag to compare

@github-actions github-actions released this 12 Nov 07:03
  • The CI's apt routes around the azure mirror. Canonical's 2026-11-11 archive incident killed four CI rolls in ninety minutes — all "Temporary failure resolving 'azure.archive.ubuntu.com'", the traffic-manager CNAME chain GitHub's runner image points every apt source at, dead on the runners while the same name answered from off-Azure and the runners' other fetches (rustup, crates) sailed through. The new apt-route action rewrites the mirror file to full http:// URLs on archive.ubuntu.com / security.ubuntu.com — different domains, different DNS; the first draft's bare-host lines made apt parse the host as the method driver, its own one-roll lesson — and the action rides before every apt-get the workflows run. The same class of fix the smoke already applies to Fedora's flapping mirrors: the road bends around upstream weather instead of waiting in it.

  • The heavy jobs carry their measured ceilings. The 45.2 audit gave the session daemons MemoryMax=256M and deliberately left the two heavy jobs uncapped until sized — now measured on a real machine (101G, 1.8M files, restic 0.19.1): a cold full backup peaks at 7.75G, the nightly incremental at 853M, a repo prune at 284M, the flatpak daily's appstream re-pull at 76M. kuma-backup gets the soft MemoryHigh=8G just over its one heavy day and a MemoryMax=12G leak line; the flatpak daily gets MemoryHigh=512M / MemoryMax=1G. A cap below the cold peak would have broken the legitimate backup outright — the sizing is the point.

  • Doctor's mime check attributes and prunes. A dead mime default used to report as mime → handler with no source: the two files it reads have different owners (the image bakes /etc's pin, the user wrote ~/.config's), and the reader could not tell whose fix it was. Each entry now names its file, and when every dead default is the user's own single-handler line, the warning carries a prune Action — a sed that deletes exactly those lines, its pattern escaped for the BRE's any-char dots and bare +/? (the quantifiers are the ESCAPED forms in a GNU BRE; the suggested command could not widen past the dead entry).

  • The prune Action's command survives the shell that would run it. The review caught the first draft's sed printed its BRE pattern UNQUOTED — the pattern's ; is a shell command separator, so the suggested command failed on every input (sed: no input files, then the shell trying \?$#d as a second command) and touched no file. Every -e expression is single-quoted now and the target an absolute path (doctor runs under sudo; a pasted ~ expands to root's home, where the file does not exist). The line's fields are user-file text: they pass through plain() at parse, sed_bre in the pattern, and the single quotes at the shell — and a field carrying a single quote refuses the Action entirely, that line staying advice rather than a broken paste.

  • The dev deploy reads the unit's LAST non-override ExecStart — the 45.2.1 bug's twin, caught before it bit. 03094c9 fixed the empty- relay deploy by reading the image fragment's arguments out of systemctl cat, and the first draft took the FIRST non-override assignment — on a delta machine, the declaration's relay drop-in (10-kuma-nostr-relays.conf) sorts before the dev override and restates ExecStart, so the parse adopted the image's relays over the declaration's, silently, on exactly the machines whose declaration had moved. The parse now takes the LAST non-override assignment (systemd's own rule: a later non-empty assignment replaces an earlier one) and only a real fragment header — a path — may move which fragment a line belongs to, so the override's own comments cannot flip the state and its bare ExecStart is never read back as the argument source. Pinned against the real drop-in interleaving.

  • Doctor reads the wire facts the daemon already reports — the 45.2.1 read-side lesson. The release's signature bug was a signer that ran, listened, and heard nothing: daemon active, vault open, EMPTY relay set — and kuma doctor graded it Ok, because the check read two of the four facts the status document carried and the two it skipped were the wire's. Now graded: the daemon's relays and connected — an empty relay set warns naming the override/drop-in suspect, no live connection warns, and the daemon's set is diffed against the declaration's (the local relay added when the layer arms it) with a mismatch naming systemctl --user cat kuma-nostrd as the interrogation. The reachability line stays declarative — the word "answers" belongs to the runtime grades, and 45.2.1 is the proof of why. And the socket client bounds every ask at ten seconds: the daemon side holds its mutex across keyring D-Bus calls, so a wedged daemon used to be able to hang the very probe that should have reported the hang; now it grades a warn.

  • Drift is measured against the authority convergence follows. The bare kuma probe counted drift against the image's baked list file directly — an authority the convergers stopped consulting when the nano-incident ruling moved the answer to the CLI: the machine's own declaration where it names the axis, the baked list otherwise. A machine whose declaration dropped an app the release still bakes read as "drifted" by an app no sync would ever touch, promising work the actor no longer meant to do — the second incident of the summary-reads-one-source class that inventory.rs already records from the brew half. The probe now asks governing for the same answer sync acts on; an authority that cannot answer stays quiet, because sync's refusal is the loud path and a guessed baseline was the bug.

  • A delta re-bakes the lists it governs. The delta compiler's guard compared the declared list against the baseline DECLARATION — an artifact it was not rewriting — so every delta whose baseline already agreed with the declaration skipped the bake, and the release's list file rode forward through the delta chain unexamined: a machine whose declaration dropped a release default kept the release's list in its image for as long as deltas were the upgrade road. The re-bake now follows the runtime's authority shape (a declaration that names the axis governs it, empty included; one that omits it leaves the base's list standing), and the overrides tree is written unconditionally — the full build's own rule, and the same skip-forever shape removed from the lists.

  • Doctor reads identity, not presence, for shadowing binaries. An unreceipted binary in ~/.local/bin used to warn for existing; shadowing is the dev-deploy mechanism itself, so presence alone is not the problem. The check now compares bytes against the image's own binary — byte-identical is the kumaui build script's legitimate staging and reads ok; anything else warns naming what it is. Bytes are read, never executed: doctor is root, and root running a user-writable binary is the opinion-refusal rule's business. A new sweep flags cargo-installed kuma binaries in ~/.cargo/bin — the one deposit no receipt knows and no gate resolves, found masquerading as the CLI for a whole reboot cycle.

  • A dev deploy keeps the daemon's arguments. kuma dev install rewrote the daemon's override with the staged binary alone — and the image's unit bakes its relay set onto the same ExecStart line, so the adopted daemon came up with an EMPTY relay set: no relay threads, no wire, no error anywhere, a bunker that listens and never hears a note. The override now carries the image unit's own arguments beside the staged binary, the parse is pinned by test, and a unit with no ExecStart fails the adoption loudly instead of inventing a bare daemon.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.3.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.3.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.3.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.3.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.3.0/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.3.0

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from 7550ab5aaec768eda4b6dc5600b80c2b5769c426.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kum...
Read more

kuma v45.2.1

Choose a tag to compare

@github-actions github-actions released this 11 Nov 00:14
  • A restored machine no longer restores again on every boot. The restore unit's sandbox — tightened in 45.1.0 to exactly the paths the script writes — left out the snapshot's PARENT directories, and restic's restore applies each directory's stored ownership on the way down: the chowns on /var, /etc and /etc/NetworkManager failed against the read-only sandbox, restic counted them into its exit code, and the script died on set -e before it could clear the restore request. Every file came back; the machine then carried a failed unit and re-ran the restore on every boot after it. The parents join the sandbox's writable set — the ownership being applied is the machine's own, a no-op on a converged system — and the test pins all three.

  • A locked keyring no longer reads as "no vault exists". The vault is found by searching the Secret Service, and a locked login collection answers that search exactly like an empty one — so a machine whose keyring daemon died mid-session (see next entry) was told, on every unlock attempt, that no vault existed, which reads as advice to run setup and threatens an overwrite of a key nobody can see. The empty search now double-checks the collection's own Locked property before it is believed: a shut wall is an error naming the lock, and only a genuinely absent vault reads as absent.

  • The daemon's startup unlock rides a retry burst. The session's first minute is the Secret Service's worst — gnome-keyring 51.1 aborts on bursts of fresh OpenSession connections (an upstream plain_negotiate bug, see hey-cli#352/#453 for the identical backtrace), and the daemon's login-morning handshake could land in the storm and take a single NoReply as the whole session's answer, stranding the bunker locked even though the PAM-unlocked daemon survived. The startup posture now gives the same wall three tries, two seconds apart, and a vault that is genuinely absent or locked still fails fast on the last error.

  • The battery's flaky laps say what hurt. A smoke lap that failed on a flaky fixture now names the flake in its verdict instead of a bare red, so a rerun can be judged against what actually failed.

  • The changelog reads newest first, and something checks. The v45.2.0 bump renamed Unreleased in place, burying the new release under the previous one; the file's convention is restored and the container battery now holds it: Unreleased is the first section and every version heading descends.

  • The battery's hibernate lap declines what its fixture cannot prove. The diagnostics of this cycle found the "flaky" hibernate reds are neither flaky nor ours: kernel 7.3's virtio-gpu driver refuses S4 on any virgl device, and the fixture's GPU is virgl because the desktop cannot boot headless without it. The lap now asks the still-live guest why the machine never powered down; the kernel's refusal reads as a loud, permanent warning naming exactly which checks the run did and did not make, and a guest without the refusal still fails honestly.

  • The publish road grants what its validation road needs. The release workflow's permissions line up with the validation jobs it runs.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.2.1/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.2.1/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.2.1/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.2.1/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.2.1/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.2.1

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from c7e5729bc0f93e51aff0043fa27d2cd1eb350186.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v45.2.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 16:50
  • Doctor's report carries facts, not escapes. The strings doctor formats into its report — receipt binary names and versions, the handler half of a mime default — come from files a user-level process can write, and doctor runs under sudo: a control character in one was a terminal escape arriving in root's terminal. Every user-controlled string is stripped to plain before it is formatted in; UTF-8 names pass, control characters keep nothing.

  • dev install only executes what you built. Three hardening fixes on the dev surface, all from the same audit. Receipt-controlled binary names are now bare filenames or the receipt reads as absent — a name with a / or .. in it (the receipt is a user-editable file) would have walked the retire path join outside ~/.local/bin. The checkout's target/ must be owned by the invoking account: the verification executes the build output it stages, and kuma dev install ~/some-cloned-repo would otherwise run a stranger's binaries before any check names it — the refusal says so, and the verb's help now states the boundary too. And the staged .new copy is re-hashed against the receipt before the rename, so a source changed between verify and copy fails the install loudly instead of staging bytes the receipt vouches for falsely.

  • The local declaration is what its owner wrote, provably. Two authority-resolution fixes in state.rs. An unreadable declaration used to read as an absent one (.ok() made "cannot be read" and "not there" the same answer), so a root converger could silently fall back to the baked list — the nano incident's shape, one directory-permission away. A declaration that exists but cannot be read is now an authority error, loud like a declaration that does not parse. And the declaration's mode and ownership are checked before its text becomes the opinion root executes: group- or world-writable (any local account's rewrite), or owned by anyone but the primary account, is refused as another account's opinion.

  • The boot path stops paying for weather it can read. Three trims from the audit, plus one boundary guard. The offline boot's six flatpak retries now cost one busctl read each instead of a full vendor flail — NetworkManager's own connectivity verdict gates the script, a machine whose network arrives minutes after boot still converges through the retry ladder, and an unreadable verdict proceeds (convergence is the machine's contract; the daily gate's opposite rule governs currency). The greeter check's settle dropped from five seconds to three — three is past greetd's own RestartSec=2 cadence, which is what makes the second sample an independent draw, and every second past that was healthy-boot latency paid on every boot — and the greeter wrapper's socket poll is bash builtins now, where ls | head forked two processes every hundred milliseconds. Both convergers' xargs calls take -d '\n': the parse is positional regardless of content, so the boundary no longer leans on the upstream charset validator alone.

  • The session's units take the same medicine the daemons wrote down. Three unit-policy changes from the audit. The shell's unit said Restart=always / RestartSec=1 with no start limit — a shell wedged at startup respawn-spun every second forever, each attempt a full GPU/allocator initialization, while holding the logind lock-listener role. It now carries the exact lesson the daemon units' comments record (StartLimitIntervalSec=60, StartLimitBurst=5, RestartSec=5). The two session daemons (kuma-nostrd, nip46-relay) take MemoryMax=256M — the first memory ceilings in the image: a daemon that runs for weeks beside a signing key now fails a leak loudly instead of quietly eating the session (the heavy jobs — restic, flatpak — stay uncapped until their ceilings are sized, because a cap too low breaks legitimate multi-GB deltas). And the brew timer's calendar moved from daily to 01:00, ending the resume-time double storm where Persistent-fired catch-ups of both convergers ran as competing network and IO jobs against the same home.

  • The daemon's queues are bounded, the relay's REQs replace. The four-axis pre-release audit (performance, resource usage, memory leaks, security) found the leak posture strong everywhere except one shape: std::mpsc channels the inbound side had bounded and the other directions hadn't. kuma-nostrd's outbound relay queue was unbounded (channel::<(Event, Fan)> per road) and the relay socket had a read timeout but no write timeout — a road whose peer died or stalled mid-write grew its queue at the bunker's publish rate for as long as the outage lasted, the daemon's one plausible OOM path on a process that runs for weeks. Both roads are closed with the idiom the inbound side already runs: a sync_channel bound (OUTBOUND_CAP 1000) with try_send-shed at the producer — a shed answer is a requester's timeout, the same end an unbounded queue gave everyone eventually, without the RSS — and a ten-second write timeout beside the read timeout, so a stalled peer tears its road down into the ordinary backoff. The status channel got the same bound (STATUS_CAP 100): nothing drains it until someone asks for status, so a relay flapping unwatched for weeks wrote messages nobody consumed, and the drain's newest-state-per-URL rule makes a shed transition free. In nip46-relay, a new REQ with a subscription id already in use now replaces the old filter (NIP-01's replace rule — without it, a client that re-REQs in a loop grew its Vec one entry a time for the life of the connection), and the connection maps' cleanup moved into a Leaving drop guard that also unwinds through a poisoned lock, so a panic inside a connection's serve loop can no longer leak its subscriptions and outbound queue.

  • The release road builds the siblings once, and the nightly gets a ledger. Two road changes from the 45.2 plan. First (#74's Option A): every job that boots a disk was re-running the kumaui sibling compile — vendored gpui, release mode, no cache, ~100 minutes — for binaries another job of the same commit had already built an hour earlier, and the tag road paid it four times. ci now has a siblings job, once per head, uploading the fifteen files the compose's staging gate resolves beside the running kuma (kuma, the five shells, the nostr trio, the entries and icons); ci's six heavy jobs download it from their own run, and the tag road's four boot jobs wait for ci's run of the same commit and download from there (actions: read is the whole added scope). The road's target is ~1h15, down from ~3h10. Second: ci's boot legs skip on push, which made a first-boot unit bug on main invisible until a tag spent its road discovering it — 45.1.0's brew and home-subvol reds were both that class. The heavy battery's daily scheduled run now keeps a ledger: one issue, opened red with the run link, commented on each further red, closed green — one thread, because a nightly that opens a fresh issue a day is a wall of noise no one reads either.

  • kuma dev install — the dev loop's promotion step, with a receipt. The container-build-and-stage loop (build in kuma-dev-gcc, land binaries in ~/.local/bin, restart the session pieces by hand) never had a record: a machine carrying four binaries from three different commits is how the 44.9.0 story happened, and nothing on the machine could answer "what is dev-built here, from what, and is any of it stale". The verb verifies before it moves — every checkout's tree must be committed (a dirty tree is a stamp no commit describes) and every target/release binary that answers --version must answer for that checkout's HEAD (the same stamp gate the image's staging runs, caught before it matters) — then stages atomically (.new + mv, so a running shell or daemon keeps working) and writes a receipt at ~/.local/share/kuma/dev-install.json. The receipt is a lease, not enforcement: the image is always the authority, and the lease retires itself on the next kuma upgrade or kuma update once the image reaches the version the dev install was staged around — the machines where it matters most are the ones whose next command is the upgrade that ends it — and the retirement is complete: the nostr daemon's override goes with the binaries, so a daemon the dev install adopted runs the image's binary again. kuma doctor grades the lease (executes nothing): a binary the receipt names that is gone, staged bytes the receipt did not record, a home binary shadowing the image's with no receipt to tell its story, and a lease the image has already caught up to, are the states where the receipt says one thing and the machine another.

  • The machine converges to its declaration, wherever that declaration lives. The provenance gap the nano incident exposed: the convergers read the lists the image baked, so a fetch-lane owner editing their own ~/.config/kuma/kuma.toml was editing a file nothing read — and a release adoption converged away formulae the machine's own declaration had installed. The convergers now ask kuma sync --print-flatpaks / --print-brews, which resolves the declared primary account's local declaration and falls back to the image's baked list when no local opinion exists. The ruling's edge rules are exact: an absent key is no opinion (the baked list governs), a named key governs even when empty — brew = [] means converge away, because silence is not a zero. A local declaration that fails to parse stops convergence loudly instead of falling back: converging to the baked list because of a typo is the incident one level deeper. kuma check now reports which declaration governs each axis and whether this file's opinion is the one the converger follows (the divergence report, in prose and in the convergence key of its JSON), and doctor grades a mime default whose handler no longer resolves — the one dangling promise a converged-away flatpak leaves behind.

...

Read more

kuma v45.1.0

Choose a tag to compare

@github-actions github-actions released this 08 Nov 15:50
  • kuma run no-home|airlock — the sandbox a build tool's scripts deserve. npm install runs lifecycle scripts on every package it touches, and pip's own documentation answers "running arbitrary code from distributions" for what an install does. The verb runs the command under bubblewrap — unprivileged, no setuid bit, already in every image — with the system read-only, a fresh /dev and /proc, a /tmp that vanishes when it exits, and the point: an empty home, a tmpfs mounted where yours is and gone when the command finishes, so the caches and tokens a postinstall reaches for are not in the sandbox to find. The working directory binds read-write after the home tmpfs (later mounts win), so the project is the one real, writable thing the child sees; the agent sockets are unset; the child cannot TIOCSTI keystrokes back into your terminal (--new-session); nothing is left orphaned (--die-with-parent). The child's output is yours and its exit code is the command's. airlock adds the network removal — loopback only — for scripts that should not phone home while they run. The verb refuses the two spellings that would defeat it: running from the home directory or any directory containing it.
  • External monitors get brightness. ddcutil rides the image — tagged uaccess, so the sitting user's session can reach the i2c bus with no group story, with i2c-dev loaded through the module loader the package already ships — and the shell's brightness control speaks DDC/CI through it. This is the machine half of the kumaUI v0.8.0 ride (pin e333d6e: DDC/CI brightness, avif through the video path's libav decode, the wallpaper-derived theme's flavor picker in Settings). The smoke asserts the plumbing rides the image.
  • A new SUID binary fails the compose. The image bakes a golden list of the seventeen setuid paths the base should have (/usr/lib/kuma/suid.golden), and the compose's check runs it — a package update that quietly adds a privileged binary fails the build instead of shipping. One-directional by design: an added SUID bit is the risk class (privilege surface arriving unseen); a removed one is visible at first boot where it matters.
  • The convergence units run sandboxed. The four units that touch the machine on a schedule — backup, restore, snapshot, and the daily converge with its gate — run under NoNewPrivileges and ProtectSystem=strict with their write surfaces settled against what the scripts actually write: restic's cache in /var/cache/restic, and NetworkManager's system-connections for the restore path.
  • The daemon's residue is tightened. The reviews' MINOR list came forward rather than waiting for 45.2: the vault's lock now retires the key with secp256k1's own non_secure_erase — the promise the doc made is the code it runs, no new dependency, the crate had the pass built in — and the same pass runs when the vault drops. The inbound relay channel is bounded: a reconnecting relay's backlog replay sheds at the cap instead of growing the daemon's RSS, and a shed is the requester's own timeout — the same end a jammed queue would have given it. The prompts queue caps at 100 and sheds its oldest, by the activity log's own eviction rule. The socket reads a request line under a 1 MiB cap, answers an over-long line with an error before closing, and no longer keeps one connection's secret-carrying buffer alive into the next. Revocation and deletion forget the relay URLs nobody serves anymore, a teardown clears the road-state map outright, and expired remembered grants are pruned where they are consulted. Two stay deliberate: the blob's wrapped secrets are ciphertext whose unwrap secret lives in memory by design — zeroizing the dead copies buys nothing — and clean's per-tag rmi loop is per-tag tolerance, not an N+1 to fix.
  • The release road keeps its composure. Every cosign invocation retries three times a minute apart (Rekor's transient failures took two road runs on release day — the conflict, the refused connection, and the maintenance window the status page named); the tag watcher checks the registry before dispatching, so re-firing it after a finished promote dispatches no leg; and the save/load digest experiment is run and recorded — the re-serialization is podman save's, so the two-digests-one-content comparison stays retired in favor of trusting bootc's verdict (#68).

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.1.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.1.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.1.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.1.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.1.0/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.1.0

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from d0b0a000409fcad6adfbc9cf790824042fc34e9c.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v45.0.1

Choose a tag to compare

@github-actions github-actions released this 07 Nov 15:30
  • kuma upgrade no longer refuses a moved declaration — the delta lane always has a path. The diff baseline was the release's baked example, so any machine whose declaration ever named a custom hostname, keymap, or [user] account diverged forever and was refused at every crossing (#65). The baseline is now the booted image's baked declaration — what the machine's last build actually honored — so a stable declaration diffs clean and compiles as the small delta it is. And when the diff carries fields a delta cannot take (a keymap moved since the last build, a changed account), the verb no longer dead-ends: it compiles the FULL declaration FROM the release digest it already pulled — the whole compiler, so hostname, the initramfs half of the keymap, and the account all ride — while the release's own binaries, version label, and branding stand. A 44.x binary can build this fallback (no compose env involved), which is the road a 44.15.2 point release gives every existing machine.
  • kuma upgrade --check tells a delta machine the truth. The delta lane's check compared the booted digest against the release tag's — and a delta machine boots its own build, whose digest can never equal the release's, so every machine that ever upgraded through the delta lane was reported a step behind the release it was current with (#67). The comparison reads the lock's release story now (what the last upgrade compiled against); a machine with no record gets an honest "cannot tell" and keeps the action, and the fetch lane keeps the booted compare — it boots the release itself.
  • A no-op upgrade is a success. A rebuild that reproduces the image the machine already runs — same declaration, same release, podman's layer cache — stages nothing, and the verb ended that in Error: nothing staged with exit 1: an error for the system being correct (#68). The no-op is confirmed against the digest bootc itself compares, read out of root's store (the user's store answers a different manifest digest for the same image — the save/load sync re-serializes the manifest), reported as already-current, exit 0. The unexplainable refusal stays an error.
  • The machine runs what it runs. update --check and update read the Fedora release from the running system's os-release, not the lock's base image — a delta upgrade boots the release's Fedora while the lock's base half keeps the last full build's story, so a machine booting 45 was told it runs 44 and an update announced a release move that already happened (#69). The full compile inside kuma upgrade also re-bases the lock's base story onto the release image it actually FROM'd, so the next git diff kuma.lock and the next update both read the build story straight.
  • The smoke's upgrade failures dump the store that failed. The delta and fallback builds run in the guest; the runner-side dump read a store that never saw a layer of the build. The failure branches ask the guest's root store now (images, disk, df) while the machine is still up (#66), and the delta lap proves the new contracts where they live: the post-upgrade check says current, the repeat upgrade stages the pure delta path, the no-op upgrade exits zero, and the fallback's full compile re-bases the lock.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.1/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.1/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.1/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.1/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.0.1/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.0.1

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from a1ec13a492e879f48d2d6b9c77092e5ff5c80af7.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v44.15.2

Choose a tag to compare

@github-actions github-actions released this 06 Nov 23:47
  • The fallback's full compiler survives its own output. The staged 44.15.1 binary generated a Containerfile whose niri-session patch asserted the unpatched line before sed'ing — and the release image the fallback compiles FROM was built by that very compiler, so the assertion failed and every upgrade that could not ride the delta lane (the 44→45 crossing, any full-rebuild move) died at the build (#70). The patch step is idempotent now (d80a9f2's fix, rebased onto this branch): the sed runs unconditionally and asserts the patched line, which holds on a virgin base and on a release image alike.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.2/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.2/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.2/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.2/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v44.15.2/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-44.15.2

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from 20cf5c8832b246d21e61db2c18dce50537d7d8b3.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v45.0.0

Choose a tag to compare

@github-actions github-actions released this 05 Nov 12:14
  • The base moves to Fedora 45. DEFAULT_BASE is quay.io/fedora/fedora-bootc:45 and the ISO build container is fedora:45 — the next composed image is F45 root to toe (kernel 7.2, systemd 262, dnf5 5.4.6, podman 6), everything layered on top baked fresh as always. The seed rides the GA digest (sha256:8076cf4f…, the 2026-10-31 release compose; the tag is frozen until base-images grows its 45 renovate lane), and the compose env's rpm-ostree 2026.3 knows F45's relocated repo configs (/usr/share/dnf5/repos.d). The greeter PAM stacks moved from /etc/pam.d to /usr/lib/pam.d and the keyring assert follows (8906e62); the oo7 secrets change is met by staying on gnome-keyring for now — the adopt lane and its preconditions are the research notes' subject, not this release's. The one F45 name change in the package set (mesa-va-drivers folded into mesa-dri-drivers) is handled by the mesa block's own version guard, which only ever installs the freeworld side. Research trail: notes/45.0.0-*.md.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v45.0.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v45.0.0/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-45.0.0

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from 505fc5d896c309213037ae0c21047e609143793c.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v44.15.0

Choose a tag to compare

@github-actions github-actions released this 30 Oct 03:09
  • One keyboard layout, every layer, with the boot layer made honest. [system].keymap ("de", "us", "de-latin1" — the console's vocabulary, because one value has to work for the console and the session both) composes a niri input stanza into /etc/kuma/keymap.kdl, included ahead of the local.kdl include so the machine's layout beats the defaults and a person's own override still beats the machine; writes /etc/vconsole.conf ahead of the build's one initramfs regeneration, so the LUKS passphrase prompt speaks it too; and the greeter's session wrapper appends the same stanza to a runtime copy of its pinned config. kuma keymap apply <layout> moves the three runtime layers on a booted machine and says plainly which layer it cannot move: the initramfs is image content, moved by declaring the keymap and rebuilding, never by the verb. kuma keymap status --json reads every layer back, the image's baked one included, and kuma doctor warns when the layers disagree — the common drift being exactly the quiet one, the prompt that kept speaking the old layout. COSMIC machines get the vconsole and boot layers; there is no session stanza to include. A keymap move refuses the delta compiler, because the runtime layers are three of the four and carrying them alone would half-converge (#58).

  • The account bridge's gap has a heal. The delta is compiled by the machine's own binary — the release the machine is leaving — and a binary predating the account emission stages a deployment whose /usr/lib/kuma/users.d is empty while the re-baked declaration still names the accounts: the ride carries the names, nothing carries the dropins, and /usr is read-only at runtime, so nothing at boot could write them where the converger looks. kuma-user-sync.service's ExecStartPre (kuma accounts-heal) fills the hole from the ride into /var/lib/kuma/users.d — 0600, the emission's own shape — the sync's loop converges the account the same boot, a dropin takes it back, and the heal retires its own file. kuma doctor cross-checks the declaration's additional accounts against what actually carries them, so the silent shape a stale compiler leaves is a finding (#60). The smoke's delta lane runs the true scenario on the N-1 compiler that needs it: 44.14.0 emits the dropin, 44.13.0 predates the emission, and the proof waits for the road whose N-1 can carry it.

  • boot-titles guarantees /boot is writable itself. No unit in the boot graph owns the rw half — ostree-remount does not touch it, and the guest's boot.mount comes from the initramfs — so a machine with stale titles to fix could only fail the write. With titles to write, the caller remounts rw on a bounded retry (ten rounds × 200 ms, the mountinfo read the authority) and refuses loudly if the filesystem stays read-only; a machine with nothing to fix touches no mounts (#59).

  • The release page teaches image verification, not just artifact verification. The body's verify section now names the thing most kuma machines actually run: cosign verify --key cosign.pub against the pinned niri-<version> tag — the key form, because a podman policy.json can name a key and not a keyless identity, which is why publish.yml signs with one — the key fetched from the release tag that names the code which shipped, and the digest-pinned form beside it, the verify response being where the digest comes from. A test holds release.yml and publish.yml to one registry path and one tag scheme, the same standard the asset names were already held to (#57).

  • doctor states its check conventions. Two species, written where the checks live: floor checks grade the image's baked posture and are permanent by design — the boot smoke's hardening lap pins the same floor — and drift reconcilers grade stateful drift, retiring once every supported install path has run them. The 44.15.0 audit's ledger: none retire; every reconciler's drift is still produced by a supported upgrade chain or by ordinary use, and the smoke's doctor lap reads by check name and asserts no count, so a retirement, when one eventually comes, is a silent no-op there (#56).

  • The third audit ran before the release. Two lanes over everything 44.15.0 ships (#63, the #55 pattern). Performance read the compose question by construction — the keymap's boot layer feeds the build's existing initramfs regeneration, zero added dracut minutes on keyed builds — and the boot graph's delta: the heal a no-op read on gapless machines, boot-titles' remount retry bounded at ~2 s and only when titles need writing, the include one stat per niri load, check_keymap four file reads against the ~6.6 s doctor baseline. Security walked the keymap value's road (one validator, three sinks — a KDL string, a single-quoted echo, an argv), the trust directions (a root-written stanza user-read; the heal steered solely by the ride), the heal's writes, boot-titles' remount, and the release page's interpolations. One finding: kuma keymap apply was the one writer in the tree off the house shape — now temp and rename with an explicit 0644, so a hardened umask cannot lock the greeter out of its own layout and a crash cannot leave a half stanza behind. Hand-forward: per-unit boot timing on green runs, carried from #55.

  • The prose names its shortcuts as commands. The README answers "why this exists" before "what do I type", and the everyday-use section names kuma add, kuma remove, kuma clean and kuma completions as commands — the verb-documentation gate reads pages for command mentions, and bare words in a list are not one.

  • doctor's /etc drift check stops watching /etc/vconsole.conf. The file's sanctioned writer is localectl set-keymap — what kuma keymap apply runs — and localectl rewrites the file in its own format (a header, FONT, the XKB lines), so re-applying even the declared layout re-shadowed the compose's one-liner and the byte compare warned again on every legitimate apply. The TTY layer's semantics stay watched by the keymap check, which reads the KEYMAP= line off every layer and already narrates the dangerous case — a local copy holding back a moved declaration — as layer-versus-initramfs drift with the right fix attached.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.15.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

The image this release publishes verifies with the committed
public key — the same key every kuma machine's own policy
enforces on update:

$ curl -sSLO https://github.com/Letdown2491/kumaOS/raw/v44.15.0/cosign.pub
$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma:niri-44.15.0

The moving tag is the convenience and the digest is the proof;
the verify response prints the digest it checked, and the same
command against that digest pins the bytes:

$ cosign verify --key cosign.pub ghcr.io/letdown2491/kuma@sha256:<digest the verify above printed>

Built from 125936e7c76c2f6c86ab94a271569e78e66f4068.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso

kuma v44.14.0

Choose a tag to compare

@github-actions github-actions released this 25 Oct 02:57
  • A machine-added account converges through a delta. The delta compiler's contract was that accounts ride the image: the declaration COPY is verbatim, but the /usr/lib/kuma/users.d dropins were build-time work, so a machine that added [other_users.<name>] and ran kuma upgrade got the re-baked declaration, no account, no refusal, no message. The compiler emits the dropin now — plus the build-time shell guard, the key file under /etc/kuma/keys/<name>, and the sshd conf serving it when the base lacks one — exactly what a full build would have baked, and the boot sync loop converges the account the same way it converges its own. A moved account re-emits (the dropin is the live config the sync reads every boot, so shell and groups moves land on the next one); a dropped one — an account the release names that the declaration does not — refuses loudly, because the sync creates accounts and never deletes them, and a removal the machine would never see is not convergence. An autologin move refuses too: the greeter's [initial_session] stanza rides the image, and a delta carrying it would silently not log anyone in. The smoke's delta lane now runs the true scenario: the release no longer bakes the account the machine declares.

  • The nostr layer's enablement converges at boot. The baked preset governs preset applications, and the build's --global preset ran once, inside the image — a booted machine's /etc kept the enable link its last image merged into it, so a disable delivered by delta was a preset file standing down over a link that never heard of it. A boot-time converger (kuma-nostr-preset.service, oneshot, before any user manager starts) re-applies the baked preset on every boot, reading the unit names from the preset file itself — the preset stays the single source of truth, a delta's rewrite of it is the whole move, and the same lines carry the arm back on. kuma sync starts it on demand, so convergence need not wait for the next boot; kuma doctor reads its last run beside the other convergers. The smoke's delta lane asserts the flip itself now: systemctl --global is-enabled answers disabled on the booted delta deployment.

  • The second audit ran with the release. Two full lanes over everything 44.13.0 shipped (#55, the #49 pattern): security re-walked the default-armed layer (arming creates nothing — the locked daemon touches the bus, the state dir, its socket; no relay), the hand-rolled vault client (signature-dispatched parsing, no key material in any error path), the account machinery (name charset, sourced dropins, the autologin singleton), the preset converger, and kumaui's Vault tab and restore path — no findings needing code, four hand-forwards recorded. Performance read the boot graph's delta by construction: one small pre-login oneshot (offline file ops, no D-Bus), zero-to-a-few no-op usermod spawns per declared account, the daemon a session cost — and named the gate that does not exist yet (per-unit boot timing on green runs), recorded as its hand-forward.

Static x86_64 binary, no runtime dependencies.

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.14.0/kuma-x86_64-unknown-linux-musl
$ chmod +x kuma-x86_64-unknown-linux-musl && sudo mv kuma-x86_64-unknown-linux-musl /usr/local/bin/kuma

The image build stages the layer's three binaries from beside
the running kuma on every compose, nostr or not, so they
install to the same place:

$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.14.0/kuma-nostrd-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.14.0/kuma-nostr-x86_64-unknown-linux-musl
$ curl -LO https://github.com/Letdown2491/kumaOS/releases/download/v44.14.0/nip46-relay-x86_64-unknown-linux-musl
$ chmod +x kuma-nostrd-x86_64-unknown-linux-musl kuma-nostr-x86_64-unknown-linux-musl nip46-relay-x86_64-unknown-linux-musl
$ sudo mv kuma-nostrd-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostrd
$ sudo mv kuma-nostr-x86_64-unknown-linux-musl /usr/local/bin/kuma-nostr
$ sudo mv nip46-relay-x86_64-unknown-linux-musl /usr/local/bin/nip46-relay

Verify it came from this workflow:

$ cosign verify-blob \
    --bundle kuma-x86_64-unknown-linux-musl.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64-unknown-linux-musl

Built from 53744a358a8caab1bcf5f364691f5dd25a6c2a7e.

The installer media on this page verifies the same way:

$ cosign verify-blob \
    --bundle kuma-x86_64.iso.bundle \
    --certificate-identity-regexp '^https://github.com/Letdown2491/kumaOS/.+@refs/tags/' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com \
    kuma-x86_64.iso