Below is a drop-in .zshrc implementation that does two things:

1. makes standard zsh history store timestamps (and shows them in history), and

2. appends two TSV log lines per command to a “history archive” file:

• before execution: (unique id, timestamp, hostname, username, cwd, command)

• after completion: (unique id, timestamp, exit status)

It avoids SQLite/Postgres and just appends lines to a file.

Paste this into your .zshrc (near the end)

Zsh
# =========================
# Timestamped zsh history
# =========================

# Store timestamps (epoch) + duration in $HISTFILE
setopt EXTENDED_HISTORY  # ~/.zsh_history lines look like: ": 1698373801:0;ls -l" :contentReference[oaicite:0]{index=0}

# Make `history` output show human-readable timestamps (optional but matches your goal)
# If you prefer using `fc`, see: `fc -li -20` to list with timestamps. :contentReference[oaicite:1]{index=1}
[[ -z ${HIST_STAMPS-} ]] && HIST_STAMPS="yyyy-mm-dd HH:MM"  # :contentReference[oaicite:2]{index=2}


# =========================
# History archive logger
# =========================
# Appends to a file:
#   start record: <id>\t<ts>\t<host>\t<user>\t<cwd>\t<command>
#   end record:   <id>\t<ts>\t<exit_status>
#
# Notes:
# - Fields are tab-separated (TSV).
# - cwd + command are ${(qqq)}-quoted so the record stays 1 line even if they contain spaces/newlines/tabs.
# - Timestamp uses $EPOCHREALTIME when available (sub-second), else falls back to epoch seconds.

__histarchive_init() {
  [[ -o interactive ]] || return 0

  # Location (override by exporting HISTARCHIVE_FILE before zsh starts)
  local state_dir="${XDG_STATE_HOME:-$HOME/.local/state}/zsh"
  : "${HISTARCHIVE_FILE:=$state_dir/history-archive.tsv}"

  # Prepare directory
  local dir="${HISTARCHIVE_FILE:h}"
  if [[ ! -d "$dir" ]]; then
    command mkdir -p -- "$dir" 2>/dev/null || return 0
  fi

  # Ensure file exists with private-ish permissions
  local old_umask
  old_umask="$(umask)"
  umask 077
  : >>| "$HISTARCHIVE_FILE" 2>/dev/null
  umask "$old_umask"

  # If we reload .zshrc, close previous FD to avoid leaking
  if (( ${+__histarchive_fd} )); then
    exec {__histarchive_fd}>&- 2>/dev/null
    unset __histarchive_fd
  fi

  # Open a persistent append FD for performance
  exec {__histarchive_fd}>>"$HISTARCHIVE_FILE" 2>/dev/null || return 0
  typeset -g __histarchive_fd
  typeset -g __histarchive_seq=0
  typeset -g __histarchive_pending_id=""
  typeset -g __histarchive_id_prefix

  # Host/user used in records
  local host="${HOST:-${HOSTNAME:-unknown-host}}"
  # Sanitize for use inside IDs (avoid whitespace)
  host="${host//[[:space:]]/_}"
  __histarchive_id_prefix="$host"
}

__histarchive_now() {
  # Prints a timestamp (prefer sub-second if available)
  # Using a function keeps preexec/precmd smaller and consistent.
  if [[ -n ${EPOCHREALTIME-} ]]; then
    print -r -- "$EPOCHREALTIME"
  else
    # EPOCHSECONDS exists in modern zsh; printf fallback is also common.
    if [[ -n ${EPOCHSECONDS-} ]]; then
      print -r -- "$EPOCHSECONDS"
    else
      printf '%(%s)T\n' -1
    fi
  fi
}

__histarchive_write() {
  # $1 = line to append
  (( ${+__histarchive_fd} )) || return 0
  print -r -u $__histarchive_fd -- "$1"
}

__histarchive_preexec() {
  # Runs just before executing the command line :contentReference[oaicite:3]{index=3}
  emulate -L zsh
  setopt localoptions noshwordsplit

  (( ${+__histarchive_fd} )) || return 0

  local cmd="$1"
  local ts="$(__histarchive_now)"
  local host="${HOST:-${HOSTNAME:-unknown-host}}"
  local user="${USERNAME:-${USER:-unknown-user}}"
  local cwd="$PWD"

  (( __histarchive_seq++ ))

  # Build unique-ish ID:
  #   <host>-<epoch(without dot)>-<pid>-<seq>-<random>
  local ts_id="${ts//./}"
  local id="${__histarchive_id_prefix}-${ts_id}-${$}-${__histarchive_seq}-${RANDOM}"

  typeset -g __histarchive_pending_id="$id"

  # Optional: skip logging commands that start with a space (common convention)
  # [[ "$cmd" == " "* ]] && return 0

  __histarchive_write "${id}\t${ts}\t${(qqq)host}\t${(qqq)user}\t${(qqq)cwd}\t${(qqq)cmd}"
}

__histarchive_precmd() {
  # Runs before each prompt; after the last command finishes :contentReference[oaicite:4]{index=4}
  local status=$?
  emulate -L zsh

  (( ${+__histarchive_fd} )) || return 0

  if [[ -n ${__histarchive_pending_id-} ]]; then
    local ts="$(__histarchive_now)"
    local id="$__histarchive_pending_id"
    __histarchive_pending_id=""
    __histarchive_write "${id}\t${ts}\t${status}"
  fi
}

__histarchive_zshexit() {
  # If the shell exits without showing another prompt (e.g. `exit`),
  # precmd won't run — so we flush a pending "end" record here.
  local status=$?
  emulate -L zsh

  (( ${+__histarchive_fd} )) || return 0

  if [[ -n ${__histarchive_pending_id-} ]]; then
    local ts="$(__histarchive_now)"
    local id="$__histarchive_pending_id"
    __histarchive_pending_id=""
    __histarchive_write "${id}\t${ts}\t${status}"
  fi

  exec {__histarchive_fd}>&- 2>/dev/null
}

autoload -Uz add-zsh-hook  # :contentReference[oaicite:5]{index=5}
__histarchive_init

add-zsh-hook preexec __histarchive_preexec
add-zsh-hook precmd  __histarchive_precmd
add-zsh-hook zshexit __histarchive_zshexit

What the archive file looks like

Two lines per command:

Start record

<id>   <ts>   <host>   <user>   <cwd>   <command>

End record

<id>   <ts>   <exit_status>

Because cwd and command are ${(qqq)}-quoted, they won’t break your TSV parsing even if they contain spaces, tabs, or newlines.

How to verify it quickly

After adding the snippet:

1. Reload your config:

Zsh
source ~/.zshrc

2. Run a couple commands:

Zsh
pwd
false
echo "hi
there"

3. Inspect the tail of the archive:

Zsh
tail -n 10 "${HISTARCHIVE_FILE:-$HOME/.local/state/zsh/history-archive.tsv}"

You should see pairs of lines with matching IDs, and exit status 0 for success / nonzero for failures.

Review of the implementation

What it gets right

• “Before running” vs “after completion”
  Uses preexec to log the start record just before execution, and precmd to log the end record after the command finishes (right before the next prompt). This matches zsh’s hook semantics. DeepWiki+1

• Handles exit / no-next-prompt cases
  If the shell exits immediately after a command (e.g., exit), precmd won’t run; the zshexit hook flushes a pending end-record so you still get (id, ts, status) for the final command.

• Doesn’t require SQLite/DB and is fast
  It opens the archive file once and appends via a persistent file descriptor, avoiding the overhead of opening/closing the file every command.

• Keeps records one-line even for multi-line commands
  ${(qqq)cmd} turns newlines/tabs into escaped sequences inside a quoted form, so each record stays one physical line in the file (important for later parsing/import).

• Also fixes standard zsh timestamped history
  setopt EXTENDED_HISTORY makes timestamps stored in ~/.zsh_history, and HIST_STAMPS makes them visible in history output. IT'S FOSS
  (And fc -li is a reliable way to view timestamped entries regardless of history formatting.) Unix & Linux Stack Exchange

Known limitations / tradeoffs (intentional, given your constraints)

• No locking between multiple shells writing to the same file
  Two interactive shells can append at the same time. In practice this is usually fine (each print is typically one write), but strict non-interleaving is not guaranteed on all filesystems. If you care later, the next step would be file locking (possible via zmodload zsh/system + zsystem flock, or external flock), or per-shell files + a merger.

• A “start” record may exist without an “end” record
  If the shell is killed hard (or execs another program), you’ll have the start line but no end line. That’s actually a feature for forensics: you still know what began running and where.

• Sensitive commands will be logged
  This will capture everything you run, including tokens/passwords typed into CLI flags. If you want a safety valve, uncomment the “leading-space skip” line so you can do:

  Zsh
   SECRET=... somecommand
  

  (leading space) to avoid archiving.

Optional improvements you might want later (not required)

• If you want your standard ~/.zsh_history to be written only after commands complete (so durations are accurate) while still writing during the session, look into INC_APPEND_HISTORY_TIME. Stack Overflow+1
  I didn’t enable it by default because it changes history write timing and sometimes interacts with shared-history setups.

If you want, I can also provide a tiny parser (awk/python) that reconstructs a single “command event” record by joining start/end lines on ID (and flags any missing ends).

Below is a drop-in zshrc snippet that:

• logs newline-delimited JSON (JSONL)

• writes to a unique file per interactive zsh session (so no locks, no cross-shell corruption even for huge commands)

• logs:

  • before each command starts: (id, timestamp, host, user, cwd, command…)

  • after it ends:

    • foreground: at prompt return

    • background (&): when the job completes, via TRAPCHLD, and it correctly handles out-of-order completions

• uses only zsh builtins/modules (no per-command external processes)

This uses:

• preexec hook args to capture the typed command line (and the “executed text”) Zsh

• jobstates to track job completion state Zsh

• TRAPCHLD which is triggered for background job completion when job control (MONITOR) is on Zsh

• sysopen/syswrite from zsh/system for efficient writes Zsh+1

Paste into ~/.zshrc

Zsh
# -----------------------------------------------------------------------------
# JSON history archive (per-shell JSONL file, no locking, background-safe)
# -----------------------------------------------------------------------------

# (Optional but recommended) Make normal ~/.zsh_history include timestamps, too.
# This is separate from the JSON archive below.
setopt EXTENDED_HISTORY

if [[ -o interactive ]]; then
  autoload -Uz add-zsh-hook 2>/dev/null

  # Load helper modules (if missing, we degrade gracefully).
  zmodload zsh/system    2>/dev/null || true
  zmodload zsh/parameter 2>/dev/null || true

  # Where to store per-shell JSONL files
  : ${XDG_STATE_HOME:=$HOME/.local/state}
  typeset -g __HISTJSON_DIR="${XDG_STATE_HOME}/zsh-history-archive"
  [[ -d $__HISTJSON_DIR ]] || command mkdir -p -- "$__HISTJSON_DIR" 2>/dev/null

  # Per-shell unique file (no shared appends => no locking, no interleaving)
  typeset -g __HISTJSON_HOST="${HOSTNAME:-${HOST:-unknown}}"
  typeset -g __HISTJSON_USER="${USER:-unknown}"
  typeset -g __HISTJSON_SESSION_START_EPOCH="$(printf '%(%s)T' -1)"
  typeset -g __HISTJSON_SESSION_ID="${__HISTJSON_HOST}.${__HISTJSON_USER}.${__HISTJSON_SESSION_START_EPOCH}.$$.$RANDOM"
  typeset -g __HISTJSON_FILE="${__HISTJSON_DIR}/hist.${__HISTJSON_SESSION_ID}.jsonl"

  integer __HISTJSON_FD=-1
  # Prefer sysopen (lets us set CLOEXEC). If sysopen missing, fall back to exec redirection.
  if sysopen -a -w -m 0600 -o cloexec -- "$__HISTJSON_FILE" 2>/dev/null; then
    __HISTJSON_FD=$REPLY
  else
    exec {__HISTJSON_FD}>>"$__HISTJSON_FILE" 2>/dev/null || true
  fi

  typeset -g __HISTJSON_ENABLED=0
  (( __HISTJSON_FD >= 0 )) && __HISTJSON_ENABLED=1

  # Global state
  typeset -g  __HISTJSON_SEQ=0
  typeset -g  __HISTJSON_CUR_ID=""
  typeset -ga __HISTJSON_JOBS_BEFORE=()
  typeset -gA __HISTJSON_START_EPOCH_BY_ID=()   # id -> start epoch
  typeset -gA __HISTJSON_ID_BY_JOB=()           # jobnum -> id

  # Reentrancy guard for writes (TRAPCHLD can fire at awkward times)
  typeset -g  __HISTJSON_WRITING=0
  typeset -ga __HISTJSON_QUEUE=()

  __histjson_now_epoch() { printf '%(%s)T' -1; }
  __histjson_now_ts()    { printf '%(%Y-%m-%dT%H:%M:%S%z)T' -1; }  # RFC3339-ish

  __histjson_escape() {
    emulate -L zsh
    local s="$1"
    s="${s//\\/\\\\}"
    s="${s//\"/\\\"}"
    s="${s//$'\n'/\\n}"
    s="${s//$'\r'/\\r}"
    s="${s//$'\t'/\\t}"
    s="${s//$'\b'/\\b}"
    s="${s//$'\f'/\\f}"
    print -r -- "$s"
  }

  __histjson_write_line() {
    emulate -L zsh
    (( __HISTJSON_ENABLED )) || return 0
    local line="$1"

    # If we re-enter (e.g. via TRAPCHLD), queue and return.
    if (( __HISTJSON_WRITING )); then
      __HISTJSON_QUEUE+=("$line")
      return 0
    fi

    __HISTJSON_WRITING=1

    # Prefer syswrite (zsh/system); fallback to print -u.
    if syswrite -u $__HISTJSON_FD -- "${line}"$'\n' 2>/dev/null; then
      :
    else
      builtin print -r -u $__HISTJSON_FD -- "$line" 2>/dev/null || true
    fi

    # Flush queued lines
    local queued
    for queued in "${__HISTJSON_QUEUE[@]}"; do
      if syswrite -u $__HISTJSON_FD -- "${queued}"$'\n' 2>/dev/null; then
        :
      else
        builtin print -r -u $__HISTJSON_FD -- "$queued" 2>/dev/null || true
      fi
    done
    __HISTJSON_QUEUE=()

    __HISTJSON_WRITING=0
    return 0
  }

  __histjson_log_start() {
    emulate -L zsh
    local _preserve_status=$?

    (( __HISTJSON_ENABLED )) || return $_preserve_status

    (( __HISTJSON_SEQ++ ))
    local epoch="$(__histjson_now_epoch)"
    local ts="$(__histjson_now_ts)"
    local id="${__HISTJSON_SESSION_ID}.${__HISTJSON_SEQ}"

    # preexec provides: $1 = history line (typed), $3 = full text executed
    local cmd_typed="$1"
    local cmd_exec="$3"

    __HISTJSON_CUR_ID="$id"
    __HISTJSON_START_EPOCH_BY_ID[$id]="$epoch"

    # Snapshot job table keys so precmd can detect newly-started background jobs
    __HISTJSON_JOBS_BEFORE=()
    if [[ -o monitor ]] && (( ${+jobstates} )); then
      __HISTJSON_JOBS_BEFORE=("${(k)jobstates}")
    fi

    local line="{\"type\":\"start\""
    line+=",\"id\":\"$(__histjson_escape "$id")\""
    line+=",\"ts\":\"$(__histjson_escape "$ts")\""
    line+=",\"epoch\":$epoch"
    line+=",\"host\":\"$(__histjson_escape "$__HISTJSON_HOST")\""
    line+=",\"user\":\"$(__histjson_escape "$__HISTJSON_USER")\""
    line+=",\"cwd\":\"$(__histjson_escape "$PWD")\""
    line+=",\"tty\":\"$(__histjson_escape "${TTY:-}")\""
    line+=",\"shell_pid\":$$"
    line+=",\"histno\":${HISTNO:-0}"
    line+=",\"cmd\":\"$(__histjson_escape "$cmd_typed")\""
    line+=",\"cmd_exec\":\"$(__histjson_escape "$cmd_exec")\""
    line+="}"

    __histjson_write_line "$line"
    return $_preserve_status
  }

  __histjson_log_end_foreground() {
    emulate -L zsh
    local _preserve_status=$?

    local id="$1"
    local status="$2"
    local epoch="$(__histjson_now_epoch)"
    local ts="$(__histjson_now_ts)"
    local start_epoch="${__HISTJSON_START_EPOCH_BY_ID[$id]:-$epoch}"
    local duration=$(( epoch - start_epoch ))

    local line="{\"type\":\"end\""
    line+=",\"id\":\"$(__histjson_escape "$id")\""
    line+=",\"ts\":\"$(__histjson_escape "$ts")\""
    line+=",\"epoch\":$epoch"
    line+=",\"status\":$status"
    line+=",\"duration_s\":$duration"
    line+="}"

    __histjson_write_line "$line"
    unset "__HISTJSON_START_EPOCH_BY_ID[$id]"
    return $_preserve_status
  }

  __histjson_log_end_background() {
    emulate -L zsh
    local _preserve_status=$?

    local id="$1"
    local job="$2"
    local status_json="$3"     # either a number or 'null'
    local status_str="$4"      # raw textual state (e.g. 'done', 'exit 1', 'killed ...')

    local epoch="$(__histjson_now_epoch)"
    local ts="$(__histjson_now_ts)"
    local start_epoch="${__HISTJSON_START_EPOCH_BY_ID[$id]:-$epoch}"
    local duration=$(( epoch - start_epoch ))

    local line="{\"type\":\"end\""
    line+=",\"id\":\"$(__histjson_escape "$id")\""
    line+=",\"ts\":\"$(__histjson_escape "$ts")\""
    line+=",\"epoch\":$epoch"
    line+=",\"bg\":true"
    line+=",\"job\":$job"
    line+=",\"status\":$status_json"
    line+=",\"status_str\":\"$(__histjson_escape "$status_str")\""
    line+=",\"duration_s\":$duration"
    line+="}"

    __histjson_write_line "$line"
    unset "__HISTJSON_START_EPOCH_BY_ID[$id]"
    return $_preserve_status
  }

  __histjson_process_done_jobs() {
    emulate -L zsh
    local _preserve_status=$?

    (( __HISTJSON_ENABLED )) || return $_preserve_status
    [[ -o monitor ]] || return $_preserve_status
    (( ${+jobstates} )) || return $_preserve_status

    local job id js job_state rest last_seg proc_state status_json status_str

    # Iterate only jobs we are tracking (so we don't touch unrelated jobs)
    for job in ${(k)__HISTJSON_ID_BY_JOB}; do
      js="${jobstates[$job]}"
      [[ -n $js ]] || continue

      job_state="${js%%:*}"
      [[ $job_state == done ]] || continue

      id="${__HISTJSON_ID_BY_JOB[$job]}"
      unset "__HISTJSON_ID_BY_JOB[$job]"

      # jobstates format: job-state:mark:pid=state:pid=state... (state may contain spaces)
      # We take the *last* pid=state segment, which corresponds to the last process in the pipeline in practice.
      rest="${js#*:*:}"       # strip "job-state:mark:"
      last_seg="${rest##*:}"  # last "pid=state..."
      proc_state="${last_seg#*=}"  # "done" | "exit 1" | etc.

      status_str="$proc_state"
      status_json="null"
      if [[ $proc_state == done ]]; then
        status_json="0"
      elif [[ $proc_state == exit\ * ]]; then
        # extract number after "exit "
        status_json="${proc_state#exit }"
        [[ $status_json == <-> ]] || status_json="null"
      fi

      __histjson_log_end_background "$id" "$job" "$status_json" "$status_str"
    done

    return $_preserve_status
  }

  __histjson_precmd() {
    emulate -L zsh
    local last_status=$?   # exit status of just-finished *foreground* command line

    (( __HISTJSON_ENABLED )) || return $last_status

    local id="$__HISTJSON_CUR_ID"
    [[ -n $id ]] || { __histjson_process_done_jobs; return $last_status; }

    # Detect newly started background jobs for THIS command by diffing job table keys.
    local -a new_jobs=()
    if [[ -o monitor ]] && (( ${+jobstates} )); then
      local -A before_set
      local j
      for j in "${__HISTJSON_JOBS_BEFORE[@]}"; do
        before_set[$j]=1
      done
      for j in ${(k)jobstates}; do
        [[ -n ${before_set[$j]} ]] || new_jobs+=("$j")
      done
    fi

    if (( ${#new_jobs} > 0 )); then
      # Async command: end record will be written when job completes (TRAPCHLD).
      local j
      for j in "${new_jobs[@]}"; do
        __HISTJSON_ID_BY_JOB[$j]="$id"
      done
      __HISTJSON_CUR_ID=""
      __histjson_process_done_jobs
      return $last_status
    fi

    # Foreground command: write end record now.
    __HISTJSON_CUR_ID=""
    __histjson_process_done_jobs
    __histjson_log_end_foreground "$id" "$last_status"
    return $last_status
  }

  # Hook up
  add-zsh-hook preexec __histjson_log_start
  add-zsh-hook precmd  __histjson_precmd

  # Background job completion -> CHLD trap (when MONITOR/job control is enabled).
  TRAPCHLD() {
    emulate -L zsh
    local _preserve_status=$?
    __histjson_process_done_jobs
    return $_preserve_status
  }

  # Optional session-start record (useful for ingestion/debugging)
  __histjson_write_line \
    "{\"type\":\"session_start\",\"session\":\"$(__histjson_escape "$__HISTJSON_SESSION_ID")\",\"ts\":\"$(__histjson_escape "$(__histjson_now_ts)")\",\"epoch\":$(__histjson_now_epoch),\"host\":\"$(__histjson_escape "$__HISTJSON_HOST")\",\"user\":\"$(__histjson_escape "$__HISTJSON_USER")\",\"shell_pid\":$$,\"file\":\"$(__histjson_escape "$__HISTJSON_FILE")\"}"
fi

What you’ll get

• One file per zsh session, e.g.:

  • ${XDG_STATE_HOME:-~/.local/state}/zsh-history-archive/hist.<host>.<user>.<epoch>.<pid>.<rand>.jsonl

• Each line is one JSON object (JSONL), with heterogeneous record types:

  • session_start

  • start

  • end

This JSONL design makes it easy to append fields later without breaking parsers.

Review of the implementation

Meets your requirements

• Timestamps in standard zsh history: setopt EXTENDED_HISTORY makes ~/.zsh_history include time metadata. (This is independent of the JSON archive.)

• JSON archive with heterogeneous record types: done (JSONL with type field).

• No locking / no corruption for long records: each shell writes to its own file, so there are no concurrent writers and thus no interleaving/corruption risk from multi-process appends.

• Logs “before” execution via preexec (captures the history line the user typed, plus the full executed text). Zsh

• Logs “after” execution:

  • Foreground: in precmd using $? of the last command.

  • Background: uses TRAPCHLD + jobstates to detect completion; this correctly supports out-of-order job completion. Zsh+1

Why it’s background-safe and order-safe

• When you run cmd &, zsh assigns it a job number. The code snapshots job numbers before execution (in preexec) and compares after execution (in precmd) to discover which jobs were newly created by that command.

• Completions are detected by observing those tracked jobs transition to done in jobstates. Zsh

• TRAPCHLD is triggered for background job completion when job control (MONITOR) is active, which is the normal interactive default. Zsh
  That means jobs finishing in a different order naturally produce end records in that completion order, each matched back to the original command id.

Important design choice: no wait inside the trap

You might be tempted to call wait %job to get a numeric exit status; wait does return the job’s exit status. Zsh
But doing so can interfere with normal job control/notifications (and can change what the user sees/what remains in the job table). So this implementation does not wait. Instead, it parses the per-process state string from jobstates and logs:

• status: 0 for done, or a number for exit N, otherwise null

• status_str: always logs the raw textual state (so you can extend parsing later)

This preserves normal interactive behavior and still gives you structured data for ingestion later.

Performance characteristics

• Fast path (foreground): two writes (start/end) of a single JSON line each.

• Background: start write immediately; end write later when the job completes.

• No per-command external processes are spawned.

• Uses sysopen/syswrite where available (zsh/system module) for efficient IO. Zsh+1

Known limitations (practical)

• Requires job control (MONITOR) for background completion tracking. If you deliberately run interactive zsh with unsetopt monitor, then you should expect background completion tracking to be incomplete, because the shell’s “background job completion triggers CHLD trap” behavior is documented under monitor mode. Zsh

• Disowned jobs (&!) / daemonized processes: if a job is disowned/fully detached from the job table immediately, you won’t get a reliable completion event via job control. (You can still log the start record.)

• Complex command lines that start multiple jobs in one line (rare): the code will map all “new jobs” to the same command id. If you care, you can later extend it to create per-job sub-ids (still JSON-friendly), but I didn’t add that complexity here.

If you want, I can also provide a tiny “ingestion prep” script that merges all per-session JSONL files (across machines) into one canonical stream (still JSONL), with optional compression/rotation—but the zsh side above already meets your stated constraints.