Stop showing coding agents the same command output twice.

Dejavu is a PATH shim for Claude Code, Codex, Cursor agent, opencode, Aider, Gemini CLI, and other terminal-based coding agents. It always runs the real command, but when output is unchanged or nearly unchanged, it returns only a compact delta instead of flooding the agent context again.

• Works without prompting the agent
• Always preserves exit codes
• Full output is stored locally and recoverable
• Supports common commands like npm, pnpm, yarn, git, rg, grep, pytest, cargo, go, tsc, eslint, and docker logs
• Early benchmark: 52-55% less intercepted output in campaign 2, 87% less output in repeated local rerun loops

Why This Exists

Coding agents rerun commands constantly: tests, typechecks, git diff, search, logs, and build output. Most of those reruns are unchanged or only slightly changed, but the agent still rereads the full output. That wastes context and makes the next step harder to see.

Dejavu is the command-output memory layer for that loop. Your agent keeps running normal shell commands. Dejavu remembers what those command outputs looked like last time and only prints the useful part when they repeat.

How It Works

dejavu start <agent> launches the agent with a shim directory at the front of PATH.

agent runs:      pnpm test
PATH resolves:   <dejavu-cache>/shims/bin/pnpm
shim runs:       dejavu run --shim-name pnpm -- test
Dejavu runs:     the real pnpm found later in PATH
Dejavu stores:   redacted stdout, stderr, metadata, exit code
agent receives:  first output, unchanged notice, compact delta, or passthrough

The trust claim is simple: Dejavu never skips command execution. It only changes how repeated command output is displayed.

Installation

Install script (macOS, Linux, WSL):

curl -fsSL https://raw.githubusercontent.com/Salnika/dejavu/master/install.sh | sh

Homebrew:

brew tap Salnika/dejavu
brew install dejavu

npm / npx (the command is still dejavu):

npx @salnika/dejavu start codex   # no install
npm install -g @salnika/dejavu       # or install globally

Cargo:

Prebuilt binaries for each release are on the Releases page. From source:

git clone https://github.com/Salnika/dejavu
cd dejavu
cargo install --path .
dejavu doctor

More detail: docs/INSTALL.md. Maintainers: docs/RELEASING.md.

Quickstart

cd my-project
dejavu start codex

Use the same pattern for other terminal agents:

dejavu start claude
dejavu start aider
dejavu start opencode
dejavu start gemini

Inside that session, the agent keeps using ordinary commands:

pnpm test
git diff
rg "TODO"
cargo test
docker logs api

Bypass Dejavu for one command:

Retrieve full output:

dejavu show latest --stdout

Full command reference (every command and option): docs/CLI.md.

Global Activation (IDE terminals, GUI-launched agents)

dejavu start only covers agents you launch from a terminal. For agents that run inside an app you launch from the Dock — the VS Code integrated terminal, Copilot agent mode, IDE extensions — activate the shims globally:

dejavu shellenv --install     # writes the activation line into your shell profiles

This adds a small managed block to ~/.zshrc, ~/.bashrc, and ~/.profile (idempotent). Target one shell with --shell zsh|bash|sh, and undo it with dejavu shellenv --uninstall. Prefer to wire it up yourself? dejavu shellenv (no flag) just prints the line for eval "$(dejavu shellenv)".

Any shell that reads your profile then resolves npm, git, rg, … through Dejavu, with no DEJAVU_* variable needed: the repo context is rebuilt from the working directory, and shims self-identify to prevent recursion.

Global activation is agent-gated: output is reduced only when an agent is actually reading it.

• Pipe-capturing agents — Claude Code, the Codex CLI, Cursor's agent — set a marker (CLAUDECODE, CODEX_SANDBOX, CURSOR_AGENT) in the shell they drive and read command output through a pipe. They get reduced output whenever that marker is present (no terminal required — the agent is the pipe reader), exactly as under dejavu start.
• VS Code Copilot runs commands in a real pty and sets AI_AGENT / COPILOT_AGENT in its agent terminals only, so it gets reduced output when the marker is present and output goes to a terminal.
• Your own terminals, scripts, pipelines, $(git …), VS Code tasks and the SCM view always get the raw output.
• DEJAVU_FORCE=1 overrides the gate for custom setups.

Other notes:

• Outside an agent context, shims take a fast path: resolve the real binary and exec it — no repo detection, no database, nothing recorded. Your own terminal stays at native speed and its history stays out of the cache. DEJAVU=off still bypasses Dejavu entirely for one command.
• Agents that execute commands without a shell never read your profile and are not covered — check with dejavu doctor from their terminal.
• dejavu stats --all gives the cross-repo view of what global activation saves.

To deactivate: dejavu shellenv --uninstall.

Example Output

First run still shows bounded command output:

FAIL tests/session.test.ts
  expected 403, received 200

Tests: 1 failed, 142 passed
Full output: dejavu show 8c51f73 --stdout

Unchanged rerun:

dejavu: output unchanged since run 8c51f73.
Command: pnpm test
Exit code: 1

Same failing test:
- tests/session.test.ts expected 403, received 200

Suppressed ~4,820 estimated tokens.
Full output: dejavu show b92d1aa --stdout
Previous output: dejavu show 8c51f73 --stdout

Small delta:

dejavu: output changed since run b92d1aa.
Command: pnpm test
Exit code: 1

Changed lines:
- expected 403, received 200
+ expected 403, received 500

Suppressed ~4,610 estimated tokens.
Full output: dejavu show c7a91e2 --stdout

The command ran each time. Only the displayed output changed.

Safety Model

• Dejavu always executes the real underlying command.
• Dejavu does not cache execution results to skip work.
• Dejavu only compresses, deduplicates, or summarizes what is printed back.
• Dejavu preserves the real exit code.
• Dejavu stores full command output locally.
• Dejavu does not send logs to any server.
• Dejavu can be bypassed with DEJAVU=off or DEJAVU_DISABLED=1.
• Mutating or sensitive commands pass through unless Dejavu explicitly supports a safe read-only form.

Useful checks:

dejavu doctor
dejavu doctor --json
dejavu repos
dejavu show latest --stdout
dejavu uninstall

Full details: docs/SAFETY.md.

Supported Commands

Dejavu defaults to passthrough. It optimizes only command shapes it recognizes as safe.

Add any command you want intercepted via the config — it gets a shim and the generic reduction (dedup, deltas, bounded summaries, test-runner output sniffing), with the usual guards (watch modes pass through, execution is never skipped):

# ~/.config/dejavu/config.toml
[intercept]
extra = ["make", "terraform", "just"]

Examples of commands that pass through unchanged:

• git commit, git push, git reset, git checkout, git add, git rebase
• docker run, docker build, docker compose up, docker compose down
• npm publish, package installs, interactive init commands
• watch modes and interactive commands
• anything Dejavu cannot confidently classify

Benchmark Summary

The built-in suite (dejavu bench) drives the real classify + reduce pipeline over deterministic scenarios — anyone can reproduce these numbers locally, and CI fails if they regress (dejavu bench --check):

What each scenario simulates:

Real agent sessions (small, early measurement):

Do not read this as a claim about total token spend. In these measurements, Dejavu reduced intercepted command output by 52-55% in real sessions. The strongest effect appears in repeated rerun loops.

Details and reproduction notes: docs/BENCHMARK.md. The chart above is generated from real bench output by scripts/render-benchmark-chart.py.

Comparison With Adjacent Tools

Dejavu is complementary to output compressors. It is not a prompt, not an MCP the agent may ignore, and not a test runner. It is a command-output memory layer.

More detail: docs/COMPARISON.md.

Limitations

• Native Windows support is not implemented; use WSL for now.
• First runs still need to show useful output.
• Token counts are estimates, currently based on a configurable character heuristic.
• Raw output is stored locally after best-effort redaction. Treat the cache as sensitive.
• Some noisy tools need better parsers and normalizers.
• Long-running watch output and interactive commands are passthrough.

Contributing

Start with CONTRIBUTING.md.

High-value contributions:

• weird command output cases
• parser and normalizer improvements
• safety reports where Dejavu compacted something it should not have compacted
• benchmark reports from real agent sessions
• install smoke tests on macOS, Linux, and WSL

License

MIT. See LICENSE.