Talk in Morse (mors) new

One key, one tape. Key your message in dots and dashes and send it to Claude, who reads it as a prompt and does what it says. The window assumes you know Morse: only Doto helps you craft the message. mors lives in the store: it is not a default.

What it is

You hold a key. A short press is a dot, a long one a dash, and the tape shows them as you key. When the message is done, Send to Claude hands it over. Claude reads it as a prompt: it says in one line what it read, then does what the message asks, in the Claude Code transcript.

The window assumes you know Morse. By default it shows three things: the key, the tape and Send to Claude. No alphabet, no translation. Help comes from one place, Doto's menu: Read it back, Spell a word for me, Check what I keyed, Show the chart and Full controller (below).

Claude can talk Morse back. Its replies blink the lamp in magenta and sound a lower tone, on a second track of the tape under yours.

mors stores nothing on the host. The message lives in the window, and in a saved session after Send to Claude.

Install

mors is not in the engine's defaults.json. It lives in lets-store, so you install it once:

/lets store mors      # inspect → confirm
/lets mors            # open it

Claude shows you the inspection (permissions, problems, the verified flag) and copies it into ~/.lets/uniques/mors only after you say yes. Manual: clone the repo into ~/.lets/uniques/mors.

mors needs engine 0.4.0 or later ("engine": ">=0.4.0") for handoff sessions; it needs no new engine endpoint. It asks for no permissions: "fs.write": [], "net": []. Its capabilities are entity, chat and components.

This page describes mors 0.1.0 (2026-10-13). Like the other lets repositories, its repository is private for now.

What you can do

The tape and the key are the page: large, centred, calm, on the deep-violet dotted grid. A toolbar sits on top and a status line at the bottom.

Keying. Pause after the last dot or dash and the letter closes; pause longer and the word closes. That is when Claude sees the message: settled words, never half a letter. With auto on, each press tunes the speed, so the window follows your hand (the rules are under the hood). If you prefer typing, . keys a dot, - or _ a dash, and / a word gap.

Erasing. Backspace removes the last dot or dash of the letter you are keying, or the last letter when none is open. Ctrl+Backspace removes the last word. Eight dots or more in one letter (........) is the operator's own eraser: it drops itself and the word you were keying, and the tape says erased for a second. Ctrl+Z undoes the last erase, insert or clear (50 steps).

A long message. A message holds up to 4,000 elements or 1,000 characters; keying beyond that is refused with a toast. The tape draws the last 300 letters, with a … n more marker at the left.

Mouse & keyboard

Outside text fields, unless the row says otherwise:

Everything is reachable with Tab in page order and every control has an accessible name. The key is a real button: Enter on it keys a dot, and Space on it is the key, as everywhere else. With read-back on, a screen reader hears the decoded text through the readout's live region; it hears a ghost once, when it appears ("Spell: HELLO"). Under reduced motion the lamp still lights (it is the signal), but the key does not squash and nothing pulses.

Doto's help

The extras are hidden by default because the window assumes you know Morse: you key and read dots and dashes, nothing else. Help is there when you ask for it, and only then. Doto's menu is the way in. Click him and pick:

The menu ends with Open chat. Each of the three toggles (read-back, chart, full controller) is remembered for the next window. Claude can open them too, with mors.reveal, when you ask in the chat ("show me the text"). It does not push them on you: it offers one when you seem stuck, such as three unreadable groups in a row, an erase storm or a question in the chat.

Your hand, your message. Claude never erases or inserts unless you ask, and it prefers a ghost over an insert: the point is that you key it. A ghost is an offer; a ghost you key away from is a "no", and Claude does not send the same one again. While you key, Claude stays quiet: the tape is your draft, not a conversation. Doto speaks on a sign-off, on an SOS (once), on a spell, a check or a finished play, never on a letter.

His reactions. At most one per thing you do: a wink when you key a ghost to the end, an oops on the eight-dot eraser, a cheer on Send to Claude, a nod when Claude's play finishes, and a start when a word closes as SOS.

Claude talks back

mors.play is Claude talking Morse. The lamp blinks magenta, a lower tone sounds, and the symbols appear on Claude's track under yours as they play (with their characters when read-back is on). The status line says Doto is keying… until the play ends with mors.played, and Doto nods. Plays queue in order. The key stays live: press during a play and you key as usual; the two tones differ in pitch.

Claude keeps plays short, 20 characters at most: R (received), K (over, your turn), 73 (best regards), SK (end of contact), or a word you asked it to spell when you also want to hear it. Whole answers go to the chat or the transcript, never to the tape.

The reply track is part of the window's state: reply holds what Claude has played so far, it travels with Send to Claude and it comes back on resume.

Send to Claude

Send to Claude (the button, or Ctrl+Enter) is a handoff. The window sends mors.export: the Morse, the window's decode, the counts, the speed, which extras were open, Claude's reply track, the end sign and the stats. The engine saves it as a session and closes the window, with a cheer from Doto. An empty message cannot be sent.

Then Claude:

1. decodes the Morse itself. The window's text is a straight table lookup; your hand is not. Claude fixes what timing broke: a missing word gap that glued two words (HELLOWORLD), an extra one that split a word, a long dot read as a dash (E as T, S as U), a # that is two letters run together;
2. says in one line what it read: "Read: SHOW ME THE FAILING TESTS." When its reading differs from the window's, it says so and goes with its own. An unreadable word gets a best guess and a question in the same line;
3. treats the text as the prompt, exactly as if you had typed it in Claude Code: a question gets the answer, a task gets done, a request for a file gets the file. A greeting or a ham call (CQ, HELLO, TEST, SOS) gets a short greeting back; 73 or SK means you are leaving: one line, no questions;
4. labels the session in three to six words of the message.

End signs. When a letter closes as <AR> (.-.-.) or <SK> (...-.-), or a word closes as K, the Send button glows and takes the next Enter. Nothing is sent by itself. The sign travels in the export as ends, and Claude reads it: AR is end of message (the normal case), K is over (you expect a reply and may come back, so Claude ends its answer with what you can key next), SK is end of contact (Claude closes the loop).

Resume. The window names the session after the decoded text (up to 60 characters) plus · mors, such as SHOW ME THE TESTS · mors. Say continue and the window comes back with mors.load: your message and Claude's reply track intact, with no ghost or accept events. If you signed off with K, Claude plays a short reply then (R K). If the tab also kept a draft, a load in the first 8 seconds wins over it.

With "handoff": "stay" in ~/.lets/config.json the window stays open after Send: Claude answers in the chat and plays R on the tape so you know it landed. If Claude is not listening, Send still exports, and the window says Doto is away (at most once every 30 seconds).

The manifest's session block names the roles:

"session": { "export": "mors.export", "snapshot": "mors.snapshot", "restore": "mors.load" }

Events (up)

Each event says what you meant. morse uses . and - only, letters split by a space and words by / : ... --- ... / -.-. --.- is SOS CQ. text is the window's decode, uppercase, one character per letter group; a group not in the table reads # and its raw pattern stays in morse. Prosigns read <AR>, <SK> and <SOS>.

rev starts at 1 on an empty tape and never goes down; every change bumps it, a load included. stats counts dots, dashes, letters, words, errors, typed and assisted letters, and accepted and rejected ghosts.

Commands (down)

Commands are idempotent and animate (300 ms at most, transform and opacity only), except a play, which lasts as long as its message. Every command accepts "ack": true on the envelope and gets lip.ack {ok, error?} back. A bad command without ack gets lip.error {code: "bad_request", message, re}.

A round trip: you pick Spell a word for me → mors.ask {kind: "spell", question} → mors.suggest {rev, text, reason: "spell"} → you key the ghost (or Tab) → mors.ghost.accept.

// spell two words as a ghost
{"type":"mors.suggest","data":{"rev":7,"text":"HELLO WORLD","reason":"spell"}}
// talk back: received, over
{"type":"mors.play","data":{"id":"p1","text":"R K"}}
// the same, as elements
{"type":"mors.play","data":{"morse":".-. / -.-"}}
// show the read-back, because you asked in the chat
{"type":"mors.reveal","data":{"readback":true}}
// slower, and stop following the hand
{"type":"mors.set","data":{"wpm":10,"auto":false}}

Under the hood

Timing

• Units. A dot is 1 unit, a dash 3, the gap inside a letter 1, between letters 3, between words 7. unit is the dot length in ms, 1200 / wpm, clamped to 40 to 400 ms (30 to 3 wpm). The default is 100 ms (12 wpm).
• Dot or dash. A press shorter than 2 units is a dot; anything longer is a dash. Press times come from performance.now() in the pointer and key handlers, never from rendering.
• Silence closes things. After 2.2 units the letter closes: it is decoded, appended to the message, and rev goes up. After 5.5 units the word closes and mors.changed goes out.
• Auto. With auto on, each press tunes the unit: unit = 0.75·unit + 0.25·(dot ? press : press / 3), clamped to 40 to 400 ms. The wpm chip shows the result.
• Typed input. Typed ., - and _ are timed with a fixed 160 ms unit: the letter closes after 350 ms, the word after 880 ms. / forces a word gap.
• The error prosign. Eight dots or more in one group (........, <HH>) is never kept. When it closes, the window drops it and the word being keyed, back to the last word gap, shows erased on the tape for a second, and Doto plays his oops. Like every erase, it bumps rev and emits mors.changed.

The table

International Morse: A–Z, 0–9, the punctuation . , ? ' ! / ( ) & : ; = + - _ " $ @ and the prosigns <AR> (.-.-.), <SK> (...-.-) and <SOS> (...---...). -...- decodes as =, -.--. as ( and .-... as &. A letter is a group of 1 to 8 elements; only the eraser, a run of dots, grows longer.

Sound and lamp

Web Audio, started on your first press (browsers want a gesture first). One sine oscillator per track: 700 Hz for you, 520 Hz for Claude, with 5 ms ramps so there is no click. Sound is on by default; M, the toolbar button, the full controller or mors.set {sound} turns it off, and the choice is remembered. The lamp always works, sound or not.

Storage and offline

Nothing is stored on the host. sessionStorage["lets.mors.draft"] keeps the message and the reply track for this tab, so a reload keeps them. localStorage["lets.mors"] holds preferences: sound, wpm, auto and view. Nothing else is stored.

Without a host, mors still works: keying, read-back, the chart and the full controller are all local. Send, Ask and the ghost need the host and say so with a toast.

The files

lets-unique-mors/
  unique.json            # manifest: domain mors, engine >=0.4.0, no permissions
  GUIDE.md               # what Claude reads on open
  CONTRACT.md            # the unique's behaviour spec
  README.md  CHANGELOG.md  LICENSE  icon.svg
  package.json          # npm run validate
  scripts/validate.mjs   # zero-dependency manifest check
  schemas/               # unique.schema.json and message schemas
  ui/index.html          # the page
  ui/mors.js             # the window
  ui/morse.js            # table, encode, decode, the keyer state machine, timing
  ui/style.css

Plain HTML, ES modules and CSS: no build step, no CDN, no inline script, no eval, no user content through innerHTML. MIT licensed. More: lets-unique-mors has the full GUIDE.md, the behaviour contract (CONTRACT.md) and JSON Schemas for the messages.

Develop

Run the host standalone from a lets checkout. The registry looks for <dir>/mors/unique.json, so point it at the parent of a folder named mors (a symlink or junction to this repo works):

LETS_UNIQUES_DIRS=/path/to/parent node engine/bin/lets.mjs serve --open mors --verbose

node engine/bin/lets.mjs send mors.play '{"text":"R K"}'   # drive it from the CLI
node engine/bin/lets.mjs events                            # drain what mors emitted

--verbose prints every event the window emits. Validate with npm run validate in the repo, or node engine/bin/lets.mjs validate <this folder> from the engine. The general recipe is in Develop & validate.