Volcan: hear your code review

src/auth/permissions.py

One press plays three renderings: earcon, speech, Braille.

Earcon

Falling cue: finding Rising cue: clean

Speech

Nothing spoken yet. Select Hear this code review and the sentence the server returns appears here as it is spoken.

Braille

No cells yet. Select Hear this code review and the server's Braille for this patch arrives here, one row per line, for a refreshable display.

Try another patch

Ask for more

Braille table

Who it is for, who would pay, and the road to Alexa+

User: Blind and low-vision developers reviewing code an AI agent wrote, which today means a screen reader reading a diff one plus sign at a time.
Buyer hypothesis: The employer, from the accommodation budget, of one of about 17,900 US software developers who report a vision difficulty (Census ACS 2024, an upper bound). Price, untested: $24 a seat a month. Why now: coding agents now ask a human for review, and the European Accessibility Act applies from 28 June 2025 (Directive (EU) 2019/882, Article 31). No buyer has been interviewed.
Alexa+ local only: An assistant that already speaks is where a review by ear belongs: Alexa+ would call this MCP server through an add-on. The hackathon FAQ says those tools are "available to select partners only", so the package is built and tested locally, not certified or deployed. Alexa+ has never called Volcan: no Alexa skill and no test on an Echo device.

By voice or by keyboard

Talk through a real pull request, then request changes

Open a public pull request, ask what changed, hear the exact lines, spell one out symbol by symbol. Every turn posts to POST /api/review/turn and reads back what it understood before it acts. The review write is dry-run by default: the server re-reads the head commit, records the exact request it would send, and sends nothing unless it runs with VOLCAN_GITHUB_WRITE=1 and a token.

1 Open a pull request

Pull request URL

A public GitHub pull request, read without a token; Enter opens it. Leave it empty and Open reviews the patch above instead, which can be discussed line by line but not submitted, because a pasted patch has no pull request behind it.

Live mode: reviewer access token

Reviewer access token for live mode

Leave empty for the public dry-run demo. For live reviews, use your reviewer credential from the server operator, never a GitHub token. It stays in this page's memory and goes only to the review API. Reload to clear it and start a new session when changing reviewer.

2 Request changes

Comment for the request changes review

By voice, say "request changes" followed by the comment. The server binds the review to the head commit it read and waits for confirm; nothing leaves this machine until you say it.

POST /api/review/turn

No review staged. Say request changes followed by your comment. The server binds the review to the head commit it read, issues a single-use grant with a 300 second lease, and waits for confirm. The outcome printed here is the server's: submitted, recorded and not sent, or refused with the reason.

What it heard, understood and answered

IDLE

Nothing heard yet. Open a pull request or the patch above, then ask what changed. Each turn shows what was heard, what Volcan understood, and what it answered, and the same words are spoken at the rate the server returned.

Command, typed or dictated

Press Enter to send. Say or type help for the list. A new command interrupts whatever is still being spoken. Microphone: microphone off

Or say one of these

Hands on the keyboard

Alt+4command box
Alt+5start or stop listening
Alt+6pull request URL
Escapeinterrupt everything

On a Mac, Alt is the Option key.

The same turn as a card on a smart display

Drawn by this page. No Echo Show and no Alexa+ has rendered this card, and the frame is a drawing, not a device. The card itself is the server's own ui://volcan/review-card, an MCP Apps view this page reads with resources/read over POST /mcp and hands each turn's result as structuredContent, the way an MCP Apps host would.

Its Confirm and Cancel send the same confirm and cancel as the buttons above, through the same grant check, so the card adds no second way to release a review. Inside the card only Tab, Shift+Tab, Enter, Space and Escape work; the other shortcuts work again once focus leaves it.

No card yet. It appears after the first review turn, when this page reads the card from the server.

For reviewers

Evidence

Every claim above, checkable against the server this page is talking to. Nothing here is prewritten: each panel fills from a real response.

Checking

Requesting GET /health on this origin. Nothing here claims a server until that request answers.

Where Alexa+ would connect. The dashed box has never run against Alexa+.

Alexa+ add-onpackage built and tested locally, not certified or deployed; the add-on tools are partner-only (hackathon FAQ); no device test
→
POST /mcpMCP 2025-11-25, Streamable HTTP; the handshake below checks it
→
Volcan toolsdigest, earcon, Braille, governed review

Model Context Protocol, handshaken in your browser

Written by hand against revision 2025-11-25 over Streamable HTTP, with no MCP SDK. This button sends a real initialize, notifications/initialized and tools/list to POST /mcp and prints what came back: stateful or stateless transport, and every tool's JSON Schema as published. Where this server keeps dialogue and pending approvals is read from GET /health, and stated here once it answers. Check it independently with python scripts/mcp_conformance.py http://127.0.0.1:8000/mcp.

Protocol version: not run yet
Server info: not run yet
Session id from header: not run yet
Tools advertised: not run yet

The tool catalog appears here after the handshake. Each entry expands to the exact inputSchema the server published, generated from the model that parses that tool's arguments.

Amazon's documented Alexa+ requests, replayed from your browser

Amazon documents its Alexa+ client's request bodies, not its headers. This button sends them to POST /mcp as three clients: one follows the version rules, one declares the revision it asked for, one never sends MCP-Protocol-Version. Alexa+ did not send them.

One line per client appears here after the replay: the header it sent, the HTTP status of each step, and the tool call's round trip as this browser timed it.

Governed action: staged, leased, never run

A high-consequence command is bound by HMAC-SHA256 to its own payload hash and to a lease. Volcan plans the command and does not run it. The countdown below is computed from the expires_at_epoch the server returned, not from a timer this page invented.

Lease state

IDLE

Nothing staged. Select Stage an action to open a 300 second lease on the server.

Audit trail

GET /api/audit_log

Not loaded. The server seals a record when a grant is actually presented, so this list fills after Approve with the grant, not after staging.

One press, one real round trip

Hear this code review calls the live digest and Braille endpoints, plays the returned WAV and reports this browser's measured round trip. No result is prewritten into the page, and there is no second implementation of the product in the browser to fall back on.

The earcon

Volcan sends a rising three-note cue, DIFF_READY, when a digest is ready, and a falling two-note cue, SECURITY_FINDING, when the patch touches security, so the verdict arrives before the sentence does. The waveform on the stage is drawn from the 16-bit PCM samples of the WAV the server returned, and the contour beside it is measured from those same samples by counting zero crossings in each note. The two cues are different audio: switch between the first and the fourth patch and the waveform, the contour and the caption all change with the bytes.

Audio plays through your speakers. Replay the cue plays it again, and every cue also carries a written description from the server in the same live region.

The spoken sentence

Words brighten as the browser's speech engine reports reaching them. When the engine reports no word positions, the whole sentence brightens when speech starts; when it has no voice at all, the sentence is shown in full at once. No word timing is invented.

The Braille

Volcan renders the patch as Unicode Braille in the U+2800 block for a refreshable display. The default is eight-dot code fidelity, one cell per printable character, so (, ) and = keep their own cells; six-dot literary Braille is lossy for code, and the server names what it lost in this patch. The large cells on the stage are the server's own code points drawn dot by dot, and the cells that differ between the removed and the added line are marked.

The three numbers

Synthesis engine is read from the synthesis_mode field of the response, with synthesis_fallback_reason printed when no model answered. Round trip is wall clock across fetch and the JSON parse, from performance.now(). Change size is counted by the server's unified diff parser, not by this page.

Keyboard map and the accessibility contract

This page is the product's shop window, so it holds itself to the standard the product argues for. tests/e2e/test_html_structure.py fails the build when any promise below stops being true of this file.

Every action here is a real button in the tab order. Nothing needs a pointer. On a Mac, `Alt` is the `Option` key.
Key	What it does
`Tab` and `Shift`+`Tab`	Move through every control in reading order.
`Enter` or `Space`	Activate the focused button.
`Tab` from the top	Reveals Skip to main content.
`?`	Open this keyboard map from anywhere outside a text box.
Speech bubble button, top right	My screen reader speaks the answers. Off, the default: this page speaks each answer in the browser's voice. On: the page stays silent and each whole answer goes to one status line for your own screen reader. Remembered in this browser.
`Alt`+`1`	Focus the primary action, Hear this code review.
`Alt`+`2`	Open and focus the patch box.
`Alt`+`3`	Focus the Braille cell region, which scrolls by keyboard.
`Alt`+`4`	Focus the review command box. Type a command and press `Enter` to send it; this is the path that needs no microphone.
`Alt`+`5`	Start or stop listening with the browser's speech recognition, when it has one.
`Alt`+`6`	Focus the pull request URL box. Paste a URL and press `Enter` to open it.
`Left` and `Right`	Move between the Evidence tabs once one has focus.
`Escape`	Interrupt: stop the speech, stop the earcon, and stop listening. Closes this map. Inside the review card it does the same, because the card asks this page to.
Inside the review card	Only `Tab`, `Shift`+`Tab`, `Enter`, `Space` and `Escape` work there. A key pressed inside the card's frame does not reach this page, so `?` and the `Alt` shortcuts work again once focus leaves it.

Every audio cue carries a written description in the same live region.
One voice per answer. By default the browser's speech engine speaks it, finding first, with every code operator named, and the status line only says a result arrived. With My screen reader speaks the answers on, or with no speech engine, the status line carries the whole answer and the page stays silent. The conversation log is history, not a live region.
Every spoken command has a typed twin, and every answer reads back what was understood before it acts.
The focus ring is a 3px outline offset from the control, in both colour schemes.
prefers-reduced-motion removes every animation and the smooth scroll; every state still changes, instantly.
Light and dark follow prefers-color-scheme, and neither is an afterthought.
An empty panel says why it is empty and which control fills it.
Words light up only when the speech engine reports reaching them; no timing is invented.