<!-- GENERATED by starlens/site/tools/reference_pages.py from the engine's sources: do not edit; run it. -->

[[nav: reference | here=verbs]]

<div class="doc">

<!-- GENERATED by love-shared/scripts/verb_sheet.py from the app's registry (scripts/verb_inventory.lua): do not edit; run it. -->

# starlore · the verbs

<p class="plain"><a href="../../verbs/starlore.md">this page as plaintext</a></p>

*The notes and cards, the feed over them and the studies record, the reader, the guide's voice, the console. 112 verbs in 15 categories: 4 undoable, 31 read-only. The app-verbs protocol (`love-shared/docs/app-verbs.md`): `staros-tap starlore verbs` lists them live, `staros-tap starlore verb <name> '<json>'` runs one, `activity --since N` reads the journal. Loaded headless from `starlore` by `scripts/verb_inventory.lua`.*

## app

### `app.mode` — low, palette word `mode`

Switch StarLore's mode (the top bar's: notes, review, map, …).

| argument | type | notes |
|---|---|---|
| `mode` | string | required; one of notes, language, review, map |

    staros-tap starlore verb app.mode '{"mode": "notes"}'

### `app.state` — low, read-only

StarLore's compact state: the mode, the focused view, the selected note, the feed (when open), the reader, the guide, the terminal, the tap's port.

    staros-tap starlore verb app.state '{}'

### `lab.set` — low

The motion lab: speed = the motion clock's scale (1, 0.25, 0.1; 0 holds it for lab.step), loupe = true | false (the caret's pixels at 8x), feel = wipe | snap | today (how a typed glyph and the caret meet), tau = the wipe's time constant in ms (0 = the token's). Returns the lab's state.

| argument | type | notes |
|---|---|---|
| `feel` | string |  |
| `loupe` | boolean |  |
| `speed` | number |  |
| `tau` | number |  |

    staros-tap starlore verb lab.set '{}'

### `lab.state` — low, read-only

The motion lab's state: { loupe, speed, feel, tau, probe = { target, caret, ink, kind, frame } } (the probe in screen pixels, while the lab watches).

    staros-tap starlore verb lab.state '{}'

### `lab.step` — low

Hold the motion clock and advance it by `frames` hand-made frames of 1/60 s (1 by default). Returns the lab's state.

| argument | type | notes |
|---|---|---|
| `frames` | number |  |

    staros-tap starlore verb lab.step '{}'

## card

### `card.draft_status` — low, read-only

Where a draft sent to the record stands: queued (the applier has not read it), applied (its commit), conflict (master moved under the field), refused (why), deferred (it waits on a dirty file or the lock). The applier runs as the daemon service staros.studies-applier.

| argument | type | notes |
|---|---|---|
| `draft` | string | required |

    staros-tap starlore verb card.draft_status '{"draft": "…"}'

### `card.edit` — medium

Rewrite one field of the focused card (or `id`). A PASSAGE's heading, tags (a list, or comma-separated) or gloss leaves as a draft for the record: the applier commits it into the bank entry, found by its quote key; its quote, attribution and verdict are sealed and refused by name; a field master changed meanwhile comes back a conflict. A STARLORE card's heading (its note's title), tags, or text (its paragraph, cloze markup and all) is saved in the vault, its schedule kept. Ask the person before you edit. Returns the draft's id and state (card.draft_status follows it) or the save.

| argument | type | notes |
|---|---|---|
| `field` | string | required |
| `id` | string |  |
| `text` | any | required; the new words (tags: a list or a comma list) |

    staros-tap starlore verb card.edit '{"field": "…", "text": "…"}'

### `card.make_cloze` — low

Make a cloze card from the focused passage (or `id`) with `span` (words of its quote) as the blank: a StarLore snippet from the passage, the span hidden. A different card from feed.keep's (which hides the whole quote). Ask which words first.

| argument | type | notes |
|---|---|---|
| `id` | string |  |
| `span` | string | required |

    staros-tap starlore verb card.make_cloze '{"span": "…"}'

### `card.open_source` — low, palette word `source`

Open the focused card's (or `id`'s) source in the reader beside the feed: the witness's transcription at the page and line, the quote found and lit; a note or a deck card's file at its line.

| argument | type | notes |
|---|---|---|
| `id` | string |  |

    staros-tap starlore verb card.open_source '{}'

## feed

### `feed.filter` — low

Narrow the feed (both tabs): lanes (lore = StarLore's cards, passage = the studies passages, deck = the programme deck; all), corpus (atlas, media, dogen, design: passages), witness (an id), tags (any of), text (a substring of the quote, heading, gloss, tags or witness). Fields merge with the filter already set; clear=true drops them all. No match is a result (an empty stream), not a refusal.

| argument | type | notes |
|---|---|---|
| `clear` | boolean |  |
| `corpus` | string |  |
| `lanes` | array |  |
| `tags` | array |  |
| `text` | string |  |
| `witness` | string |  |

    staros-tap starlore verb feed.filter '{}'

### `feed.focus` — low

Focus a card by id (from feed.state's visible), or step through the stream (step = 1 / -1). The column glides it onto the resting line.

| argument | type | notes |
|---|---|---|
| `id` | string |  |
| `step` | integer |  |

    staros-tap starlore verb feed.focus '{}'

### `feed.grade` — low, undoable, palette word `grade`

Grade the focused card (or `id`): 1 again, 2 hard, 3 good, 4 easy — StarLore's scheduler for a lore card, the deck ledger for a deck card. Reveal first. A passage is not graded (feed.read / feed.keep). feed.undo takes it back. The person grades; an agent grades only when asked to.

| argument | type | notes |
|---|---|---|
| `grade` | integer | required; minimum 1; maximum 4 |
| `id` | string |  |

    staros-tap starlore verb feed.grade '{"grade": 0}'

### `feed.keep` — low, undoable, palette word `keep`

Keep the focused passage (or `id`) in StarLore: it crosses as a cloze snippet (starpress's keep, the same snippet whichever app keeps it) and becomes a card in the lore lane. feed.undo takes it back.

| argument | type | notes |
|---|---|---|
| `id` | string |  |

    staros-tap starlore verb feed.keep '{}'

### `feed.open` — low, palette word `feed`

Open the feed in the focused pane: Today (what is due, then a capped few new, then caught up) or Browse (everything, newest first). The model and its day survive closing the pane.

| argument | type | notes |
|---|---|---|
| `tab` | string | one of today, browse |

    staros-tap starlore verb feed.open '{}'

### `feed.read` — low, undoable, palette word `read`

Mark the focused passage (or `id`) read: it leaves today and the sample does not draw it again.

| argument | type | notes |
|---|---|---|
| `id` | string |  |

    staros-tap starlore verb feed.read '{}'

### `feed.refresh` — low, palette word `refresh`

Re-read the vault's cards, the studies snapshot and the deck ledger.

    staros-tap starlore verb feed.refresh '{}'

### `feed.reveal` — low, palette word `reveal`

Reveal the focused card (or `id`): a card's answer, a passage's heading, gloss and tags.

| argument | type | notes |
|---|---|---|
| `id` | string |  |

    staros-tap starlore verb feed.reveal '{}'

### `feed.say` — low

The person's say line (`:` in the feed). A dotted verb name runs at once ('feed.filter lanes=passage'), as does one palette word alone ('undo'); anything else goes to the guide in the console. Agents speak with guide.say, never this.

| argument | type | notes |
|---|---|---|
| `text` | string | required |

    staros-tap starlore verb feed.say '{"text": "…"}'

### `feed.skip` — low, undoable, palette word `skip`

Skip the focused card (or `id`) for today; a skipped passage rests two weeks before the daily sample may draw it again. feed.undo takes it back.

| argument | type | notes |
|---|---|---|
| `id` | string |  |

    staros-tap starlore verb feed.skip '{}'

### `feed.state` — low, read-only

The feed as the person sees it: the tab, the filter, the day's counts (due, new, done, total, caught_up), each lane's status, the corpora, the FOCUSED card (front; back only once revealed; heading, gloss, tags; source: witness, page, line; what is sealed and what is editable), the visible ids top to bottom, an open edit, the sitting's tally. Read it first, and after every change.

    staros-tap starlore verb feed.state '{}'

### `feed.tab` — low

Switch the feed between today and browse.

| argument | type | notes |
|---|---|---|
| `tab` | string | required; one of today, browse |

    staros-tap starlore verb feed.tab '{"tab": "today"}'

### `feed.undo` — low, palette word `undo`

Take back the last grade, skip, read or keep (the card comes back, focused and revealed).

    staros-tap starlore verb feed.undo '{}'

## guide

### `guide.clear` — low

Take away the margin cards (pinned ones stay), the pointing, or both (what: cards | points).

| argument | type | notes |
|---|---|---|
| `what` | string | one of cards, points |

    staros-tap starlore verb guide.clear '{}'

### `guide.pin` — low, palette word `pin`

Keep a margin card (default: the guide's newest) as a StarLore snippet whose source_url is guide://task/starlore/<slug>/<stamp>-<n>, so an explanation worth keeping stays in the vault with where it came from. Ask before pinning on the person's behalf.

| argument | type | notes |
|---|---|---|
| `card` | string |  |

    staros-tap starlore verb guide.pin '{}'

### `guide.point` — low, palette word `point`

Make a card's gutter pulse for a few seconds and bring it into focus, so the person sees where to look: card (an id from feed.state's visible; default the focused card), field (heading, quote, gloss, tags, source, grade), label (a few words), secs 1-60 (default 4). Point before you explain.

| argument | type | notes |
|---|---|---|
| `card` | string |  |
| `field` | string | one of heading, quote, gloss, tags, source, grade |
| `label` | string |  |
| `secs` | number | minimum 1; maximum 60 |

    staros-tap starlore verb guide.point '{}'

### `guide.say` — low, palette word `say`

Say one line to the person, in the feed: a margin card under the card they are on (or the card `at` names). Short and concrete (at most ~240 characters): what to look at, what to do next, or a question. tone: info (default), ask (waiting on the person), done (a step finished), result. **bold** and `code` are drawn. Never an undo step.

| argument | type | notes |
|---|---|---|
| `at` | string |  |
| `text` | string | required |
| `tone` | string | one of info, ask, done, result |

    staros-tap starlore verb guide.say '{"text": "…"}'

### `guide.state` — low, read-only

The margin cards in the stream (id, the card each is under, tone, text, pinned), the thinking slot (seconds the person's line has waited), and what is pointed at.

    staros-tap starlore verb guide.state '{}'

## links

### `link.open` — low

Open a link wherever it belongs (shared.links): here, a host, another app's tap or a spawn, a soft handoff on iOS.

| argument | type | notes |
|---|---|---|
| `uri` | string | required |

    staros-tap starlore verb link.open '{"uri": "…"}'

### `open` — low

A link handed to this StarLore (note://, cart://, a piece's, starlore://feed): opened here at the place, retried until the snapshot holds it.

| argument | type | notes |
|---|---|---|
| `line` | integer |  |
| `note` | string |  |
| `uri` | string | required |

    staros-tap starlore verb open '{"uri": "…"}'

## map

### `map.find` — low, read-only

Find nodes in the shown lens (or `lens`) by title, label or id, best first: the label itself, then a label that starts so, then a word that does, then anywhere; every word must land. Returns { lens, hits = { {id, kind, label} } } (at most `limit`, 12). Nothing is selected.

| argument | type | notes |
|---|---|---|
| `lens` | string | one of vault, studies, ecosystem |
| `limit` | integer |  |
| `text` | string | required |

    staros-tap starlore verb map.find '{"text": "…"}'

### `map.lens` — low

Show the Map on a lens: vault (her notes and what they link to: tasks, cards, branches, studies pieces), studies (the record's pieces and articles, what each cites, mentions and gathers, read at the checkout's HEAD), ecosystem (the house's apps, features and techniques by region). Switches to the Map. Returns map.state.

| argument | type | notes |
|---|---|---|
| `lens` | string | required; one of vault, studies, ecosystem |

    staros-tap starlore verb map.lens '{"lens": "vault"}'

### `map.open` — low

Open the selection (or `id` in the shown lens) where it lives: a note in Notes, a card in Review, a studies piece in a running workbench or the studies reader, an article in its compose pane when the piece snapshot serves it, else its file; outside = true skips the in-app view. Returns { ok, said }.

| argument | type | notes |
|---|---|---|
| `id` | string |  |
| `outside` | boolean |  |

    staros-tap starlore verb map.open '{}'

### `map.select` — low

Select a node by id (a note is note:<slug>, a vault leaf <kind>:<target> such as fascicle:F03, a studies piece F03 / T74 / J02, an article A:<stem>, a reading note N:<stem>, an ecosystem node its slug) in the shown lens or in `lens`, and glide to it; depth (0, 1, 2) shows only what is that near. id omitted clears the selection. Returns map.state, the selection's links grouped as the inspector lists them.

| argument | type | notes |
|---|---|---|
| `depth` | integer |  |
| `id` | string |  |
| `lens` | string | one of vault, studies, ecosystem |

    staros-tap starlore verb map.select '{}'

### `map.state` — low, read-only

The Map as she sees it: the lens (its nodes, links, whether its layout has settled, "links read at <head>" for Studies, or why it is disabled), every lens's size, the kinds with their counts and which are shown, the camera, what the last frame drew and culled, the selection (id, kind, title, state, file, its links grouped: Cites, Cited by, Mentions, Gathers, Gathered in, Links to, Linked from), the neighbourhood's depth, an open search and its hits, the history. Read it first.

    staros-tap starlore verb map.state '{}'

## media

### `media.audio_to_store` — medium

Move the old audio into the device's sound store (the one every app reads; docs/sound.md): a dry run unless apply = true. It lists each audio file in media/ (its store id, every note and snippet line that links it, and what stays: m4a, opus, aac, a take's own copy); applied, it files each sound in the store, backs up every note and snippet it changes to notes-backup/<UTC>/, rewrites their links to vault://sound/<sha16>.wav (skipping, and naming, anything with unsaved edits or changed on disk), and deletes nothing.

| argument | type | notes |
|---|---|---|
| `apply` | boolean |  |

    staros-tap starlore verb media.audio_to_store '{}'

## note

### `lapse.set` — low

Steer the time-lapse in front: view = final | all | deleted | edited; mode = text | blocks; anim = revisions | versions | write; version = n shows the text as of version n (0 = the last); play = true | false. Returns its state.

| argument | type | notes |
|---|---|---|
| `anim` | string |  |
| `mode` | string |  |
| `play` | boolean |  |
| `version` | number |  |
| `view` | string |  |

    staros-tap starlore verb lapse.set '{}'

### `media.ingest` — medium

Take a picture or a sound from a file on this box into the vault's media under the store's own name; a file already there is kept. Returns { uri, filename, hash, kind, existed }: a note shows it with ::image[src="<uri>"].

| argument | type | notes |
|---|---|---|
| `alt` | string |  |
| `mime` | string |  |
| `path` | string | required |

    staros-tap starlore verb media.ingest '{"path": "…"}'

### `note.autosave` — low

Autosave: a dirty note is saved once its text has been still for a moment (prefs `autosave`). on = true | false sets it; omitted reads it. Returns { on, pending, kept }.

| argument | type | notes |
|---|---|---|
| `on` | boolean |  |

    staros-tap starlore verb note.autosave '{}'

### `note.delete` — medium

Delete a note: its file is kept first as <save>/notes-trash/<slug>-<time>.note.md, its schedule stays in srs.json, the panes that showed it are cleared. A note in a live session is refused. Returns { slug, trash }.

| argument | type | notes |
|---|---|---|
| `slug` | string | required |

    staros-tap starlore verb note.delete '{"slug": "…"}'

### `note.disk` — low, read-only

A note's file against what StarLore holds (same | changed | gone | new | none), whether it has unsaved edits or an open conflict; with no slug, every note followed now (in a pane, selected, played) and the open conflicts.

| argument | type | notes |
|---|---|---|
| `slug` | string |  |

    staros-tap starlore verb note.disk '{}'

### `note.keep` — medium

In a conflict (the file changed under unsaved edits), keep StarLore's text: the file's own is kept in notes-conflicts, then the note is written over it.

| argument | type | notes |
|---|---|---|
| `slug` | string | required |

    staros-tap starlore verb note.keep '{"slug": "…"}'

### `note.lapse` — low

Open a note's time-lapse in the centre pane: its kept versions (core/versions.lua) folded into every word ever written. `journal` = a date opens a journal day's instead. Returns the view's state { versions, totals, counts, text_view, mode, anim }.

| argument | type | notes |
|---|---|---|
| `journal` | string |  |
| `slug` | string |  |

    staros-tap starlore verb note.lapse '{}'

### `note.new` — medium

Make a note: a new file notes/<slug>.note.md in the vault with text as its body and title as its title (the slug's words by default), saved at once; select = true opens it. kind goes in its front matter ("script": a script you play as pages, docs/formats/script.md in the monorepo). An existing note, or a file already under that slug, is refused. The slug is [a-z0-9][a-z0-9-_]*, at most 80.

| argument | type | notes |
|---|---|---|
| `kind` | string |  |
| `select` | boolean |  |
| `slug` | string | required |
| `text` | string |  |
| `title` | string |  |

    staros-tap starlore verb note.new '{"slug": "…"}'

### `note.overlay` — low

Lay a mark list (brushwork/1's `marks`; {} clears) over the focused note editor's text.

| argument | type | notes |
|---|---|---|
| `marks` | array |  |

    staros-tap starlore verb note.overlay '{}'

### `note.pin` — low

Pin a note to the library's PINNED section (its front matter's `pinned = true`, saved at once); on = false unpins; omitted toggles. Returns { slug, pinned }.

| argument | type | notes |
|---|---|---|
| `on` | boolean |  |
| `slug` | string | required |

    staros-tap starlore verb note.pin '{"slug": "…"}'

### `note.reload` — medium

Read a note's file again and take it. A note with unsaved edits, or in conflict, is taken only with theirs = true, and the unsaved text is kept in notes-conflicts first.

| argument | type | notes |
|---|---|---|
| `slug` | string | required |
| `theirs` | boolean |  |

    staros-tap starlore verb note.reload '{"slug": "…"}'

### `note.version` — low

Keep the note's text as a version now (what Ctrl+S does). Returns { slug, versions }.

| argument | type | notes |
|---|---|---|
| `slug` | string |  |

    staros-tap starlore verb note.version '{}'

### `note.versions` — low

A note's kept versions, oldest first: { slug, versions = [{ at, sha, words, why }] } (read-only).

| argument | type | notes |
|---|---|---|
| `slug` | string | required |

    staros-tap starlore verb note.versions '{"slug": "…"}'

## piece

### `piece.board` — low

A shot script's storyboard in StarBoard (board://<slug>[#<shot>]); `dry` returns the uri only.

| argument | type | notes |
|---|---|---|
| `dry` | boolean |  |

    staros-tap starlore verb piece.board '{}'

### `piece.config` — medium

Point this StarLore at the piece media server(s): {servers=[{base, token, write_token}]} or {base, token}; the phone's; `force` on a desktop. Tokens are stored, never echoed.

| argument | type | notes |
|---|---|---|
| `base` | string |  |
| `force` | boolean |  |
| `servers` | array |  |
| `token` | string |  |
| `write_token` | string |  |

    staros-tap starlore verb piece.config '{}'

### `piece.edit` — low

Set one field's edit on the focused script ({key = "F2.voice", text}; text null drops it). Pending until piece.send.

| argument | type | notes |
|---|---|---|
| `key` | string | required |
| `text` | string |  |

    staros-tap starlore verb piece.edit '{"key": "…"}'

### `piece.goto` — low

In an article or companion: the caret to a line, to a note's definition, or just after the first place the draft says `after`'s words.

| argument | type | notes |
|---|---|---|
| `after` | string |  |
| `line` | integer |  |
| `note` | string |  |

    staros-tap starlore verb piece.goto '{}'

### `piece.jump` — low

In an article or companion: the caret between the reference under it and its definition (Ctrl+]).

    staros-tap starlore verb piece.jump '{}'

### `piece.list` — low, read-only

The snapshot's pieces (slug, docs), the client's root, and the PIECES rows' on-screen rects.

    staros-tap starlore verb piece.list '{}'

### `piece.margin` — low, read-only

An article's or companion's margin: notes, references the build refuses, answers, each at its line.

    staros-tap starlore verb piece.margin '{}'

### `piece.open` — low, palette word `piece`

Open a piece's document (script | article | companion) as the focused pane's view, at a line or a note.

| argument | type | notes |
|---|---|---|
| `doc` | string | one of script, article, companion, story, stack |
| `line` | integer |  |
| `note` | string |  |
| `slug` | string | required |

    staros-tap starlore verb piece.open '{"slug": "…"}'

### `piece.outbox` — low, read-only

The outbox's items (no text, no tokens) and how many writers it has.

    staros-tap starlore verb piece.outbox '{}'

### `piece.pins` — low

The article's pinboard in StarBoard (pins://<slug>) at the pin on the caret's line; `dry` returns the uri only.

| argument | type | notes |
|---|---|---|
| `dry` | boolean |  |

    staros-tap starlore verb piece.pins '{}'

### `piece.play` — low

The band's play button: the open field's newest take, or stop it.

    staros-tap starlore verb piece.play '{}'

### `piece.point` — low, read-only

A script field's on-screen point (to tap it through the real touch path); refused when scrolled off.

| argument | type | notes |
|---|---|---|
| `key` | string | required |

    staros-tap starlore verb piece.point '{"key": "…"}'

### `piece.record` — low

The band's record button: a take of the open field (`key` opens that field first). action: start | stop | toggle | cancel.

| argument | type | notes |
|---|---|---|
| `action` | string | one of start, stop, toggle, cancel |
| `key` | string |  |

    staros-tap starlore verb piece.record '{}'

### `piece.save` — medium, palette word `save`

Save the focused article's or companion's draft here (Ctrl+S). piece.send sends it.

    staros-tap starlore verb piece.save '{}'

### `piece.scroll` — low

Set the focused piece view's scroll (px), clamped.

| argument | type | notes |
|---|---|---|
| `to` | number | required |

    staros-tap starlore verb piece.scroll '{"to": 0}'

### `piece.send` — medium

Queue the focused script's edits as a draft (the header chip's action); the nonce.

    staros-tap starlore verb piece.send '{}'

### `piece.state` — low, read-only

The focused view if it is a piece, the open key, the mode, the phone view, the selected note.

    staros-tap starlore verb piece.state '{}'

### `piece.sync` — medium

Start a sync of the snapshot now (piece.config first); its status.

    staros-tap starlore verb piece.sync '{}'

### `piece.sync_state` — low, read-only

Whether a server is configured, the sync's status, the client's root, any tick error.

    staros-tap starlore verb piece.sync_state '{}'

### `piece.take_record` — medium

Keep the draft's words beside it and make the draft the snapshot's text again.

    staros-tap starlore verb piece.take_record '{}'

### `piece.takes` — low, read-only

The focused shot script's takes (the index; no audio).

    staros-tap starlore verb piece.takes '{}'

### `piece.web` — low

The article's page in the studio at the note near the caret; `dry` returns the url only.

| argument | type | notes |
|---|---|---|
| `dry` | boolean |  |

    staros-tap starlore verb piece.web '{}'

## play

### `play.back` — low

Back along the reader's own path (else the page before).

    staros-tap starlore verb play.back '{}'

### `play.bounce` — low

Bounce a StarTune song into the sound store from here, StarTune open or not (love-shared sound/bounce.lua: its CLI over the saved song, the same bytes StarTune makes): `song` (its folder's name) and `section`, else the song the page playing names (its music, tune://<song>[#<section>]). Answers at once; bounce_done (or bounce_failed) lands in activity, and the page playing is read again so it plays the new bounce.

| argument | type | notes |
|---|---|---|
| `section` | string |  |
| `song` | string |  |

    staros-tap starlore verb play.bounce '{}'

### `play.close` — low

Stop playing: the sound stops, the reader's place is kept.

    staros-tap starlore verb play.close '{}'

### `play.go` — low

Go to a page by its id (a link's way, a step of the reader's path).

| argument | type | notes |
|---|---|---|
| `id` | string | required |

    staros-tap starlore verb play.go '{"id": "…"}'

### `play.next` — low

The next page (as Right or a click; a hold or a page with no Next refuses, saying why).

    staros-tap starlore verb play.next '{}'

### `play.open` — low, palette word `play`

Play a script note as pages (its front matter kind = "script"; docs/formats/script.md): beside the note on a desktop, in its place on a phone; from `page` (an id), else where the reader left off.

| argument | type | notes |
|---|---|---|
| `page` | string |  |
| `slug` | string | required |

    staros-tap starlore verb play.open '{"slug": "…"}'

### `play.reload` — low

Read the played note from disk again (Ctrl+R): taken when the note is clean, refused with why when it has unsaved edits.

    staros-tap starlore verb play.reload '{}'

### `play.sample` — low

Put the sample script, "The last ferry" (the-last-ferry), and its three sounds (made here, never shipped as files) in the vault, each only when it is not there yet.

    staros-tap starlore verb play.sample '{}'

### `play.state` — low, read-only

Where the played script is: the state (page, hold, ended, error), the page (id, n of), its row (the music and style in force, with where each was set), its wait, the bookmark, the errors and warnings (each with its line and fix), the sound's last error.

    staros-tap starlore verb play.state '{}'

### `play.table` — low, read-only

The fold's table: every page's music, style, cues, loops, wait and next, as a reader landing there would have them.

    staros-tap starlore verb play.table '{}'

## poetics

### `poetics.analyze` — low, read-only

Read a text's lines: each line's metre with its band (clear, likely, open, none) and reasons, its rhyme scheme letter, and each word's syllables, stress and beats. Without text, the snippet in front, as its lens reads it (English only).

| argument | type | notes |
|---|---|---|
| `text` | string |  |

    staros-tap starlore verb poetics.analyze '{}'

### `poetics.cards` — low, read-only

The cards about its sound a text asks for (phase 4: a `::scansion[line=N]::` or `::rhyme[word=W]::` line): the note named or in front, else the snippet in front. Each its kind, id, front and back.

| argument | type | notes |
|---|---|---|
| `slug` | string |  |

    staros-tap starlore verb poetics.cards '{}'

### `poetics.check` — low, read-only

The checker that explains: refusals from a form's limits (a line over twelve words, digits, a second dedication, the words past the budget), questions on rhyme and metre, notes on the sound, each with its line and its ruling (forms.json, the rules studies brushwork's form brush applies). With text, that text under `form` (default poem); without, the note in front as it is written, under its declared form, whose marks are the overlay's form layer.

| argument | type | notes |
|---|---|---|
| `form` | string |  |
| `scheme` | string |  |
| `slug` | string |  |
| `text` | string |  |

    staros-tap starlore verb poetics.check '{}'

### `poetics.form` — low, palette word `form`

Declare the form the note in front is written in (poem, dotoku, card; "" clears): its front matter's `form`, saved with the note. The checker then reads it as it is written.

| argument | type | notes |
|---|---|---|
| `form` | string | required |
| `slug` | string |  |

    staros-tap starlore verb poetics.form '{"form": "…"}'

### `poetics.gate` — low, read-only

Gate the note in front's quotations as the kit gates a piece (essay_gate: each blockquote against the witness its `— <id>,` line names), in a worker; a desktop's. The verdicts come as the overlay's gate layer and the CHECK section's rows; poetics.state's `gate` says when it is done.

| argument | type | notes |
|---|---|---|
| `slug` | string |  |

    staros-tap starlore verb poetics.gate '{}'

### `poetics.lens` — low, palette word `lens`

Set the Language tab's lens, as v and 1–4 do: vocab (the vocab states), sound (syllables, stress, alliteration and assonance), meter (beats, the metre in the gutter), rhyme (one hue per rhyme family, the scheme letter in the gutter). Without lens, the next one (step -1: the one before). English only for now; another language keeps the lens and draws vocab.

| argument | type | notes |
|---|---|---|
| `lens` | string | one of vocab, sound, meter, rhyme |
| `step` | integer |  |

    staros-tap starlore verb poetics.lens '{}'

### `poetics.point` — low, read-only

A word's rect in the reading view as it was last drawn (the nth with that surface, default the first), to tap it through the real click path, which selects it for the lemma pane's SOUND block. Refused when it is not drawn.

| argument | type | notes |
|---|---|---|
| `nth` | integer |  |
| `surface` | string | required |

    staros-tap starlore verb poetics.point '{"surface": "…"}'

### `poetics.state` — low, read-only

The Language tab's lens, the snippet and its language (supported: English), the lens chip's rect (a phone's acceptance taps it), the selected word, and the rhyme scheme a lens is reading.

    staros-tap starlore verb poetics.state '{}'

### `poetics.word` — low, read-only

One word's sound, by its surface (never its lemma): syllables, stress ("100"), the phones by syllable, IPA, the part a rhyme turns on, and where it came from (CMUdict, or a guess naming its rule).

| argument | type | notes |
|---|---|---|
| `surface` | string | required |

    staros-tap starlore verb poetics.word '{"surface": "…"}'

## reader

### `reader.close` — low

Close the reader beside the feed (the keyboard returns to the feed).

    staros-tap starlore verb reader.close '{}'

### `reader.seek` — low

Move the open reader: page (a @@PAGE marker's number), line (1-based), or quote (words found and lit, the tiers exact / normalized / squash said). The reader follows the focused card by itself; seek is for going elsewhere in the same witness.

| argument | type | notes |
|---|---|---|
| `line` | integer |  |
| `page` | any | a page marker's number (a number or a string) |
| `quote` | string |  |

    staros-tap starlore verb reader.seek '{}'

### `reader.state` — low, read-only

The reader: open or not, the card it shows, the witness (or note, or file), the page and line of the reading position, the span's tier (exact / normalized / squash), and what it could not find.

    staros-tap starlore verb reader.state '{}'

## study

### `study.verdict` — low, read-only

The last verify's answer: the witness, the span, concord's verdict, tier, locus and line (or why there was none), and whether one is still running.

    staros-tap starlore verb study.verdict '{}'

### `study.verify` — low, palette word `verify`

Verify a span against its witness, as Ctrl+Shift+K does the selection: concord's verdict lands in the flash and in study.verdict. Without span, the focused editor's selection; without witness, essay_gate's pairing (the attribution under the blockquote, or the text's one witness).

| argument | type | notes |
|---|---|---|
| `exact` | boolean |  |
| `span` | string |  |
| `witness` | string |  |

    staros-tap starlore verb study.verify '{}'

## terminal

### `terminal.focus` — low

Move keyboard focus to the terminal (showing it) or back to the app; toggles with no `to`.

| argument | type | notes |
|---|---|---|
| `to` | string | one of terminal, app |

    staros-tap starlore verb terminal.focus '{}'

### `terminal.hide` — low

Hide the drawer; the session stays attached and the agent keeps streaming.

    staros-tap starlore verb terminal.hide '{}'

### `terminal.open` — low, palette word `term`

Show the task's terminal (the drawer) and start an agent in it on first creation: claude, code (starsage) or shell.

| argument | type | notes |
|---|---|---|
| `agent` | string | one of claude, guide, code, shell, greenkeeper, warden, stoker, scribe, herald, busker, porter |

    staros-tap starlore verb terminal.open '{}'

### `terminal.screen` — low, read-only

What the task's terminal shows now: its visible lines, title, size, the link's state.

    staros-tap starlore verb terminal.screen '{}'

### `terminal.send` — low, palette word `ask`

Type a line into the task's terminal and press Enter (enter=false types without it): hand the agent there a request.

| argument | type | notes |
|---|---|---|
| `enter` | boolean |  |
| `text` | string | required |

    staros-tap starlore verb terminal.send '{"text": "…"}'

## ui

### `ui.close` — low

Close the UI editor's overlay.

    staros-tap starlore verb ui.close '{}'

### `ui.get` — low, read-only

A colour's value and its hex, a house table's ([theme.color], [base.color]) or one the app registered; or a named motion's value (motion.toast.slide ms); or a layout token's step and px ([theme.corner] button).

| argument | type | notes |
|---|---|---|
| `key` | string | required |
| `table` | string | required; one of aesthetic.panel, aesthetic.substrate, aesthetic.themed, app_accent, base.color, base.radius, base.space, launcher.color, motion.card.enter, motion.card.exit, motion.card.flash, motion.card.reveal, motion.caret.blink, motion.editor.caret, motion.editor.caret_glide, motion.editor.caret_hold, motion.editor.caret_type, motion.editor.scroll, motion.editor.select_fade, motion.editor.select_snap, motion.feed.follow, motion.lapse.version, motion.lapse.write_in, motion.list.scroll, motion.overlay.fade_in, motion.overlay.fade_out, motion.panel.slide, motion.prompt.pulse, motion.toast.fade, motion.toast.life, motion.toast.pulse, motion.toast.slide, palette, starboard.color, starlore.color, starsaga.color, startune.color, startune.phone, startune.section, theme.color, theme.corner, theme.inset, theme.pad, theme.radius |

    staros-tap starlore verb ui.get '{"table": "aesthetic.panel", "key": "…"}'

### `ui.inspect` — low, read-only

The widgets the last frame drew while the overlay is open: kind, rect, and each colour role with its owner.

| argument | type | notes |
|---|---|---|
| `limit` | integer | minimum 1 |

    staros-tap starlore verb ui.inspect '{}'

### `ui.open` — low

Open the in-app UI editor's overlay (the widgets note what they draw while it is open).

    staros-tap starlore verb ui.open '{}'

### `ui.ops` — low, read-only

The unsaved changes as the writer's ops (token ops, and the shell document when it was edited).

    staros-tap starlore verb ui.ops '{}'

### `ui.revert` — low

Put every unsaved change back as it was.

    staros-tap starlore verb ui.revert '{}'

### `ui.save` — medium

Write the unsaved changes through scripts/ui_edit.py: tokens.toml (the floors checked first) and the shell document (the format checked first; dry_run reports without writing).

| argument | type | notes |
|---|---|---|
| `dry_run` | boolean |  |

    staros-tap starlore verb ui.save '{}'

### `ui.set` — low

Change a colour live, a house table's or one the app registered (hex or [r, g, b, a] in 0..1): the next frame draws it. Or a named motion's value (a number, or a name: an easing, a law, a shape): the next motion that starts takes it. Or a layout token's step ("radius.2" for [theme.corner] button): the next frame draws it. Unsaved until ui.save.

| argument | type | notes |
|---|---|---|
| `key` | string | required |
| `table` | string | required; one of aesthetic.panel, aesthetic.substrate, aesthetic.themed, app_accent, base.color, base.radius, base.space, launcher.color, motion.card.enter, motion.card.exit, motion.card.flash, motion.card.reveal, motion.caret.blink, motion.editor.caret, motion.editor.caret_glide, motion.editor.caret_hold, motion.editor.caret_type, motion.editor.scroll, motion.editor.select_fade, motion.editor.select_snap, motion.feed.follow, motion.lapse.version, motion.lapse.write_in, motion.list.scroll, motion.overlay.fade_in, motion.overlay.fade_out, motion.panel.slide, motion.prompt.pulse, motion.toast.fade, motion.toast.life, motion.toast.pulse, motion.toast.slide, palette, starboard.color, starlore.color, starsaga.color, startune.color, startune.phone, startune.section, theme.color, theme.corner, theme.inset, theme.pad, theme.radius |
| `value` | any | required |

    staros-tap starlore verb ui.set '{"table": "aesthetic.panel", "key": "…", "value": "…"}'

### `ui.shell` — low, read-only

The app's shell document as the editor holds it (docs/formats/shell.md): its file, identity, panes, toolbar rows, sheet, seed, keys, docks and rooms, and whether it is unsaved.

    staros-tap starlore verb ui.shell '{}'

### `ui.shell_insert` — low

Insert a row before row i of a list (the path ends in [i]: toolbar[2], sheet[1], panes[17]); the value is the row. Checked first; unsaved until ui.save.

| argument | type | notes |
|---|---|---|
| `path` | string | required |
| `value` | any | required |

    staros-tap starlore verb ui.shell_insert '{"path": "…", "value": "…"}'

### `ui.shell_move` — low

Move a row of a list (toolbar, sheet, panes, rooms.order) from one position to another. Unsaved until ui.save.

| argument | type | notes |
|---|---|---|
| `from` | integer | required; minimum 1 |
| `list` | string | one of toolbar, sheet, panes, rooms.order |
| `to` | integer | required; minimum 1 |

    staros-tap starlore verb ui.shell_move '{"from": 0, "to": 0}'

### `ui.shell_remove` — low

Remove what a path names: a row (toolbar[3]), a key (keys.zoom), a dock or a room (docks.library, rooms.list.loop). Checked first; unsaved until ui.save.

| argument | type | notes |
|---|---|---|
| `path` | string | required |

    staros-tap starlore verb ui.shell_remove '{"path": "…"}'

### `ui.shell_set` — low

Set what a path into the shell document names, live (toolbar[3].label, sheet[2].action, panes[17], keys.close, docks.terminal.ratio, rooms.active, rooms.list.loop.title, seed.first.ratio; a name on the way is made, an index is not); the format's check runs on a copy first. Unsaved until ui.save.

| argument | type | notes |
|---|---|---|
| `path` | string | required |
| `value` | any | required |

    staros-tap starlore verb ui.shell_set '{"path": "…", "value": "…"}'

<details class="changes">
<summary>The work on this page: the commits of the last 30 days on its sources, the work open against them, its checks</summary>

[[timeline: src=love-shared/docs/verbs/starlore.md | kinds=commit | days=30]]

[[work: open | src=love-shared/docs/verbs/starlore.md]]

[[work: checks | rows=lint/web-reference,lint/verb-sheets]]

</details>

<nav class="pager"><span></span><a href="../../">The reference</a><span></span></nav>

*Generated by `tools/reference_pages.py` from `love-shared/docs/verbs/starlore.md`; the twin `bfaad079a7ce` (434093 bytes). The words are a draft.*

</div>
