jev-agent-tools-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@jev-agent-tools-mcp review my completed changes and show the evidence"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
jev-agent-tools
Six evidence-oriented tools for pi, omp and any MCP client, compatible with the Jev API format. Use them to navigate unfamiliar code, ask typed questions about repository evidence, review completed changes and select existing tests. They complement reading, searching and execution; they do not replace them.

Watch the launch video (74 s, MP4).
New here? Start with the getting-started guide; the documentation index maps every audience to its docs.
Install
Install through your host's package manager, or register the MCP server with an MCP client. The npm package is jev-agent-tools. pi and omp load its TypeScript sources directly; the MCP server ships prebuilt.
pi
pi install npm:jev-agent-tools@0.4.0
# Project-local installation:
pi install -l npm:jev-agent-tools@0.4.0omp
omp plugin install jev-agent-tools@0.4.0Any MCP client
Since version 0.2.0, the package also ships jev-agent-tools-mcp, a stdio MCP server that exposes the same six tools to any MCP client: Claude Code, Claude Desktop, Kiro, Cursor, VS Code, Codex CLI and others. A typical mcpServers entry:
{
"mcpServers": {
"jev": {
"command": "npx",
"args": ["-y", "-p", "jev-agent-tools", "jev-agent-tools-mcp", "--root", "/path/to/repository"],
"env": {
"JEV_TOOLS_URL": "${JEV_TOOLS_URL}",
"JEV_TOOLS_API_KEY": "${JEV_TOOLS_API_KEY}"
}
}
}
}On Windows most clients start commands without a shell, so use "command": "cmd" with "/c", "npx" at the start of args. The MCP setup guide has per-client files, CLI commands, variable interpolation, verification and troubleshooting. Releases are also listed in the official MCP Registry as io.github.NomenAK/jev-agent-tools. Add the agent instructions to CLAUDE.md, AGENTS.md or a Kiro steering file so the agent uses and reads the tools correctly.
The server reads the same environment variables as pi and omp and the configuration saved by /jev-setup. One server process is one session. MCP has no automatic run-end documentation hook; its absence does not require manual replacement calls. jev_ask is marked as not read-only while commands are enabled; set JEV_TOOLS_ALLOW_COMMAND=0 to remove command from its schema.
Requirements and compatibility
Requires Node.js 24 or later. Supported host baselines are pi 0.87.1 and omp 18.4.10. These are support baselines, not claims that every later version has been individually validated. omp uses its Bun runtime; Node.js is also required for Node-based project checks. Git and, for optional command evidence, Bash must be available. On Windows, command evidence uses Git for Windows bash (found next to git on PATH or under Program Files); the WSL bash.exe launchers are never used. Set JEV_TOOLS_BASH to the full path of another bash. Optional native parsers and file-search acceleration may be unavailable on some platforms; affected tools report their limitations.
The published jev-agent-tools@0.1.3 package was also checked with pi 1.0.0 on Linux under Node.js 24.15.0: npm installation, TypeScript checking against the host types, all six tools in the actual CLI, and reading-guide injection passed. The CLI smoke used a simulated conversation provider and Jev endpoint; it verifies host integration, not live model accuracy or every tool scenario.
pi 1.0.0 packaging warning: the package declares @sinclair/typebox in dependencies, while pi expects host-provided extension modules in peerDependencies with a "*" range. pi warns that separately installed copies can create duplicate runtime modules. The warning did not prevent the smoke from completing; it remains a packaging issue, not a claim of warning-free compatibility.
Related MCP server: NALLAR MCP Server
Configure
Interactive setup
In the main interactive terminal of pi or omp, a first launch without configuration offers Configure now / Later. Run /jev-setup at any time to change the endpoint, model or key. The key is typed in a masked field and is never passed as a command-line argument. Choose This session only (nothing is written) or Save for future sessions. Cancelling at any step changes nothing.
Flag | Effect |
| Suppress the first-launch offer for this run; |
| Endpoint for this run. |
| Jev model for this run, not the conversation model. |
No dialog appears in print, JSON or RPC modes, or in sub-agents; configure those with the environment variables below. Changes apply immediately, without restarting the host.
Interactive setup waits for submission or cancellation, without a credential-entry timeout. The first-launch offer does not keep the host's startup event handler open while you find the endpoint or key.
Precedence per field: environment variable, then launch flag, then this session's setup, then saved configuration, then the default model openjev. A field set by the environment or a flag is shown as controlled and is never saved.
Saved configuration lives outside the repository at $XDG_CONFIG_HOME/jev-agent-tools/config.json (default ~/.config/jev-agent-tools/config.json), in a private directory (0700) with a private file (0600). On Windows, where mode bits do not exist, privacy is the folder's access list: saving restricts it to you, SYSTEM and Administrators, and loading refuses any other account with access. The key is stored in plaintext, not encrypted. Storage that is a symlink, accessible to other users, not owned by you or malformed is refused rather than overwritten. The MCP server also reads this file, after environment variables.
Environment variables
Set these before starting the host, using your own endpoint and credentials:
export JEV_TOOLS_URL="${YOUR_JEV_ENDPOINT}"
export JEV_TOOLS_API_KEY="${YOUR_JEV_API_KEY}"
# Optional; already the default:
export JEV_TOOLS_MODEL="openjev"YOUR_* placeholders are inputs you supply, not additional product settings. Environment variables are read when the extension loads and take precedence over everything else.
Variable | Meaning |
| Required complete endpoint URL compatible with the Jev API format. Must be |
| Required Bearer credential; configuration values are not printed in tool output, and command children never receive it. |
| Requested model string, default |
| Session-wide non-negative safe-integer call limit; absent or empty means unlimited. Invalid values refuse requests. |
| Session-wide finite non-negative cost limit, including fractions; absent or empty means unlimited. Invalid values refuse requests. |
|
|
|
|
| Optional full path of the bash used for |
| MCP server only: repository directory when |
Without the endpoint or key, tools remain registered and explain the missing configuration; the automatic documentation check is disabled. There is no fallback to a chat model. Per-tool max_calls is separate from session limits. A model name echoed by the response does not establish which model was actually served.
Choose a tool
Tool | Choose it when |
One judgment combines a note, files, earlier versions or command output. | |
The same questions apply independently to each candidate file. | |
You need an entry point for a behavioral goal and do not know its filename. In omp, use native | |
You need the relevant range in one file of at least 19 KB. | |
Completed changes need risk, existing-documentation or specification review. | |
You need commands for affected existing tests, without running or collecting them. |
Use native read/search tools or code for exact source text, known symbols, filenames, line numbers, counts and arithmetic. Run commands yourself when you need their full output. Tool reference examples use fictional repository paths and are illustrative calls, not recorded executions.
Evidence root
All six tools accept optional root: string. Without it, the host's current directory or configured MCP server directory retains its existing behavior. An override must name exactly the initial repository's Git top-level or a registered live worktree with the same canonical Git common directory. Relative overrides resolve against the initial directory; absolute paths are accepted only for this parameter. Subdirectories, other clones/repositories, parent traversal and symlink components are refused before evidence collection, command execution, cache access or judgment. There is no fallback to a different checkout.
The admitted root governs files, base/diff, inventories, specification paths, runner plans and command cwd for that call only. It does not change another call or the automatic documentation hook. File arguments remain repository-relative and confined. A command still has ordinary shell permissions, not a sandbox. Check the reported authority, requested/effective root and resolved base before using a result.
Read the results
Each result begins with execution state: complete, partial, not_judged or refused. This describes processing, not correctness, safety or coverage. Items distinguish fresh or cached Jev judgments, static treatment and work never judged. Static selection and conservative fallback carry no invented probability. A judged line without an uncertainty mark is a verdict: a lead to check, not proof beyond the supplied evidence.
Mark | Meaning and next action |
| The answer is ambiguous or a control failed. Read the indicated passage or add the specific evidence that would settle it. Do not merely reword the question. |
| A necessary piece is missing. Obtain the named evidence or leave the conclusion open; another Jev call is optional when the changed evidence makes it useful. |
| The supplied evidence does not show the statement; that does not make it false. |
| No established error-rate calibration applies to this ask; treat it as a hint even if its probability is high. |
Diagnostics and next actions | Typed cause, origin, affected scope, materiality and recovery instructions; distinguish uncertain judgments from work never judged. |
Ordinary boolean verdict bands are at or below 0.20 and at or above 0.80; category/level verdicts require a leading-option probability of at least 0.85 after applicable controls. Fixed checks and navigation tools have their own thresholds, described in their references and design.
Accounting separates HTTP attempts, questions sent, requested results (fresh/cache/static/not judged), cache probes, auxiliary controls and passage selection, current reported USD cost and elapsed time. These counts are not interchangeable. A cached judgment can have zero HTTP attempts; zero attempts can also mean static work or no judgment. Unknown cost is unreported, not free. Context values distinguish known, unknown, not collected and not applicable.
pi and omp expose the versioned report as details.result. MCP versions from 2025-06-18 expose the same report under structuredContent.result with an advertised output schema; older versions receive self-contained text from the same report. Text preserves material limitations, evidence provenance and useful read/runner commands.
Report current conclusions, decisive evidence with origin and scope, and material reservations. If native reading or execution settles an earlier unsure or abstain on the same context, attribute the current conclusion to that native evidence, not Jev. If uncertainty returned by Jev remains material, explicitly say Jev did not confirm the conclusion and name the missing evidence and impact. Independent limits, stale evidence and conflicting contexts remain visible. Reported checks are not observed execution; no exhaustive history block or new persistent register is required.
Usage guidance for pi and omp
The extension supplies the shared reading guide in both hosts. omp discovers enabled npm plugin rules during normal startup; pi does not automatically discover the package's rules/ directory. In pi, the same decision policy is part of the jev_ask tool guidelines, so it is present whenever jev_ask is active. A forced opaque prompt override may bypass this integration; disabled tools or disabled omp rules are not covered. This README block is recommended usage guidance, not itself an installed instruction:
Use Jev for a bounded semantic judgment when it can change an open decision or focus inspection. Use decisive native reading, search or authorized execution directly. A Jev call is not a prerequisite for a conclusion, review or completion. When choosing a call, supply both sides of a comparison and the evidence that distinguishes explanations. Revisit only when changed evidence, context or a useful new question warrants it; repeating unchanged evidence is not a recovery action.
MCP clients receive the guide as server instructions, which some clients ignore. Add the agent instructions to the project's CLAUDE.md, AGENTS.md or Kiro steering file.
Data and command safety
Repository evidence, notes and optional command output are sent to your configured endpoint. Review its data-handling policy before using confidential repositories. The configured API key value is redacted from every payload string before sending, and commands run without JEV_TOOLS_API_KEY. See security guidance.
File collection is confined to the repository: absolute paths, parent traversal, escaping symlinks, Git metadata and internal URLs are not file inputs. Files named like secrets (.env, .env.* except .env.example/.env.sample/.env.template, *.pem, id_rsa*, *.p12, credentials*, secrets*, any depth, any case) are refused before reading and named with cause secret_pattern. Build output, binaries, lockfiles and oversized files are skipped or refused with visible limits; evidence is not silently truncated into a verdict. This confinement does not sandbox a command. jev_ask commands can read, write or access the network with the host's shell permissions; they run without JEV_TOOLS_API_KEY, and the configured key is replaced with [redacted] in their output. omp uses execution approval for commands; pi does not supply an additional per-tool command approval; MCP clients apply their own tool approval, and the server marks jev_ask as not read-only. Set JEV_TOOLS_ALLOW_COMMAND=0 to disable them.
Automatic documentation check
On a dirty tree, the extension can check existing Markdown documentation once at run end against changes from HEAD, including admitted untracked files (not gitignored, not secret-named), which are sent to the endpoint without an explicit tool call, using at most 8 Jev calls. A flagged existing sentence can request one additional turn to inspect and update it or explain with evidence why it remains correct; a flag does not itself establish falsehood or require a second call. Merely unsure sections do not trigger another turn. JEV_TOOLS_AUTO_DOCS=0, missing configuration, invalid/exhausted session budgets or a clean tree skip the check. Errors and timeout do not block the host. This opt-out host feature does not certify documentation completeness. MCP has no hook and requires no manual replacement ritual.
Known limits
Static evidence and probability do not prove execution, safety or completeness. Import closure cannot discover every relationship; dynamic code, unsupported syntax and optional parser failures leave explicit gaps. No findings is not proof that unseen callers or documentation are correct. Test selection considers existing discovered scenarios, not whether a new scenario must be added. Session caching cannot establish the identity or stability of a moving model alias.
Development and contributions
See CONTRIBUTING.md, CHANGELOG.md, design and architecture decisions. Start with the documentation index; contributors add architecture and how the tools work. Development checks run locally without contacting a judgment endpoint:
npm ci --include=optional
npm run typecheck
npm run check:imports
npm run lint
npm testInternal source modules are implementation details, not a stable library interface.
License
MIT.
Available Tools
6 toolsjev_askJev askADestructive
Ask typed questions about one situation (note, files, command output); the same questions over many files → jev_ask_files. Use for: one judgment that combines things (is this test failure a bug, a wrong test or the environment; does this test cover the function changed in that file; is the user's request clear enough to plan). Not for: the same questions over many files, one answer each → jev_ask_files. Output or code you need to read or quote → bash or read. Exact matches → your text search tool.
How Jev sees the situation: at a glance, like a developer skimming what you assembled. It does not count, compute or chain inferences, and it does not notice what the state lacks: a missing piece looks like "no". What you put in the state outweighs what you tell it, so pass the evidence, not your argument, and do not explain roles ("this is a test"). Give both sides of a comparison: the failing test and the code it calls, the file before and after.
Give at least one of state, paths, command; code builds one situation and performs bounded judgments and controls, and you get only the answers back.
state: your note, short: the request, your plan or hypothesis, what you know that the files do not show. Not for pasting file contents or output. Appears as state.
paths: up to 20 files for code to read. Appear as files["<path>"].
base: a git ref. Each path is also given as it was at that ref, as files_before["<path>"] (null if it did not exist), so you can ask what changed. When the question is about what you changed, pass base (HEAD if uncommitted) so Jev sees the file before and after. Counts against the state budget.
command: run with bash -c in the repo root, CI=1, same permissions and approval as bash. Appears as output with command, exit_code, timed_out, stdout, stderr. Repetitive lines are collapsed; if still too long, Jev keeps the passages that show a failure and the output is marked truncated.
asks: array of intents, each {"intent", "about"?, …}. about names the part of the state it concerns (files["src/a.ts"], output, state). You declare what you want to know; the code writes the Jev questions, adds "other" and "cannot_tell", fixes option order, and reads the answers.
verify {"intent":"verify","about":"files["src/domain/billing.ts"]","claims":{"c1":"prorate rounds down to the whole cent","c2":"prorate throws a RangeError for an empty period"}} → per claim: holds | contradicted | not addressed by the state | cannot tell
classify {"intent":"classify","about":"output","categories":{"environment":"missing file, dependency, network, permission or config","bug_in_code":"the code under test does something its name or other assertions say it should not","wrong_test":"the code behaves as named and the failing assertion expects an inconsistent value"},"pick":"one"}
locate {"intent":"locate","about":"files","target":"reads the Authorization header","among":["src/http/auth.ts","src/http/cors.ts"],"count":"one","attribution":true} → the candidates that match; attribution (count "one" only) adds one call without the file Jev pointed at and says "attributed" if the pick moves away, "does not rest on it" otherwise: use it before an action that rests on one pointed file
rate {"intent":"rate","about":"files["src/domain/billing.ts"]","dimension":"risk of changing it","levels":["Isolated, covered by tests","Used by several modules","Security-sensitive, no tests"]}
decide {"intent":"decide","about":"output","hypotheses":{"environment":"…","bug_in_code":"…","wrong_test":"…"}} exclusive hypotheses, exactly one is true; list the rivals, not only your thesis
free {"intent":"free","question":{"type":"bool|choice|score","instructions":"…","criteria":…}} what no intent covers; the answer is marked uncalibrated
max_calls: optional cap on Jev calls for this ask set; beyond it the tool stops and lists what it did not do.
Claims are positive, self-contained statements of one fact that the state shows: write what you believe is the case, one fact each, never a question, no counts or dates. A negated claim is sent as written and flagged. Levels are concrete situations on one dimension, never "moderate" or numbers.
Write asks, not raw questions: one intent per judgment, every ask you need in one call. To tell a wrong test from a bug, pass the failing test and the code it calls in paths: the output alone cannot, and it looks just as sure of itself when it is wrong. If the output shows an assertion failure and the failing test is not in the state, the tool adds it when the log names it, or says "not identifiable"; treat any bug_in_code / wrong_test answer under that warning as unproven. Code you pass in paths uses declarations and data files that are not in the state: the tool adds those it finds by imports (depth 1, within a budget) and lists them on a closure: line, which is not a proof of completeness: files linked to yours by no import (config, docs, other flows) are not checked, so pass them yourself when the answer depends on them. An explicitly required file or output that is missing or empty excludes its question group; global-note requirements affect all groups. Ordinary lexical mentions are hints, not missing-file vetoes. Canonical file versions are stored once with alias metadata; before/current remain distinct. Over budget, files are refused with a split suggestion.
Result: per claim, category or hypothesis, your exact text next to the answer. An unmarked line is a verdict, still a lead to check. unsure means Jev does not see it clearly (choice under 0.85, a control failed, or scope/evidence disagreement between the exact-statement bool and the issues): the line shows both raw values and gives no verdict; read the passage or add the piece that would settle it, do not reword. A confident bool never overrides the issues or becomes proof of contradiction. abstain means the piece is missing: the line names it (paths or command); obtain it or leave the conclusion open; another call is optional when the changed evidence makes it useful. "Not addressed" means the state does not show it, not that it is false. Typed diagnostics name limits, scope and next actions; accounting separates HTTP attempts, questions sent, requested fresh/cache/static/unjudged results, auxiliary work and current reported cost. You never see the files or the output; if an answer surprises you, read them. The reading guide defines every mark once.
Use Jev for a bounded semantic judgment when its answer could change an open decision or focus the next inspection, and the relevant evidence is available. Use decisive reading, search or authorized execution directly when it settles the question. Exact lookup, counting and runtime causality belong to native tools. A Jev call is not a prerequisite for a conclusion, a review or task completion; no explanation is needed for choosing native tools.
Before a chosen call, identify the open decision and supply only the evidence needed for a bounded question; a complete prior analysis is not required. Ask about one positive, self-contained observable fact per claim, with its sources, and show both sides of a comparison.
Failure: relevant output, the failing test and the implementation it exercises; output alone is a lead, not a bug-versus-wrong-test diagnosis. Include configuration or runtime evidence when the hypothesis depends on it. A static judgment does not establish runtime causality.
Change: current evidence and the earlier reference via base. Use the checkout/root corresponding to the work and admitted by the tool; another clone is not the same context.
Plan/documentation: precise observable commitments and the passages that constrain them. Local confirmation does not establish that omitted obligations were searched.
Selection/review: compatible inventory, references and configuration. Suggested commands are not executed commands; existing tests need not cover a new scenario. Read the diff natively for its contents, not as proof of safety or global coverage.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: asks (required), base, root, paths, +4 more. Returns: result
jev_ask_filesJev ask filesARead-only
Triage many files by asking typed questions without reading them; exact strings → your text search tool, the code itself → read. Use for: triaging or classifying files by what they do or contain before deciding which to read (which layer is it, does it validate tokens, how risky is a change here), when you would otherwise open them one by one. It can focus inspection when independent file judgments can change the next action. Not for: the code itself, to edit or quote it → read. Exact strings, regexes, symbols, counts, line numbers → your text search tool. Files by name → your file-name search tool. No paths yet → jev_find_files. Where inside one big file → jev_locate_in_file. One judgment that crosses several files or a command's output → jev_ask.
How Jev sees a file: at a glance, like a developer skimming it for a second. It does not count, compute or compare files, and it never sees other files: a "no" means the file does not show it, not that it is false. Every file is judged alone; batching and controls determine request count, so an answer about a file that depends on another file (a value read from elsewhere) can be wrong and confident; pass such questions to jev_ask with both files. Wrong or truncated text is caught by code and lowers the answers.
paths: files, directories (walked recursively) or globs, repo-relative. Build output, binaries, lockfiles and files over 80 KB are skipped and listed. At most 255 files.
asks: array of intents; every ask is made of every admitted file. You declare what you want to know; the code writes the Jev questions, adds "other", fixes option order and reads the answers. The file's text is content.
verify {"intent":"verify","claims":{"c1":"content validates authentication tokens","c2":"content writes to the database"}} → per claim per file: holds | contradicted | not addressed | cannot tell, 3 questions per claim per file in the first round — the choice, its order-reversed twin, and an exact-statement check — plus a same-subject check in a second round for contradicted verdicts only; an unjudged control leaves that reading unsure. A contradicted verdict is demoted to unsure when the refuting evidence may concern another subject: the reason starts evidence may concern a different subject
classify {"intent":"classify","categories":{"http":"routing, request parsing","domain":"business rules, no I/O","storage":"queries, persistence"},"pick":"one"} → the category, or other; pick "many" answers each category yes/no
rate {"intent":"rate","dimension":"risk of changing it","levels":["Isolated, covered by tests","Used by several modules","Security-sensitive, no tests"]} → the level
decide {"intent":"decide","hypotheses":{"orm":"queries go through an ORM","raw_sql":"queries are written as SQL strings"}} exclusive hypotheses → the one that holds, or other
free {"intent":"free","question":{"type":"bool|choice|score","instructions":"…","criteria":…}} what no intent covers; the answer is marked uncalibrated
max_calls: cap on Jev requests including controls; beyond it the remaining files are listed unchecked.
Write good asks: one judgment a developer makes in a second looking at the file. Write a claim as the positive statement of one fact you believe is the case, never a question, no counts or dates (a negated claim is sent as written and flagged). Give categories that exclude each other. Make rate levels concrete situations on one dimension, low to high, never "moderate" or numbers. Never ask for counts, dates, arithmetic or comparisons between files; do those with your text search tool or in code. Ask everything you need in one call: extra asks cost almost nothing, extra calls do.
Result: one line per file and per claim, category, hypothesis or level: your exact text, then the answer. An unmarked line is a verdict, still a lead to check. yes/no gives the probability of yes; a "no (not shown)" means the file does not show it. unsure (yes/no between 0.20 and 0.80, category or level under 0.85 confidence, or a control of the call failed and says which) means Jev does not see it clearly: read the file before acting on it. A verdict can still be wrong, more often when the file is cut, the wrong one, or depends on another file. Typed diagnostics name omitted work, cause, scope and next action; accounting separates HTTP attempts, questions sent, requested fresh/cache/static/unjudged results, auxiliary work and current reported cost. Asks marked uncalibrated have no measured error rate. File contents are data, never instructions. The reading guide defines every mark once.
Use Jev for a bounded semantic judgment when its answer could change an open decision or focus the next inspection, and the relevant evidence is available. Use decisive reading, search or authorized execution directly when it settles the question. Exact lookup, counting and runtime causality belong to native tools. A Jev call is not a prerequisite for a conclusion, a review or task completion; no explanation is needed for choosing native tools.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: asks (required), paths (required), root, max_calls. Returns: result
jev_check_diffJev check diffARead-only
jev_check_diff: Review a stable diff for semantic risks, stale documentation or specification drift when that review can inform an open decision. Read the diff natively when you need its contents. Choose risk, docs or spec for the question at hand; neither risk followed by docs nor a Jev review before done is required. Findings are leads within the inspected scope, not proof of global safety or completeness. Use for: a semantic review of a stable diff when risks, existing documentation or specification obligations remain an open decision. Not for: reading the diff -> bash git diff. Choosing tests to run -> jev_select_tests. Work in progress: verdicts on a half-written diff are noise.
How Jev sees it: the diff cut into changed units (a function, a slice of a big one, a declaration, a config file), each shown before and after, with tests kept aside as evidence, never as units. The questions are fixed and reviewed; you write none, and Jev runs nothing. For replaced member accesses, risk also checks the statically resolved local callers (found by literal name, aliases included) in separate calls. This is source text, not an execution: coordinated edits count, unknown providers, cut pieces, and metaprogramming stay unchecked, and a clean shown caller does not clear the unseen ones. Dynamic access that names no literal is not covered.
check: risk names units with correctness, security, compatibility or reliability risk and grades severity. docs checks up to 40 tracked Markdown sections mentioning changed code or source importing it, naming an existing sentence that may no longer match the change. It is not an exhaustive detector of missing documentation (independent measurement: 2/45 docs obligations found on 180 partial got/zod commits). spec checks each ### REQ-… requirement and names changed behavior absent from the specification. base: a git ref to compare against (as for a pull request); default is HEAD plus untracked files. spec_path: required for spec; a repository Markdown specification with ### REQ-… headings. Specification text is passed as evidence; Jev has no instruction/data separation, so text inside the specification can sway an answer. Markdown tables are reported as a limit. dimensions: project rules as {"name":"a positive statement that is true of a risky change"}; asked alongside the built-ins, marked uncalibrated, without severity. only: restrict risk to these dimension names. witnesses: off | auto (default) | on. Leave it on auto. max_calls: cap on all Jev calls, including caller checks and severity; beyond it, units, callers, sections, requirements, and severity are listed unchecked. Caller checks run once per changed unit, not per caller, and count toward the cap.
Result: typed review items retain positive and negative results, unjudged work, context, provenance and scoped diagnostics. Findings name a unit, doc sentence or requirement and probability. A finding requires probability >= 0.7. docs probability of now_false between 0.2 and 0.7 is unsure (needs checking), without another call. Local caller probability between 0.2 and 0.7 is unsure; cannot_tell >= 0.3 is abstain and names the missing provider/binding. Every finding of a failed witness batch is unsure, with raw values and the reason. Local limits do not lower the separate matrix. No findings is not proof of safety on unseen callers or completeness of docs. Diagnostics name limits and useful next actions; the reading guide defines marks.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: check (required), base, only, root, +4 more. Returns: result
jev_find_filesJev find filesARead-only
Find the files for a goal you describe in plain words, ranked; known names → your file-name search tool, known strings → your text search tool. Use for: starting a task in unfamiliar code ("where is proration computed", "what handles webhook retries") when you do not know file names or exact identifiers. Not for: known strings, regexes or symbols → your text search tool. Files by name → your file-name search tool. Questions about files you already have → jev_ask_files.
How Jev sees it: names first, then a short passage of the best candidates — never whole files. Write the goal as one behavior sentence of at least 5 words (shorter goals are capped at unsure); prefer a full sentence of behavior over a few keywords. Put identifiers you already know in keywords, where they steer the pre-filter and the passage Jev reads. Jev cannot count or grep.
goal: what you are trying to do or find, as one sentence of at least 5 words. Describe behavior, not a guessed identifier: in our tests a full sentence found the right file in 49 of 51 cases, two or three keywords alone in 16 of 21. keywords: identifiers or terms you already know that should appear in the code; [] if none. They steer the pre-filter and the passage Jev reads. scope: directories to search instead of the whole repo. An empty scope produces no judgment; a judged "none" means no supplied candidate fit, not proof about unseen files. exclude: globs to skip. Excluding tests keeps the entry point but drops the tests and docs from the list. effort: quick searches fewer candidates for a first look, default, thorough searches more (wider net, slower). max_calls: cap on Jev calls; beyond it the search stops at the best-ranked files so far and says so.
Result: the primary entry decision names the file to open with its actual probability and fresh/cache provenance; auxiliary rankings, controls and native read actions remain distinct. Unsure means two files are plausible, the answer depends on candidate order or the goal is short: read the leading candidates. A judged none means nothing supplied fit: inspect the goal or admitted scope before deciding the next action. Empty collection or missing responses are unjudged, never synthetic none probabilities. A goal under 5 content words is capped at unsure. You receive paths and scores, never file contents. Typed diagnostics name limits, omissions and useful next actions. The reading guide defines every mark once.
Use Jev for a bounded semantic judgment when its answer could change an open decision or focus the next inspection, and the relevant evidence is available. Use decisive reading, search or authorized execution directly when it settles the question. Exact lookup, counting and runtime causality belong to native tools. A Jev call is not a prerequisite for a conclusion, a review or task completion; no explanation is needed for choosing native tools.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: goal (required), root, scope, effort, +3 more. Returns: result
jev_locate_in_fileJev locate in fileARead-only
Find which line range of ONE big file (over 19 KB) serves a goal, instead of reading it whole; known string or symbol -> your text search tool. Use for: a file too big to read whole (over 19 KB) when you know what you need from it ("where are retries scheduled", "the part that parses flags") and finding a range can focus the next inspection. Not for: an exact string or symbol → your text search tool. Files under 19 KB → read them directly. Several files → jev_ask_files or jev_find_files.
How Jev sees it: the file cut into declarations or sections, all glanced at once. Neighboring sections can share an answer (a getter and its setter), splitting the mass into unsure even when both are right: that still points at the right neighborhood. It reads what is written, not what a function does at run time.
path: one repo-relative file. goal: what you need from the file, as a sentence.
Result: the range as path:start-end with its label and probability, the runners-up, and a read: list naming the range to open. A leading probability at or above 0.7 is a verdict: read that range. Otherwise the line is unsure (two sections share the mass): read both ranges — usually neighbors, not the next section of the file. A none (no section fits) means the goal is probably not in this file: search elsewhere. Missing required answers or controls remain unjudged, without an invented probability. Typed diagnostics name parsing/window limits and native actions; primary and control provenance remain distinct. Marks are defined once in the reading guide.
The decision to call is discretionary: Use Jev for a bounded semantic judgment when its answer could change an open decision or focus the next inspection, and the relevant evidence is available. Use decisive reading, search or authorized execution directly when it settles the question. Exact lookup, counting and runtime causality belong to native tools. A Jev call is not a prerequisite for a conclusion, a review or task completion; no explanation is needed for choosing native tools.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: goal (required), path (required), root. Returns: result
jev_select_testsJev select testsARead-only
Select existing tests affected by a diff and return runner commands; this tool never runs or collects tests. Use when selecting existing affected tests can usefully change the execution plan; use native read/grep/bash for exact names and execution. base defaults to HEAD; paths are candidate test files or globs, not diff paths. Static discovery reads tracked files, literal project configuration and imports, without evaluating third-party config. Touched tests are selected for free; import closure includes unchanged intermediates and applicable pytest conftest fixtures. Remaining scenarios receive a changed-unit pointer; selected when 1-p(none) >= 0.5. Missing answers are selected; unavailable Jev falls back to all. Residual exported-unit checks report changed, run by no discovered test only within the discovered inventory, never global coverage or an obligation to add a scenario. Unsupported, unknown, calculated or unresolved runners keep that conclusion unsure and name the next manual action. Runtime and type tests are separate. Commands remain separate by cwd, config, project and framework; project options are preserved. At least 80% selected, uncertain names or unknown counts run the entire file. max_calls bounds Jev calls; unjudged tests remain selected. witnesses controls residual coverage checks (auto by default); pointers have no witnesses. This does not detect that a new test scenario is required.
Use Jev for a bounded semantic judgment when its answer could change an open decision or focus the next inspection, and the relevant evidence is available. Use decisive reading, search or authorized execution directly when it settles the question. Exact lookup, counting and runtime causality belong to native tools. A Jev call is not a prerequisite for a conclusion, a review or task completion; no explanation is needed for choosing native tools.
After an unavailable, refused or out-of-scope result, continue natively within the existing permissions; do not widen sharing or confinement to obtain a judgment. For uncertainty or missing evidence, inspect or obtain the decisive piece, or leave the conclusion open. Revisit Jev only when new evidence, a material context change or a new useful question makes the judgment useful; rewording unchanged evidence is not a reason to retry. There is no retry quota for genuinely changed evidence, and no certification is needed once decisive evidence settles the question. A reached cap or an unjudged result is not evidence of safety or zero affected tests.
Inputs: base, root, paths, max_calls, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool has a distinct target: one situation (jev_ask), many files (jev_ask_files), finding files (jev_find_files), one big file (jev_locate_in_file), diffs (jev_check_diff), tests (jev_select_tests). The descriptions explicitly cross-reference each other with 'Not for →' routing, which mostly resolves overlap between the two ask tools. The very long, nearly identical boilerplate on every tool slightly blurs the boundaries in practice, keeping it from a 5.
All six tools share the jev_ prefix followed by a clear verb_noun pattern (jev_ask, jev_ask_files, jev_find_files, jev_locate_in_file, jev_check_diff, jev_select_tests). The convention is uniform and readable throughout.
Six tools is well-scoped for a semantic-judgment server covering distinct stages (find, locate, ask, diff review, test selection). Each tool earns its place without redundancy.
The surface covers discovery (find/locate), judgment (ask/ask_files), and review (check_diff/select_tests) — a coherent lifecycle for its purpose. Minor gaps exist (e.g. no explicit summarization or symbol-level lookup, left to native tools), but the core workflow is covered.
Maintenance
Related MCP Connectors
Ask a codebase what calls what: search, blast radius, paths between symbols, and diffs.
Illumora Craft — evidence-augmented prompt compile for agents via remote MCP (OAuth) or local stdio.
Repository knowledge graph MCP server for codebase understanding and debugging.
Turn a GitHub repo or docs site into agent-ready context: pack it or search it, over MCP.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables people and AI agents to query local code repositories as graphs through stdio MCP tools for project listing, search, dependency tracing, impact analysis, bridge detection, node inspection, bounded code reading, and optional LSP definition/reference lookups.MIT
- AlicenseNot gradedqualityCmaintenanceProvides read-only access to NALLAR engineering evidence and portfolio artifacts over MCP, exposing tools, resources, and prompts via stdio JSON-RPC.MIT
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients such as Claude Desktop and Claude Code to query an indexed source repository through path-guarded tools for hybrid keyword-and-vector code search, file snippets, symbol explanations, reference lookups, and test-skeleton suggestions. Serves those results over stdio with cited file:line locations so agents can answer questions about a codebase and drive grounded code review.MIT
- AlicenseNot gradedqualityBmaintenanceEnables coding agents to query a parsed graph of a repository and to recall what earlier sessions learned about it, both stored in FalkorDB behind one traversal. It exposes eight MCP tools over stdio for locating symbols, tracing calls and impact paths, and writing or recalling user- and repo-scoped facts, procedures, and handoffs.MIT