Fix Bash History Not Saving All Commands in Linux

You run commands all day, reboot or open a new terminal, and the up arrow shows nothing useful—or yesterday's work never made it into ~/.bash_history. That is a common Bash configuration problem, not a sign that Linux forgot your account.

Commands appear in the current terminal but not in ~/.bash_history.
Commands executed in one terminal are missing from another terminal.
Commands disappear after closing several SSH or terminal sessions.
Some commands are stored while others are silently skipped.

Bash normally keeps each terminal's history in memory and writes it to ~/.bash_history when that shell exits. With multiple terminals, commands may not be shared immediately and can be lost when sessions end abruptly or overwrite the same history file. Enable histappend and append/read history at every prompt to synchronize sessions.

The fixes below were verified with Bash 5.2 on Rocky Linux 10. The same settings apply on other distributions that use Bash as the default interactive shell.

Tested on: Rocky Linux 10.2; Bash 5.2.26.

Quick reference

Use this section to match what you see with the right fix. Each row links to the chapter that explains the cause and the full steps.

Bash keeps two copies of your command history:

• history — commands in the current terminal's memory
• ~/.bash_history — commands saved on disk

They are not always the same. A command can appear when you press the up arrow but still be missing from the file until Bash flushes memory to disk.

Category 1 — history works, but ~/.bash_history is empty or behind

Category 2 — commands missing across multiple open terminals

Category 3 — history gone after reboot, crash, or forced close

Category 4 — some commands never appear in history at all

Category 5 — permissions, sudo, or wrong account

Category 6 — IDE, script, or non-Bash shell

Permanent fix at a glance

Add this to ~/.bashrc after /etc/bashrc is sourced, then run source ~/.bashrc in every open terminal:

Full copy-paste block and Rocky Linux 10 PROMPT_COMMAND array handling: Fix history lost across multiple terminals.

Test commands (silent success is normal)

How Bash command history is stored

Bash history has three layers:

The diagram shows how commands sit in the current shell's memory first. They reach ~/.bash_history when the shell exits or when you run history -a.

A command can appear in history without yet appearing in ~/.bash_history if the shell has not flushed memory to disk.

Bash may keep additional lines in the file when necessary to avoid cutting a multi-line history entry in half.

On the tested Rocky Linux 10.2 host, /etc/profile sets HISTSIZE=1000 and HISTCONTROL=ignoredups, while /etc/bashrc enables histappend for interactive shells. That helps at shell exit, but it does not synchronize history while multiple terminals stay open.

Confirm the defaults on your own distribution:

grep -nE 'HISTSIZE|HISTFILESIZE|HISTCONTROL|histappend|history -a' /etc/profile /etc/bashrc /etc/bash.bashrc /etc/profile.d/*.sh 2>/dev/null

Sample output on Rocky Linux 10.2:

/etc/bashrc:40:    shopt -s histappend
/etc/profile:50:    HISTSIZE=1000
/etc/profile:56:    export HISTCONTROL=ignoredups

Including /etc/bash.bashrc makes the same search useful on Debian and Ubuntu hosts.

Diagnose why Bash history commands are missing

Run the checks below in the same interactive shell where history is failing—an IDE panel, SSH session, or local terminal.

Start by comparing memory and disk: history | tail shows what this shell remembers, while tail "$HISTFILE" (or the existence check below) shows what has been saved. They often differ until you run history -a or exit the shell.

Confirm the shell is Bash and note its version:

echo "$BASH_VERSION"

5.2.26(1)-release

A version string confirms you are troubleshooting Bash history, not Zsh or another shell.

See which file this shell will write to on flush or exit:

echo "$HISTFILE"

/root/.bash_history

An empty line here means persistent history is disabled for this session.

Check how many commands Bash keeps in memory and on disk:

echo "$HISTSIZE"

1000

Check the on-disk history limit with declare, not only echo:

declare -p HISTFILESIZE 2>/dev/null || echo "HISTFILESIZE is unset"

HISTFILESIZE is unset

Bash normally initializes HISTFILESIZE from HISTSIZE after reading startup files. If HISTFILESIZE is later unset or assigned an empty, non-numeric, or negative value, Bash does not truncate the history file. It also does not dynamically fall back to HISTSIZE again after that invalid assignment.

See whether duplicate or leading-space commands are filtered:

echo "$HISTCONTROL"

ignoredups

ignoredups drops consecutive identical commands. It does not hide leading-space commands unless the value is ignorespace or ignoreboth.

List custom ignore patterns, if any:

echo "$HISTIGNORE"

No output means HISTIGNORE is unset and not excluding commands by pattern.

Confirm that command-history recording is enabled:

set -o | grep '^history'

history        	on

history on means the shell maintains the command-history list. history off would explain an empty in-memory list. History expansion (!!, !$, and similar) is controlled separately by the histexpand option.

Recheck append mode in this session:

shopt -p histappend

shopt -s histappend

See whether a prompt hook already synchronizes history between terminals:

declare -p PROMPT_COMMAND 2>/dev/null

On Rocky Linux 10, an empty array is common until you add the sync hook:

declare -a PROMPT_COMMAND

Inspect the history file on disk when it exists:

if [[ -z "${HISTFILE:-}" ]]; then
  echo "HISTFILE is unset or empty"
else
  ls -l "$HISTFILE"
fi

-rw-------. 1 root root 0 Jul  7 07:00 /root/.bash_history

A zero-byte file with commands visible in history means nothing has been flushed to disk yet. No such file or directory means Bash has not created the file yet.

Check whether Bash can write the history file:

if [[ -z "${HISTFILE:-}" ]]; then
  echo "HISTFILE is unset or empty"
elif [[ ! -e "$HISTFILE" ]]; then
  echo "History file does not exist yet"
elif [[ -w "$HISTFILE" ]]; then
  echo "History file is writable"
else
  echo "History file is not writable"
fi

History file is writable

A failed check is not always a permission problem. Bash also skips persistent history when HISTFILE is unset, the file does not exist yet, the parent directory is missing, or the filesystem is read-only. Fix the reported condition before changing HISTSIZE or PROMPT_COMMAND.

Bash does not save persistent history when HISTFILE is unset or the target file is not writable. Non-interactive shells—scripts, some IDE terminals, and bash -c one-liners—do not behave like login or interactive SSH sessions.

Fix history lost across multiple terminals

Add the following block to ~/.bashrc after the line that sources /etc/bashrc. If you are unsure when each startup file runs, see .bashrc vs .bash_profile.

# Retain a larger Bash history
HISTSIZE=10000
HISTFILESIZE=20000

# Append this shell's history instead of replacing the history file
shopt -s histappend

# Share history between concurrent interactive shells
__golinuxcloud_hist_sync() {
  history -a
  history -n
}

if declare -p PROMPT_COMMAND 2>/dev/null | grep -q 'declare -a'; then
  if [[ "${PROMPT_COMMAND[*]}" != *'__golinuxcloud_hist_sync'* ]]; then
    PROMPT_COMMAND+=(__golinuxcloud_hist_sync)
  fi
else
  case "${PROMPT_COMMAND:-}" in
    *__golinuxcloud_hist_sync*) ;;
    *) PROMPT_COMMAND="${PROMPT_COMMAND:+${PROMPT_COMMAND%;};}__golinuxcloud_hist_sync" ;;
  esac
fi

The PROMPT_COMMAND hook runs before each prompt, so every command is flushed soon after you press Enter. The array branch preserves Rocky Linux's existing PROMPT_COMMAND array from /etc/bashrc. The case branch covers distributions that still use a string PROMPT_COMMAND. The duplicate guard prevents adding the hook twice when you source ~/.bashrc again.

Reload the file in each open terminal so the new variables and hook take effect:

source ~/.bashrc

The command returns to a prompt with no message when sourcing succeeds. Open two terminals, run unique markers such as echo "terminal-a-$(date +%s)" and echo "terminal-b-$(date +%s)", press Enter once in each terminal, then search with history | grep terminal- in the other window. Both markers should appear without closing either session.

Fix commands filtered by HISTCONTROL or HISTIGNORE

Some commands never reach history because Bash filters them before they are stored. Check both variables before you change retention settings.

Check HISTCONTROL

On the tested Rocky Linux 10.2 host, /etc/profile sets HISTCONTROL=ignoredups unless the variable was already ignorespace, in which case it becomes ignoreboth.

Display the active filtering mode before you change it:

echo "$HISTCONTROL"

ignoredups

Run the same command twice to see duplicate suppression:

echo histcontrol-dup-test

Run it again immediately:

echo histcontrol-dup-test

Inspect the last few history lines:

history | tail -3

Only one echo histcontrol-dup-test line is stored when ignoredups is active.

Test leading-space exclusion only when ignorespace or ignoreboth is set—the extra space before echo matters:

echo histcontrol-hidden-test

Search for that marker:

history | grep histcontrol-hidden-test

With Rocky's default ignoredups, the leading-space command is still recorded. With ignoreboth, grep finds no match.

Check HISTIGNORE

HISTIGNORE uses colon-separated shell patterns, not regular expressions. See whether it is set in the current shell:

declare -p HISTIGNORE 2>/dev/null

No output means the variable is unset. A broad pattern silently drops common commands:

HISTIGNORE='ls*:cd*:history*'

That example would stop ls, cd, and history from being saved.

Search startup files for overrides that load before your ~/.bashrc changes:

grep -RnsE 'HISTCONTROL|HISTIGNORE|HISTFILE|HISTSIZE|PROMPT_COMMAND' ~/.bashrc ~/.bash_profile ~/.bashrc.d /etc/bashrc /etc/profile /etc/bash.bashrc /etc/profile.d 2>/dev/null

Sample output on Rocky Linux 10.2:

/etc/bashrc:40:    shopt -s histappend
/etc/profile:50:    HISTSIZE=1000
/etc/profile:56:    export HISTCONTROL=ignoredups

Comment out or narrow any HISTIGNORE line that excludes commands you still expect in history.

If you need every entered command retained, remove or unset HISTCONTROL and clear HISTIGNORE in ~/.bashrc after the /etc/profile sourcing chain runs. That also keeps password-like commands you type on the command line in plaintext history—avoid that on shared or compliance-sensitive hosts.

Fix .bash_history permission and ownership problems

Before changing ownership, confirm that HISTFILE is set and inspect the target path:

if [[ -z "${HISTFILE:-}" ]]; then
  echo "HISTFILE is unset or empty"
else
  ls -l "$HISTFILE"
fi

-rw-------. 1 root root 412 Jul 15 12:05 /root/.bash_history

Mode 600 and ownership by your user are correct. A root owner on a normal user's home file often follows an incorrectly configured privileged shell, a command that wrote to the file through sudo, a restored home directory, or manual file manipulation. A one-command invocation such as sudo dnf update does not by itself change ownership of the calling user's history file.

Walk the path to catch a non-writable home directory or intermediate mount:

namei -l ~/.bash_history

Each directory in the path needs execute permission for your user, and the file needs write permission.

Common breakages include:

• A root shell inherited the normal user's HOME or HISTFILE, or the file was created, copied, restored, or redirected using elevated privileges
• Home directory not writable, preventing updates
• Read-only filesystem or full disk
• HISTFILE pointing to a missing directory
• HISTFILE unset, empty, or set to /dev/null

Restore ownership and permissions when the file belongs to the wrong user. A normal user cannot repair a root-owned file without privilege, and the primary group is not guaranteed to share the username:

sudo chown "$(id -u):$(id -g)" "$HISTFILE"

chmod 600 "$HISTFILE"

Both commands exit silently on success when you have the required permissions. Run ls -l "$HISTFILE" again to confirm the owner and mode.

Do not delete ~/.bash_history as the first troubleshooting step—you lose whatever was already saved.

Privilege, shell type, and abrupt termination

Some history problems are not caused by HISTSIZE or histappend at all. The sections below cover the wrong account, the wrong shell, and sessions that never flush history cleanly.

Why history differs for root, sudo, and other shells

Identify the shell process that is running your current session and the environment it is using. The sudo command reference explains how privileged shells differ from a normal sudo command line.

printf 'Current process: '
ps -p $$ -o comm=

Current process: bash

printf 'Configured login shell: %s\n' "$SHELL"
printf 'HOME=%s\nHISTFILE=%s\n' "$HOME" "${HISTFILE:-<unset>}"

Configured login shell: /bin/bash
HOME=/root
HISTFILE=/root/.bash_history

echo "$SHELL" does not reliably identify the shell currently executing commands. Bash normally initializes $SHELL from the account's configured login shell, so you can be running Zsh, a nested Bash, or another shell while $SHELL still shows the login-shell path. Use ps -p $$ -o comm= for the active process.

Check HOME and HISTFILE for the account shown in your prompt—not only the file in your personal home directory.

Why history disappears after forced termination

Bash flushes history most reliably on normal exit or end-of-file on an interactive shell. History can be lost when:

• An SSH client disconnects abruptly
• A terminal emulator crashes
• The shell receives kill -9
• The system reboots or loses power before open shells exit
• A long-running shell is replaced with exec without flushing
• Containers or ephemeral home directories are destroyed

Prompt-time history -a writes after each command, which greatly reduces loss but still cannot guarantee recovery from every failure mode.

Verify the permanent history synchronization

Use unique markers during verification so you can tell terminals apart:

echo "terminal-a-$(date +%s)"

echo "terminal-b-$(date +%s)"

After the next prompt in each terminal, confirm both markers reached the shared file when it exists:

if [[ -e "${HISTFILE:-$HOME/.bash_history}" ]]; then
  grep terminal- "${HISTFILE:-$HOME/.bash_history}"
else
  echo "The history file has not been created yet"
fi

You should see one line per marker. If a marker is missing, the shell that ran it has not flushed history yet or HISTCONTROL filtered the command.

Bash history is not an audit log

Users can disable history, change HISTFILE, edit ~/.bash_history, run leading-space commands, or kill shells before flush. Built-in Bash history is a convenience feature, not tamper-resistant evidence.

For security or compliance requirements, evaluate dedicated mechanisms:

• auditd for syscall-level auditing (not a complete record of every shell builtin)
• tlog for terminal session recording
• Sudo I/O logging for privileged commands
• Centralized session recording or privileged-access management
• Login and session records such as those described in Linux login history

Pick tooling that matches your retention, search, and integrity requirements instead of relying on .bash_history alone.

Troubleshoot Bash history problems

Summary

Work through Bash history problems in this order:

1. Confirm you are in interactive Bash (echo $BASH_VERSION, echo $-).
2. Compare history | tail with tail ~/.bash_history.
3. Check HISTFILE, sizes, ownership, and permissions with declare -p HISTFILESIZE and ls -l "$HISTFILE".
4. Inspect HISTCONTROL and HISTIGNORE in profile scripts.
5. Enable histappend and larger HISTSIZE / HISTFILESIZE values.
6. Add prompt-time history -a and history -n for multiple terminals.
7. Preserve existing PROMPT_COMMAND hooks—use the array-safe block on Rocky Linux 10.
8. Use proper auditing tools when command recording must be tamper-resistant.

References

• Bash manual — Bash History Facilities
• Bash manual — The history builtin
• Red Hat — How to save command history immediately after you type it in bash
• Red Hat — Shell history cannot be shared between terminals
• Red Hat — How to manage your Linux command history