starlore · the verbs

this page as plaintext

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//-, 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 '{}'

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:, a vault leaf : such as fascicle:F03, a studies piece F03 / T74 / J02, an article A:, a reading note N:, 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 ” 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//, rewrites their links to vault://sound/.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=“”].

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 /notes-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/.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://[#]); 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://) 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://[#

]). 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": "…"}'
The work on this page: the commits of the last 30 days on its sources, the work open against them, its checks

  • love-shared 05b668f docs: StarLore's verb sheet regenerated (112 verbs: the Map's map.* among them); the joins' note says before the deck

  • love-shared 7704975 the desk tidied, batch 2: the actual library (the studies bibliography), PDFs read, clips into StarLore and StarBoard launcher/the-desk-tidied-batch-2-the-actual-library-the-studies-bibliography-pdfs-read-the-folders-and-clips-into-starlore-and-starboard-pages

  • love-shared 7185c68 a song's new bounce plays at the next look; an app keeps its bounces as jobs (the scripts program's phase 3b, 2026-11-02 night, the M2)
  • love-shared 9658d24 docs/verbs: take.to_sound writes a take's words beside its sound; StarLore's note.new takes a kind; StarBoard's agents, regenerated by scripts/verb_sheet.py (the takes reach the stories, 2026-11-02 night, the M2)

  • love-shared 8109b86 the keepers, K4-K6 (2026-10-31 night, the M2): agents/worlding.lua (the stoker and the scribe in the registry: eight launchers), scripts/tap_conformance.py (the bare `open`, the links' verb every app answers, admitted by name: the one undotted verb; the scribe's finding task://staros/the-bare-link-verb-open-…), scripts/verb_inventory.lua (StarLore's editor verbs join on attach, so the sheet lists note.*, play.*, guide.*, feed.*, media.* as the running app answers), docs/verbs/ regenerated (StarLore 95 verbs with note.new; StarBoard with card.add and link.add)

  • love-shared fb20a2e the verb sheets regenerated (2026-10-31, the M2): starlore's poetics verbs and startune's deck and mix verbs

  • love-shared 40cf415 docs/verbs: StarLore's pages regenerated on the M2 — ui.get / ui.set name the layout tokens and the apps' colour tables (2026-10-29, the M2)

  • love-shared 169a7bb verb sheets: the index with every app (demogolf, starplot and starlore joined), and the pages that drifted after the merges, regenerated with luajit on the M2 (2026-10-24)
  • love-shared 09d4ca2 verb sheets: StarLore's pages regenerated on the merged line (ui-blender / ui-motion's ui.get, ui.set, ui.shell)

  • love-shared 4baefd0 verb sheets: StarLore's (the feed program; the sheet P1 owed)

The work record as of , from the fold on tower.

Nothing open against these sources.

  • FAILlint/web-reference 12 Nov on tower
  • NOT RUNlint/verb-sheets 12 Nov on tower

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