yummy-pi-extensions

How we reviewed this: we ran the package’s own checks in node:24 — 46 tests, typecheck and build — then drove the shipped prefilter and policy directly against the built artifact with our own inputs. We made no Jev calls; the routing path needs none, because the questions and the policy are separable from the client.

What it is

One of three extensions in yummy-pi-extensions, and the only one that touches Jev. Before a prompt enters your pi session, it asks whether that prompt should continue here, be answered as a side chat, fork into a branch that keeps the history, or start a new session — then offers the move rather than making it.

(Nothing to do with philippdubach/pi-jev-router, which shares the name and routes models rather than sessions. Two different packages, both for pi.)

The cheapest question is the one you don’t ask

Before anything goes to a model, a prefilter decides whether the prompt needs judgment at all. We fed it our own inputs:

"merged"                          skip (tiny-steer)
"Try again"                       skip (tiny-steer)
"/compact"                        skip (command)
"!ls -la"                         skip (bash)
"~/projects/thing/src/main.rs"    skip (file-ref)
"[Image #1]"                      skip (tiny-steer)
"Base directory for this skill:"  skip (skill-load)
"Some queued text" (pasted)       skip (source:paste)
…same prompt while streaming      skip (streaming)
"Now refactor the parser to stream instead of buffering."   -> ask Jev
"What does ENOTEMPTY mean again?"                           -> ask Jev

The README says this settles about 45% of mid-session prompts on the author’s own transcripts. We can’t check that ratio against someone else’s typing, but the rules are the right rules, and each one names its reason in the result so a surprising skip is traceable.

Four questions, then a policy file

The request carries a route choice with four options and three booleans — on_topic, needs_history, one_off — and the file that defines them opens with the right instruction: “Wording is data: change it here, re-run the eval, never reach for prose.”

The decision is then made by policy.ts, where every threshold is a named constant. We exercised it:

what the answers say	route taken	rule	confidence
model says continue	continue	—	0.80
model says new_session, but on_topic 0.75	continue	on_topic	0.20
side_chat, but needs_history 0.85	fork	needs_history	0.90
new_session, but one_off 0.85	side_chat	one_off	0.90
new_session, nothing else fires	new_session	—	0.80

The second row is the detail worth pointing at. When a post-rule overrides the model’s own route back to continue, the confidence reported is the model’s probability for continue — 0.20 — rather than the rule’s certainty. It tells you the override went against the model’s preference instead of hiding that behind a confident-looking number.

The author’s own note on the eval is equally candid: on 13 hand-labelled pivot prompts, needs_history “did more work than the route choice”, because in both history-needing pivots the model’s top choice was new_session while needs_history sat at 0.75–0.89 — so the README says to “treat the choice as a prior”. Thirteen prompts is a small set and it says that too.

Engineering

46 tests pass, typecheck is clean, and tsdown produces a 19 KB bundle. The tests cover the prefilter (22 of them), the state builder, the policy with the eval numbers as fixtures, and the full input → dialog → /route-go flow against a fake client, with no network needed.

Three engines are supported — TypeSafe direct, OpenRouter and the Vercel gateway — and each honours a base-URL override (TYPESAFE_BASE_URL and friends), which is also how we pointed it somewhere of our own without patching anything. With no key configured at all, resolveClient returns undefined and the extension simply does not route.

Published to npm as @sugarforever/pi-jev-router 0.2.0, MIT, with the repository’s other two extensions — a throughput meter and a zvec-backed workspace search — carrying no Jev dependency at all.

What it sends

The state is the new prompt plus a bounded slice of recent session text, which is what the questions need to be answerable. That is your working conversation, so the usual rule applies: this is a tool that shows your prompts to a third party in order to decide where they belong. The prefilter is what keeps that volume down, and it is the first thing to read if the idea makes you uneasy.

Verdict

A small, well-argued extension with the two properties we keep looking for: it does not ask when it doesn’t need to, and the thresholds that turn answers into actions live in one reviewable file rather than scattered through the handler. It also offers the move instead of taking it, which is the correct default for something that reorganises your session.

If you use pi and your long sessions collect tangents, this is a sensible thing to try. Read questions.ts first — that wording is the product.

For the model-routing project with the same name, see pi-jev-router (Dubach); for compaction rather than routing, fast-jev-compaction.

See how it compares with other tools in Best Jev tools, tested hands-on.

Review updated Sep 21, 2026. Numbers quoted from the project are its author's own; we don't publish our own measurements of Jev.