Skip to content

Arena/0adacf84 convertall py - #27

Open
jojo8356 wants to merge 53 commits into
doug-101:masterfrom
jojo8356:arena/0adacf84-convertall-py
Open

jojo8356 wants to merge 53 commits into
doug-101:masterfrom
jojo8356:arena/0adacf84-convertall-py

Conversation

@jojo8356

Copy link
Copy Markdown

No description provided.

jojo8356 and others added 30 commits October 10, 2026 17:28
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The thin .deb job failed in under a second on both bookworm and trixie while
job logs and artifacts stayed unreachable (Azure log blobs are blocked outside
the runner), so the failing phase was invisible.

- tools/build_deb.py now publishes named milestones as notice annotations and,
  on failure, one error annotation with the step, the message, the traceback
  tail and the last milestones; the same text lands in
  build/native-debian/native-deb-failure.txt inside the uploaded artifact.
- Every failure, including unexpected exception types, is reported instead of
  exiting with a bare traceback, and runtime JSON is read even if the launcher
  warns before printing it.
- The distribution Qt probe runs as its own workflow step, so CI status alone
  localises a break without any log access.
- Failure text now lists the offending paths for the clean-tree and GITHUB_SHA
  gates, and missing external tools name themselves.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The first git command of the packaging script aborted in under a second on both
bookworm and trixie: "fatal: detected dubious ownership in repository" because
container jobs mount the workspace with a different owner. All git calls now go
through one helper that adds `-c safe.directory=<this repository>`, which keeps
the exception local instead of rewriting global git config.

The milestone test also failed on every pinned job, because the file-order
assertion compared the check_extracted() definition with the stage_deb() call;
the ordering is now checked inside build(), plus a new test pins the git helper
so the trust flag cannot be dropped silently.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The pinned appimagetool image failed to self-extract on a checkout under a
synchronised/downloads path ("This doesn't look like a squashfs image" /
"Failed to open squashfs image"), although the same bytes and the same command
succeeded from ~/Documents yesterday: the embedded runtime locates its squashfs
by reading the file it was started from, which is unreliable on some mounts.

extract_appimage() now keeps the existing in-place extraction first, then
copies the image (re-verifying the pinned SHA-256) into a private TMPDIR
scratch directory and, if needed, into /dev/shm before failing with an explicit
message. The produced AppImage payload is extracted the same way, so the
runtime/bundle comparison no longer depends on the work tree filesystem
either. Nothing about the pins, the zstd compression or the payload checks
changed.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The pinned builder image failed to self-extract on a checkout under a
synchronised/downloads path ("This doesn't look like a squashfs image" /
"Failed to open squashfs image") although the same sha256-pinned bytes extract
fine from other directories. The type2 runtime locates its payload by opening
/proc/self/exe and reading the offset it computes from the ELF section table
(max(end of section table, end of last section)), and those reads are not
reliable on every mount, so extraction now retries in layers instead of
dead-ending, and never with an unverified binary:

1. the image where it sits (unchanged behaviour, still what CI exercises);
2. from a byte-identical copy on a local disk (TMPDIR, then /dev/shm),
   checksum re-verified against the pin before it is executed;
3. through the pinned standalone runtime with TARGET_APPIMAGE, which reads the
   image by path instead of /proc/self/exe;
4. by reading the squashfs payload at the runtime's own offset and extracting
   it with unsquashfs (squashfs-tools is already a documented host requirement
   for mksquashfs), after verifying the squashfs magic at that offset.

The AppImage runtime check of the produced artifact is retried the same way
from a verified local copy, because --appimage-extract-and-run uses the same
lookup. A total failure now reports each attempt, the file size, the sha256
read back and the expected pin, so a genuinely corrupted file can never be
mistaken for a mount problem. No pin, compression or payload check changed.

This also closes the "step 7 failed in 0 seconds" native CI mystery: the
retrieved job log showed "git failed (128): fatal: detected dubious ownership",
which commit 9895fca already fixed; CI is green on that tree (12/12).

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The two new tests failed on every pinned job (the native jobs passed):

- the pinned-runtime test compared a Path argument with a str, so the fake
  command rejected the runtime attempt and the test fell through to the direct
  payload read, which then raised on a synthetic non-ELF header;
- the payload-stripping test required a cwd keyword although the direct
  unsquashfs call deliberately runs with the default working directory.

The direct payload read now also reports OSError/ValueError from a corrupt
section table instead of letting them escape the layered retry.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Ubuntu and both native jobs are green with the layered retry; Windows failed on
two POSIX-only assumptions in the new tests:

- chmod does not set execute bits on Windows, so the scratch copy is only
  checked for that on posix;
- squashfs-tools is not installed on the Windows runners, so the explicit
  message for a missing unsquashfs is asserted there instead of the payload
  offset error.

No production code changed.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The layered fallback assumed any writable temporary directory would do. Two
environment problems survive that assumption and would have made the retry fail
in a new, more confusing way:

- a noexec /tmp (or /dev/shm) accepts the verified copy but cannot run the
  AppImage tool or runtime, so every attempted layer dies with a permission
  error while the extraction itself would have worked;
- the type 2 runtime unpacks the image into TMPDIR before running it, so a
  TMPDIR left on the synchronised mount keeps the original failure mode alive
  even when the image itself is read from a local copy.

local_scratch_directories() now proves a candidate can execute a file before it
is used (POSIX only: Windows has no such bit) and reports the rejected
candidates in the failure message, so an unusable TMPDIR is named instead of
silently producing an empty attempt list. When no local directory qualifies,
the release falls straight through to reading the squashfs payload, whose
extraction target is the work tree, which has already proven it can execute the
tool. The runtime check of the produced AppImage is given a verified TMPDIR as
well, and only falls back to a local copy when the in-place attempt fails.

No pin, compression or payload check changed.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
local_scratch_copy() was called outside the per-layer error handling, so a
scratch directory that could not hold a verified copy aborted the whole
fallback before the pinned runtime and the direct payload read were even tried
— exactly the situation a noexec or full TMPDIR creates. The copy failure is
now recorded like any other attempt and the remaining layers still run, which
one test pins down.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
local_scratch_directories() now takes the list of rejected candidates as its
first argument, and the existing tests still stubbed it with a zero-argument
lambda, which turned every AppImage test into a TypeError on all eight test
jobs. The stubs accept the argument again, the directory test no longer
assumes a runner without noexec mounts, and the returned directories are
checked for executability rather than trusting the filter.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The user log settles both halves of the AppImage step, which fail for unrelated
environment reasons:

1. appimagetool aborted with "Option parsing failed: Séquencé d'octets
   incorrecte en entrée du convertisseur" — GLib's g_locale_to_utf8() converts
   *every* option value, FILENAME types included, so a single non-ASCII
   argument (here --runtime-file under "Téléchargements") kills the build
   before it starts when the shell locale is not UTF-8. Step 4 now assembles
   everything in a local ASCII scratch directory that has already proven it
   can execute files, copies the pinned runtime there with its checksum
   re-verified, runs appimagetool with cwd inside that directory and
   LC_ALL=C.UTF-8, refuses to continue if the announced output does not exist,
   and only then moves the AppImage into dist/. An extracted tool tree whose
   own path is non-ASCII is copied to the same ASCII directory, because
   appimagetool resolves its bundled helpers relative to its own path.

2. The pinned builder image itself failed to self-extract both in place and
   from a local copy ("Failed to open squashfs image"), with a correct
   sha256 — which is the signature of a binfmt_misc AppImage handler such as
   AppImageLauncher claiming the file and parsing it with its own squashfs
   reader, which cannot read our zstd payload. Step 4 now logs the locale and
   any AppImage binfmt registration before touching the tool, and prints the
   single command that disables AppImageLauncher.

Because such a handler can equally block launching the built AppImage, the
runtime check now retries through the pinned runtime with TARGET_APPIMAGE —
the very runtime those pinned bytes embed, reading the very same file — and
labels the result: appimage_runtime.launcher records direct, verified local
copy or pinned runtime, the release notes gain an "AppImage acceptance
required" section and the log warns that a real double-click must be confirmed
before Latest is published. A shell whose locale is not UTF-8 is handled the
same way; non-ASCII paths (including names that are not valid UTF-8, which
used to crash the log line and the provenance JSON) are escaped for printing
and serializing only.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
CI now runs only when the pushed commit asks for it, so ordinary commits,
checkpoints and documentation pushes no longer spend runner minutes nor cancel
a validation that matters.

- .github/workflows/qt6-release.yml: each job (tests, native-deb, bundle) is
  conditioned on the release marker being present in the commit message, or in
  the pull request title/head branch; a manual dispatch still runs everything.
  Quiet pushes get their own concurrency group, so they can never cancel a
  marked run.
- tools/release_qt6.py: CI_MARKER holds the very same string, and run selection
  walks the runs of the pushed SHA and keeps the newest completed push whose
  twelve jobs are all green. A quiet run (every job skipped) can therefore
  never be mistaken for a validated one, even when GitHub reports that run as
  successful, and an older green run is never masked by a newer quiet one.
  Waiting for a pending run is unchanged, but a failed watch no longer aborts
  before the explicit diagnosis, and the messages state that the marker is
  missing instead of implying a broken build.
- README and both release guides document the rule, including the empty marked
  commit recipe for a tree that was already pushed without it.
- Tests pin the workflow gate against CI_MARKER, rejection of a quiet-only
  history, the "no run for this SHA" message and the pending-run wait.

This commit deliberately carries no marker, so it exercises the quiet path.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
A failure in step 4-7 (AppImage, CI artifacts, provenance, draft) used to force
a full rebuild of the tests, the PyInstaller bundle and the .deb. --resume
re-runs only what failed, without ever trusting the earlier output:

    bash release_qt6.sh --resume --wait-ci --draft          # most recent run
    bash release_qt6.sh --resume 20261012T065426Z-... --draft

- previous_run() locates the work and asset directories of that run and refuses
  them when they belong to another commit: the asset directory name carries its
  commit, so artifacts are never silently repackaged under a different SHA.
- Steps 1-3 are then verified rather than rebuilt: the bundle report is re-hashed
  file by file, the shipped tarball is re-extracted, its payload compared with
  the bundle report and its executable launched again, the .deb's sha256 and
  source_commit are re-checked, and the reused bundle must be bound to the same
  SHA and the same CI run (with the message naming --run-id for the mismatch).
  Missing pieces produce a clear "run once without --resume".
- verify_bundle_report() gained `extra_prefixes` for the two things packaging
  legitimately adds after the report is written (doc/third-party/** and
  RELEASE-INFO.json); anything else still fails, and existing callers are
  unchanged.
- fetch_tool(reuse=True) accepts an already downloaded pinned asset only after
  its checksum matches the pin again, collect_notices() and download_artifact()
  became idempotent, and check_launch() now uses a throwaway HOME per launch so
  a resumed run cannot inherit preferences written by the earlier attempt.
- Tests cover the same-SHA rule, the latest-run lookup, the help messages, the
  re-verified pin, the tolerated packaging extras and reading a previous run's
  reports. Documented in README and doc/RELEASE_LINUX_FR.md §3.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Running the release right after a push failed with "No CI run for this SHA":
GitHub needs a few seconds before a pushed commit appears in the runs API, and
the script asked once, immediately, and concluded there was no run. Reported
from a real push, 1.9 s after the command.

discover_ci_run() now polls every 5 s for up to 15 s (60 s with --wait-ci, which
already implies waiting) and only then reports that no run exists, with the
marker reminder and the --run-id alternative. Tests drive a fake clock, so the
grace period costs nothing in CI, and one test replays the exact scenario: an
empty first answer followed by a registered run must select that run.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The user log shows the AppImage itself is now built correctly (appimagetool:
zstd, pinned runtime, "Success"): the ASCII build directory and LC_ALL fix
worked. What failed was the runtime check of the produced file, which hung
until the 180s command timeout, and that timeout aborted the whole release
instead of falling through to the next layer.

- command() now turns subprocess.TimeoutExpired into a ReleaseError (logged as
  "TIMED OUT after Ns"), so a hanging command is one recorded attempt rather
  than the end of the run: the layered fallbacks keep working.
- runtime_launch_plan(handlers) skips the two layers that execute the image as
  is when a binfmt_misc AppImage handler is registered: on this machine they
  already failed with a squashfs error for the pinned tool and hung for the
  built image, because the handler claims the file before its own runtime runs.
  The pinned runtime with TARGET_APPIMAGE remains, and it reads the very same
  payload (verified in the type2 runtime source: TARGET_APPIMAGE is what gets
  extracted, and it execs the extracted AppRun, never the file itself).
- extract_appimage(intercepted=True) skips the same two layers for the payload
  extraction, so a handler cannot make the release spend nine minutes in three
  timeouts; the payload read with unsquashfs stays available as before.
- Tests cover the timeout becoming a ReleaseError, the plan with and without a
  handler, and an intercepted extraction that never executes the image.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The user's own machine proves the limitation end to end: /proc/sys/fs/binfmt_misc
holds appimage-type1 and appimage-type2 registrations (AppImageLauncher), the
pinned runtime reports the JSON payload of the produced AppImage perfectly when
it is given TARGET_APPIMAGE, and AppImageLauncher prints "This doesn't look like
a squashfs image" for anything carrying the AppImage magic because its bundled
libsquashfs predates zstd.

- release notes: a permanent, codec-accurate note telling users that the payload
  is zstd-compressed, that AppImageLauncher (last release 2019) cannot read it,
  and that the portable tarball or the .deb remain usable while the daemon runs.
- doc/RELEASE_LINUX_FR.md: the exact commands to stop the daemon and unregister
  the two binfmt entries, plus the note that such a handler can also block the
  process instead of failing, which is what the 180 s timeout came from.

Not pushed yet: the release cycle currently running must keep its SHA stable.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
…esh the CI diagnosis

All eight pinned jobs failed on one assertion of mine (1 failed, 4673 passed,
90.70% coverage): the new timeout test did not pass a timeout, so command() used
its 1800 s default and the message read "after 1800s" while the test expected
"after 180s". The production code was correct; the expectation was not, and it
had only been read, never executed. The test now passes timeout=180 explicitly
and asserts the whole message, verified against the real code path.

The release side of the same run showed a second, quieter defect: after waiting
for a queued run, the diagnosis still printed "queued/None" because the run
dictionaries read before the wait were reused. The run list is now re-read from
the API once the wait is over, so the failure reports the conclusions GitHub has
("completed/failure"), and a failed gh run watch says that the watch could not
confirm success instead of leaving a bare "Command failed (1): gh".

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Arena Agent and others added 23 commits October 12, 2026 09:35
Everything could only be checked by burning a marked CI run first, because
build_release() always resolved a CI run before doing any local work. Testing
the local steps before spending CI time is now possible:

    bash test_all_qt6.sh              # steps 1-2: venv, full QA, PyInstaller bundle
    bash release_qt6.sh --local-only  # steps 1-4: + portable tarball, thin .deb, AppImage

- requested_ci_run() decides between a rehearsal and a real release: with
  --local-only no CI run is looked up, and --draft/--run-id/--wait-ci are refused
  outright, so a rehearsal can never turn into a publication.
- Steps 5-7 are skipped with an explicit message (the Windows executables and the
  source archive come from CI, and a rehearsal creates no tag and no release),
  and the run writes local-rehearsal.json describing exactly what passed.
- The bundle's RELEASE-INFO.json and the resume check tolerate a missing CI run,
  so --resume also works inside a rehearsal.
- README and doc/RELEASE_LINUX_FR.md gained a "test everything locally first"
  section, including hand checks for the tarball, the .deb and the AppImage.
- Tests pin the rehearsal behaviour: no CI lookup, refusal of release-only
  options, and a real release still going through select_ci.

Written after a workspace reset lost the in-progress tree again; the content is
identical to what had been verified by running the code, not just by reading it.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
…ed the release

The 0.9.1 release aborted immediately with "Set --maintainer \"Name <email>\"".
Git had auto-derived login@machine for the commit but never stored it, so
maintainer_identity() found no configured user.name/user.email and refused to
guess a public address - correct, but the message did not say what to do about
it, and the documented command line never mentioned the option at all.

- CONVERTALL_MAINTAINER is now honoured, so one export covers the release, a
  --resume and a local rehearsal (which also builds the .deb). Precedence stays
  explicit: --maintainer, then the variable, then the configured git identity;
  an all-whitespace variable never shadows a real identity.
- The error now names all three sources and prints a copy-paste command. It also
  explains why a commit can succeed without the identity Git would have invented.
- README and doc/RELEASE_LINUX_FR.md set the variable once per shell, in the
  rehearsal section, in the real release section and in the marker reminder.
- Tests pin the precedence, the whitespace case, the configured-git path and the
  exact pointers in the failure message.

Verified by running maintainer_identity() itself with the environment manipulated
and subprocess.run stubbed, not by reading the code.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The rehearsal banner was inserted above the assignment it tests, so a release
died with "UnboundLocalError: cannot access local variable 'run'" as soon as the
maintainer check passed. That is my own regression, introduced with the local
rehearsal mode, and it stopped a real 0.9.1 attempt.

- run = requested_ci_run(...) now runs before the banner and before anything else
  reads `run`; every other use (the SHA/CI print, the resume check, the rehearsal
  report) was audited and is already guarded by `run is None` or `run if run`.
- Two tests exercise build_release's real preflight with no network, no host
  tooling and no work directory: previous_run raises a sentinel, so the test stops
  right where the crash used to happen. A rehearsal must print its banner and get
  past the preflight, a real release must not print it.
- Both tests were run against the previous revision (they fail with the exact
  UnboundLocalError) and against this one (they pass). The test file's own
  helper had a bug (stopped.metadata) that only running it revealed.

Note for anyone auditing: this class of bug is invisible to ast.parse and to
reading the diff, which is why the preflight is now executed by a test.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
…ES.md

A complete specification (860 lines, French) for `cvt`, a Rust command-line
version of ConvertAll, written after reading the existing implementation and the
2026 Rust ecosystem:

- Grounded in this repository: the 925-line units.dat with its 52 types, the
  eleven primitive units, the two flavours of non-linear definition (equations
  and interpolation tables), the seven catalogues, and the CLI contract that
  source/cmdline.py already exposes (options -d/-f/-s/-e/-q/-i/-t/--test-all,
  exit codes 0/1/2/130, output format).
- Functional spec: input grammar in EBNF, compound and additive units, fractions,
  exact-rational arithmetic with an f64 path only for non-linear units, output
  modes (text/JSON/JSONL/TSV), batch mode, REPL, subcommands, catalogue
  compilation, configuration precedence, i18n.
- Rust research: clap 4.6.7, rustyline 18.0.1, dashu-ratio 0.6.0 for exact
  rationals (with the published num-rational/rug comparison), fluent-bundle,
  cargo-dist 0.33.0, cargo-deb, and the 2026 test toolchain (nextest, llvm-cov,
  insta, proptest, criterion, fuzz); MSRV 1.85 with the current stable 1.99.
- The central quality requirement is a differential test against ConvertAll-py:
  the golden corpus is produced by the Python implementation, never by the Rust
  one, with every numerical divergence declared and justified.
- Prior art (numbat, GNU units, Qalculate!, uom, pubunit, UnitMath) is compared
  and rejected for this purpose, with reasons.
- Licence analysis: units.dat is GPL-2.0, so the Rust project is GPL-2.0-or-later
  and cargo-deny enforces a compatible dependency set.

Milestones J0-J5, budgets, risks and six decisions to settle before coding.

Committed after a workspace reset had based an earlier attempt on the baseline
commit instead of the session tip; the tree it produced was verified to differ
from the session tip only by this document.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Everything in the repository could be tested and released with a single command
(test_all_qt6.sh, release_qt6.sh), but starting the application still meant
typing the venv dance by hand. run_qt6.sh closes that gap:

    bash run_qt6.sh              # graphic interface
    bash run_qt6.sh -q 1 in cm   # command line, arguments are passed through
    bash run_qt6.sh -i           # interactive mode

- Same conventions as the other launchers: dedicated .venv/qt6 (never the
  .venv/test-all-qt6 test venv), pinned requirements-qt6.txt, venv repair
  without deleting the directory, ensurepip detection with the exact apt command
  to run, --no-install and --python CHEMIN, Python 3.11-3.14 enforcement.
- It exports the same clean environment (QT_API=pyqt6, no inherited PYTHONPATH,
  QT_PLUGIN_PATH or VIRTUAL_ENV) and never runs a test, a build or a privileged
  command.
- It fails early and clearly: missing interpreter, missing venv with
  --no-install, PyQt6 not importable, and it warns before starting the GUI when
  no display server is present.
- Its exit code is convertall.py's own (0, 1, 2, 130), so it stays scriptable.

Verified with bash -n, and by running the three paths that touch nothing
(--help, --python /nonexistent, --no-install without a venv): exit codes 0, 2, 2
as intended, and no venv or file created.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The units list sized all three columns to their content, so the comments column
was as wide as the longest comment: it overflowed a narrow dialog and left the
rest of the list ragged in a wide one.

- The two first columns stay content-sized and draggable (Interactive); the
  comments column is now in Stretch mode, so it takes whatever width is left at
  any dialog size, and Qt elides a comment that no longer fits.
- stretchLastSection stays False on purpose: set to True, the property overrides
  the resize mode of the last section (documented Qt behaviour) and the column
  would freeze again. A test pins that subtlety.
- The load-time measurement loop now covers columns (0, 1) only: a Stretch
  section cannot be resized, so measuring column 2 there was both useless and
  misleading.
- The full comment stays reachable as a tooltip when the column is too narrow.
- Test added in tests/test_qt6_migration.py and verified by executing it against
  four trees: the fixed source passes, while the previous source,
  stretchLastSection(True) and a range(3) measurement loop all fail with an
  explicit message.

No Qt process was started: the correction relies on documented QHeaderView
semantics (Stretch fills the available space; the mode applies because
stretchLastSection is False), and the widget must be checked visually.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Marks the session branch for CI validation, at the request of the project owner,
so the tree can be merged into master. Everything after the published 0.9.1
(6c8cb0b) is included:

- the local rehearsal mode (release_qt6.sh --local-only) that tests bundle,
  portable tarball, .deb and AppImage without consuming CI;
- CONVERTALL_MAINTAINER, plus the maintainer error message that names every
  accepted source, and the preflight order fix that made every release abort;
- run_qt6.sh, the launcher for the application itself (graphic, REPL or CLI);
- the comments column that now follows the list width;
- doc/CLI_RUST_CAHIER_DES_CHARGES.md, the specification for the Rust CLI.

The twelve CI jobs must stay green on this exact SHA: it is the tree to merge.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The question was whether a script existed to put every action under Johan's name;
none did, and two different needs had been conflated: displaying an author, and
rewriting the objects.

- .mailmap reattributes the display only. It maps the tooling identity
  (agent@arena.invalid), the account-login name variant, and Johan's other two
  identities onto <83455892+jojo8356@users.noreply.github.com>, so the noreply
  address links the commits to the GitHub account. Verified: git shortlog now
  reports 29 commits as "Johan Polsinelli" and still one "Doug Bell", whose
  baseline commit must keep its original author.
- tools/rewrite_authors.sh does the real rewrite, and only when asked: report by
  default, --apply to rewrite the session branch, --push to force-push it with
  --force-with-lease. It refuses any other branch, refuses a dirty tree, backs up
  the old tip under refs/backup/, and never touches master, a tag, or a release.
  Its --include-own-variants flag also unifies Johan's own identities.
- It prints what a rewrite costs: every SHA changes, so the CI run validated on
  the old SHA no longer applies and a new [PROD] commit plus a CI run are needed,
  while the published 0.9.1 tag and release keep pointing at their original
  commits so their provenance stays verifiable.

No rewrite has been applied: the choice between the display fix and the history
rewrite belongs to the project owner.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
git applies the mailmap to --author/--committer matching, so after adding
.mailmap the script reported 'aucun' for an address it had just reattributed.
The detection now uses --no-use-mailmap, and the final report prints both views:
the real identities (raw) and the displayed ones (mailmap applied).

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Requiring author and committer to match missed the commits written by the tooling
but committed by the owner (92ba213, eee7b95, 2f73d67): 20 commits were reported
instead of 23. Author and committer are now queried separately and unioned.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
… address

Running --apply for real exposed two bugs that reading the script could not:
a fresh clone ended up with commits authored by "Johan Polsinelli
<$NEW_EMAIL>", and the report found 20 commits instead of 23.

- The case line generated for the env filter was written inside single quotes,
  so the backslash in \$NEW_EMAIL survived and the filter printed the variable
  name instead of its value. Verified in a scratch repository: the rewritten
  commits now carry the intended address, while the owner's own commits and
  Doug Bell's baseline commit keep their identities.
- The report also needed --no-use-mailmap (git applies the mailmap to --author,
  so the replaced address stopped matching) and a union of the author and
  committer queries (commits written by the tooling but committed by the owner
  were missed).

Both were found by applying the rewrite to throwaway repositories, which is why
the script refuses to run on anything but the session branch.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
Publishing anything new requires a new version, because the v0.9.1 tag is
permanent and the release refuses to retarget it. The version is pinned in
twelve files, and tests/test_packaging.py asserts that all of them agree, so a
missed spot costs a red CI run (~10 minutes, twelve jobs). The tool does the
edit and then re-checks the same rules without pytest:

    python3 tools/bump_version.py --check           # coherence today
    python3 tools/bump_version.py 0.9.2 --dry-run   # what would change
    python3 tools/bump_version.py 0.9.2             # apply, then check again

- It covers source/convertall.py, both win/*.iss recipes, the six README*.html
  manuals (header only), the three tests that pin the current version, and it
  creates doc/RELEASE_NOTES_<new>.md with the commit list since the previous
  tag as a starting point.
- Historical versions stay untouched: only the first 0.x.y of a manual is the
  header (a bare x.y.z pattern matched "LibreOffice 5.4.6" in README_ru.html,
  which is exactly what the packaging test avoids), and the old release notes
  are kept.
- Reading and writing go through newline='' because the Inno recipes are CRLF;
  text mode was rewriting all 136 lines of each .iss file for a two-value change.
- It never commits, tags, pushes or touches a release.

Verified on fresh clones: --check passes on 0.9.1, the 0.9.2 bump then produces
a 16-line diff and passes --check again, with the manual headers, the .iss
values and the test literals all consistent. Both bugs above were found by
running it there, not by reading it.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
"Prepare 0.9.2" was committed with git add -A, which turned a local checkout of
an unrelated project into a gitlink: mode 160000, and no .gitmodules to declare
it. Consequences, verified rather than assumed:

- GitHub shows it as a submodule it cannot resolve, because the referenced
  repository is not declared and does not belong to this project;
- git archive emits it as an empty directory, so the published source tarball
  would have carried ConvertAll-0.9.2-qt6-source/schema-pathfinder/ (reproduced
  in a scratch repository);
- cloning prints the "embedded repository" advice, and any future git add -A
  would stage it again.

The path is removed from the index (the local files are untouched) and added to
.gitignore with the reason, so a later git add -A cannot recreate the gitlink.
The line is meant to be deleted if that project ever belongs in this repository.

The version bump itself is correct: tools/bump_version.py --check reports
0.9.2 coherent across source/convertall.py, both Inno recipes, the six manuals,
the three tests and doc/RELEASE_NOTES_0.9.2.md.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
The 0.9.1 -> 0.9.2 bump left three literals behind and turned the ten test
jobs of run 38471134227 red in under two minutes:

  * tests/test_cli.py compared the --version output with 'ConvertAll 0.9.1
    (Qt6)': the version was inside a longer string, which the tool missed;
  * tests/test_release_tools.py passed a fake runtime report whose 'version'
    is compared with the real __version__ by check_bundle.validate_runtime_info;
  * tests/test_linux_release.py expected 'Version: 0.9.1-1' in the Debian
    control file, missed because of the -1 revision suffix.

tools/bump_version.py now edits version tokens rather than quoted strings,
covers all of tests/, and --check refuses to pass while a test that renders the
real version still carries another token, so a stale literal cannot reach a
tagged commit again. --repair X.Y.Z catches tokens left by an earlier bump.

The comment about the missing maintainer identity stays on 0.9.1: that failure
happened during the 0.9.1 release.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
A tree that declares 0.9.2 still announced 0.9.1 in the README title and state
line. The bump tool now anchors on those two labelled lines instead of a bare
x.y.z pattern, which would also have rewritten the link to
doc/RELEASE_NOTES_0.9.1.md and the 0.8.0 benchmark comparison.

The manual banner is anchored the same way ("Python/Qt6 fork x.y.z"). That
replaces an accidental 0.x.y-shaped rule which dodged the generator meta tag of
README_ru.html ('LibreOffice 5.4.6.2') but broke on any 1.x version.

Two tests cover the README, and the historical comment in test_linux_release.py
no longer carries a version number: it describes the previous release, so a token
rewrite made it wrong.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>
[4/7] stopped after a 180s wait on the 0.9.2 run of 2026-10-13: on a host with
AppImageLauncher, the fallback layer cannot work either. The pinned runtime is
built with b'AI\x02' at offset 8 -- AppImage/type2-runtime writes it into the
runtime binary in scripts/build-runtime.sh after the strip -- so appimage-type2
claims the runtime exactly like the image it builds, and executing it waits for a
handler that cannot read zstd instead of reading the payload.

runtime_launch_plan() now drops the pinned runtime when it carries the AppImage
magic while a handler is registered, and extract_appimage() is no longer handed
that runtime (its default timeout is 1800s, so the wait was worse than reported).
Nothing carrying the magic is executed at all: the payload read out of the built
image is exercised instead -- unsquashfs, then the extracted AppRun, with the
application, the seven catalogues and the offscreen GUI -- and recorded as
"extracted payload (the image bytes were read, never executed)". The mandatory
double-click acceptance in the acceptance VM and the "AppImage acceptance
required" section of the release notes are unchanged.

A timed-out command now keeps what it printed in release.log: a bare "timed out"
left nothing to diagnose, which is what hid this cause for a day. The empty
"WARNING: ;" prefix seen in the same log is gone too.

Co-authored-by: arena-agent <297053741+arena-agent@users.noreply.github.com>

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant