Changelog

All notable changes to Argos are documented here. Loosely follows Keep a Changelog.

[1.7.1] - 2026-10-09

Fixed

• The macOS .dmg could never be granted Full Disk Access. Its universal binaries are built by lipo-ing an arm64 and an x86_64 build together, and only the arm64 half carried a signature: the linker ad-hoc signs arm64 output by itself, not x86_64. macOS validates every slice, so argos-helper failed code validation and TCC denied Full Disk Access with the toggle switched on, surfacing as “opening the device: Operation not permitted” on every write and restore from Argos.app. The app and its three binaries are now ad-hoc signed as a whole when the bundle is built. Local arm64-only builds were never affected, which is why 1.6.0’s validation, done on one, passed.

  Full Disk Access now goes to Argos.app itself, added with the ordinary “+” button, rather than to argos-helper dragged out of the bundle: with the bundle signed, macOS attributes the helper’s disk access to the app it lives in. Upgrading from an earlier version: remove the old Argos and argos-helper entries from Full Disk Access and add /Applications/Argos.app again. That re-grant is still needed after every update, because an ad-hoc signature changes with every build; the README walks through it.

[1.7.0] - 2026-10-08

Added

• argos format and “Restore drive…” in the GUI: turn an installer stick back into an ordinary one. A stick Argos wrote was hard to reuse with a desktop’s own formatter. Windows media carries a partition sized to its contents, and a Linux ISO written byte for byte carries the image’s own partition table (with a backup GPT where the image ended, not the device), so a file manager’s “Format” reformatted one small volume and left the rest of the stick unreachable – or refused the partition map outright. The new operation rewrites the partition table itself: it zeroes the first and last MiB of the device (old MBR and boot code, GPT headers, the ISO9660 descriptor that made Linux see the whole stick as a read-only iso9660), writes an MBR with one inactive FAT32 partition spanning the whole device, and formats it – the same pure-Rust, one-file-descriptor path as Windows media, so it works identically on Linux and macOS. Takes seconds. Same safety as a write: system disks are refused, the helper re-validates the device’s serial and size before touching it, and the device path has to be typed back to confirm. Devices from 512 MiB to 2 TiB; --label (or the field beside the GUI button) names the volume. Writing ISOs is unchanged.

[1.6.0] - 2026-09-09

Added

• A graphical interface: argos-gui. One window, in the spirit of Rufus – pick an image, pick a device, write. It shares every safety check with the CLI through a common argos-session crate (the same device refusals, the same TOCTOU re-validation in the privileged helper, the same retype-the- device-path confirmation), so there is no separate, weaker path through the window. Ships in the same package as argos on every platform – Homebrew, the .deb, the .dmg, and every release tarball install all three binaries (argos, argos-gui, argos-helper) together, never split – because a mismatched pair invites “the GUI can’t find its helper” as a confusing failure mode.

  Elevating from a window with no controlling terminal needed its own route on each host: macOS uses the system’s own authorization dialog (osascript ... with administrator privileges) over a pair of FIFOs standing in for the pipes a terminal would have given it, so the password never transits the Argos process; Linux uses pkexec, now with its own polkit policy (packaging/linux/org.argos.helper.policy) so the prompt names what is about to happen to the disk instead of showing polkit’s generic message. Both routes leave argos-helper itself untouched.

  Cancelling is honest about what it can actually do: measured on real hardware, the CancelToken reaches the copy loop and nothing after it – not the final flush, not the read-back verification – so on a multi- gigabyte write the cancellable window is roughly the first 2% of the wall clock. Past that point the Cancel button goes inert and says why, rather than staying live through a press that would silently do nothing.

• The GUI speaks English and Brazilian Portuguese, in one binary, switchable without a restart. Detected from the desktop (LC_ALL/LC_MESSAGES/LANG on Linux, AppleLanguages on macOS, because LANG is frequently empty for an app opened from Finder), overridable from a menu, and saved to a small config file ($XDG_CONFIG_HOME/argos/config.toml on Linux, ~/Library/Application Support/argos/config.toml on macOS). Every label and every error message the window can show comes from a catalogue checked at compile time – a string missing from either language is a build failure, not a blank label found later. The CLI stays English-only: its help text, man page and shell completions all come from the same clap definitions the packaging scripts run at build time, and a locale-dependent argos man would ship whatever language the CI runner happened to have.

• Linux packaging now installs the GUI’s desktop integration. The .deb and the AUR package (once a tagged release contains argos-gui; see the AUR PKGBUILD’s own comment) add a launcher entry, an icon under the hicolor theme, and the polkit policy above – so the graphical authorization prompt and the window itself are both reachable without a terminal.

• macOS packaging now produces a universal Argos.app and .dmg, unsigned. lipo’d from both Apple Silicon and Intel builds, so nobody installing it has to know which one their Mac is. Deliberately not signed or notarized in this phase (a paid Developer ID plus notarization on every release, for a project whose macOS install story already has a better answer): Homebrew never sets the quarantine bit, so brew install sidesteps Gatekeeper entirely. The .dmg is the convenience download for someone who wants the GUI without a Rust toolchain, with xattr -dr com.apple.quarantine documented for anyone who downloads it through a browser instead.

Fixed

• argos now exits with the code the privileged helper actually reported. Every failure that happened inside argos-helper – a device that turned out to be a system disk (12), a checksum mismatch after writing (17), a cancelled write (18) – exited 19 instead, because the unprivileged side wrapped the helper’s message in a generic I/O error and dropped the exit_code the helper had gone to the trouble of sending. Anything scripting argos could tell “it failed” from “it worked” and nothing more. The messages themselves are unchanged; only the code is now the true one. Found while extracting argos-session.

• Dismissing the graphical authorization dialog now reports itself correctly. On Linux, cancelling the pkexec prompt used to come back as a generic I/O failure (exit 19); it now reads pkexec(1)’s own documented exit codes (126 for a dismissed dialog, 127 for any other authorization failure) and reports “authorization was declined” at exit 27, matching what a declined macOS prompt already said. Confirmed by hand, not guessed: exit 126 with an empty stderr and Error executing command as another user: Request dismissed is what a real dismissal on GNOME actually produces.

• A translated helper error no longer glues the raw English message onto its own category, on the same un-collapsible line. Found on real hardware during G9’s validation: yanking a USB stick mid-write showed operação cancelada: operation cancelled by user; the device is left in an inconsistent state... – a Portuguese phrase stitched to an entire English sentence. The raw text was never lost, only shown twice; it now stays in the “Details” pane, same as every other error category already did.

• The language selector reads as one now. The combo box in the header showed only its current value (“Automatic”, “English”…) with nothing beside it – a human tester read it as some kind of write/recording setting, not a language picker. It now carries a “Language”/“Idioma” label.

Changed

• The write phase now crosses the privilege boundary as a value rather than as a Debug-formatted string. No visible difference – every phase label a user has ever seen is byte-identical, and both binaries ship together in every package Argos produces – but a front end can now match on the phase to label it in the user’s own language, and renaming one is a compile error instead of a silently unlabelled progress bar. An older helper’s string form still parses, so a mixed pair degrades to an odd-looking label rather than a dropped event.

Known limitations

• On macOS, Full Disk Access does not survive an update. argos-helper is unsigned and carries an ad-hoc code signature – a hash of its own contents – so every new build, including every tagged release, gets a new one. macOS’s TCC remembers a Full Disk Access grant by that identity, not by path, so upgrading Argos.app loses the grant along with the old binary: a write fails with a plain Operation not permitted again until the new argos-helper is granted access by hand (System Settings -> Privacy & Security -> Full Disk Access), the same as on first install. Confirmed by reproducing it twice, independently, across real rebuilds. A stable signing identity would fix this; not done in this phase (see packaging/README.md).

[1.5.5] - 2026-09-04

Changed

• The write progress bar now tracks bytes the device has actually taken, not bytes merely handed to the OS – without slowing the write down. Reported from real hardware: the bar climbed to 100% in an instant (a write() only queues bytes in the page cache), then the write sat there looking finished while the kernel was still flushing gigabytes to a slow USB stick in the background. 1.5.4’s Flushing phase named that wait but had nothing to show during it.

  Progress now comes from the kernel’s own per-device counter (field 7 of /sys/block/<dev>/stat, completed sectors written), sampled during the copy and again on a background thread while the final fsync blocks – so the flush phase advances with real numbers instead of standing still. Nothing about the write path itself changed: it stays plain buffered writes, which is what lets the kernel merge them into large sequential device requests.

  The first attempt at this instead forced the answer to be true, with an fsync every 64MiB. Measured on the same stick, that dropped a write the kernel otherwise kept 100% busy to roughly 1 MiB/s, because each barrier drains the queue and flushes the device’s internal cache. Watching a counter costs nothing; forcing a barrier costs almost everything.

  Platforms with no such counter (macOS, for now) fall back to the previous behavior rather than losing progress reporting.

Fixed

• eject failing silently claimed “Safe to unplug” anyway. Reported from real hardware: eject: cannot open /dev/sdX: Permission denied printed to the terminal, immediately followed by Ejected /dev/sdX. Safe to unplug. Both the Linux and macOS PlatformOps::eject backends discarded the underlying eject/diskutil eject exit status and always returned Ok(()) – eject_best_effort in the CLI already had the right behavior for a real failure (a warning telling the user to eject manually, without failing the write), but that path was dead code since the backends never actually produced an Err. Both now report a real failure (while still treating a missing eject binary on Linux as nothing to report, since there’s no eject-manage step to have failed); the write itself is unaffected either way – the physical flush already happened earlier, in argos-helper, before eject is ever attempted.

• The post-write eject then failed for a much simpler reason: it had no privilege. With the message above finally telling the truth, what it told was could not eject /dev/sdg: eject exited with exit status: 1, from eject: cannot open /dev/sdg: Permission denied – on a stock Ubuntu, /dev/sdX is root:disk mode 0660 and the user running argos is typically not in disk. Writing works because it happens in the elevated argos-helper; ejecting was the one step left behind in the unprivileged CLI, so it could not even open the device it had just written. The eject now travels in the plan (WritePlan::eject, WriteWindowsPlan::eject) and runs in the helper, which reports the outcome back as a new Ejected event – so the CLI prints the same two messages as before, but from a process that could actually do the work. --no-eject is unchanged. Note this is an EACCES on open, not the EBUSY an in-flight write would give: the data was already flushed and verified by the time eject ran.

[1.5.4] - 2026-09-04

Added

• argos write now also accepts --iso <path>, in addition to the existing positional form. Reported from real use, within hours of the README/man page documenting verify’s --iso: the same flag typed for write was a hard error, since its ISO had always been positional-only. Both forms parse to the same value; giving neither or both is a clear error rather than one being silently preferred. Positional remains what every example leads with – this only stops the other form from being a hard error.

Fixed

• The DD-mode write path never forced a real flush to the device. Reported from real hardware: a 5.8GB Ubuntu ISO write to a USB stick looked done almost instantly, then verification stalled with no visible progress. device.flush() is a no-op default on std::fs::File, which doesn’t override it – a plain write() only queues bytes in the page cache, so the write loop finishing meant nothing about whether the OS had actually committed anything to the physical device yet. Verification’s read-back was landing behind whatever the kernel was still flushing in the background, which is what looked like a hang. Replaced with a real fsync (the same partition_io::sync_device the Windows write path already used), and added a Flushing progress phase so the wait is visible instead of looking like a stalled bar.

[1.5.3] - 2026-09-04

Changed

• argos man now documents every subcommand’s own flags on one page, instead of clap_mangen’s default: a thin top-level page whose SUBCOMMANDS section cross-references argos-list(1), argos-write(1) and so on as if they were separate manual pages – which nothing in this project generates or installs, so man argos-write reported nothing found. list, write, verify and completions each get their own .SH block (synopsis, description, options) inlined into argos(1) instead, the way dd(1)/rsync(1) document a whole tool on one page. Also gives --help (both the top-level and per-subcommand) fuller prose, including an EXAMPLES block covering the same three-command flow as the README’s new Usage section.

Fixed

• argos write/argos verify failed on a relative ISO path, elevating via pkexec. Reported from real hardware: argos write some.iso --device /dev/sdg, run from the directory holding the ISO, passed the confirmation prompt and started unmounting, then failed with a bare “No such file or directory” and no further explanation. pkexec resets the working directory before running the elevated argos-helper (the same cwd-reset hardening any setuid-style launcher applies, so a relative path can’t resolve somewhere the caller didn’t intend) – sudo commonly preserves it, which is why this went unnoticed on macOS. The ISO path is now resolved to absolute in argos itself, before the confirmation prompt, so a bad path fails immediately and by name instead of well after the user has already confirmed a write.

[1.5.2] - 2026-09-04

Also the first tag to actually exercise the .deb-building step release.yml gained in this release – it was added and merged after v1.5.1 had already been tagged, so v1.5.1’s GitHub Release went out built by the old workflow and carries no .deb, despite the changelog below describing it as done. This tag is what makes it real.

Added

• A Debian/Ubuntu .deb package (backlog #46). packaging/build-deb.sh builds argos and argos-helper together, generates shell completions and the man page from the built binary (never a hand-maintained copy), and produces a package with a single dependency (libc6) – no mkfs.ntfs, no ntfs-3g, nothing else. Built and lintian-checked on every push (CI) and attached to every GitHub Release. Install with: sudo apt install ./argos_<version>_amd64.deb. See packaging/README.md for how it’s built and two non-obvious things cargo-deb needed correcting for.
• A Homebrew tap (macOS): brew install jp-guimaraes/argos/argos. See jp-guimaraes/homebrew-argos.
• An AUR PKGBUILD for pacman-based distros (Arch, and derivatives like Omarchy), same shape as the .deb: both binaries, completions and man page generated from the built binary, one runtime dependency (gcc-libs). Built and namcap-checked on every push (CI). Not published to the AUR itself yet – that needs the maintainer’s own AUR account – so for now, build it locally from packaging/aur/. See packaging/README.md.

Changed

• Release binaries are now stripped ([profile.release] strip = true). Found missing while packaging the .deb: Debian’s lintian flags an unstripped binary as a packaging error, and cargo-deb’s own stripping only takes effect when it does the build itself – a workspace build done ahead of time (as packaging, and cross-compiled release builds, both do) skipped it silently. Smaller binaries on every distribution channel as a side effect, not just the .deb. Note this doesn’t reach a plain cargo install from crates.io – that builds each crate outside the workspace, so the workspace-level profile setting doesn’t apply there.

[1.5.1] - 2026-09-04

Added

• argos completions <shell> and a hidden argos man (#46). Both are generated from the same clap definition the CLI already carries, so a Homebrew formula, PKGBUILD or .deb never has to keep a hand-written copy in step with the real flags. argos man is hidden because its audience is packaging, not people at a terminal.

Changed

• Unmounting uses umount2(2) instead of shelling out to umount(8) (M7.1, #46). One fewer runtime dependency for a distribution package to declare, and one fewer program whose presence or output could change under us. Note the argument changed with it: umount(8) accepts either the source device or the mountpoint, the syscall takes only the mountpoint.

Removed

• The xtask crate. Its only task rebuilt crates/argos-privileged/assets/uefi-ntfs.img, which was deleted along with the NTFS write path, and its only dependency existed to serve that task.

Fixed

• A USB stick whose label contains a space could not be unmounted. /proc/mounts escapes space, tab, newline and backslash as \040, \011, \012 and \134, and Argos read those fields verbatim – so a stick auto-mounted at /media/jp/My USB was seen as /media/jp/My\040USB, a path that does not exist. Found while replacing the umount shell-out, which passes the mountpoint straight to the kernel and so has no tolerance for it.

[1.5.0] - 2026-09-03

Phase 3: self-contained Windows installer media, on Linux and macOS, for UEFI and legacy BIOS machines. See docs/plan-phase3-self-contained.md for the plan this delivers against.

The headline: producing Windows install media no longer requires a Windows machine, an external mkfs, a FUSE filesystem, or a vendored binary blob.

Added

• image::udf — Argos’s own streaming UDF reader (M1, #40). Official Windows ISOs are UDF bridges, and the previous dependency read whole files into memory, which OOMed on a 5GB install.wim. Copying now runs in constant memory: 3 MiB peak RSS streaming a 7.58GB file, with a digest byte-identical to macOS’s own UDF driver reading the same file.

• image::wim — Argos’s own WIM reader and splitter (M2, #42). Splits install.wim into install.swm parts under FAT32’s 4GiB limit by redistributing whole stored resources verbatim: nothing is decompressed or re-encoded, so the lookup table’s SHA-1s stay valid by construction and no XPRESS/LZX codec is needed. Validated against wimlib as an external oracle (including wimlib-imagex apply reproducing a source tree byte for byte from our parts) and, ultimately, by Windows Setup itself on real hardware.

• --layout fat32 — a single pure-Rust FAT32 partition (M3, #43), written directly into the partition’s byte range of the open device: no mkfs, no mount, no partition device nodes, no kernel filesystem driver. GPT-partitioned; boots UEFI firmware via the ISO’s own bootx64.efi.

• --layout fat32-bios — the same media, MBR-partitioned and carrying Argos’s own boot records (M6, #45): an MBR bootstrap in 279 of the 440 bytes available, and a FAT32 volume boot record in 418 of 420, both written from scratch in 16-bit assembly under MIT/Apache rather than porting ms-sys’s GPL binary blobs. Boots legacy BIOS machines.

• Windows write support on macOS (M4, #34) — enabled by the FAT32 route, which superseded the original macFUSE/ntfs-3g plan entirely.

• tools/mediadiff.py — dumps a written device’s full structure (MBR, GPT, BPB, FAT, directory tree) and diffs two dumps, with ~25 conformance checks. Written to run a differential diagnosis against Rufus-made media; it is what found the stale-GPT bug below.

• End-to-end write cancellation (M7.5, #35). Ctrl-C during a write now reaches the privileged helper: argos keeps the helper’s stdin open and a SIGINT handler writes protocol::CANCEL_SIGNAL into it, a watcher thread in the helper turns that into a CancelToken, and the write path checks it on every buffer. The helper ignores SIGINT itself – Ctrl-C reaches the whole foreground process group, and letting the default disposition kill the helper would stop it before it could act on the cancellation. The pipe closing counts as a cancellation too, so a parent that dies outright still stops the write.

Fixed

• argos --version reported 0.1.0. The workspace version was never bumped, so v1.0.0 shipped — tagged, released and published — announcing itself as a pre-1.0 build. Set to 1.5.0 here, which is also the first version string the binary has ever agreed with the changelog on.

• A stale GPT surviving underneath the MBR layout (#59). mbrman writes sector 0 and nothing else, so a stick recycled from --layout fat32 kept its entire GPT — primary header, entry array, and backup header in the device’s last sector, CRCs intact — under a non-protective MBR. Windows refuses to assign a drive letter to a volume on a disk in that state, while the media still boots, which made it hard to localize.

• Directory entries fatfs writes that violate the FAT specification: long filename entries placed before . and .., and .. pointing at the root’s cluster instead of 0 (#56, confirmed upstream).

• BPB_HiddSec left at 0 on the GPT path, and a BPB CHS geometry (32×64) that contradicted the 255×63 the MBR partition entries are built from.

• A fixed volume serial number, so every medium Argos wrote claimed the same identity; and a previous bootloader surviving in sector 0 across a GPT write.

• Media writes now cost roughly 8× fewer I/O operations.

Removed

• hadris-udf, and with it the check_windows_memory preflight that existed only to refuse writes it would have OOMed on.
• The NTFS/UEFI:NTFS Windows write path (--layout ntfs), retired at decision point M4.3 once --layout fat32/fat32-bios was validated on real hardware from both hosts and both firmwares (see below). Out of the tree, not just unused: the vendored uefi-ntfs.img boot image and its provenance doc, the mkfs.ntfs/ntfs-3g shell-outs, the two-partition WindowsPartitionPlan, and the three PlatformOps methods that existed only to support it (reread_partition_table, mount_ntfs_partition, unmount_path). --layout now defaults to fat32; ntfs is no longer a valid value.

Verified against real hardware

The acceptance criterion throughout was Windows Setup reaching disk selection — not the language screen, which proves only that the firmware found a bootloader. Reaching disk selection is what proves Setup found and accepted its installation source, split .swm parts included.

• Media written from macOS: a UEFI machine (with an unsplit install.esd and with a split install.wim) and a legacy-BIOS machine (Intel Atom N455 netbook, AMI BIOS dated 2011), through Argos’s own MBR and VBR.
• Media written from Linux (M5.1): a real Windows 10 22H2 ISO — 6.14 GB, install.wim 5.18 GB, so the splitter is genuinely exercised — to a physical 28.7 GB stick, booting a UEFI machine with --layout fat32 and a legacy-BIOS machine with --layout fat32-bios.
• Both hosts, both firmwares, with no Windows machine, no mkfs.ntfs, no ntfs-3g, no FUSE and no vendored binary blob anywhere in the path.
• The stale-GPT scenario (#59) on real hardware: one stick written with the GPT layout and then the MBR layout still reached its installation source, which a surviving GPT would have prevented.

Still open: an installation carried through to completion rather than stopping at disk selection, and Secure Boot (M5.3).

Known limitations

• No GUI yet. Planned for 2.0; the CLI is architected so one can sit on the same argos-core/argos-platform crates without a rewrite.
• Windows as a host OS is still out of scope. Argos writes Windows media from Linux and macOS.
• Windows installer media has been carried to Setup’s disk selection on real hardware, on both firmwares and from both hosts, but not through a completed installation.
• Secure Boot is untested (M5.3).
• A solid .esd larger than FAT32’s 4GiB file limit cannot be written: only a WIM can be split, and a solid ESD cannot. Use an ISO edition whose install image is a WIM.
• Non-hybrid ISOs are refused rather than partially supported.
• A Homebrew tap is not published yet (crates.io and GitHub Releases are both available today).

[1.0.0] - 2026-08-30

Initial release. Argos creates bootable Linux installer USB drives on Linux and macOS hosts, in the spirit of Rufus. See docs/architecture.md for the full design.

Added

• argos list — lists every disk the platform backend can see, and whether each looks safe to write to.
• argos write <iso> --device <id> — the core destructive flow: refreshes the target device, applies the non-negotiable safety gate (a system disk is refused unconditionally; a non-removable disk needs --i-know-what-im-doing), classifies the ISO (refusing anything that isn’t a hybrid image), runs capacity and source/target-collision preflight checks, requires the user to retype the exact device path to confirm, unmounts the device, writes it byte-for-byte (“DD mode”), verifies the write by reading it back and comparing hashes (--no-verify to skip), ejects the device afterward (--no-eject to skip), and reports progress as a live bar — or periodic plain-text lines when stdout isn’t a real terminal (a pipe, a log file, CI).
• argos verify <device> --iso <iso> — re-runs post-write verification against a device without writing again.
• Safety model: a disk is only ever offered for writing when three independent signals agree — not a detected system disk, OS-reported removable, and on the USB bus. No single OS-reported flag is ever trusted alone, and the privileged helper re-checks identity immediately before opening the device regardless of what was confirmed earlier (the TOCTOU guard).
• Linux backend: disk enumeration via /sys/block/* and the udev database, cross-checked against UDisks2 over D-Bus when reachable. System-disk detection resolves LVM/RAID/dm-crypt device-mapper stacks to the physical disk underneath.
• macOS backend: disk enumeration via diskutil list/info -plist, parsed defensively against schema drift across macOS versions. System-disk detection walks through APFS containers (the Apple Silicon case, where the boot volume’s immediate parent is a virtual container, not the real internal disk) to the physical disk underneath.
• Privilege separation: argos-helper, a small binary deliberately kept “dumb”, is the only thing that ever opens a raw device, and runs as root only for that. It parses no ISO and talks to no D-Bus/plist/UDisks2 API itself.
• ISO classification: distinguishes hybrid ISOs (byte-for-byte writable) from El-Torito-only or plain-data images (refused) by inspecting the embedded MBR/GPT/El Torito structures already baked into the ISO — Argos never creates or modifies a partition table itself, only verifies one is already there before trusting a raw copy.
• Pre-built binaries on GitHub Releases for x86_64-unknown-linux-gnu, aarch64-apple-darwin, and x86_64-apple-darwin.
• Published on crates.io — install with cargo install argos-cli argos-privileged (both crates are needed: argos-cli alone installs argos but not the separate argos-helper binary it looks for next to itself at runtime).

Verified against real hardware

• Real, official Linux distro ISOs (Ubuntu 26.04.1, 22.04.5, and 18.04.5; Alpine Linux 3.24.1) written to real physical USB drives on both Linux and macOS hosts, checksum-verified against each distro’s own published sums before writing and independently re-hashed outside Argos afterward.
• Real boot confirmation on both UEFI and BIOS/legacy (MBR) hardware, including one genuinely old BIOS-only machine.
• A write to a real system disk is refused before any privilege escalation, with and without --i-know-what-im-doing.
• Real-hardware integration tests for the write/verify path without needing physical USB media for every run: Linux loop devices, macOS hdiutil-attached disk images.

Known limitations

• Windows image support and Windows as a host OS are both out of scope for v1 — a future phase.
• No GUI yet; the CLI is architected so one can sit on top of the same argos-core/argos-platform crates later without a rewrite.
• Non-hybrid ISOs are refused rather than partially supported.
• A Homebrew tap is not published yet (crates.io and GitHub Releases are both available today).