claude code plugin · mit · open source

Long sessions. Lean context.
Nothing rewritten.

fast-jev-plus replaces Claude Code's lossy compaction summary with verbatim pruning. Stale tool calls and results are removed; every message that stays is kept word for word.

claude plugin marketplace add gaaurav03/Jev-Project

claude plugin install fast-jev-plus@fast-jev-plus

quick start → view on github ↗

verbatim kept messages are never rewritten 2 modes jev model or offline local rules safe fallback built-in summary when savings are small open data live, anonymous usage metrics

recorded runs & benchmarksconnecting to run history…

estimated tokens saved

—

Estimated from transcript characters

average reduction

—

Across runs with recorded metrics

critical retention

—

Labelled benchmark information kept

task pass rate

—

Deterministic benchmark verification

01 / how it works

Delete what's stale. Keep the rest exactly.

Summaries are lossy: a file path, exact error, or constraint can vanish when it matters later. This plugin never rewrites. It only removes tool calls and results that are no longer needed.

01
Trigger

/compact, or automatically when context reaches 60%.
02
Redact

Secrets and PII are stripped from the outbound copy. Your transcript is untouched.
03
Score

jev asks the Jev model about every call in one fast request, or local applies offline rules.
04
Decide

Each call is kept, has its result truncated, or is removed with its result. Recent messages are pinned.
05
Apply or fall back

Enough savings: the pruned, verbatim history replaces the summary. Otherwise: Claude's built-in summary.

kept verbatimnever rewritten

Every user and assistant text message, in order
The first message and the newest messages (pinned)
Tool calls and results still needed for the task
In local mode: errors, edits, and anything uncertain

removed or truncatedre-runnable if needed

Tool calls that no longer matter, with their results
Stale results, cut to their first 300 characters plus a note
In local mode: old, successful duplicate file reads
Nothing at all when savings fall below the minimum

02 / features

Built to be trusted with your context.

core

Verbatim pruning

Deletes whole tool calls or truncates results. Kept messages are the original objects, unchanged.

jev mode

One fast request

The Jev model scores every call and result against the whole conversation, with a 30-second timeout.

local mode

Offline, no API key

Deterministic rules with zero network requests. Conservative by design: only old duplicate reads go.

security

Outbound redaction

Bearer tokens, API keys, passwords, private keys, emails, and phone numbers are removed before anything is sent.

safety

Safe fallback

Errors, timeouts, or savings below the minimum hand off to Claude's built-in summary. Compaction never breaks.

metrics

Per-run metrics

Tokens before and after, reduction, latency, requests, and provider usage when reported. Nothing invented.

quality

Retention benchmark

npm run bench checks that labelled critical calls survive and that tasks still pass, in both modes.

history

Local run history

Every run is appended to .jev/runs.jsonl with decisions, never prompts or tool output.

dashboard

Private dashboard

npm run dashboard serves this page on 127.0.0.1 with per-run decision details.

03 / quick start

Running in two minutes.

Function hooks are an early-access Claude Code feature (2.1.274+), so enable them first.

Enable function hooks

Add this to ~/.claude/settings.json. The API key is only needed for Jev mode.

{
  "env": {
    "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS": "1",
    "TYPESAFE_API_KEY": "<your key, jev mode only>"
  }
}

Install the plugin

From a terminal, or as slash commands inside Claude Code.

claude plugin marketplace add gaaurav03/Jev-Project
claude plugin install fast-jev-plus@fast-jev-plus

Pick a mode

Open /config and set mode to jev (more savings, needs a key) or local (offline, most conservative). Restart Claude Code.

Compact

Run /compact, or let it trigger at 60% context. The toast reports the result:

kept 20/140 messages, no summary (98% reduction; 60 call_dropped …)

Measure it yourself (optional)

From a clone of the repository:

npm install
npm run bench -- --mode both   # retention + reduction
npm run dashboard              # private dashboard on 127.0.0.1

04 / in claude code

See it where you work.

Claude Code plugin manager showing the plugin installed and enabled with a green check. — Installed from the repository's marketplace, next to Claude Code's built-in plugins.

Claude Code terminal after /compact: the plugin logs its decisions and a toast reports a fallback to the built-in summary because a 10% reduction was below the minimum. — When a session is too short to save much, it says so and falls back to Claude's own summary instead of forcing a weak result.

05 / live telemetry

Signal, not guesswork.

Reduction and latency come directly from recorded runs. Missing values stay visibly unavailable.

run-trends.svg loading trend data…

mode-comparison.json jev · local

JEV— runs

avg reduction: —
avg latency: —
tokens saved: —

LOCAL— runs

avg reduction: —
avg latency: —
tokens saved: —

API requests—

known cost—

input tokens—

output tokens—

06 / run history

Every run leaves a signal.

runs.jsonl loading records…

time	mode	before / after	reduction	critical	requests	latency	cost	status
Loading run history…

07 / benchmarks

Retention before reduction.

Four labelled cases, run in both modes. Each case marks the calls and results that must survive, then runs a deterministic check that the task still passes.

npm run bench -- --mode both recorded 2026-09-30

case	jev reduction	jev critical kept	local reduction	local critical kept	task
obsolete-read	40.3%	100%	40.3%	100%	pass · pass
required-error	69.6%	0%	0.0%	100%	pass · pass
repeated-test	42.4%	100%	0.0%	100%	pass · pass
protected-constraint	64.7%	0%	0.0%	100%	pass · pass
total	52.1%	50%	12.7%	100%	4/4 · 4/4

jev saves about four times more context, but in two of four cases it removed information the benchmark marks as critical. local saves less and kept everything critical. Choose local when exact errors and constraints must survive; the assistant can always re-run a removed tool.

live critical-information retentionNo benchmark data yet

Across benchmark runs uploaded to this dashboard.

live deterministic task pass rateNo benchmark data yet

Reviewed verification commands passed.

08 / compare

How it differs.

Claude Code's built-in compaction asks a model to summarize old turns. fast-jev-plus keeps the original messages and only removes what is stale.

capability	claude built-in /compact	fast-jev-plus
How history shrinks	LLM-written summary	verbatim pruning via Jev or local rules
Exact paths, errors, commands	can be lost in the summary	kept unless pruned
Works without an extra API key	yes	yes, local mode
Secrets redacted before sending	n/a	yes
Falls back when savings are small	n/a	yes, to the built-in summary
Per-run metrics and history	no	yes
Retention benchmark	no	yes
Dashboard and public metrics	no	yes

09 / privacy

Privacy by design.

Community totals come from anonymous, opt-out telemetry. The first compaction only shows a notice; nothing is sent until the next one.

sent per compaction

A random install ID, not tied to you or your machine
Plugin version, mode, and applied or fallback
Estimated tokens before and after, and latency

never sent

Prompts, messages, code, or tool output
File names, paths, or tool names
API keys, run IDs, or IP addresses

Opt out with JEV_TELEMETRY=0, DO_NOT_TRACK=1, or the plugin's telemetry option in /config. Benchmark runs are never sent.

This page shows constrained metrics only. Token figures are estimates; API usage and cost stay unknown unless the provider reports them.