---
name: ericjuta-jevify
title: jevify
kind: skill
version: 0.5.1
description: >
  Use when asked to go through, check, triage or classify every item in a long
  list and say which ones stand out: every changed hunk or file in a commit or
  PR (which aren't explained by its message), every call site after a refactor
  (which still need changing), every log line, compiler diagnostic, review
  finding or test. Also on the word jevify. Judges each item with the eval
  kernel's judge_batch (Jev) against questions frozen up front, with %load-able
  jv helpers. Not for summaries, counts, single-file reviews or plain edits.
updated: 2026-11-10
authored_by: ericjuta
author_url: https://github.com/ericjuta
source_url: https://github.com/ericjuta/omp-jevify/tree/main/skills/jevify
brought_by: SD
license: MIT
---

# Jevify

Jev is an optional classifier, not evidence of correctness or permission to edit.
An explicit Jev request still needs a suitability decision; explain a better method
when deterministic tools or direct reading answer the actual question more reliably.

## Choose the method

- Prefer a compiler, search, AST rule or short script when a rule decides the answer.
- Prefer direct reading for small jobs or tightly cross-dependent reasoning.
- Consider Jev for repeated, independently judgeable semantic decisions with the
  necessary shared context. Repetition or list length alone is not a reason to use it.
- Loading this skill or its helper does not require a judge call. If choosing Jev,
  pilot before relying on results, including for read-only answers. A pilot may also
  show that a direct method is the better choice.

Optional Python helper, loaded in an `eval` cell of its own (combining `%load` with
other code in one cell fails):

```python
%load skill://jevify/jevify.py
```

Read [the on-demand reference](skill://jevify/reference.md) only for needed helper
APIs, extraction details or existing recipes; it is not a second mandatory workflow.

## Source-backed evidence preparation

For review comments, documentation promises, migrations, or issue/log intake, use
`jv.prepare_review`, `jv.prepare_documentation`, `jv.prepare_migration`, or
`jv.prepare_issue` with explicitly selected sources and bounded reference resolution.
Structured fields stay deterministic. For prose, `jv.extraction_request(plan)` returns
arguments for the `jevify_extract` tool, or `None` when extraction is unnecessary.
**Clairic defaults on** for these selected inputs; `--no-jevify-extract` opts out.
Selected private source leaves the machine for OpenRouter; exclude secrets. Credentials
come only from the host resolver. Transport currently requires Linux; deterministic
Python preparation remains available without a key or provider. Failure is unresolved
evidence, never an invented candidate. When a result path exists, adopt it with
`jv.adopt_evidence(plan, result_path)`; otherwise keep the deterministic plan and its
unresolved fields. An exact occurrence is not proof of a finding.

Use `jv.workflow_review(evidence, Q)` for ready-only per-question batches. Judge each
batch with its own `Q` and `extraction=batch["manifest"]`, then open the existing inbox
with that manifest, the bound rows, and `evidence=evidence`. Missing base versions,
contracts, wrappers, or related findings block dependent questions, not the scope
ledger. Open the supporting sources before confirming. An unresolved sibling question
prevents whole-record approval. Changed source/dependencies require explicit refresh;
imported snapshots cannot be deleted. Explicit external imports preserve attribution,
not authority. See the reference for the full workflow and interchange contract.

Live preparation experiments require separate approval of the frozen manifest digest
and spending cap; default-on extraction is not experiment approval. The controlled
runner compares Clairic plus deterministic preparation against the same deterministic
preparation without Clairic. Synthetic/injected demonstrations never establish gains.

## With the host notice

OMP 18.12.5's `jevify-notice` fires on the word "jevify" and directs bulk work to the
built-in `judge_batch()` for about 20 or more items; it never mentions `jv.*`. Its item
count is not a reason to use Jev: choose the method above first. If `judge_batch()`
already ran, bind its output with `jv.adopt(items, states, Q, batch=b)` (drained items
keep their served model; `batch=` adds batch ID, cost estimate and host counts), then
continue with `jv.flag`, `jv.pilot_check`, review and `jv.export`.

## If choosing Jev

1. Declare the question, source scope and unit boundaries. Define mutually exclusive
   labels, including uncertainty, against a concrete contract before judging data.
   Set escalation/action thresholds before the pilot; do not tune them to obtain
   desired outcomes. Scores and threshold estimates are not correctness guarantees.
   Default escalation: top choice probability below 0.7, unknown labels, and bool
   probabilities in 0.3–0.7; name additional flag labels in the rubric up front.
2. Check extraction coverage and context. Map independent source hits to units;
   matching totals alone do not prove coverage. Account for filters, dropped/empty
   states, truncation and oversize inputs. Include relevant helpers, siblings and
   consumers; sanitize logs and never submit credentials or keys.
   `jv.plan` checks full-request budgets; `jv.pack` groups without silent truncation.
   Bind source hashes and exclusions with `jv.extraction` before relying on coverage.
   Settle script-decidable fields with `jv.facts` (`requires=` warns when a unit lacks
   what a question asks about). Refuse elided reads (`jv.refuse_elided`,
   `jv.units_from_table`); pass the `jv.states` report to `jv.flag(rows, report=...)` so
   truncated or oversize units are flagged.
3. Pilot the chosen representation. Read flagged sources and near misses, compare
   verdicts with evidence, and repair misread wording or missing context. Rejudge the
   pilot after changes; abandon Jev if the judgments remain unsuitable. Run
   `jv.pilot_check(rows, Q, rule=...)` with the frozen rule: `use_direct` (flag rate,
   uncertainty band or catch-all share above about 40%) means stop and read directly or
   script it. `jv.remaining` reuses unchanged pilot verdicts in the sweep.
4. Freeze the rubric/questions and preserve their hash for full and after-action
   runs. A post-freeze wording change invalidates prior verdicts: re-freeze and
   rejudge the affected declared sweep, not just the flags.
5. When doing a sweep, judge every unit in the declared scope and reconcile every
   missing result, including originals dropped before grouping. A pilot is not
   complete coverage. Check the run's bound receipt as well as row flags; an empty
   flag list cannot prove completeness. Retain errors, fallback routes and unknowns
   as unresolved, never as safe labels; rerun or inspect their sources.
6. Persist the frozen questions/hash, source-to-unit mapping, rendered states and
   group slots, batch IDs, returned rows and receipt before discarding evidence.
   Use `bundle_path` for checkpointed `jv.run` recovery and `jv.resume` after a kernel
   loss. Recovery reconciles saved items and a surviving host batch; stale or missing
   batches remain unresolved unless resubmission is explicitly requested. This is
   not exactly-once execution; see the reference for crash and host-session limits.
7. A `jv.splice` of re-judged rows into an earlier run is never a full sweep; report it as
   spliced. Compare sweeps with `jv.gate`, which separates regressions from judge noise.

## Confirm before action

- Read every flagged source in full, not just a truncated render or score; confirm
  or overturn the claim from reachable behavior and the governing contract.
  Escalate uncertainty, near-threshold ambiguity, errors, explicit fallback rows
  and unknown provenance. Stock OMP (audited 18.8.7–18.9.1 and 18.12.5) exposes only a
  served `model` per item and model/cost in `status()`, no selected/primary, fallback or
  cache fields, so `provenance_unknown` stays true on every row. Cached repeats report the
  alias `~typesafe/jev-latest`, fresh answers a versioned model, so such rows are not
  `comparable`; a familiar model label is not a substitute for provenance.
- Record source-bound confirm, overturn or unresolved decisions in the review inbox
  (`jv.review_queue`, `jv.review_questions`, `jv.adjudicate`, `jv.review_status`), using a
  durable review path. `approved_units` lists units whose items are all confirmed and
  not stale; deletion additionally requires a `settled` review. The status always
  reports `grants_authority: false`.
  Stale approvals are reported under `stale`; decide them again rather than carrying them forward.
- Calibrate before bulk edits or destructive action; read-only calibration is
  optional. Model agreement is an estimate, not source confirmation or authority.
  Poor agreement calls for revisiting the pilot/context, not relaxing thresholds.
- Grouping is a separate instrument, not an interchangeable cheaper flat run.
  Pilot grouped judgments separately; calibrate them separately before bulk or
  destructive action. Do not mix grouped and flat rows in one decision.
- Act only on confirmed items within granted authority. Review authority is not
  deletion authority. For deletion, call `jv.delete_spans` with the manifest, the review
  path and `Q`, dry-run first, and inspect the printed spans. Preserve dirty/unrelated
  work, and use LSP references for exported-symbol refactors. Delegate exact confirmed
  IDs for edits rather than asking editors to rediscover candidates.
- After edits, re-extract and remap coverage, then rejudge with the same frozen
  questions. Unresolved flags/errors/unknowns or uncovered hits prevent a clean
  closure claim. Receipt completeness is independent of row flags and source
  coverage; a zero-unit extraction is not a model verdict.

## Report honestly

Report the chosen method and declared scope; extracted/covered, dropped/truncated,
piloted/judged and manually reviewed counts; errors, models/fallbacks, flags,
calibration if performed, receipt completeness, review status (pending, unresolved,
stale, settled) if an inbox was used, and changed/remaining items.
Separate judge estimates from source-confirmed conclusions. Say when the result is
pilot-tuned or sampled, not a full read; do not claim complete coverage or successful
action without evidence.