Concepts

The words VIDA uses, and what each one means in practice.

Talking

Push to talk and always listening: Hold space to talk, or arm the microphone and say "VIDA". Always listening keeps the last sixteen words in a rolling buffer, so the sentence you were already in the middle of arrives with her name. Silence ends the turn, and the pause it waits for is tunable live.
Asides: Spoken replies are at most about three sentences, answer first. Anything meant to be read rather than heard, such as a list, code, a path, an id or the numbers behind an answer, goes in an aside: drawn on the HUD and never read out.
The thread and open loops: The live conversation survives VIDA restarting. Things left hanging ("you said you would check the calendar") are kept as open loops for a week, so VIDA raises them itself.
Delegations: "I'll look into that" is recorded with what was promised and why. When the work finishes, the result comes back on your next turn, or VIDA starts a turn of her own to tell you, within limits that stop her talking over you.

Tasks and branches

Task: A Claude Code session working one brief in the background, in a git worktree and branch of its own. It survives VIDA restarting, streams a live feed to the HUD, and ends with a patch note.
Patch note: Three or four lines a task writes when it finishes: what changed, why, and what a person will notice. It goes into the merge commit.
dev and main: Everything lands on dev. main only ever receives: it is fast-forwarded to dev when a person confirms a promotion, and at no other time. If main has something dev does not, the promotion is refused.
Needs review: Work that is finished, unmerged and not queued. It is listed first, longest-waiting first, and never ages out of view.
Needs rebase: A finished task rebases onto dev before it reports done. If that conflicts, the rebase is rolled back and the task says which files disagree. Nothing went wrong in the task; it just cannot land unattended.
Landing: Merging a task onto dev as one --no-ff merge commit. Either as it stands, or through the merge queue, which rebases, builds and tests each branch in its own worktree and merges only on green.
Revert: Any landing comes back out as one revert commit of everything that task brought in. Nothing is rewritten, and the revert is itself revertible.
Self-landing: Opt-in, per task. VIDA merges the task herself only if its build and tests pass and no changed file matches a security-sensitive path: auth, secrets, crypto, .env, tool policy, CI or the task machinery. There is no override.

Running unattended

Autopilot: A standing goal over one tracker project. Arming it starts nothing; it shows what it would pick and what it holds. Once set going it lands what finished, then starts the next, up to a budget, and stops for review after a set amount of change. It only ever lands on dev.
Screens: Before the autopilot starts an issue, it checks it against a fixed list: security-sensitive, already attempted, known broken, needs an outside account, destructive, needs a decision, too big. Held issues are reported with the reason. Security holds can never be overridden; most of the others can, by a person naming the issue.
Self-check: One sweep across everything that could be stuck: failed and conflicted tasks, stalled landings, refused merges, work sitting unread and VIDA's own recent errors. It only reads. The usual answer is one line: nothing needs you.
While you were away: After a few hours without you, the first thing VIDA says is what happened unattended, with the full list at the top of the HUD.

Plans

SynthKit plan: For changes too big for one task: a design document plus one brief per task, each stating the interface it must deliver, the files it may touch, its acceptance criteria and the tests that prove them. VIDA can create an empty plan from a sentence; you refine it in design rounds.
Signing: A person signs a plan by typing their SSH key's passphrase into the plan card's Sign box. VIDA cannot sign: no voice command, tool or schedule reaches it. A signed plan is frozen while its signature matches and nothing it was built from has changed.
Waves and Execute: Tasks are grouped into dependency waves. Execute asks for a budget, prices the run with a dry run, and spends nothing until you confirm. A task starts as soon as everything it depends on has landed.
Plan card and graph view: Each plan has a card on the HUD with its sign-off state, its Design and Execution halves and its tasks by wave. The graph view draws the whole plan as one graph: briefs, their dependencies and the modules each changes.

Housekeeping

Project registry: Where each project's code lives: its checkout on this machine and its remote. Every repository-wide feature reads its paths from here.
Repo health: A read-only check of every registered repository for lost work (unpushed branches, stashes, stale worktrees), leaked secrets and quietly broken delivery. Critical and high findings can be filed as tracker issues, and closed again when the check passes. A secret is reported by file, line and a masked preview, never its value.
Issues log: Parked failures, separate from the backlog: what broke, where, what was expected and what happened. The same failure twice is counted rather than filed twice.
Reminders: One line each, optionally with a due-by date, links and a note. They sit as cards under the conversation, and clearing one by voice or on screen is the same thing.
Grants and tokens: Connected apps are read by default and written only after a second consent. Tokens are sealed on disk and never enter the conversation or the HUD; the processes that need one get a short-lived grant instead.
Seams: Memory, integrations, policy and history are VIDA's, not the model's. The model is one adapter behind a seam, and swapping it changes one file.