regatta

You say an idea into your phone, or type a line into a note, and by the time you sit down it is one note per idea, in plain words, filed where it will be read, committed. It reads the audio and the notes you point it at; nothing else.

It decides nothing about what to build. That is sextant's job, and sparks is sextant's intake: it ships inside the sextant plugin, never as a plugin of its own.

Principles

• One note per idea, never a transcript.
• Filed where it will be read, not where it arrived.
• Redacted before a model reads it, where an inbox opts in.

Today

• In the sextant plugin: voice memos, written notes and Apple Notes in.
• Audio transcribed on your machine with whisper.cpp.
• Redaction is built, a classifier and a regex layer; no inbox has switched it on yet.
• Each note committed to a knowledge vault or a project's docs.
• An install script: the launcher, the schedule, the two macOS grants; a chat notice when a note is filed.

Your north star, goals, priorities and budgets in one file. Every week the module reads the numbers, the ideas pool and your ventures against it, turns kept ideas into proposals and the best proposals into candidates with a verdict. A candidate that is safe to build starts on its own, inside the budget you set.

It does not set your goals, and it never launches past a question only you can answer.

Principles

• The mechanism is public; your strategy stays private.
• A candidate names its goal, its estimate and its verdict.
• Nothing unattended past a Reversible: no question.

Today

• sparks, its ideas intake.
• north-star.md: your goals, priorities and budgets, parsed and checked.
• A weekly pass that writes proposals from ideas and numbers into a queue of candidates.
• A sounding before each launch, checked against the charted shoals.
• Launches armed after one dry week.

The meeting watch, on sparks' pipeline. Five minutes before: a brief from your calendar. During: one page, half a screen wide, with what to say, the context, the transcript tail and research on a question you mark, with URLs. After: notes filed where they belong, follow-ups seeded. Nothing starts before the disclosure line is said.

It never joins the call or speaks in it. It records, and the other side's words reach a model only under wording you chose; a call that forbids listening is refused.

Principles

• Nothing listens before the consent line.
• Spend per meeting is tracked; over the cap, it says so.
• Each organization gets its own wording, login and storage.

Today

• A brief five minutes before each meeting, from the calendar you point it at.
• Both sides of the call, transcribed with speaker labels in the language spoken.
• One page on spacesheep: a suggestion a second or so after each line, and a two-minute research run per question you mark.
• At the end, notes filed through sparks and follow-ups seeded; audio and transcript archived outside git.
• Each organization gets its own disclosure wording.

A large idea arrives as one doc. helm breaks it into ships and blocks, turns each block into a task and starts the ready ones through wharf-runs, relays the one question that needs you, and keeps a board that shows what waits on whom. Skippers, the manager agents, run a ship each.

It builds nothing itself and starts no session of its own: wharf-runs does. There is no bare helm command either; Kubernetes owns that name, so the verb is regatta helm.

Principles

• One skipper per ship; you answer only Reversible: no.
• A stall it can retry is retried; the rest are reported.
• The board shows what waits, and on whom.

Today

• The tick, asks, the board.
• A skipper per ship, an agent that keeps it moving.
• A ship starts itself once its course is answered.
• Groundings counted; a cause seen twice is charted as a shoal.

One session, one worktree, on its own branch. Every turn that changed a file is committed, with the prompt quoted. A finish curates the branch into clean commits, proves nothing was lost, runs the review gate and launches it through a pull request. main moves no other way, bar the records a repo marks to be written in place.

It needs git and a terminal, and GitHub adds pull requests and CI before a merge. It runs while someone is in the session. Starting work with nobody there is wharf-runs.

Principles

• main moves only through /finish, by a pull request where GitHub is the remote, bar the records a repo marks in place.
• Every turn that changed a file is a commit.
• Git is the only state.

Today

• The hook, /finish, /todo, the review gate, seven agents.
• /finish scans the curated commit messages where the repo has a public twin.
• Needs git; any remote carries work between machines, GitHub adds pull requests.

A branch seeded with a brief starts on its own at the time you set, in a fresh session, and ends in a pull request. A chain starts the next step itself. A branch left idle about forty minutes launches itself through /finish, every gate run; a tight week pauses it, bar a branch already deployed, which launches at once.

It needs wharf, and today macOS: the schedule runs on launchd. It does not choose what to build; a brief does.

Principles

• A run starts fresh, from a brief in git.
• Every gate stops it; a tight week pauses it.
• Idle and green launches itself.

Today

• orca-host, which keeps each Mac's Orca set up and paired.
• Dispatch, chains, blueprints, the launcher, pickup, three harnesses: Claude Code, Codex, Orca.
• install.sh --schedule writes the launcher's sweep, every ten minutes.
• macOS only: launchd runs the schedule.

Every module needs the same few things: one library, a table that says which model and effort each task gets, a price shown as list and effective, a secrets check, and one command that says what is installed. The core is those things once, so no module carries its own copy.

It runs no business by itself. Install it alone and you have a config directory and a CLI; the work starts with the first module beside it.

Principles

• One library; no module keeps a copy.
• A model and its effort are a table row, not a prompt.
• Hosts, logins and people live in config, never in code.

Today

• The library, the model gate, cost, secrets, the CLI.
• regatta <name> runs a tool kept off PATH: regatta pr, regatta helm.
• install.sh names the clone in the config directory; check says what is missing.
• Config in one directory: .config/regatta in your home folder, or wherever REGATTA_CONFIG points.
• A contract check every module passes before the marketplace lists it.
• Needs Python 3.9, git and Claude Code; macOS first.

The door from a private repo to a public one. Name the project first: handles, domains and packages probed, then a decision doc. Then publish: the allowlisted files go to a public twin behind a privacy scan of every path, word and commit message, and the scan fails closed. The first push and every merge are yours.

It will not make a repo public for you, and it has no opinion on your code. It gates words, paths and names.

Principles

• What goes public is an allowlist, never everything-but.
• A private word never reaches a twin; the gate fails closed.
• The public history should read like the private one.

Today

• name-check, /name, publish, and check as the source repo's gate.
• This repo's own twin is published through it, since 2026-10-19.
• Replay: each curated commit becomes one public commit, scanned on its own; a failing one folds into the next; one squash only as the fallback.
• check-message scans a commit message before it reaches main.
• publish --pr needs wharf for its pre-push guard, and refuses without it.

What the work costs, in dollars and in attention, counted. Your own time per project each week; the agents' usage and cost per project and per week, list and effective; how much of the week is left and a tier hint at the first prompt; how often a session stopped to ask you. Every number comes with the command that made it.

It measures; it does not throttle. The gates that read its numbers live in the modules they guard.

Principles

• Every price: list and effective.
• Count what cost attention, not only what cost money.
• A number has a command that reproduces it.

Today

• crew-report, your own time per project each week.
• Usage, cost, the week, interruptions, a status line, a limits card per login.
• Groundings per week, for helm's board.
• Benches for decisions and sessions, run by hand.

Every question a session has for you reaches you in one doc: a numbered list, each item with its options and a recommendation, on its own branch, with a page you can read on your phone. You answer inline. The answers come back as commits, and the session carries on.

It asks only what you must answer: an irreversible choice, two good options, money, or a third party's say. The rest is built and reported. A Reversible: no item is always yours.

Principles

• One place to answer, each item with a recommendation.
• Ask only what is irreversible, costly, or a real fork.
• An answer is a commit, never a chat line.

Today

• The D-list, keel lint, the page, answers as commits.
• A reply-ending lint that blocks, once, a reply that asks D-items outside their doc.
• Reads the other modules through guards, so it works on its own.

What a session learns outlives the session. A fact gets one home: the bulletin every session reads this week, the rules every session loads, a project's docs, the knowledge vault. Promotion moves it up; the records and charts keep the long story. The next session finds it without being told.

Plain files in git: no search index, no embeddings, no search service. It remembers what a session filed, nothing it did not.

Principles

• One home per fact; the others point at it.
• Short-lived things expire; rules are dated.
• A lesson that failed twice becomes a mechanism.

Today

• The bulletin, /share, /promote, vault commits, the docs map.
• A vault commit goes through a pull request when wharf is installed; records commit in place.
• Transcripts archived; records and charts kept by the night job.

Aurora Borealis, the night job. While you sleep it reads the week, memory, bulletin and transcripts, and writes one reviewed diff of what should change in the rules; it updates the charts, digests the week and tends the branches. Monday starts with the reading done.

It changes no rule on its own: the diff waits for you. It works best with atlas, wharf and plumb, and says what is missing without them.

Principles

• One reviewed diff a week, never a silent edit.
• The night reads; the morning decides.
• Every rule change is dated.

Today

• The weekly loop, the dream, the charts, the digest.
• /embark, the Monday sitting that applies what you approve.
• install.sh --schedule writes its nightly job.

The machines stay in shape without anyone remembering to. Settings are declared in a file and written to each config directory; a health check runs daily and names its fix; logins, trusted projects and windows are set the same way. Drift is reported, never quietly repaired.

It writes only what a declared file says, and it tends one machine at a time; beacon, its support part, is one Cloudflare Worker you deploy to your own account. There is no fleet view.

Principles

• Declared in a file, applied by a script, drift reported.
• A finding names its fix.
• Nothing a person must click twice.

Today

• Health, declared settings, the login walk, trust, tiling, publish.
• Four guard hooks: the account, secrets, the design route, the tool path.
• Shoals, the causes of a stuck run, kept as items.
• beacon: a site's contact form and its bot, one Cloudflare Worker on your Cloudflare account; it needs Node 22.13+.
• deadman: a dead-man's switch for the machines that run work unattended, one Cloudflare Worker on the free plan.
• macOS: the schedule and the window tiling are Mac tools; tiling needs yabai.
• Needs helloworld as well as the core.