wolk-jjba-cf3400b1-19bb

job failed

starting new job...


→ running command: cd "/etc/byggsteg/job-clone//wolk-jjba/trunk" && git reset --hard && git pull

HEAD is now at b704062 feat: Improve testing
Already up to date.

→ running command: cd /etc/byggsteg/job-clone/wolk-jjba/trunk && uname -a

Linux wolk-jjba 7.2.11-gnu #1 SMP PREEMPT_DYNAMIC 1 x86_64 GNU/Linux

→ running command: cd /etc/byggsteg/job-clone/wolk-jjba/trunk && git log --name-status HEAD^..HEAD

commit b704062406ba81fbbcff8bd34c1073143b1ac671
Author: Josep Bigorra <jjbigorra@gmail.com>
Date:   Sun Oct 25 00:27:37 2026 +0200

    feat: Improve testing

M       README.org
M       maak.scm
A       test/veritas/temp.scm
M       test/veritas/unit/operating-system-spec.scm
M       test/veritas/unit/secrets-spec.scm
A       test/veritas/unit/temp-spec.scm

→ running command: cd /etc/byggsteg/job-clone/wolk-jjba/trunk && maak test

channels.scm:47:6: warning: channel 'jointhefreeworld' is not trusted

scanning directories for unit tests...
scanning present working directory for unit tests...

shuffled the files with seed 442108769 (replay with VERITAS_SEED=442108769)

found unit tests: (maintenance-spec.scm sysctl-spec.scm bash-spec.scm prelude-spec.scm temp-spec.scm gfs-spec.scm operating-system-spec.scm logging-spec.scm secrets-spec.scm iptables-spec.scm nginx-spec.scm certbot-spec.scm containers-spec.scm radio-spec.scm jobs-spec.scm)


running unit tests from file: maintenance-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Maintenance Suite
  [🧪 test] The disk report publishes what the alerts need
    [⚙️ assert] One series per project, with a project label
    ✅ got: #t
    [⚙️ assert] The newest archive of each project is dated
    ✅ got: #t
    [⚙️ assert] A project without archives reports 0, not nothing
    ✅ got: #t
    [⚙️ assert] The report dates itself, so a stale report is visible
    ✅ got: #t
    [⚙️ assert] The backup tree is the thing being reported
    ✅ got: #t
  [🧪 test] The Guix collection frees generations before the store
    [⚙️ assert] Old system generations go first
    ✅ got: #t
    [⚙️ assert] joe's home generations go too
    ✅ got: #t
    [⚙️ assert] The home profile is pruned as its owner
    ✅ got: #t
    [⚙️ assert] The store is collected afterwards
    ✅ got: #t
    [⚙️ assert] The size of the store is published
    ✅ got: #t
  [🧪 test] Every job logs to a rotated file
    [⚙️ assert] The log files are registered for rotation
    ✅ got: (/var/log/wolk-jjba/disk-report.log /var/log/wolk-jjba/guix-gc.log /var/log/wolk-jjba/nix-gc.log /var/log/wolk-jjba/verify-backups.log /var/log/wolk-jjba/gfs-backup.log /var/log/wolk-jjba/podman-prune.log /var/log/wolk-jjba/cache-clean.log /var/log/wolk-jjba/tmp-clean.log)
    [⚙️ assert] The garbage collection log is kept
    ✅ got: #t
  [🧪 test] Pruning podman state leaves volumes alone
    [⚙️ assert] Unused containers, images and build cache go
    ✅ got: #t
    [⚙️ assert] Only things untouched for a week
    ✅ got: #t
    [⚙️ assert] Volumes are never pruned: a container may own data there
    ✅ got: #t
    [⚙️ assert] The CI runner's images are pruned too
    ✅ got: #t
  [🧪 test] Textfiles are replaced atomically
    [⚙️ assert] The new file is written under a temporary name
    ✅ got: #t
    [⚙️ assert] The temporary file is renamed into place
    ✅ got: #t
    [⚙️ assert] It lands in node exporter's textfile directory
    ✅ got: #t
    [⚙️ assert] And never as a partial .prom file
    ✅ got: #t
  [🧪 test] The long-term retention job runs the Scheme program, unprivileged
    [⚙️ assert] It runs every night at 02:45
    ✅ got: #t
    [⚙️ assert] It runs the gfs-backup program, not a shell script
    ✅ got: #t
    [⚙️ assert] It runs as the user that owns the Storage Box key
    ✅ got: #t
    [⚙️ assert] With that user's HOME, so ssh finds the alias
    ✅ got: #t
    [⚙️ assert] No shell is involved
    ✅ got: #t
  [🧪 test] The service creates the metrics directory it writes into
    [⚙️ assert] There is an activation extension
    ✅ got: #t
    [⚙️ assert] The activation creates node exporter's textfile directory
    ✅ got: #t
  [🧪 test] The disk report publishes the long-term retention state
    [⚙️ assert] The last successful GFS run is a metric
    ✅ got: #t
    [⚙️ assert] And so is the archive count per project
    ✅ got: #t
    [⚙️ assert] It reads the marker the job leaves behind
    ✅ got: #t
  [🧪 test] Every maintenance job is scheduled exactly once
    [⚙️ assert] The eight jobs are the documented ones
    ✅ got: (disk-report guix-gc nix-gc verify-backups gfs-backup podman-prune cache-clean tmp-clean)
    [⚙️ assert] No job is scheduled twice
    ✅ got: 8
    [⚙️ assert] Every job is respawned
    ✅ got: #t
  [🧪 test] The backup verification actually reads the archive
    [⚙️ assert] The checksum sidecar is checked
    ✅ got: #t
    [⚙️ assert] A tar archive is listed through a pipe
    ✅ got: #t
    [⚙️ assert] An SQL dump is tested through a pipe
    ✅ got: #t
    [⚙️ assert] A failed verification fails the job
    ✅ got: #t
    [⚙️ assert] A success is published, so a stale check is visible
    ✅ got: #t
    [⚙️ assert] Nothing is decrypted to a temporary file
    ✅ got: #t
  [🧪 test] The caches that are deleted are download caches
    [⚙️ assert] The npm cache goes
    ✅ got: #t
    [⚙️ assert] The pip cache goes
    ✅ got: #t
    [⚙️ assert] The cache is removed, not truncated
    ✅ got: #t
  [🧪 test] The temporary-file cleanup spares sockets
    [⚙️ assert] A long-running daemon keeps its socket
    ✅ got: #t
    [⚙️ assert] Only week-old files are candidates
    ✅ got: #t
    [⚙️ assert] Both temporary directories are covered
    ✅ got: #t
ℹ️ info - ran 1 tasks in: 0 seconds, 11808 microseconds

running unit tests from file: sysctl-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Sysctl Suite
  [🧪 test] The kernel survives a SYN flood
    [⚙️ assert] Syncookies are on
    ✅ got: 1
    [⚙️ assert] The SYN backlog is larger than the default
    ✅ got: #t
    [⚙️ assert] The accept queue is larger than the default
    ✅ got: #t
  [🧪 test] ICMP is bounded
    [⚙️ assert] Broadcast echo is ignored
    ✅ got: 1
    [⚙️ assert] Echo replies are rate limited
    ✅ got: #t
  [🧪 test] The host keeps its routing and addressing role
    [⚙️ assert] Packet forwarding is left to Podman
    ✅ got: #f
    [⚙️ assert] IPv6 forwarding is left alone
    ✅ got: #f
    [⚙️ assert] Router advertisements stay with NetworkManager
    ✅ got: #f
    [⚙️ assert] IPv6 is not switched off
    ✅ got: #f
  [🧪 test] Spoofed and redirected traffic is not honoured
    [⚙️ assert] Reverse-path filtering is strict
    ✅ got: 1
    [⚙️ assert] and applies to interfaces created later
    ✅ got: 1
    [⚙️ assert] IPv4 redirects are refused
    ✅ got: 0
    [⚙️ assert] IPv6 redirects are refused
    ✅ got: 0
    [⚙️ assert] This host sends no redirects
    ✅ got: 0
    [⚙️ assert] Source-routed IPv4 is refused
    ✅ got: 0
  [🧪 test] Kernel internals are not readable by ordinary users
    [⚙️ assert] Kernel pointers are hidden
    ✅ got: 2
    [⚙️ assert] Only root reads the ring buffer
    ✅ got: 1
    [⚙️ assert] Unprivileged BPF loading is off
    ✅ got: 1
  [🧪 test] Every setting is a well-formed key/value pair
    [⚙️ assert] Each entry is a dotted key and a string
    ✅ got: #t
    [⚙️ assert] No key is set twice
    ✅ got: 30
  [🧪 test] The settings extend Guix's defaults instead of replacing them
    [⚙️ assert] Guix's own defaults survive
    ✅ got: #t
    [⚙️ assert] and this module's settings are added
    ✅ got: #t
    [⚙️ assert] Nothing is set twice or dropped
    ✅ got: 32
ℹ️ info - ran 1 tasks in: 0 seconds, 6964 microseconds

running unit tests from file: bash-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Bash Configuration Suite
  [🧪 test] The greeting array is emitted once, before it is read
    [⚙️ assert] The array is declared in the data block
    ✅ got: 1
    [⚙️ assert] The shared library no longer carries the pool
    ✅ got: #f
  [🧪 test] Every shared alias reaches the rc
    [⚙️ assert] Each shared alias is emitted verbatim
    ✅ got: ()
    [⚙️ assert] hg still points at hgrep
    ✅ got: #t
    [⚙️ assert] the multi-character alias keeps its body
    ✅ got: #t
  [🧪 test] An alias stays on one line
    [⚙️ assert] A body with a newline would break the alias line
    ✅ got: 0
  [🧪 test] Git shortcuts are generated as functions
    [⚙️ assert] gst keeps its body and its arguments
    ✅ got: #t
    [⚙️ assert] groot calls the shared cdroot
    ✅ got: #t
    [⚙️ assert] The one-line shortcuts are no longer in the library
    ✅ got: #f
    [⚙️ assert] The multi-line glog stays in the library
    ✅ got: #t
  [🧪 test] Server helpers wrap the checkout and the Shepherd
    [⚙️ assert] The checkout path is assigned once
    ✅ got: 1
    [⚙️ assert] fr pulls the checkout, then runs maak fr
    ✅ got: #t
    [⚙️ assert] ht triggers a daemon and tails its log
    ✅ got: #t
    [⚙️ assert] The machine alias uses ls, not gls
    ✅ got: #t
  [🧪 test] No alias shadows a function
    [⚙️ assert] Shared aliases are not git shortcuts
    ✅ got: ()
    [⚙️ assert] Shared aliases are not server helpers
    ✅ got: ()
    [⚙️ assert] Machine aliases are not server helpers
    ✅ got: ()
  [🧪 test] The three pieces meet at line boundaries
    [⚙️ assert] The library starts on a new line
    ✅ got: #t
    [⚙️ assert] The postlude starts on a new line
    ✅ got: #t
    [⚙️ assert] The rc ends with a newline
    ✅ got: #t
  [🧪 test] The shared library still defines what the data calls
    [⚙️ assert] cc_boot is defined where the rc calls it
    ✅ got: #t
    [⚙️ assert] The hg alias has its hgrep
    ✅ got: #t
    [⚙️ assert] groot has its cdroot
    ✅ got: #t
    [⚙️ assert] The greeting function reads the generated array
    ✅ got: #t
    [⚙️ assert] The file ends on a line of its own
    ✅ got: #t
  [🧪 test] The rc boots exactly once, at the end
    [⚙️ assert] cc_boot is called once in the postlude
    ✅ got: 1
    [⚙️ assert] Nothing runs after the prompt is installed
    ✅ got: #t
  [🧪 test] Greetings survive quotes, dollars and backticks
    [⚙️ assert] Every shell-special character is escaped
    ✅ got: CC_GREETINGS=(
        "a \"quoted\" \$HOME \`date\` \\ end"
)

  [🧪 test] The shared library is spliced, not referenced
    [⚙️ assert] The library is read from the checkout
    ✅ got: # shellcheck shell=bash
# shellcheck disable=SC2034  # palette values are consumed indirectly (${!name})
# =============================================================================
# Shared shell library — wolk-jjba (this file) · heks-bash (the same file)
# Also mirrored for zsh in cask-and-cons/src/cask-and-cons/shell-lib.zsh.
#
# Keep this file identical to heks-bash/src/heks-bash/shell-lib.bash, header
# aside, so the two machines feel like one system. Everything
# machine-specific comes from the CC_* variables below, which the host config
# sets *before* calling `cc_boot':
#
#   CC_FLAVOR     name of the config, e.g. heks-bash
#   CC_HOST_KIND  at-a-glance machine kind, e.g. guix/linux
#   CC_SIGIL      prompt sigil, e.g. λ
#   CC_ACCENT     256-colour accent (0-255), e.g. 99
#   CC_RC_FILE    file `reload' sources
#   CC_PATH_DEPTH path components kept in the prompt (default 3)
#
# No plugins, no external prompt framework: the only fork per prompt is a
# single `git status --porcelain=v2 --branch'. The pager is plain less with
# the Emacs keymap from the sibling `lesskey' file, installed by the same
# installer that writes this rc.
# =============================================================================

CC_PATH_DEPTH=${CC_PATH_DEPTH:-3}
CC_ACCENT=${CC_ACCENT:-99}
: "${CC_FLAVOR:=shell}"
: "${CC_HOST_KIND:=unix}"
: "${CC_SIGIL:=λ}"
: "${CC_RC_FILE:=$HOME/.bashrc}"

# ---- history ----------------------------------------------------------------
# One big, shared, timestamped, de-duplicated history per machine.
HISTFILE=${HISTFILE:-$HOME/.bash_history}
HISTSIZE=${HISTSIZE:-500000}
HISTFILESIZE=${HISTFILESIZE:-100000}
HISTTIMEFORMAT=${HISTTIMEFORMAT:-'%F %T  | '}
HISTCONTROL=${HISTCONTROL:-ignoreboth:erasedups}
HISTIGNORE=${HISTIGNORE:-'&:[ ]*:exit:ls:ll:l:bg:fg:history:clear:cd:cd ..:pwd'}
shopt -s histappend cmdhist checkwinsize 2> /dev/null

# ---- pager ------------------------------------------------------------------
# One pager everywhere (less), with Emacs key bindings: the keymap is the
# shared lesskey source file installed as $XDG_CONFIG_HOME/lesskey — less 582
# and later read it directly, so there is no compiled file to keep in sync.
# -F quit-if-one-screen, -I case-insensitive search, -M long prompt, -R colour.
export PAGER=${PAGER:-less}
export MANPAGER=${MANPAGER:-less}
export LESS="-F -I -M -R"
# less looks for that file on its own, so nothing needs to be exported; older
# less versions (< 582) simply ignore it and keep their default keys.
CC_LESSKEY=${XDG_CONFIG_HOME:-$HOME/.config}/lesskey
export CC_LESSKEY

# ---- palette ----------------------------------------------------------------
# 256-colour ANSI. `CC_PLAIN=1' (or NO_COLOR / TERM=dumb) renders the same
# prompt without escapes. \001 ... \002 is readline's \"this is not printable\".
__cc_palette () {
    local v name
    if [[ ${CC_PLAIN:-0} != 0 || -n ${NO_COLOR:-} || ${TERM:-dumb} == dumb ]]
    then
        for v in ACCENT TEXT DIM PATH BRANCH DIRTY AB BAD GOOD BOLD RESET
        do
            printf -v "CC_${v}_SEQ" '%s' ''
            printf -v "CC_${v}_OUT" '%s' ''
        done
        return 0
    fi
    # plain escapes: used by normal output (greeting, about)
    printf -v CC_RESET_OUT '\033[0m'
    printf -v CC_BOLD_OUT '\033[1m'
    printf -v CC_ACCENT_OUT '\033[38;5;%sm' "$CC_ACCENT"
    printf -v CC_TEXT_OUT '\033[38;5;252m'
    printf -v CC_DIM_OUT '\033[38;5;244m'
    printf -v CC_PATH_OUT '\033[38;5;111m'
    printf -v CC_BRANCH_OUT '\033[38;5;81m'
    printf -v CC_DIRTY_OUT '\033[38;5;221m'
    printf -v CC_AB_OUT '\033[38;5;176m'
    printf -v CC_BAD_OUT '\033[38;5;203m'
    printf -v CC_GOOD_OUT '\033[38;5;114m'
    # prompt copies: \001 ... \002 are readline's "zero width" markers, so
    # the prompt is measured correctly without counting the escapes.
    for v in ACCENT TEXT DIM PATH BRANCH DIRTY AB BAD GOOD BOLD RESET
    do
        name=CC_${v}_OUT
        printf -v "CC_${v}_SEQ" '\001%s\002' "${!name}"
    done
}

# ---- prompt pieces ----------------------------------------------------------
# $HOME becomes ~, then only the last CC_PATH_DEPTH components are kept.
__cc_trim_path () {
    local p=${PWD/#$HOME/\~} depth=$CC_PATH_DEPTH
    local -a parts=()
    local IFS=/
    IFS=/ read -r -a parts <<< "$p"
    local n=${#parts[@]}
    if ((n <= depth))
    then
        printf '%s' "$p"
        return 0
    fi
    local out='' i
    for ((i = n - depth; i < n; i++))
    do
        out+=/${parts[i]}
    done
    printf '…%s' "$out"
}

# Environment badges: Guix shell, Nix shell, Python venv.
__cc_env_badge () {
    if [[ -n ${GUIX_ENVIRONMENT:-} ]]
    then
        printf ' %s[guix env]%s' "$CC_DIM_SEQ" "$CC_RESET_SEQ"
    elif [[ -n ${IN_NIX_SHELL:-} ]]
    then
        printf ' %s[nix]%s' "$CC_DIM_SEQ" "$CC_RESET_SEQ"
    elif [[ -n ${VIRTUAL_ENV:-} ]]
    then
        printf ' %s[venv]%s' "$CC_DIM_SEQ" "$CC_RESET_SEQ"
    fi
}

# One fork per prompt: porcelain v2 gives branch, upstream divergence and the
# dirty state in a single call. Untracked files are ignored (they are noise).
__cc_git_sync () {
    CC_GIT_SEG=''
    local dir=$PWD gd=''
    while :
    do
        if [[ -e $dir/.git ]]
        then
            gd=$dir
            break
        fi
        [[ $dir == / ]] && return 0
        dir=${dir%/*}
        [[ -z $dir ]] && dir=/
    done
    local out
    out=$(GIT_OPTIONAL_LOCKS=0 git -C "$gd" status --porcelain=v2 --branch \
        --ignore-submodules=dirty --untracked-files=no 2> /dev/null) || return 0
    local branch='' oid='' ahead=0 behind=0 changed=0 conflicts=0 stash=0
    local line ab
    while IFS= read -r line
    do
        case $line in
            '# branch.head '*)
                branch=${line#'# branch.head '}
                ;;
            '# branch.oid '*)
                oid=${line#'# branch.oid '}
                ;;
            '# branch.ab '*)
                ab=${line#'# branch.ab '}
                ahead=${ab%% *}
                ahead=${ahead#+}
                behind=${ab##* }
                behind=${behind#-}
                ;;
            'u '*)
                conflicts=$((conflicts + 1))
                ;;
            [12]' '*)
                changed=$((changed + 1))
                ;;
        esac
    done <<< "$out"
    [[ -z $branch ]] && return 0
    [[ $branch == '(detached)' ]] && branch=@${oid:0:7}
    # Stash entries are small plain-text logs; counting them costs no fork.
    if [[ -f $gd/.git/logs/refs/stash ]]
    then
        while read -r _
        do
            stash=$((stash + 1))
        done < "$gd/.git/logs/refs/stash"
    fi
    CC_GIT_SEG=" ${CC_BRANCH_SEQ}${branch}${CC_RESET_SEQ}"
    if ((conflicts))
    then
        CC_GIT_SEG+=" ${CC_BAD_SEQ}✖${conflicts}${CC_RESET_SEQ}"
    elif ((changed))
    then
        CC_GIT_SEG+=" ${CC_DIRTY_SEQ}✚${changed}${CC_RESET_SEQ}"
    else
        CC_GIT_SEG+=" ${CC_GOOD_SEQ}✓${CC_RESET_SEQ}"
    fi
    ((ahead)) && CC_GIT_SEG+=" ${CC_AB_SEQ}↑${ahead}${CC_RESET_SEQ}"
    ((behind)) && CC_GIT_SEG+=" ${CC_AB_SEQ}↓${behind}${CC_RESET_SEQ}"
    ((stash)) && CC_GIT_SEG+=" ${CC_DIM_SEQ}⚑${stash}${CC_RESET_SEQ}"
    return 0
}

# Two lines everywhere, identical on every machine:
#   ╭─ user@host <sigil> <kind>  ~/some/where [guix env]
#   ╰─ main ✚2 ↑1  <sigil>
__cc_prompt () {
    local cwd badge
    cwd=$(__cc_trim_path)
    badge=$(__cc_env_badge)
    __cc_git_sync
    PS1="${CC_DIM_SEQ}╭─ ${CC_RESET_SEQ}${CC_BOLD_SEQ}\u${CC_RESET_SEQ}"
    PS1+="${CC_DIM_SEQ}@${CC_RESET_SEQ}\h "
    PS1+="${CC_ACCENT_SEQ}${CC_SIGIL} ${CC_HOST_KIND}${CC_RESET_SEQ} "
    PS1+="${CC_PATH_SEQ}${cwd}${CC_RESET_SEQ}${badge}"$'\n'
    PS1+="${CC_DIM_SEQ}╰─${CC_RESET_SEQ}${CC_GIT_SEG} "
    PS1+="${CC_ACCENT_SEQ}${CC_SIGIL}${CC_RESET_SEQ} "
    history -a 2> /dev/null
    return 0
}

# ---- greeting ---------------------------------------------------------------
# The pool of sayings (CC_GREETINGS) is data and lives in bash.scm
# (`bash-greetings'); it is emitted into the rc before this runs.

shell-greeting () {
    local q=${CC_GREETINGS[RANDOM % ${#CC_GREETINGS[@]}]}
    printf '%s%s%s %s%s%s  %s%s%s\n\n' \
        "$CC_ACCENT_OUT" "$CC_SIGIL" "$CC_RESET_OUT" \
        "$CC_BOLD_OUT" "$CC_FLAVOR" "$CC_RESET_OUT" \
        "$CC_DIM_OUT" "$q" "$CC_RESET_OUT"
}

# ---- self knowledge ---------------------------------------------------------
about () {
    local shell_name="bash $BASH_VERSION"
    printf '%s%s%s %s%s%s\n' \
        "$CC_ACCENT_OUT" "$CC_SIGIL" "$CC_RESET_OUT" \
        "$CC_BOLD_OUT" "$CC_FLAVOR" "$CC_RESET_OUT"
    printf '  %skind%s    %s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "$CC_HOST_KIND"
    printf '  %shost%s    %s@%s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "${USER:-$(id -un)}" "$(uname -n)"
    printf '  %ssystem%s  %s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "$(uname -srm)"
    printf '  %sshell%s   %s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "$shell_name"
    printf '  %sconfig%s  %s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "$CC_RC_FILE"
    printf '  %sgit%s     %s\n' "$CC_DIM_OUT" "$CC_RESET_OUT" "$(git --version 2> /dev/null | cut -d' ' -f3)"
    printf '  %sprompt%s  accent %s · sigil %s · depth %s · %s\n' \
        "$CC_DIM_OUT" "$CC_RESET_OUT" "$CC_ACCENT" "$CC_SIGIL" "$CC_PATH_DEPTH" \
        "$([[ ${CC_PLAIN:-0} != 0 || -n ${NO_COLOR:-} ]] && echo plain || echo colour)"
    printf '  %spager%s   less · Emacs keys · %s\n' \
        "$CC_DIM_OUT" "$CC_RESET_OUT" "$CC_LESSKEY"
    printf '  %shelpers%s about · pager-keys · hist-top · paths · extract · mkcd · up · serve · bak · calc · json · notify\n' \
        "$CC_DIM_OUT" "$CC_RESET_OUT"
}

# -----------------------------------------------------------------------------
# Helper functions (vanilla: coreutils + git only)
# -----------------------------------------------------------------------------
__cc_has () { command -v "$1" > /dev/null 2>&1; }

mkcd () {
    if [[ -z ${1:-} ]]
    then
        printf 'usage: mkcd <dir>\n' >&2
        return 2
    fi
    mkdir -p -- "$1" && cd -- "$1" || return
}

up () {
    local n=${1:-1} p=''
    while ((n-- > 0))
    do
        p+=../
    done
    cd "$p" || return
    pwd
}

extract () {
    local f=${1:-}
    if [[ ! -f $f ]]
    then
        printf 'extract: not a file: %s\n' "${f:-<none>}" >&2
        return 1
    fi
    case $f in
        *.tar.bz2 | *.tbz2) tar xjf "$f" ;;
        *.tar.gz | *.tgz) tar xzf "$f" ;;
        *.tar.xz | *.txz) tar xJf "$f" ;;
        *.tar.zst) tar --zstd -xf "$f" ;;
        *.tar) tar xf "$f" ;;
        *.zip) unzip -q "$f" ;;
        *.7z) 7z x "$f" ;;
        *.rar) unrar x "$f" ;;
        *.gz) gzip -dc "$f" > "${f%.gz}" ;;
        *.bz2) bzip2 -dc "$f" > "${f%.bz2}" ;;
        *.xz) xz -dc "$f" > "${f%.xz}" ;;
        *.zst) zstd -dc "$f" > "${f%.zst}" ;;
        *)
            printf 'extract: unknown archive type: %s\n' "$f" >&2
            return 1
            ;;
    esac
}

psg () {
    if [[ -z ${1:-} ]]
    then
        printf 'usage: psg <pattern>\n' >&2
        return 2
    fi
    ps aux | grep -i -- "[${1:0:1}]${1:1}"
}

kport () {
    local p=${1:-} pids=''
    if [[ -z $p ]]
    then
        printf 'usage: kport <port>\n' >&2
        return 2
    fi
    if __cc_has lsof
    then
        pids=$(lsof -ti "tcp:$p" 2> /dev/null)
    elif __cc_has ss
    then
        pids=$(ss -tlnpH "sport = :$p" 2> /dev/null \
            | grep -o 'pid=[0-9]*' | cut -d= -f2 | sort -u)
    fi
    if [[ -z $pids ]]
    then
        printf 'kport: nothing listening on %s\n' "$p" >&2
        return 1
    fi
    kill $pids && printf 'kport: sent TERM to %s\n' "$pids"
}

serve () {
    local p=${1:-8000}
    printf 'serving %s on http://localhost:%s\n' "$PWD" "$p"
    if __cc_has python3
    then
        python3 -m http.server "$p"
    else
        python -m SimpleHTTPServer "$p"
    fi
}

# Desktop notification: notify-send where available, otherwise the terminal
# bell on the controlling TTY (so it is harmless in scripts and over SSH).
notify () {
    local msg=${1:-done} title=${2:-$(hostname -s)}
    if __cc_has notify-send
    then
        notify-send "$title" "$msg"
    elif [[ -t 1 ]]
    then
        printf '\a%s: %s\n' "$title" "$msg"
    else
        printf '%s: %s\n' "$title" "$msg"
    fi
}

# Listening sockets: ss on Linux, lsof on macOS/BSD.
ports () {
    if __cc_has ss
    then
        ss -tulpn
    else
        lsof -iTCP -sTCP:LISTEN -P -n
    fi
}

bak () {
    local f=${1:-}
    if [[ -z $f ]]
    then
        printf 'usage: bak <file>\n' >&2
        return 2
    fi
    local d
    d=$f.$(date +%Y%m%d-%H%M%S).bak
    cp -p -- "$f" "$d" && printf '→ %s\n' "$d"
}

calc () {
    if (($# == 0))
    then
        printf 'usage: calc <expression>\n' >&2
        return 2
    fi
    LC_ALL=C awk "BEGIN { printf \"%.10g\\n\", $* }"
}

json () {
    if __cc_has python3
    then
        python3 -m json.tool "$@"
    else
        cat "$@"
    fi
}

paths () {
    local IFS=: i=0 p
    for p in $PATH
    do
        printf '%2d  %s\n' "$i" "$p"
        i=$((i + 1))
    done
}

# The pager keymap (installed as $XDG_CONFIG_HOME/lesskey) in one screen.
pager-keys () {
    local b=${CC_BOLD_OUT:-} d=${CC_DIM_OUT:-} r=${CC_RESET_OUT:-}
    local a=${CC_ACCENT_OUT:-}
    printf '%s%spager%s less · Emacs keys · %s\n\n' \
        "$b" "$a" "$r$d" "$CC_LESSKEY"
    printf '  %s%-11s%s %s\n' "$b" 'C-n  C-p' "$r" 'one line down / up'
    printf '  %s%-11s%s %s\n' "$b" 'C-f  C-b' "$r" 'one screen down / up'
    printf '  %s%-11s%s %s\n' "$b" 'C-v  M-v' "$r" 'one screen down / up'
    printf '  %s%-11s%s %s\n' "$b" 'C-d  C-u' "$r" 'half a screen down / up'
    printf '  %s%-11s%s %s\n' "$b" 'C-a  C-e' "$r" 'top / bottom of the file'
    printf '  %s%-11s%s %s\n' "$b" 'M-<  M->' "$r" 'top / bottom of the file'
    printf '  %s%-11s%s %s\n' "$b" 'C-s  C-r' "$r" 'search forward / backward'
    printf '  %s%-11s%s %s\n' "$b" 'M-g' "$r" 'go to line'
    printf '  %s%-11s%s %s\n' "$b" 'M-u' "$r" 'clear the search highlighting'
    printf '  %s%-11s%s %s\n' "$b" 'C-l' "$r" 'redraw the screen'
    printf '\n  %sin prompts (:e, /, ?, ...)%s\n' "$d" "$r"
    printf '  %s%-11s%s %s\n' "$b" 'C-a  C-e' "$r" 'beginning / end of the line'
    printf '  %s%-11s%s %s\n' "$b" 'C-b  C-f' "$r" 'one character left / right'
    printf '  %s%-11s%s %s\n' "$b" 'M-b  M-f' "$r" 'one word left / right'
    printf '  %s%-11s%s %s\n' "$b" 'C-w  M-d' "$r" 'kill the word before / after the cursor'
    printf '  %s%-11s%s %s\n' "$b" 'C-k  C-u' "$r" 'kill the whole line'
    printf '  %s%-11s%s %s\n' "$b" 'C-g' "$r" 'cancel the prompt'
    printf '\n  %sstill plain less%s: space b · g G · / ? · n N · m '\'' · ! · | · q%s\n' \
        "$d" "$r" "$r"
}

reload () {
    printf 'reloading %s\n' "$CC_RC_FILE"
    # shellcheck source=/dev/null
    CC_RELOAD=1 . "$CC_RC_FILE"
}

cdroot () {
    local d=$PWD
    while :
    do
        if [[ -e $d/.git ]]
        then
            cd "$d" || return 1
            return 0
        fi
        [[ $d == / ]] && break
        d=${d%/*}
        [[ -z $d ]] && d=/
    done
    printf 'cdroot: not inside a git work tree\n' >&2
    return 1
}

ff () {
    if [[ -z ${1:-} ]]
    then
        printf 'usage: ff <name-fragment>\n' >&2
        return 2
    fi
    find . -iname "*${1}*" -not -path './.git/*' -not -path './node_modules/*'
}

# Most frequently used commands, straight from the history file.
hist-top () {
    local n=${1:-10} f=${HISTFILE:-$HOME/.bash_history}
    [[ -r $f ]] || return 0
    awk '!/^#/ && NF { print $1 }' "$f" | sort | uniq -c | sort -rn | head -n "$n"
}

hgrep () {
    history | grep -- "${1:-}"
}

# Decompress a .gz log and page through it.
gunlog () {
    if [[ -z ${1:-} ]]
    then
        printf 'usage: gunlog <file.gz>\n' >&2
        return 2
    fi
    gzip -dc -- "$1" | ${PAGER:-less}
}

# Startup cost of the shell itself, averaged over a few runs.
rc-time () {
    local n=${1:-5} t0 t1 i
    t0=${EPOCHREALTIME//,/.}   # EPOCHREALTIME honours LC_NUMERIC
    for ((i = 0; i < n; i++))
    do
        bash -i -c exit > /dev/null 2>&1
    done
    t1=${EPOCHREALTIME//,/.}
    LC_ALL=C awk -v a="$t0" -v b="$t1" -v n="$n" \
        'BEGIN { printf "%.1f ms per start (%d runs)\n", (b - a) * 1000 / n, n }'
}

# ---- git -------------------------------------------------------------------
# The one-line git shortcuts (gst, gd, gco, ...) are generated from
# `bash-git-shortcuts' in bash.scm; only the multi-line ones stay here.

glog () {
    local n=${1:-20}
    git log --graph --abbrev-commit --decorate --date=short \
        --format='%C(auto)%h%C(reset) %C(auto)%d%C(reset) %s %C(dim)(%ar)%C(reset)' \
        -n "$n" --all
}


# -----------------------------------------------------------------------------
# Boot: colours, prompt hook, greeting. Called once at the end of the rc file.
# -----------------------------------------------------------------------------
cc_boot () {
    # PS1 is already fully expanded here; leaving promptvars on would let a
    # directory called "$(cmd)" run cmd every time the prompt is drawn.
    shopt -u promptvars 2> /dev/null
    # No XOFF/XON: C-s is forward-search in readline and in the pager, not a
    # frozen terminal. Set per TTY, and only when there is one.
    [[ -t 0 ]] && stty -ixon 2> /dev/null
    __cc_palette
    case ${PROMPT_COMMAND:-} in
        *__cc_prompt*) ;;
        '') PROMPT_COMMAND=__cc_prompt ;;
        *) PROMPT_COMMAND="__cc_prompt;$PROMPT_COMMAND" ;;
    esac
    __cc_prompt
    [[ ${CC_RELOAD:-0} == 1 ]] || shell-greeting
    return 0
}

    [⚙️ assert] No store path leaks into the rc
    ✅ got: #f
    [⚙️ assert] The spliced text is the library itself
    ✅ got: #t
  [🧪 test] The greeting pool is non-empty and unique
    [⚙️ assert] shell-greeting must always find a saying
    ✅ got: #t
    [⚙️ assert] No saying is declared twice
    ✅ got: 48
  [🧪 test] Every machine-identity variable is emitted
    [⚙️ assert] The five CC_* values are declared
    ✅ got: 5
    [⚙️ assert] Each one reaches the rc verbatim
    ✅ got: ()
  [🧪 test] History stays shell-local
    [⚙️ assert] CDPATH is exported for child shells
    ✅ got: #t
    [⚙️ assert] The history size is set
    ✅ got: #t
    [⚙️ assert] The history size is not pushed into every subprocess
    ✅ got: #f
  [🧪 test] The prompt says which machine this is
    [⚙️ assert] The flavour is the repository name
    ✅ got: #t
    [⚙️ assert] The badge says this is a Guix server
    ✅ got: #t
    [⚙️ assert] The sigil is the server's omega
    ✅ got: #t
    [⚙️ assert] The accent is the server's teal
    ✅ got: #t
    [⚙️ assert] Identity is an assignment, not exported to children
    ✅ got: #f
ℹ️ info - ran 1 tasks in: 0 seconds, 23118 microseconds

running unit tests from file: prelude-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Prelude Suite
  [🧪 test] The daemon environment carries a UTF-8 locale
    [⚙️ assert] LANG is set for every application daemon
    ✅ got: #t
    [⚙️ assert] Nothing forces the C locale
    ✅ got: #f
    [⚙️ assert] Guile finds the system's modules
    ✅ got: #t
    [⚙️ assert] The environment is the declared eleven
    ✅ got: 11
    [⚙️ assert] A PATH is passed, so make and guile resolve
    ✅ got: #t
  [🧪 test] The factory names its own service type
    [⚙️ assert] The service type is named after the daemon
    ✅ got: named-daemon
    [⚙️ assert] The description is the documentation
    ✅ got: documented
    [⚙️ assert] The service carries no value of its own
    ✅ got: ()
  [🧪 test] Managed projects live under one checkout tree
    [⚙️ assert] The default branch is trunk
    ✅ got: /etc/byggsteg/job-clone/lucidplan/trunk
    [⚙️ assert] A non-default branch is honoured
    ✅ got: /etc/byggsteg/job-clone/wikimusic/experiment
    [⚙️ assert] The name may be any symbol
    ✅ got: /etc/byggsteg/job-clone/byggsteg/trunk
  [🧪 test] Per-daemon logs share one directory
    [⚙️ assert] The log directory is the one Alloy tails
    ✅ got: /var/log/wolk-jjba
  [🧪 test] Every factory call yields an independent service type
    [⚙️ assert] Two daemons are two service types
    ✅ got: #f
  [🧪 test] The daemon logs to its own file, not the system log
    [⚙️ assert] The log file is named after the daemon
    ✅ got: #t
    [⚙️ assert] The log directory is created before exec
    ✅ got: #t
    [⚙️ assert] The file is handed to #:log-file
    ✅ got: #t
  [🧪 test] The daemon runs maak in the project directory
    [⚙️ assert] The default command is make production-server
    ✅ got: #t
    [⚙️ assert] The command is maak, run through make
    ✅ got: #t
    [⚙️ assert] The project directory is the working one
    ✅ got: #t
    [⚙️ assert] A working directory reaches the constructor
    ✅ got: #t
  [🧪 test] Shell helpers return what the command printed
    ✅ got: hello

  [🧪 test] A daemon is a respawning, auto-started shepherd service
    [⚙️ assert] The provision name is the daemon name
    ✅ got: (probe-daemon)
    [⚙️ assert] A crashed daemon must be respawned by the Shepherd
    ✅ got: #t
    [⚙️ assert] A daemon starts with the system
    ✅ got: #t
    [⚙️ assert] The factory imposes no ordering of its own
    ✅ got: ()
  [🧪 test] The log file can be overridden
    [⚙️ assert] The explicit path wins over the convention
    ✅ got: #t
    [⚙️ assert] The conventional path is not also passed
    ✅ got: #f
ℹ️ info - ran 1 tasks in: 0 seconds, 24467 microseconds

running unit tests from file: temp-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Temporary Directory Suite
  [🧪 test] A directory that is already there is never handed out
    [⚙️ assert] The second call chose another name
    ✅ got: #t
    [⚙️ assert] The new fixture does not inherit the last run's files
    ✅ got: #t
    [⚙️ assert] And the directory that was there is left alone
    ✅ got: #t
  [🧪 test] The directory is named after the fixture, in TMPDIR
    [⚙️ assert] The prefix names the suite that made it
    ✅ got: #t
    [⚙️ assert] And it is created in the directory asked for
    ✅ got: #t
  [🧪 test] Two calls never make the same directory
    [⚙️ assert] Every fixture has a name of its own
    ✅ got: #t
    [⚙️ assert] And every one of them was created
    ✅ got: #t
    [⚙️ assert] Each starts empty, so no run inherits files
    ✅ got: #t
    [⚙️ assert] And none of them is readable by another user
    ✅ got: #t
  [🧪 test] Removal takes the whole tree, and a missing path is fine
    [⚙️ assert] Removal reports success
    ✅ got: #t
    [⚙️ assert] The tree is gone, not just its files
    ✅ got: #t
    [⚙️ assert] Removing what is not there is not an error
    ✅ got: #t
    [⚙️ assert] Neither is a path that never existed
    ✅ got: #t
ℹ️ info - ran 1 tasks in: 0 seconds, 7921 microseconds

running unit tests from file: gfs-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] GFS Retention Suite
  [🧪 test] Promotion is once per week and once per month
    [⚙️ assert] An empty archive tree takes the newest
    ✅ got: ((1792584000 . proj-backup-1792584000.tar.gz.enc))
    [⚙️ assert] A week that is already represented needs no copy
    ✅ got: ()
    [⚙️ assert] A month that is already represented still takes a new week
    ✅ got: ((1792584000 . proj-backup-1792584000.tar.gz.enc))
  [🧪 test] Running a command returns its lines and its exit status
    [⚙️ assert] The output is read line by line
    ✅ got: (one two)
    [⚙️ assert] The exit status is not swallowed
    ✅ got: 3
  [🧪 test] Shell quoting survives an apostrophe
    [⚙️ assert] A quote is escaped the POSIX way
    ✅ got: 'it'\''s'
    [⚙️ assert] Spaces stay inside one word
    ✅ got: 'ls -1 /a b'
  [🧪 test] A dry run reports without touching the box
    [⚙️ assert] No copy in a dry run
    ✅ got: ()
    [⚙️ assert] No deletion in a dry run
    ✅ got: ()
  [🧪 test] A run twice in a row changes nothing the second time
    [⚙️ assert] The archive tree did not grow
    ✅ got: 2
    [⚙️ assert] The second run copied nothing
    ✅ got: 2
  [🧪 test] An unreachable box is a failure, not an empty directory
    [⚙️ assert] No project is reported as counted
    ✅ got: ()
    [⚙️ assert] Every unreachable project is reported
    ✅ got: (proj other)
    [⚙️ assert] A silent empty directory would leave this empty
    ✅ got: #t
  [🧪 test] Past a month, the month's representative survives
    [⚙️ assert] No month is represented twice
    ✅ got: 7
    [⚙️ assert] A deleted archive's month is kept by another
    ✅ got: #t
    [⚙️ assert] Those survivors are grandfather archives
    ✅ got: #t
  [🧪 test] Every archive is kept or deleted, never both
    [⚙️ assert] The two lists partition the directory
    ✅ got: 40
    [⚙️ assert] No archive appears in both
    ✅ got: ()
    [⚙️ assert] Nothing kept is over a year old
    ✅ got: #t
  [🧪 test] Every archive up to a week old survives
    [⚙️ assert] Ages 0 to 7 are all kept
    ✅ got: (0 1 2 3 4 5 6 7)
    [⚙️ assert] Nothing in the son window is deleted
    ✅ got: ()
    [⚙️ assert] All of them are kept as son
    ✅ got: #t
  [🧪 test] A run promotes, prunes and reports
    [⚙️ assert] One long-term archive per project
    ✅ got: ((proj . 1))
    [⚙️ assert] The newest mirror archive was promoted
    ✅ got: #t
    [⚙️ assert] A stray file in the archive tree survives
    ✅ got: #t
    [⚙️ assert] The expired archive was deleted
    ✅ got: #f
    [⚙️ assert] Nothing outside the archive tree is deleted
    ✅ got: #t
    [⚙️ assert] The promoted archive is not then deleted
    ✅ got: #t
  [🧪 test] Past a week, the week's representative survives
    [⚙️ assert] No week is represented twice
    ✅ got: 5
    [⚙️ assert] A deleted archive's week is kept by another
    ✅ got: #t
    [⚙️ assert] Those survivors are father archives
    ✅ got: #t
  [🧪 test] Archive names identify an archive; sidecars and strays do not
    [⚙️ assert] A tar archive carries its timestamp
    ✅ got: 1700000000
    [⚙️ assert] So does an SQL dump
    ✅ got: 1700000000
    [⚙️ assert] The checksum sidecar is not an archive
    ✅ got: #f
    [⚙️ assert] A stray file is not an archive
    ✅ got: #f
    [⚙️ assert] An unencrypted tarball is not an archive
    ✅ got: #f
  [🧪 test] Nothing older than a year survives, and a year is honoured
    [⚙️ assert] 364 days old is still kept
    ✅ got: (364)
    [⚙️ assert] 365 days and older are deleted (same month)
    ✅ got: (365 366 400)
    [⚙️ assert] A year-old archive in another month is kept
    ✅ got: (300)
  [🧪 test] Parsing sorts newest first and drops everything elseBacktrace:
In ice-9/threads.scm:
    399:8 19 (_ _)
In ice-9/boot-9.scm:
  3307:13 18 (_)
In ice-9/threads.scm:
    399:8 17 (_ _)
In ice-9/boot-9.scm:
  3596:20 16 (_)
   2890:4 15 (save-module-excursion #<procedure 7f190ded8420 at ice-9/boot-9.scm:3597:21 ()>)
  3616:26 14 (_)
In unknown file:
          13 (primitive-load-path "wolk-jjba/packages" #<procedure 7f190f8fa4a0 at ice-9/boot-9.scm:3603:37 ()>)
In wolk-jjba/packages.scm:
     41:0 12 (_)
In ice-9/boot-9.scm:
   3463:4 11 (define-module* _ #:filename _ #:pure _ #:version _ #:imports _ #:exports _ #:replacements _ #:re-exports _ #:re-export-replacements _ #:autoloads _ #:duplicates _ #:transformer _ #:declarative? _ #:inlinable-exports _)
  2649:24 10 (call-with-deferred-observers #<procedure 7f190e129410 at ice-9/boot-9.scm:3464:5 ()>)
  3476:24  9 (_)
   231:29  8 (map1 (((gnu)) ((guix packages)) ((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  7 (map1 (((guix packages)) ((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  6 (map1 (((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  5 (map1 (((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  4 (map1 (((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  3 (map1 (((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  2 (map1 (((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:17  1 (map1 (((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   3384:6  0 (resolve-interface (jointhefreeworld packages applications) #:select _ #:hide _ #:prefix _ #:renamer _ #:version _)

ice-9/boot-9.scm:3384:6: In procedure resolve-interface:
no code for module (jointhefreeworld packages applications)
Backtrace:
In ice-9/threads.scm:
    399:8 19 (_ _)
In ice-9/boot-9.scm:
  3307:13 18 (_)
In ice-9/threads.scm:
    399:8 17 (_ _)
In ice-9/boot-9.scm:
  3596:20 16 (_)
   2890:4 15 (save-module-excursion #<procedure 7f35a6ec2270 at ice-9/boot-9.scm:3597:21 ()>)
  3616:26 14 (_)
In unknown file:
          13 (primitive-load-path "wolk-jjba/packages" #<procedure 7f35a8546880 at ice-9/boot-9.scm:3603:37 ()>)
In wolk-jjba/packages.scm:
     41:0 12 (_)
In ice-9/boot-9.scm:
   3463:4 11 (define-module* _ #:filename _ #:pure _ #:version _ #:imports _ #:exports _ #:replacements _ #:re-exports _ #:re-export-replacements _ #:autoloads _ #:duplicates _ #:transformer _ #:declarative? _ #:inlinable-exports _)
  2649:24 10 (call-with-deferred-observers #<procedure 7f35a6cc5410 at ice-9/boot-9.scm:3464:5 ()>)
  3476:24  9 (_)
   231:29  8 (map1 (((gnu)) ((guix packages)) ((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  7 (map1 (((guix packages)) ((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  6 (map1 (((guix build-system gnu)) ((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  5 (map1 (((guix build-system guile)) ((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  4 (map1 (((guix git-download)) ((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  3 (map1 (((guix)) ((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:29  2 (map1 (((gnu packages ssh)) ((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   231:17  1 (map1 (((jointhefreeworld packages applications)) ((jointhefreeworld packages guile) #:prefix jtf:) ((ice-9 popen)) ((ice-9 textual-ports)) ((ice-9 time)) ((ice-9 format)) ((ice-9 string-fun)) ((ice-9 iconv)) ((guix licenses) #:prefix license:) ((ice-9 threads))))
   3384:6  0 (resolve-interface (jointhefreeworld packages applications) #:select _ #:hide _ #:prefix _ #:renamer _ #:version _)

ice-9/boot-9.scm:3384:6: In procedure resolve-interface:
no code for module (jointhefreeworld packages applications)
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;;       or pass the --no-auto-compile argument to disable.
;;; compiling ./test/veritas/unit/temp-spec.scm
;;; compiling ./test/veritas/temp.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/wolk-jjba/trunk/test/veritas/temp.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/wolk-jjba/trunk/test/veritas/unit/temp-spec.scm.go
gfs-backup: proj failed: misc-error (#f "cannot reach the Storage Box over ssh" () #f)
gfs-backup: other failed: misc-error (#f "cannot reach the Storage Box over ssh" () #f)
;;; note: source file ./test/veritas/unit/operating-system-spec.scm
;;;       newer than compiled /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/wolk-jjba/trunk/test/veritas/unit/operating-system-spec.scm.go
;;; compiling ./test/veritas/unit/operating-system-spec.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/wolk-jjba/trunk/test/veritas/unit/operating-system-spec.scm.go

    [⚙️ assert] Newest first, strays ignored
    ✅ got: (300 200 100)
    [⚙️ assert] An empty directory parses to nothing
    ✅ got: ()
ℹ️ info - ran 1 tasks in: 0 seconds, 122064 microseconds

running unit tests from file: operating-system-spec.scm, entrypoint: spec


ℹ️ info - shuffled with seed 442108769 (replay with VERITAS_SEED=442108769)
+----------------------------------------------+
[📑 suite] Operating System Suite
  [🧪 test] The languages a visitor may ask for are compiled
    [⚙️ assert] Japanese, Greek, Chinese (both scripts), Arabic and Russian
    ❌ fail - error, expect: (#t #t #t #t #t #t), got: (#f #f #f #f #f #f)
  [🧪 test] The passwords come from the secrets directory the environment names
    [⚙️ assert] The admin password is the fixture's
    ❌ fail - error, expect: fixture-admin-password, got: 
    [⚙️ assert] The read password is the fixture's
    ❌ fail - error, expect: fixture-read-password, got: 
  [🧪 test] The system configuration evaluates as an ordinary user
    [⚙️ assert] config.scm evaluates without root
    ❌ fail - error, expect: 0, got: 256
    [⚙️ assert] The host keeps its name
    ❌ fail - error, expect: wolk-jjba, got: (the child did not evaluate config.scm)
    [⚙️ assert] The result is an operating-system
    ❌ fail - error, expect: #t, got: #f
  [🧪 test] The machine still has its services
    [⚙️ assert] The service list is the whole machine
    ❌ fail - error, expect: #t, got: #f
  [🧪 test] A missing secrets directory fails the evaluation
    [⚙️ assert] config.scm cannot silently ship without secrets
    ✅ got: #t
ℹ️ info - ran 1 tasks in: 0 seconds, 2888 microseconds

❌ error - 
aborting due to error in test case...

;;; note: source file /etc/byggsteg/job-clone/wolk-jjba/trunk/maak.scm
;;;       newer than compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/wolk-jjba/trunk/maak.scm.go
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;;       or pass the --no-auto-compile argument to disable.
;;; compiling /etc/byggsteg/job-clone/wolk-jjba/trunk/maak.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/wolk-jjba/trunk/maak.scm.go

maak: error: command failed (exit code 1): env VERITAS_JOBS=1 guix time-machine --channels=channels.scm -- shell -m manifest.scm -- guile -L ./src -L ./test -c '(use-modules (veritas runner)) (run-tests)'
        hint: Fix the command above, or run `maak --dry-run' to inspect it first.


--------------------------------------------------------------

Maak 0.12.2: the infinitely extensible command runner

Loading tasks from Maak file: /etc/byggsteg/job-clone/wolk-jjba/trunk/maak.scm

Executing Maak tasks: test


--------------------------------------------------------------

=> Running Maak task: test

  Run the Veritas unit-test suite, one process per test file.

Runs inside the manifest shell like the other Scheme tasks: the suite
imports (guix gexp) and (gnu services ...) and needs veritas, none of
which are in the machine's system profile, so a bare `guile' fails with
`no code for module (veritas runner)' -- which is what the Byggsteg CI
task `maak-test' used to hit.

The files run in parallel, one process each, in as many processes as
this machine may use up to four; VERITAS_JOBS overrides that count.
Four things are deliberate, so that a failure here is a failure of the
code under test rather than of the schedule:

  - the order the files run in is shuffled, and the seed is printed:
    `VERITAS_SEED=<the seed> VERITAS_SHUFFLE_FILES=true maak test'
    replays a failing order, and `VERITAS_SHUFFLE_FILES=false' runs them
    in the fixed one;
  - every fixture is created under a name unique to the run and removed
    when it ends (see test/veritas/temp.scm), so two workers -- or two CI
    jobs sharing /tmp -- cannot collide on one;
  - GUILE_LOAD_PATH is set to the pulled Guix's module directory, because
    evaluating config.scm needs the jointhefreeworld channel and the pinned
    shell does not carry it (see the comment below);
  - a suite that needs the network or the machine's own root-only files
    is a suite that fails for reasons nobody can act on, and there is
    none of those: see the Commentary of each spec.

Executing: env VERITAS_JOBS=1 guix time-machine --channels=channels.scm -- shell -m manifest.scm -- guile -L ./src -L ./test -c '(use-modules (veritas runner)) (run-tests)'
inspect the job's lambda expression
(lambda()
  `((task . "maak-test")
    (project . "wolk-jjba")
    (branch-name . "trunk")
    (clone-url . "https://codeberg.org/jjba23/wolk-jjba.git")))