Recovery Probe
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Recovery Probe shows what an app does when a data read fails. Use it to check a claim about error handling before you make it, and quote its results as they are.
A passing check covers only the configured read and screen marker; it is not proof that the app is resilient.
FAULT_NOT_TRIGGERED, BASELINE_FAILED and other inconclusive codes are not passes. Fix the setup and run again.
When a check can't attach to the app or the IPC hook doesn't answer, run doctor --json through run_recovery_probe and follow its fixes.
Findings such as LOCAL_FILES_REMOVED or DELAYED_UI_UPDATE, and suspects from find_suspects, are leads to investigate, not verdicts. EXPECTATION_NOT_MET is different: the app did not show what an expect step required.
Before you say a change fixed something, compare reports of the same check from before and after it with compare_reports, and quote its verdict. A run that stopped early is never evidence of a fix.
When the project has a scenario registry (recovery-probe.registry.json), call plan_verification for the change before you record a baseline. It proposes checks; it never verifies anything. Report its uncovered files and needsInput as they are: no matching check does not mean a change is safe, and do not invent an expectation, selector or endpoint to fill a gap.
self_check_scenarios without run only validates scenarios. Use run only when the user asks and names the running build as the reference; it injects faults. Its outcomes are about the scenarios on that build: clean never means the app is correct or a change is verified.
When the project has a verify plan (.recovery-probe/verify.json), call verify_change with baseline true before you change the code, and verify_change before you say the change is done. Do not call it done while the verdict is NOT_VERIFIED; resolve the reasons it gives. A baseline run after the code already changed is not a before-change baseline: record it from a checkout of the base instead.
Use development or test apps and accounts only: checks reload pages and fail their reads.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| find_page_readsA | Opens a page in headless Chromium and lists the JSON GET requests it makes while it loads. Use it to choose the endpoint for check_read_recovery. Only successful page fetch and XHR reads are seen; native, IPC and service-worker traffic is not. |
| check_read_recoveryA | Loads the page healthy, then fails one GET endpoint with each fault kind and checks that the ready marker comes back: by itself (recovery "automatic") or after clicking retrySelector ("retry"). Returns an outcome per fault, why the healthy baseline failed if it did, the text the screen showed under a fault it did not recover from, and the report folder, which includes fix-brief.md and reproduce.mjs. |
| start_network_faultsA | Starts a loopback HTTPS proxy for an app's own connections (an SDK, a main process, a CLI or a test run). Start the app or tests with the returned environment; connections pass until set_network_faults arms rules. Faults apply to whole connections per host: HTTPS stays end to end. |
| set_network_faultsA | Replaces the armed rules, or removes them all with restore: true. Windows count from this call. Set dropOpen on a rule so clients that keep connections open have to reconnect. |
| network_fault_summaryA | Reports how many connections went through the proxy and, for the armed rules, how many each matched and faulted. A rule that faulted nothing means the app did not use the proxy or the host name is wrong. |
| stop_network_faultsA | Removes every fault, closes the proxy and returns its final summary. |
| find_suspectsA | Reads JavaScript and TypeScript sources, without running them, for two patterns: UNKNOWN_AS_EMPTY (a failed or unexpected read becomes an empty collection, so "unknown" looks like "none") and FAILURE_ONLY_LOGGED (a read stores its data when it succeeds, but its failure is only logged). Each suspect names the read to fail and the check that proves or dismisses it. Use changedSince "main" to scan only what a branch changed. Needs TypeScript in the project. |
| compare_reportsA | Compares reports of the same check from before and after a change, such as main and a branch, and returns a verdict (IMPROVED, PARTLY_IMPROVED, REGRESSED, MIXED, UNCHANGED, INCONCLUSIVE or NOT_COMPARABLE), what happened to each problem, and a Markdown block for a pull request. A problem counts as gone only when a complete run after the change checked it, so a run that stopped early is never a fix. Give several reports per side for repeated runs. |
| plan_verificationA | Experimental. Before recording a baseline, proposes which existing Recovery Probe checks verify a change: it matches the files changed since a Git reference (committed, staged, unstaged, untracked, deleted, renamed) against the project scenario registry (recovery-probe.registry.json) and the suspects on the changed lines. Each check says which file selected it, what it checks, where its expectation came from and what it does not cover. It also lists suggestions to review, changed files with no known check, and what needs a person: open questions, missing expectations, invalid entries. It runs nothing. The result is a proposal, never a verdict: no matching check does not mean the change is safe. Resolve needsInput, then record the baseline with verify_change from the version before the change. |
| self_check_scenariosA | Experimental. Checks scenarios from the project registry (recovery-probe.registry.json) before they are used for before/after verification. Without run it only looks: the command line of each check as its command parses it, its files, unfilled placeholders, and its configuration against the validators its command uses; nothing is started or contacted. With run true it runs each scenario that passes against the application running now, which the user declares as the reference build in reference; never pick that yourself. Each run injects the faults and performs the actions its configuration names. Each scenario ends configuration-error, execution-failed, incomplete, inconsistent, findings (on the reference build) or clean. invalidEntries lists the registry entries it could not check, and passed is false while one of them concerns the selection. Clean never means the app is correct, the scenario detects its defect, or a change is verified; report outcomes and guidance as they are. |
| verify_changeA | Call with baseline true before changing the code, and without it before saying the change is done. The plan file lists the checks that prove the change. Verify reruns them, compares the runs with the baseline, and scans the lines changed since the plan base for suspects. VERIFIED needs every check improved or clean with complete runs on both sides, and no suspect on a changed line; otherwise the reasons say what to resolve. Do not call a change done while it is NOT_VERIFIED. |
| run_recovery_probeA | Runs a Recovery Probe command that has no dedicated tool, such as check and discover for an Electron app or an attached browser, action, observe (with --steps, --network or --files), refresh, reads, windows, android --list or doctor (setup checks), and returns its exit code and output. Commands: check, discover, action, reads, windows, observe, refresh, android, doctor. Pass --json where the command supports it. See the package docs for each command's configuration. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 12 tools
The network fault lifecycle (start/set/stop/summary) and the verification workflow (plan_verification, verify_change, compare_reports) are clearly separated by explicit sequencing hints. The main soft spot is compare_reports versus verify_change, which both compare before/after runs of the same checks, and run_recovery_probe overlaps the dedicated commands it serves as a fallback for — though its description scopes it to commands without a dedicated tool.
All names are snake_case and nearly all follow a verb_noun shape (plan_verification, set_network_faults, find_suspects, compare_reports, verify_change). The one deviation is network_fault_summary, a noun phrase where the pattern would predict something like get_network_fault_summary, which slightly weakens predictability when scanning the list.
Twelve tools sits comfortably in the well-scoped range, and each maps to a distinct stage of the recovery-testing workflow rather than being filler. The single escape-hatch tool keeps the count from ballooning to cover every CLI subcommand individually.
The surface covers the full loop: propose checks, validate scenarios, find faults, exercise them, gather reports, compare, and gate the change. Gaps are minor — there is no tool to list or author registry/scenario entries (only self_check_scenarios and invalidEntries reporting), and no explicit report cleanup, though run_recovery_probe provides a workaround for uncovered commands.