Database Formalization Progress — Part 3

Agreed, with one precision: only pooling still requires an attribute read. The other three are explicit choices:

• truncate_dim = NULL, passed explicitly
• max_seq_length = 8192
• overlength_policy = reject
• normalize_embeddings = true, passed explicitly
• Pooling: read and record the complete loaded module configuration; expected mean pooling

The rejection check must count the fully prefixed input—including search_query: or search_document: and special tokens—before calling encode(). That prevents SentenceTransformers from silently truncating anything.

So the canonical encoder will never depend on call-site defaults. It will explicitly supply normalization and truncate_dim, enforce the token ceiling itself, and record the profile used.

That closes measurement and execution design. The next physical sequence is:

1. Create the complete legacy archive.
2. Verify that it can be restored.
3. Preserve the investigation record, scripts, logs, and both benchmark files with it.
4. Recheck remaining disk capacity.
5. Decide whether the replacement uses the existing PostgreSQL cluster or a separate clean cluster.
6. Begin the seven-step implementation slice.

We are genuinely at the archive boundary now.

Agreed. The encoder contract is now complete:

• Count the fully prefixed, special-token-inclusive input.
• Reject anything exceeding 8,192 tokens before encoding.
• Require chunking profiles to leave explicit headroom below that ceiling.
• Convert query-side rejection into a clear user message, not a raw exception.
• Offer an oversized paste for document ingestion/chunking rather than silently embedding only part of it.

No further design work is needed here. Next is the verified legacy archive, followed by the clean implementation slice.

Yes. We begin with the archive, and we will not alter or stop PostgreSQL until we have resolved the exact source directory, every tablespace, the archive destination, and the required capacity. The first pass is entirely read-only.

We begin now. First we establish exactly what must be copied and where it can safely fit. This command is read-only; it does not stop PostgreSQL or change the database.

It may ask for your sudo password once.

sudo -v

STAMP="$(date +%Y%m%d-%H%M%S)"
LOG="$HOME/Desktop/ougway-archive-preflight-$STAMP.txt"

{
    echo "Archive preflight: $(date -Is)"
    echo "Host: $(hostname)"

    printf '\nMounted storage:\n'
    findmnt -o SOURCE,FSTYPE,SIZE,USED,AVAIL,USE%,TARGET
    printf '\nBlock devices:\n'
    lsblk -o NAME,SIZE,FSTYPE,FSAVAIL,FSUSE%,MOUNTPOINTS
    printf '\nExact filesystem capacity:\n'
    df -B1 --output=source,fstype,size,used,avail,pcent,target

    printf '\nPostgreSQL clusters:\n'
    pg_lsclusters 2>&1 || true

    printf '\nPostgreSQL configuration and databases:\n'
    sudo -u postgres psql -X -P pager=off -d postgres <<'SQL'
SELECT version();

SELECT name, setting
FROM pg_settings
WHERE name IN (
    'data_directory',
    'config_file',
    'hba_file',
    'ident_file',
    'server_version',
    'archive_mode',
    'wal_level',
    'data_checksums'
)
ORDER BY name;

SELECT
    oid,
    datname,
    pg_database_size(datname) AS bytes,
    pg_size_pretty(pg_database_size(datname)) AS readable
FROM pg_database
ORDER BY pg_database_size(datname) DESC;

SELECT
    oid,
    spcname,
    CASE
        WHEN pg_tablespace_location(oid) = ''
        THEN '[inside data directory]'
        ELSE pg_tablespace_location(oid)
    END AS location
FROM pg_tablespace
ORDER BY oid;
SQL

    printf '\nTokenspace extensions and largest relations:\n'
    sudo -u postgres psql -X -P pager=off -d tokenspace <<'SQL'
SELECT current_database(), pg_size_pretty(pg_database_size(current_database()));

SELECT extname, extversion
FROM pg_extension
ORDER BY extname;

SELECT
    n.nspname AS schema_name,
    c.relname,
    c.relkind,
    pg_total_relation_size(c.oid) AS total_bytes,
    pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size
FROM pg_class c
JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
  AND c.relkind IN ('r', 'm', 'i', 't')
ORDER BY pg_total_relation_size(c.oid) DESC
LIMIT 25;
SQL

    printf '\nPhysical directory sizes:\n'
    for path in \
        /mnt/storage/tokenspacedata \
        /mnt/storage/pile_uncopyrighted \
        /mnt/storage/backups \
        /home/darren/Documents/tokenspace
    do
        if sudo test -e "$path"; then
            sudo du -x -B1 -s "$path"
            sudo du -x -h -s "$path"
        else
            echo "NOT FOUND: $path"
        fi
    done

    printf '\nRelevant directory permissions:\n'
    ls -ld \
        /mnt \
        /mnt/storage \
        /mnt/storage/backups \
        /mnt/storage/tokenspacedata \
        "$HOME/Desktop" 2>&1 || true

    printf '\nPostgreSQL service state:\n'
    systemctl is-active postgresql
    systemctl status postgresql --no-pager -n 20
} 2>&1 | tee "$LOG"

echo
echo "Preflight saved to: $LOG"

Let it return fully to the prompt, then paste the output. From that, we will choose the archive method and exact destination before copying a single database file.

I have the preflight output. I’m checking the filesystem capacity against the physical cluster size and looking for any external tablespaces before choosing between a cold physical copy, a logical dump, or both.

The preflight gives us a clean answer: there are two physical disks, not merely two folders. The 156 GB PostgreSQL cluster is on the 4 TB storage disk, while the 1 TB system disk has about 702 GB free. There are no external PostgreSQL tablespaces.

I’m choosing the system disk for the legacy archive. That preserves the physical database on a different device while leaving the storage disk available for the replacement. We have room for both a byte-preserving physical copy and a portable logical dump.

We have enough space for the strongest archive:

• A cold physical copy preserving the database’s exact physical state
• A compressed logical dump for portability
• PostgreSQL configuration, scripts, logs, investigation records, and benchmarks
• Checksums and later restoration verification

The archive will live on /dev/sda2, physically separate from the database on /dev/sdb.

First create its structure and collect the small records. PostgreSQL remains online during this step.

set -Eeuo pipefail

ARCHIVE_ID="tokenspace-legacy-$(date +%Y%m%d-%H%M%S)"
ARCHIVE_ROOT="/srv/ougway-archives/$ARCHIVE_ID"

sudo install -d -o darren -g darren -m 0750 "$ARCHIVE_ROOT"
sudo install -d -o postgres -g postgres -m 0700 \
    "$ARCHIVE_ROOT/physical" \
    "$ARCHIVE_ROOT/logical"

install -d -m 0750 \
    "$ARCHIVE_ROOT/config" \
    "$ARCHIVE_ROOT/logs" \
    "$ARCHIVE_ROOT/records" \
    "$ARCHIVE_ROOT/scripts" \
    "$ARCHIVE_ROOT/benchmarks" \
    "$ARCHIVE_ROOT/manifests"

printf '%s\n' "$ARCHIVE_ROOT" \
    | tee "$HOME/Desktop/current-ougway-archive.txt"

sudo cp -a /etc/postgresql/16/main \
    "$ARCHIVE_ROOT/config/postgresql-16-main"

sudo cp -a /var/log/postgresql \
    "$ARCHIVE_ROOT/logs/postgresql-initial"

cp -a "$HOME/Documents/tokenspace/." \
    "$ARCHIVE_ROOT/scripts/"

for file in \
    "$HOME/Downloads/ingest_pile_v2.py" \
    "$HOME/Desktop"/ougway-archive-preflight-*.txt \
    "$HOME/Desktop"/nomic-cpu-benchmark-*.txt \
    "$HOME/Desktop"/qwen-vram-benchmark-*.txt
do
    if [ -f "$file" ]; then
        case "$file" in
            *benchmark*) cp -a "$file" "$ARCHIVE_ROOT/benchmarks/" ;;
            *preflight*) cp -a "$file" "$ARCHIVE_ROOT/records/" ;;
            *) cp -a "$file" "$ARCHIVE_ROOT/scripts/" ;;
        esac
    fi
done

sudo -u postgres pg_dumpall --globals-only \
    > "$ARCHIVE_ROOT/logical/cluster-globals.sql"

sudo -u postgres pg_dump --schema-only --no-owner \
    --file="$ARCHIVE_ROOT/logical/tokenspace-schema.sql" \
    tokenspace

find /home/darren /mnt/storage \
    -type f \( \
        -iname 'ingest.log' -o \
        -iname '*ingest*.log' -o \
        -iname '*tokenspace*.sql' -o \
        -iname '*investigation*.txt' \
    \) \
    -printf '%s\t%TY-%Tm-%Td %TH:%TM:%TS\t%p\n' 2>/dev/null \
    | sort -n \
    > "$ARCHIVE_ROOT/records/candidate-record-files.txt"

{
    echo "Archive ID: $ARCHIVE_ID"
    echo "Created: $(date -Is)"
    echo "Host: $(hostname)"
    echo "Source cluster: PostgreSQL 16/main"
    echo "Source data directory: /mnt/storage/tokenspacedata"
    echo "Source database: tokenspace"
    echo "Archive filesystem:"
    df -hT "$ARCHIVE_ROOT"
    echo
    echo "Archive contents created:"
    find "$ARCHIVE_ROOT" -maxdepth 2 -printf '%M %u:%g %s %p\n' | sort
} | tee "$ARCHIVE_ROOT/records/archive-creation.txt"

echo
echo "Archive scaffold completed:"
echo "$ARCHIVE_ROOT"

Paste the final output when it returns. The next operation will be the compressed logical dump; PostgreSQL will remain online for that portion.

That was my mistake. I used set -e directly in your interactive shell. When the first command encountered a permissions error, Bash exited the entire terminal window. The likely failure was the output redirection into the PostgreSQL-owned logical directory.

PostgreSQL was not stopped or altered. The archive scaffold was probably created partially.

Open a new terminal and run this recovery block. It does not enable exit-on-error, and failures cannot close the window:

ARCHIVE_MARKER="$HOME/Desktop/current-ougway-archive.txt"

if [ ! -f "$ARCHIVE_MARKER" ]; then
    echo "Archive marker was not created. Stop here and report this message."
else
    ARCHIVE_ROOT="$(cat "$ARCHIVE_MARKER")"

    echo "Recovering archive at:"
    echo "$ARCHIVE_ROOT"
    echo

    sudo find "$ARCHIVE_ROOT" -maxdepth 2 \
        -printf '%M %u:%g %s %p\n' 2>/dev/null | sort

    echo
    echo "Creating global-object dump..."

    sudo -u postgres sh -c \
        'pg_dumpall --globals-only > "$1"' \
        archive-shell \
        "$ARCHIVE_ROOT/logical/cluster-globals.sql"

    echo "Creating schema-only dump..."

    sudo -u postgres pg_dump \
        --schema-only \
        --no-owner \
        --file="$ARCHIVE_ROOT/logical/tokenspace-schema.sql" \
        tokenspace

    echo "Locating additional records..."

    find /home/darren /mnt/storage \
        -type f \( \
            -iname 'ingest.log' -o \
            -iname '*ingest*.log' -o \
            -iname '*tokenspace*.sql' -o \
            -iname '*investigation*.txt' \
        \) \
        -printf '%s\t%TY-%Tm-%Td %TH:%TM:%TS\t%p\n' 2>/dev/null \
        | sort -n \
        > "$ARCHIVE_ROOT/records/candidate-record-files.txt"

    {
        echo "Archive root: $ARCHIVE_ROOT"
        echo "Recovered: $(date -Is)"
        echo "Host: $(hostname)"
        echo "Source cluster: PostgreSQL 16/main"
        echo "Source data directory: /mnt/storage/tokenspacedata"
        echo "Source database: tokenspace"
        echo
        df -hT "$ARCHIVE_ROOT"
    } | tee "$ARCHIVE_ROOT/records/archive-creation.txt"

    echo
    echo "Current archive size:"
    sudo du -sh "$ARCHIVE_ROOT"

    echo
    echo "PostgreSQL remains:"
    pg_lsclusters

    echo
    echo "Recovery step completed."
fi

Paste the output when it finishes. The terminal will remain open even if an individual command reports an error.

The archive itself is fine, and it already captured the important scripts, ingest.log, ingest_full.log, benchmarks, configuration, and preflight report.

The remaining permission problem is now clear: the logical directory belongs to PostgreSQL, but its parent archive directory did not allow the postgres account to pass through it. We need change only the parent directory’s group.

Run this:

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"

sudo chgrp postgres "$ARCHIVE_ROOT"
sudo chmod 0750 "$ARCHIVE_ROOT"

echo "Testing PostgreSQL archive access..."
sudo -u postgres touch "$ARCHIVE_ROOT/logical/.write-test"

if sudo test -f "$ARCHIVE_ROOT/logical/.write-test"; then
    echo "Write test succeeded."
    sudo rm "$ARCHIVE_ROOT/logical/.write-test"

    echo "Creating global-object dump..."
    sudo -u postgres sh -c \
        'pg_dumpall --globals-only > "$1"' \
        archive-shell \
        "$ARCHIVE_ROOT/logical/cluster-globals.sql"

    echo "Creating schema-only dump..."
    sudo -u postgres pg_dump \
        --schema-only \
        --no-owner \
        --file="$ARCHIVE_ROOT/logical/tokenspace-schema.sql" \
        tokenspace

    echo
    echo "Created logical metadata:"
    sudo ls -lh "$ARCHIVE_ROOT/logical"

    echo
    echo "PostgreSQL status:"
    pg_lsclusters
else
    echo "Write test failed. No dump was attempted."
fi

This should take only seconds. Once the two SQL files appear, we can start the full compressed logical dump.

The archive permissions are now correct, and both the cluster globals and complete schema have been captured successfully. I’m marking the archive method as settled and starting the first long-running component: the portable compressed dump. PostgreSQL stays online and usable during it.

Start the portable logical dump in the background. It uses reduced CPU and disk priority so Oogway remains responsive.

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
DUMP_DIR="$ARCHIVE_ROOT/logical/tokenspace-directory.dump"
DUMP_LOG="$ARCHIVE_ROOT/records/logical-dump.log"
PID_FILE="$ARCHIVE_ROOT/records/logical-dump.pid"

if sudo test -e "$DUMP_DIR"; then
    echo "Dump destination already exists:"
    echo "$DUMP_DIR"
    echo "Nothing was started."
else
    echo "Starting compressed logical dump..."

    sudo -u postgres nohup \
        ionice -c 2 -n 7 \
        nice -n 10 \
        pg_dump \
            --format=directory \
            --jobs=2 \
            --compress=zstd:3 \
            --create \
            --verbose \
            --file="$DUMP_DIR" \
            tokenspace \
        >"$DUMP_LOG" 2>&1 &

    DUMP_PID=$!
    printf '%s\n' "$DUMP_PID" | tee "$PID_FILE"

    sleep 5

    if ps -p "$DUMP_PID" >/dev/null 2>&1; then
        echo
        echo "Logical dump is running in the background."
        echo "Process: $DUMP_PID"
        echo "Current archive growth:"
        sudo du -sh "$DUMP_DIR" 2>/dev/null || true
        echo
        echo "Latest log entries:"
        tail -20 "$DUMP_LOG"
    else
        echo
        echo "The dump stopped during startup."
        echo "Log contents:"
        cat "$DUMP_LOG"
    fi
fi

The terminal prompt should return after about five seconds while the dump continues.

Paste that immediate output. We will then monitor its size without interrupting it. Do not stop PostgreSQL while this dump is running.

Good—the logical dump is running correctly. It has already completed the small tables and is now working through the large content data. PostgreSQL must remain online until this finishes.

Give it roughly 10–15 minutes, then run this one-time status check:

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
DUMP_DIR="$ARCHIVE_ROOT/logical/tokenspace-directory.dump"
DUMP_LOG="$ARCHIVE_ROOT/records/logical-dump.log"
DUMP_PID="$(cat "$ARCHIVE_ROOT/records/logical-dump.pid")"

if ps -p "$DUMP_PID" >/dev/null 2>&1; then
    echo "Logical dump is still running."
    ps -p "$DUMP_PID" -o pid,etime,%cpu,%mem,stat,cmd
else
    echo "Logical dump process has finished."
fi

echo
echo "Current dump size:"
sudo du -sh "$DUMP_DIR"

echo
echo "Latest log entries:"
tail -20 "$DUMP_LOG"

Paste that output afterward. A long pause on content.chunks is expected; it is processing the only enormous table, not stalled.

That is the startup output again—the dump was running correctly at that point.

Now run this shorter status check:

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
DUMP_PID="$(cat "$ARCHIVE_ROOT/records/logical-dump.pid")"

ps -p "$DUMP_PID" -o pid,etime,%cpu,%mem,stat,cmd
sudo du -sh "$ARCHIVE_ROOT/logical/tokenspace-directory.dump"
tail -20 "$ARCHIVE_ROOT/records/logical-dump.log"

If ps shows only its header, the process has finished. Paste the new output and we’ll determine whether it completed successfully.

It is healthy and actively progressing:

• Runtime: 20½ minutes
• Dump growth: 152 MB → 28 GB
• No error messages
• The visible sudo process is sleeping because it is waiting for the underlying pg_dump worker to finish the enormous content.chunks table.

At the observed rate, it may need another 20–40 minutes. Leave PostgreSQL and that background process alone.

After another 20 minutes, run:

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
DUMP_PID="$(cat "$ARCHIVE_ROOT/records/logical-dump.pid")"

if ps -p "$DUMP_PID" >/dev/null; then
    echo "Still running"
else
    echo "Process finished"
fi

sudo du -sh "$ARCHIVE_ROOT/logical/tokenspace-directory.dump"
tail -30 "$ARCHIVE_ROOT/records/logical-dump.log"

The unchanged log tail is normal: one worker is inside the huge table and has nothing new to report until it finishes.

Correct—it had not completed. We deliberately launched it in the background with &, so the terminal prompt returned immediately and remained usable while the dump continued.

Your last check showed:

• Process 111473 still running
• 20½ minutes elapsed
• Dump already grown to 28 GB

When it finishes, the terminal may display something like:

[1]+  Done

The prompt itself only means the foreground is available, not that the background dump is finished. You can safely use the terminal for unrelated commands, but do not stop PostgreSQL or reboot until we confirm completion.

Sounds good. Let it work undisturbed. When you see the Done notification—or after another 20–30 minutes—run the status check and bring me the output. We’ll verify the logical archive before moving to the physical copy.

The portable dump completed successfully at 48 GB, including the final content.chunks item. Before stopping PostgreSQL for the physical copy, we’ll validate the dump catalogue, scan its log for failures, and test every compressed data file. This is still read-only and leaves PostgreSQL online.

Run this logical-archive verification:

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
DUMP_DIR="$ARCHIVE_ROOT/logical/tokenspace-directory.dump"
DUMP_LOG="$ARCHIVE_ROOT/records/logical-dump.log"
TOC_FILE="$ARCHIVE_ROOT/manifests/tokenspace-restore-list.txt"
VERIFY_LOG="$ARCHIVE_ROOT/records/logical-verification.txt"

{
    echo "Logical verification started: $(date -Is)"
    echo

    echo "Errors or warnings in pg_dump log:"
    if grep -Ein 'error|fatal|warning' "$DUMP_LOG"; then
        echo "Messages above require review."
    else
        echo "None found."
    fi

    echo
    echo "Creating and validating restore catalogue..."
    sudo -u postgres pg_restore --list "$DUMP_DIR" \
        | tee "$TOC_FILE" >/dev/null
    RESTORE_STATUS="${PIPESTATUS[0]}"

    echo "pg_restore catalogue status: $RESTORE_STATUS"
    echo "Catalogue entries: $(wc -l < "$TOC_FILE")"
    echo "TABLE DATA entries: $(grep -c 'TABLE DATA' "$TOC_FILE")"

    echo
    echo "Compressed data files:"
    ZSTD_COUNT="$(sudo find "$DUMP_DIR" -maxdepth 1 -type f -name '*.zst' | wc -l)"
    echo "$ZSTD_COUNT"

    if [ "$ZSTD_COUNT" -gt 0 ]; then
        echo "Testing every Zstandard stream..."
        sudo find "$DUMP_DIR" -maxdepth 1 -type f -name '*.zst' -print0 \
            | sudo xargs -0 -r -P 2 zstd --quiet --test
        ZSTD_STATUS="${PIPESTATUS[1]}"
        echo "Zstandard verification status: $ZSTD_STATUS"
    else
        echo "No .zst files were found; listing archive file types:"
        sudo find "$DUMP_DIR" -maxdepth 1 -type f \
            -printf '%f\n' | sed 's/.*\././' | sort | uniq -c
    fi

    echo
    echo "Logical dump size:"
    sudo du -sh "$DUMP_DIR"

    echo
    echo "Logical verification finished: $(date -Is)"
} 2>&1 | tee "$VERIFY_LOG"

echo
echo "Verification record:"
echo "$VERIFY_LOG"

The Zstandard test may take several minutes because it reads all 48 GB. Success is:

• No dump errors or warnings
• pg_restore catalogue status: 0
• Zstandard verification status: 0

Once those are confirmed, we can safely stop PostgreSQL and make the cold physical copy.

The logical dump itself did complete. Your previous terminal output contained all three completion signals:

[1]+ Done
Process finished
pg_dump: finished item 3873 TABLE DATA chunks

The 48 GB directory is the completed logical dump.

The new verification command will appear to pause at:

Testing every Zstandard stream...

That is expected—it must read and decompress-test all 48 GB and may produce no progress output until it finishes. It is the verification that is running now, not pg_dump.

Let it continue until the terminal prompt returns. If you are seeing a different process or message, paste exactly what the terminal shows.

The logical archive is now verified: no dump errors, a valid 207-entry restore catalogue, all 20 table-data streams passed Zstandard integrity testing, and the archive is 48 GB.

The next step is the cold physical copy. This will deliberately stop only PostgreSQL 16/main, copy the exact 156 GB data directory to the other physical disk, and leave PostgreSQL stopped afterward so we can checksum the copy against the source. Open WebUI and the rest of Oogway remain running.

Run the following. This time the copy stays in the foreground: the terminal prompt will not return until the copy has succeeded or failed.

ARCHIVE_ROOT="$(cat "$HOME/Desktop/current-ougway-archive.txt")"
SOURCE_DIR="/mnt/storage/tokenspacedata"
DEST_DIR="$ARCHIVE_ROOT/physical/tokenspacedata"
RSYNC_LOG="$ARCHIVE_ROOT/records/physical-copy-rsync.log"
VERIFY_LOG="$ARCHIVE_ROOT/records/logical-verification.txt"

READY=1

case "$ARCHIVE_ROOT" in
    /srv/ougway-archives/tokenspace-legacy-*) ;;
    *)
        echo "Unexpected archive path: $ARCHIVE_ROOT"
        READY=0
        ;;
esac

if ! command -v rsync >/dev/null; then
    echo "rsync is not installed."
    READY=0
fi

if [ ! -d "$SOURCE_DIR" ]; then
    echo "Source directory not found: $SOURCE_DIR"
    READY=0
fi

if ! grep -q 'pg_restore catalogue status: 0' "$VERIFY_LOG" ||
   ! grep -q 'Zstandard verification status: 0' "$VERIFY_LOG"; then
    echo "The logical-verification record does not contain both success results."
    READY=0
fi

SOURCE_BYTES="$(sudo du -s -B1 "$SOURCE_DIR" | awk '{print $1}')"
AVAILABLE_BYTES="$(df -B1 --output=avail "$ARCHIVE_ROOT" | tail -1 | tr -d ' ')"

echo "Physical source bytes: $SOURCE_BYTES"
echo "Archive filesystem available bytes: $AVAILABLE_BYTES"

if [ "$AVAILABLE_BYTES" -lt $((SOURCE_BYTES + 21474836480)) ]; then
    echo "Insufficient archive space with the required safety margin."
    READY=0
fi

sudo install -d -o postgres -g postgres -m 0700 "$DEST_DIR"

if [ -n "$(sudo find "$DEST_DIR" -mindepth 1 -print -quit)" ]; then
    echo "Physical destination is not empty. Copy will not start."
    READY=0
fi

if [ "$READY" -eq 1 ]; then
    echo
    echo "Stopping PostgreSQL 16/main for the cold copy..."
    sudo systemctl stop postgresql@16-main
    sleep 3

    if pg_isready -q ||
       pgrep -af '[p]ostgres.*tokenspacedata' >/dev/null; then
        echo "PostgreSQL still appears to be running."
        echo "The copy was not started."
        pg_lsclusters
    else
        echo "PostgreSQL is stopped."
        pg_lsclusters
        echo
        echo "Beginning physical copy at $(date -Is)"
        echo "The terminal prompt will return only after rsync finishes."
        echo

        sudo rsync \
            -aHAXS \
            --numeric-ids \
            --partial \
            --human-readable \
            --info=progress2 \
            --log-file="$RSYNC_LOG" \
            "$SOURCE_DIR/" \
            "$DEST_DIR/"

        RSYNC_STATUS=$?

        echo
        echo "rsync status: $RSYNC_STATUS"

        if [ "$RSYNC_STATUS" -eq 0 ]; then
            sudo cp -a /var/log/postgresql \
                "$ARCHIVE_ROOT/logs/postgresql-final"

            sudo /usr/lib/postgresql/16/bin/pg_controldata "$SOURCE_DIR" \
                > "$ARCHIVE_ROOT/records/source-pg_controldata.txt"

            sudo /usr/lib/postgresql/16/bin/pg_controldata "$DEST_DIR" \
                > "$ARCHIVE_ROOT/records/archive-pg_controldata.txt"

            echo "Physical copy completed at $(date -Is)"
            echo
            echo "Source and archive sizes:"
            sudo du -sh "$SOURCE_DIR" "$DEST_DIR"
            echo
            echo "PostgreSQL intentionally remains stopped:"
            pg_lsclusters
        else
            echo "Physical copy failed. Restarting the original cluster."
            sudo systemctl start postgresql@16-main
            pg_lsclusters
        fi
    fi
else
    echo
    echo "Preflight failed. PostgreSQL was not stopped."
fi

Expect approximately 156 GB to cross from the storage disk to the system disk. It may take 30–90 minutes. PostgreSQL will remain stopped after a successful copy; that is intentional for the checksum comparison.

Good time for one. Leave the terminal and machine running; the foreground copy will continue by itself.

When you return, the normal terminal prompt will mean rsync finished. Bring me the final output, especially:

• rsync status
• Source and archive sizes
• PostgreSQL cluster status

If it succeeds, PostgreSQL should still show as stopped—that is intentional, and the next step will be checksum verification before we touch the original.