At your computer, explore this page with your agent
Turn on WebMCP in this browser and your coding agent can read this page and press its controls. In formula editors, it can suggest text inline; Tab accepts a suggestion into your draft.
Waiting for your agent. Start your coding agent; it starts the relay, and this tab connects when the relay answers.
Allow this page to reach your computer. The browser asks before a site may connect to a program on this machine, and it only asks from a click. Choose Allow connection, then Allow on the browser prompt.
The browser blocked this page. In the address bar, allow access to apps and services on this device for this site, then reload.
Your agent’s relay answered. Connecting this tab…
Your agent is connected to this tab. It reads this page with yichus_page_feedback. For inline suggestions, ask it to follow yichus_autocomplete_wait_for_request.
Your agent’s relay refused this page: Start it with --base-url .
Edit Bosatsu in the browser and query its compiled dependency graph
Loading sample...
Current structural-analysis step
Loading Explorer Lesson and Evidence Route
The guided workbench will appear after the first sample finishes loading.
Technical purpose: input connectivity
Explorer helps you check whether an output is actually connected to real inputs or only looks like it is.
The tools can identify ignored inputs and literal-derived results. Those findings do not establish who wrote the code or whether an intentional constant is a defect.
Lesson mode
When a lesson says Make the judgment, pause and
make a mental prediction before reading the evidence. The page has no
answer-recording control; the prediction is for comparison with the
explanation that follows.
Lesson map
Recovery and free play
Sample Source and Compiled Scope
Work with your agent
WebMCP connects your agent to this page. Connection and tool instructions. Use yichus_page_feedback to read the current editor and displayed feedback. The agent can use yichus_page_edit to update the current source and yichus_page_action to run a listed button, then read feedback for completion and diagnostics. Autocomplete suggestions remain available for you to accept with Tab.
Analysis and navigation run in a background worker. Editing, resetting, or switching samples clears the previous results and cancels pending work. After Analyze, wait for “Analysis complete” before reading the new results. A failed analysis leaves no program available for navigation.
Compiler Diagnostics
Fix the reported file, line, and column before
interpreting any Explorer result.
Matchless Explorer Results
Package
-
Bindings
-
Mode
In-browser
Selected Binding Evidence Prompt
Analyze a sample and the guided workbench will tell you what to look for first.
Focus binding-
waiting-for-analysisNeed analysis
Load a sample, analyze it, and the workbench will surface one plain-language explanation before the raw payload.
The next useful move will appear here once the focused binding is known.
Explorer Query Operations and Typed Paths
Drive the same in-browser explorer state through `overview`, `explore`, `connections`, `search`, `path`, `trace`, and `traceFlow` without leaving the page.
Recovery. If an operation fails, read the
navigator status and open the raw payload for its exact message.
Analyze the current sample again to rebuild the graph; if
analysis fails, fix the Compiler Diagnostics above first. If a
custom query stops compiling, reload the page to restore the
minimal query, then keep its entry point and target defaults
while changing one branch at a time.
Reference: paths, edge kinds, filters
Node paths are slash-separated:
Package/binding reaches a binding
(Demo/Counter/increment); append
/io:N for one of the binding's IO sites,
using the site number shown in explorer output
(Demo/Counter/increment/io:1).
Edge kinds (the kind
filter in connections):
dependency = one binding's value uses
another's; causal = ordering induced by
effect sequencing; io_chain = successive
IO operations in one flat_map chain.
Each upstream edge also carries an influence tag:
return-data (carries data into the return
value), guard-only (gates control flow,
e.g. a match discriminant, but contributes no data), or
detached (declared but unused).
followEdges: return-data-only in
trace/traceFlow keeps only the
first kind. Trace output can also include a
read-origin edge: it links an IO read site
to a binding whose value originates at that read.
Search filters combine
key:value terms, e.g.
kind:io_site primitive:write (also
primitive:read). depth/maxDepth
count graph hops from the start node;
limit caps returned landmarks.
The same queries run outside the browser through the npm CLI:
echo '{"verb":"trace_flow","binding":"<binding>"}' | npx yichus@0.3.9 call api_explore --source <file> --args -.
The JVM command-line tool, which is not distributed yet, has them as
yichus explore; every flag is in the
yichus explore reference.
Analyze a sample to populate the graph-backed browser API.
`overview(path, overlay, limit)`
Scan a package or binding neighborhood and surface landmarks: effect hotspots, bindings carrying signal tags (for example literal-root), or boundary crossings.
`explore(path, depth)`
Zoom from the system root down to one package, binding, IO site, expression, or source node.
`connections(path, direction, kind)`
Inspect incoming and outgoing edges such as `dependency`, `causal`, or `io_chain` around one node.
`search(query, scope)`
Query IR-derived structure with filters like `kind:io_site primitive:write` instead of reading source text.
`path(from, to, maxDepth)`
Route between two bindings to see how one point in the graph connects to another through dependency edges.
`trace(binding, maxDepth, followEdges)`
Walk upstream from one binding and get a compact summary of the nodes that feed it.
`traceFlow(binding, maxDepth, followEdges)`
Inspect explicit upstream edges so you can see which dependencies carry return data and which only guard control flow.
`query(source, entryPoint, target)`
Compile a Bosatsu `ProgramData -> ClassifyResult` query against the in-browser explorer workspace and inspect the classification result.
The textarea starts with a minimal compiling query package.
Leave its source unchanged, keep the entry point as
classify and the target as
playground, then click Run query. To narrate one
result: select Pure computation and Analyze
first. The query sees that the workspace has no IO binding,
returns the pure-computation label, and gives
pure computation as its reason. Edit one
branch at a time to create a custom classifier. The available
fields and helper signatures are defined in
Yichus/Explorer/Query.
Raw explorer payload
Run one of the recursive primitives to inspect the browser-side explorer graph.
Ask your agent about anything here; it has the detail.