mrkeyoor.com_
Wed 07 Oct 06:43 UTC
LLM Toolsevaluationupdated 07 Oct 2026

jev-pruner review

jev-pruner is a Claude Code plugin that asks TypeSafe Jev which parts of very long Bash output still matter, then gives Claude the retained lines and archives the original locally. It also has a Codex plugin and skill, but Codex commands must be run through its wrapper because native post-tool hooks cannot replace shell output.

Verdict

Our jev-pruner run installed 53 packages, passed all 291 tests, and reported 0 audit findings, so the offline pruning logic is better tested than most agent add-ons. Use it for repeated, successful commands above 10,000 estimated tokens when TypeSafe may receive the output and conversation context. Skip it for secret-heavy work or if Codex wrapper discipline costs more attention than reading a saved log.

We ran it

Lab card: what happened when we ran jev-prunerScreenshot of jev-pruner (github.com/tamaratran/jev-pruner)
Install✓ · 11s53 packages · 64 MB
Build✓ · 4s
Tests✓ · 18s291 passed · 0 failed of 291 (vitest)
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo151 files~24,486 lines of source · 1.3 MB · 0 CI workflows · tests dir

Answers from our run

Does jev-pruner build from source?

Dependencies installed in 11 seconds (53 packages), and the build succeeded in 4 seconds. We cloned commit edbc602 into a clean Debian container with 3 CPUs and no project-specific setup.

Do jev-pruner's tests pass?

Yes: 291 of 291 passed when we ran the project's own test command (vitest). Some failures need services or credentials a bare container does not have.

Does jev-pruner have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use jev-pruner?

Work involving secrets or private source that cannot leave your environment: the README says its credential heuristic does not redact content or stop it from being sent to Jev.

What are the alternatives to jev-pruner?

fast-jev-compaction, OpenJev, Claude Code native output persistence. Our jev-pruner run installed 53 packages, passed all 291 tests, and reported 0 audit findings, so the offline pruning logic is better tested than most agent add-ons.

Setup3/5Build is quick; useful pruning needs keys, credits, and host setup
Docs5/5The README spells out gates, retention, privacy, and recovery
Community3/5160 stars with 3 open issues and 12 open pull requests
Maturity3/5291 tests passed, but no CI workflow and host limits remain

Who it’s for

Claude Code users whose successful builds, installs, tests, or searches regularly produce more than 10,000 estimated tokens.
Developers willing to send command output and conversation context to TypeSafe Jev for relevance scoring.
Teams that want omitted lines recoverable from a local archive instead of summarized into new prose.
Codex users prepared to invoke a dedicated skill for each noisy non-interactive command.

Who it’s NOT for

Work involving secrets or private source that cannot leave your environment: the README says its credential heuristic does not redact content or stop it from being sent to Jev.
Anyone expecting all noisy output to shrink: 10,000 estimated tokens or fewer, errors, structured documents, diffs, source code, and several whole-document commands pass through unchanged.
Codex users who want automatic coverage for every shell call: Codex requires the opt-in wrapper and buffers output until the command completes.
Teams that cannot add a paid service: pruning needs a TypeSafe API key and credits separate from Claude or Codex subscriptions.
Workflows that depend on live progress or interactive commands: the documented Codex wrapper is for non-interactive commands, and output above 8 MiB switches to unchanged streaming.

Setup reality

Our Node 22 sandbox installed commit edbc602 in 11 seconds, adding 53 packages and using 64 MB. The build passed in 4 seconds. Vitest finished in 18 seconds with 291 passed and 0 failed; npm audit found 0 known vulnerabilities.

Node 18 or newer is enough for the library, but useful pruning needs a TypeSafe API key, paid credits, and network access. Claude Code uses the plugin hook. Codex requires a built local plugin, a trusted hook, the explicit jev-pruner skill, and a wrapper around each eligible command.

The checkout had 151 files, about 24,486 source lines, a tests directory, 0 CI workflows, and no Dockerfile. Short output and protected formats bypass scoring. Jev failures preserve the original, while successful pruning writes a local archive unless the secret heuristic suppresses it.

Only output above 10,000 estimated tokens enters the scorer

A normal command never reaches Jev. The plugin first checks whether stdout exceeds 10,000 estimated tokens, then excludes failed commands, JSON, XML, YAML, diffs, binary data, source code, documentation, and several whole-document commands. Eligible text is split into at most 200 chunks. Jev answers one yes-or-no relevance question per chunk using the command, current task, and conversation history as context.

Retention is deliberately conservative. The first and last chunks stay, as do diagnostics, test totals, warnings, result lines, and artifact paths. A chunk also stays if any history segment gives it more than a 0.1 keep probability or if scoring coverage is incomplete. The plugin replaces dropped runs with line counts and leaves the kept text verbatim. This avoids a generated summary inventing a detail, but it also means ambiguous output often remains large.

What happened when we ran it

Our sandbox installed commit edbc602 in 11 seconds. npm added 53 packages and used 64 MB on disk. The TypeScript build completed in 4 seconds, and Vitest finished in 18 seconds with 291 passed and 0 failed. npm audit found 0 known vulnerabilities across critical, high, moderate, and low severities.

The unprivileged Node 22 container had 3 CPUs, 8 GB of RAM, and no secrets. It checked the offline repository, not a paid Jev request or a live Claude Code session. The 1.3 MB checkout contained 151 files and roughly 24,486 lines of source. We found a tests directory but 0 CI workflow files and no Dockerfile, so the extensive local suite is not backed by a visible GitHub Actions gate.

Claude Code intercepts Bash, while Codex needs a wrapper

Claude Code can let the plugin wrap Bash tool results before the main model sees them. It reads up to 4,096 main-conversation messages from the host, but not the system prompt or a subagent's transcript. When pruning succeeds, the complete result is archived under the project and a recovery path is appended. A later Read or Grep can retrieve a line the scorer dropped.

Codex CLI 0.152.1 cannot replace native shell output through PostToolUse, according to the README. Its integration therefore installs a plugin and skill, records a transcript pointer, and runs selected commands through a Node wrapper. You must invoke the skill for each command. The wrapper buffers stdout until completion and stops pruning above 8 MiB. Interactive tools, servers, live progress, and commands run outside the wrapper keep their normal behavior.

Jev receives conversation context and command output

Pruning is an external API operation. Jev receives eligible stdout plus partitioned conversation history, tool inputs, and tool results so it can judge relevance. A TypeSafe key and credits are required, separate from a Claude or Codex subscription. The plugin's secret check can prevent a local archive, but the README warns that this check does not redact data or prevent transmission to Jev.

That warning decides whether many teams can use the plugin at all. A build log may contain internal paths, package names, source excerpts, customer identifiers, or credentials the heuristic misses. Codex requests have a documented 30-second timeout and fail open to the original output. An open issue says the Claude path lacks the same explicit timeout. If policy forbids sending workspace context to another provider, the 291 passing offline tests do not change the answer.

Local archives make omissions recoverable

Before the first scoring request, the plugin saves complete output with private file permissions and adds a local ignore rule. The footer tells the agent where to recover it. Successful pruning does not destroy evidence, and a Jev error returns the unmodified host result. Credential-like commands are treated differently: their output is not archived, so a missing line may require rerunning the command.

The recovery design is more useful than a one-way summary, but storage still needs a policy. Archives persist until someone removes them. On a shared workstation or repository with regulated data, private file permissions and a gitignore are only two controls. Teams should decide retention and cleanup before rollout, especially if 64 MB of package dependencies becomes a plugin installed across many projects.

Open host-limit issues temper the strong test suite

GitHub showed 160 stars, 3 open issues, and 12 open pull requests on October 7, 2026. The last push was September 30, while repository activity continued into October. There is no tagged GitHub release. The package identifies itself as version 0.1.0, so installation points at a moving checkout rather than a published release trail.

One open report says persisted Claude Code output could exceed the scoring request budget and pass through unchanged. Another explains that the visible keepThreshold behaves differently above the hard 0.1 retention floor and notes the missing Claude timeout. These reports target the pruning path, not cosmetic edges. jev-pruner is worth trying on known noisy commands, but verify that omission markers appear before assuming it is saving context.

Alternatives

ProjectWhat it isPick it when
fast-jev-compaction gh↗A related Claude Code plugin that prunes old session material during compaction rather than trimming one Bash result.pick this instead when accumulated conversation history is the problem, not a single oversized command.
OpenJev gh↗An open Jev-compatible decision server that can run on your own hardware.pick this instead when you want to build a private scorer and accept the model hosting work.
Claude Code native output persistenceThe host's built-in behavior keeps a preview and stores oversized command output for later reads.pick this instead when local data handling matters more than saving context automatically.

What people are saying

  1. [velocity-scout] tamaratran/jev-pruner

Sources

  1. jev-pruner repository
  2. jev-pruner README
  3. Claude persisted-output issue
  4. Threshold and timeout issue

More llm tools reviews

minorun-marp-skill · jev-skill · llm-d-router · Rapid-MLX · simple-jev · kev · the whole board →