Getting started

Virtia is mission control for your AI coding agents. It points at the real Claude Code sessions you already run — in your real repo, on your real machine — and lets you watch, steer, and ship them by voice from your phone.

It is not a sandboxed web IDE. There is no hosted model and no copy of your code in someone else's box. Virtia is a thin cockpit over the Claude Code you already own, so it rides your own subscription and you keep the compute and the data.

The three pieces

1. The Virtia server — a tiny zero-dependency Node process that runs on the same machine as your Claude Code. It tails each session's transcript and exposes a live stream.
2. The Cockpit — the web app you open in a browser (or add to your home screen). It shows every session as a feed of cards you can read and reply to.
3. The bridge — the link from the Cockpit's composer back into a real terminal, so what you say or type is delivered to the actual Claude Code session.

Opening the Cockpit

• Marketing and sign-up live at virtia.com.
• The app itself lives at cockpit.virtia.com.

Open cockpit.virtia.com, authenticate, and you land in the multi-session hub. On a phone, use Add to Home Screen (see Install as an app) so it opens full-screen with no address bar — it behaves like a native app.

Your first minute

• Each project shows up as its own lane. Tap a lane to filter to just that project; you stay in it until you exit.
• New assistant replies stream in as cards, newest at the bottom.
• Cards render rich markdown — including real tables: an agent's comparison table shows

as an actual table (never raw | a | b | lines), scrolls sideways inside its card when wide, and tap it to expand full-screen (pinch to zoom, swipe down to close). Links, ~~strikethrough~~, and checklists render natively too.

• Tap the mic and talk, or tap the prompt line to type. Either way, your message goes straight to the live session.
• Turn on voice-out and replies are read back to you — fully hands-free.

Quick terminal check-ins — the qq code-word

Sometimes you just want a fast answer at the terminal, not a card that lives on the board until you settle it. Start your message with qq and neither your question nor the agent's reply appears on the board — they stay in the transcript and the archive, just out of the way.

For example, typing qq which account am I on? gets you the answer in the session, but no card shows up in the feed, no count ticks up, and it doesn't clutter the sidebar. The board stays reserved for the conversations that actually need to live until they're done.

A few details:

• It has to be the whole word at the very start — qq status? is quiet, but qqq or a

sentence that merely mentions "qq" somewhere in the middle is a normal message.

• The agent's answer to a qq message is kept quiet too, even if it forgets to mark it — a terse

terminal reply never leaks onto the board.

• Nothing is lost. Quiet exchanges stay in the full transcript and remain findable in your

cross-project prompt archive; they're just kept off the live board.

Reading the icons

Virtia uses a handful of small icons to keep cards compact. You never have to memorize them: open the ⋯ hub → 📖 What the icons mean for a grouped glossary of every icon and short-word, each with a one-line meaning. A few you'll see early:

• ⚡ Needs you — something is waiting on your input.
• ◐ wk / ◐ 5h — your Anthropic weekly and 5-hour usage.
• ✦ — the model this session is running on; tap it to switch.
• ↦ move / ↩ move back — re-file a card under another topic, or undo that.

On a computer, hovering most icons shows the same meaning as a tooltip. On a phone, where hovering isn't possible, the 📖 legend is the place to look.

The composer & voice

The composer is the bar pinned to the bottom of the Cockpit. It is deliberately voice-first and decluttered for one-handed phone use.

The mobile button row

On a phone the row is just what you need and nothing else:

• ⋯ — a small menu (far left) holding the less-used actions, so they never crowd the row.
• 📷 — attach a photo or screenshot. On mobile this is a single camera button; the desktop-only screen-capture is hidden.
• 🎙/⚡/🔇 — the mic-mode glyph, showing the current mode. One tap opens the mode picker.
• 🎤 — the mic. Tap to start dictation, tap again to stop.
• Send — sits right next to the mic, so capture-then-send is one thumb movement.

Talking to Claude

Tap 🎤 and speak. Audio is captured silently and transcribed, and the text lands in the prompt line. Review it, then Send. Because real dictation is never perfect with technical jargon (session names, tool names, product names), Virtia is built to ask you what you meant when a message is ambiguous rather than act on a bad reading.

Switching mic modes — one tap

The mic has three modes: 🎙 Live (streaming, never cuts off — recommended), ⚡ Fast (instant, plays a start chime) and 🔇 Silent (no chime, ~1s slower). Switching is a single tap on the mode glyph next to the mic — it opens a picker sheet with big, labeled rows; tap one and you're switched (a small toast confirms). No long-press gymnastics needed — though holding the mic still works as a shortcut, and that quick menu now stays open until you actually pick. Your choice is remembered for the composer; the search mic runs independently.

Typing when you want to

On a phone the prompt line is a review surface by default — mic-first — so a stray tap never throws the keyboard in your face. Tapping the field starts dictation, not the keyboard.

When you actually want to type, tap the ⌨ chip (it sits next to the prompt line, showing 🎤 talk in voice mode). One tap brings the keyboard straight up with the cursor in the box. Tap it again — now showing ⌨ type — to go back to mic-first. Your choice is remembered per device, so a laptop stays keyboard-on while your phone stays mic-first, automatically.

Replies to a card work the same way. Every inline reply box has its own ⌨ button right beside its 🎤 — one tap and the keyboard comes up with the cursor in that reply, no need to scroll back to the main composer. Tap it again to return that box to voice.

Example: you're answering a card by voice, but one word came out wrong. Tap the ⌨ on that reply box, the keyboard appears with your dictated text already there, fix the word, and Send — all without leaving the card.

Quick keys — one-tap answers (mobile)

Just above the composer on a phone is a small, side-scrolling quick-keys strip: go, done, yes, no, the digits 1–9 (for answering numbered options), and chips for the latest few cards (↳c1a2b3 — inserts a [re: card …] reference). Tap one and the token drops into your message at the cursor — without opening the keyboard and without interrupting dictation, so you can tap done, add a word by voice, and Send. If a reply box is open, the chips land in that reply; otherwise they go to the main composer.

Example: Claude asks "1) restart now 2) wait for the build 3) skip — which?" You tap 2, then Send. No keyboard, no dictation — one thumb.

Your message arrives exactly as you wrote it

Sending types your message into the session's terminal prompt — the same box you'd type into if you were sitting at that terminal. If anything was already sitting there un-sent, it used to end up glued onto the front of your message with no space, and Claude read the whole thing as one sentence.

Example: Virtia's own supervisor mistakenly believed a healthy session had crashed and tried to "restart" it by typing a recovery command into the terminal — but the session was alive, so the text just piled up in its input box. The next reply you sent from your phone arrived as brew upgrade claude-code@latest; claude --dangerously-skip-permissions[re: …] I'm out of terminal session now…, looking as if you'd typed a shell command into your own message. It also stacked: another copy every time the supervisor tried again.

Two things changed. The supervisor now decides whether a session is alive by checking whether Claude is actually running, not by guessing from the terminal's foreground process — and it refuses to type into any terminal that isn't sitting at a plain shell prompt. And sending now clears leftover text before typing, so what Claude receives is only what you wrote (plus the [re: … · card …] marker that tells it which card you're answering).

If you happen to be typing directly at the terminal when a message goes out, Virtia notices and holds the send rather than clearing your draft; it retries on its own a moment later. Anything it does clear is written to the server log first, and Ctrl+Y in that terminal pastes it back — so nothing is silently destroyed.

Hands-free replies

Turn on voice-out and each new reply is read aloud with a natural voice. Combined with mic input, you can run a whole session without looking at the screen — useful while walking, driving hands-free, or away from a desk.

Attaching images

Tap 📷 to send a screenshot or photo into the session — handy for showing Claude a UI bug, an error, or a design. The image is uploaded and referenced in your message.

When a message carries two or more images, they show side by side in a grid on desktop (using the wide viewport instead of one tall column), and stack in a single column on mobile. Tap any image to open it full size.

Threading & focus mode

A busy session is a river of messages. Virtia keeps you oriented with WhatsApp-style threading: you choose what you are replying to, and you stay there until you decide to leave.

Focus mode — the thread "jail"

Tap any card and it becomes the subject you are replying to. From that moment you are jailed into that thread — every message you send goes to it — until you explicitly exit. No more guessing which message your reply attached to. It stays consistent until you choose another card or step out.

The project switcher stays at the top of every view — including a focused thread and a task focus. Switching projects mid-thread is safe: your typed draft is saved (and restored when you come back), and each project keeps its own thread binding — nothing you were replying to leaks into the other project.

Quote a part of a long message

Long replies often have several points. Select any text inside a card and a ❝ Quote reply button appears right by your selection — tap it and your reply opens with just that excerpt quoted above the composer, already aimed at that card. The quote is a clean chip, never raw text pasted into your prompt. Because it's plain text selection, you can also just copy any message the normal way.

Tap to respond — quick-action buttons on a card

Typing on a phone is the friction. When a card actually needs a decision, Virtia adds small tap-to-respond buttons right on the card, so you can answer with one tap instead of a typed message. A button only appears when it makes sense for that card — a card with nothing to decide stays clean.

It works like a shopping cart — but the cart comes pre-filled. The agent's enhancement ideas are checkboxes, and the safe ones come already checked and the list already expanded, so one ✓ Approve takes them all — you don't have to tick anything. Ticking or unticking a box just changes what's selected; it sends nothing. Underneath sits one primary button, always last, that commits everything in a single tap: it approves the recommendation (if there is one) and queues whichever extras are checked. There's exactly one terminal button, so the old "do I pick the extras first or approve first?" question disappears — you glance at what's pre-selected, uncheck anything you don't want, then check out.

*The exception — risky or uncertain extras start unchecked for your review. Anything the agent isn't sure you'd want, or that touches something serious — auth, money, deleting, deploying to production, anything irreversible, or a big ADR-level commitment — is never pre-checked. Those rows start off with a muted flag (review when the agent just wasn't sure, your call* when it's risky/irreversible) so your eye catches them. "Approve all" can never sweep a risky item through by default; you have to tick it on yourself.

When a card has both a recommendation and ＋ suggestions, it opens with a one-line hint: "Extras are pre-checked — one Approve takes them all; uncheck any. Flagged ones start off for your review." (A card with only one of the two shows no hint — there's nothing to explain, so it would just be noise.)

The colour law — blue means "you can tap this," green means "done":

• ＋ N suggestions ▾ — when the agent offers 2-3 enhancement ideas (each tagged (quick) /

(medium) / (big)), the list opens expanded by default with the safe ideas already checked, so nothing gets missed and one Approve takes them all. (The expander is still there — tap it to collapse the list if you want, then tap again to reopen.) Checking or unchecking a box selects only — nothing is sent, nothing is queued until you commit. You can tick, untick, and change your mind freely; the extras don't leave the cockpit until you commit. Your selection stays put even if new messages arrive while you're deciding — a fresh reply landing on the screen won't clear your cart.

• review / your call — a suggestion the agent left unchecked on purpose carries a small muted

flag. review means it just wasn't sure you'd want this one (a quick look, tick it if you agree); your call means it's risky or irreversible (auth, money, deploy/production, delete, or a big ADR-level call) and will never be auto-checked — you decide. These rows sit with a dashed border so they read as "weigh this," not "already in your cart."

• ★ Recommended — when the agent has a genuine best pick among the suggestions, that one row

wears a ★ Recommended badge and an accent border, and the list opens already expanded so you see it at a glance. The star means "this is my strongest call — the best solution, not the easiest or cheapest." A safe recommended extra comes pre-checked like the other safe ones; the star just adds emphasis so you can spot the best pick before you commit. No star means no strong pick — when the options are genuinely yours to weigh (or the agent didn't stake a recommendation), nothing is highlighted, and that absence is itself the signal: this one's your call. The same ★ appears on a numbered options list in the card's own text: if the agent writes an option like "1. Build after restart (recommended)", that single line gets a subtle ★ accent bar — again, only ever the one the agent explicitly marked, never a guess about which "looks" best.

• The commit button (blue, last) — one button whose label updates live as you check boxes,

so it always says exactly what one tap will do:

• recommendation present, 0 checked → "✓ Approve & mark done" (approve only)
• recommendation present, N checked → "✓ Approve & queue N selected" (approve and queue the checked extras)
• no recommendation, N checked → "＋ Queue N selected"
• no recommendation, 0 checked → the button is disabled (nothing to commit yet)

One tap commits everything. On a recommendation card it approves the plan, queues any checked extras, sends it all to the agent as a single message, and settles the card into Done with an ↺ Undo toast — same as tapping ♡ Done. (A card with only suggestions and no recommendation just queues your checked extras and stays open — there's nothing to "approve" or close.)

• ★ Prioritize and ⏸ Later sit next to the ♡ Done and ↳ Reply buttons on every card, so you

can bump a card up or push it to the backlog without opening the composer.

So at a glance: anything blue is an action still waiting for your tap; anything green is already settled. A blue button never means "done," and a green one is never still asking you for something.

What a tap actually does — and why it's safe: a quick-action button is a typing shortcut, not a remote control. Tapping it sends a short message on your behalf through the same send path as the composer, and the agent reads it and applies its usual judgment. It never reaches past the agent to run anything directly — so the normal guardrails (nothing risky happens without an explicit yes) stay exactly as they are.

Your taps update the card in place — they don't create a new card. The message a quick-action sends is a control signal to the agent, not a new topic to discuss, so Virtia does not turn it into its own second card for you to settle. Instead the acknowledgement lands right on the card you tapped: the button flips to its settled green state ("✓ Approved · done", "✓ Queued", "Prioritized", "Later ✓"), and a subtle line appears on the card's action row — e.g. "★ prioritized — on it". One tap, one card; you never get a stray "★ Prioritize this: …" echo card to clean up afterward.

Example: you tap ★ Prioritize on a card. Behind the scenes Virtia sends the agent a short "★ Prioritize this: …" — but that message never shows up as its own card. The card you tapped simply shows Prioritized with a small "★ prioritized — on it" note, and stays put. (System-notice view, on by default on wider screens, shows these control signals as a thin muted transcript line so you can still see one was sent; on phones they're hidden entirely — either way, never a card.)

Example: the agent ends a card with "📐 Recommendation: cache with LRU" plus three enhancement ideas. The card opens with the list already expanded, the hint "Extras are pre-checked — one Approve takes them all; uncheck any. Flagged ones start off for your review," and one blue button that already reads ✓ Approve & queue 2 selected — because two of the three ideas are safe and came pre-checked. The third idea is "add a metrics endpoint that auto-deploys to production"; because it touches deploy/production the agent left it unchecked with a muted your call flag, so "Approve all" can't sweep it in. You glance, agree with the two, and tap once: that single tap sends the agent your approval and the two checked extras in one message, and the card drops into Done (Undo is right there if you change your mind). If you'd rather not queue one of the pre-checked extras, untick it first — untick both and the button reads ✓ Approve & mark done and approves the plan on its own. On a card that has only suggestions and no recommendation, the button reads ＋ Queue N selected and committing just queues your picks — the card stays open, because there's nothing to close.

supersedes/cuts: the ★ Recommended highlight is purely additive — it changes nothing about how the cart, the commit button, ♡ Done, or any quick action behaves, and it cuts nothing. A card whose agent marks no best pick looks and works exactly as before (no highlight anywhere); the star only adds emphasis to a row the agent explicitly stars, and strips that ★ from the label it sends.

supersedes/cuts: the extras now default to checked-and-expanded, replacing the old "collapsed-and-unchecked" default where every suggestion started off, hidden behind ＋ N ▾, and you had to expand and tick each one before approving. Now the safe ideas arrive pre-selected with the list open, so one Approve takes them all — the only ones that still start unchecked are the ones the agent flags review (unsure) or your call (risky/irreversible), which are never auto-checked. Nothing about what a commit sends or the safety model changed; you can still uncheck any pre-checked extra before committing.

supersedes/cuts: this cart model replaces the old "each ＋ Build tap queues immediately" behaviour. Previously every ＋ Build button sent its idea the moment you tapped it and lit up green ("✓ Queued: …"); now the suggestions are checkboxes that select only, and a single commit button sends the whole selection at once. The separate "✓ Approve & mark done" button and the "put extras first, Approve last" ordering fix are folded into that one commit button — since there is now exactly one terminal button, inherently last, the ordering question no longer exists. What a commit sends to the agent, and the safety model, are unchanged; ♡ Done, ↳ Reply, ★ Prioritize, ⏸ Later, and the custom one-tap buttons below all stay exactly as they were.

supersedes/cuts: the "you" echo a quick-action used to post ("✓ Go with your recommendation on: …", "★ Prioritize this: …", "＋ Build this: …", "⏸ Move this to …", "PRIORITY P0/P1 — …", "Approved — …") no longer appears as its own card. The tap is now reflected on the origin card instead (settled button state + a subtle "— on it" note); the agent still receives the message exactly as before, so nothing about sending or approval changes — only the confusing second card is gone. This applies retroactively: existing echo cards already in your history disappear from the card view on the next render too.

Custom one-tap buttons for a specific decision

The buttons above (✓ Approve, ＋ Build, ★ Prioritize) are the fixed set that shows up when a card fits the pattern. But sometimes the agent poses a one-off choice that will never recur — "should I deploy the batch I just merged?", "rename it or leave it?", "ship to staging?" — and typing or speaking the answer is the only friction left. For exactly those moments the agent can attach its own custom buttons to that one card. You just tap the answer.

When it offers a one-off choice you'll see buttons like [🚀 Deploy the merged batch] [⏸ Hold], or [Yes — rename it] [No], right on the card, under a hint that reads "One tap sends your answer — I act on it." Where the answer text differs from the short label, the button also shows a small sends: "…" line so you always know exactly what a tap will say before you tap it — never a blind button.

What a tap does is the same safe thing as every other quick action: it SENDS your answer through the normal send path, and the agent reads it and acts with its usual judgment. The button never runs anything itself — even a [🚀 Deploy] button only sends the word "deploy" to the agent; the agent still applies every guardrail (a deploy, a payment, a delete always needs that explicit yes). The button is just a one-tap way to give it.

Once you tap one, that button turns green (✓ Deploy the merged batch) and the other buttons in the set grey out — the decision is answered, so you can't accidentally tap both Deploy and Hold. Like every quick action, your tap reflects on that same card (no stray echo card to clean up), and the settled state sticks across refreshes. These buttons are deliberately rare — the agent adds them only for a genuine one-tap decision, so cards don't turn into button farms.

Example: the agent finishes merging three batches and posts a card: "Merged batches 12–14, tests green. Deploy to staging now, or hold?" with two buttons — [🚀 Deploy the merged batch] (its sends: "Deploy the merged batch now" line visible) and [⏸ Hold]. From your phone you tap 🚀 Deploy — Virtia sends "Deploy the merged batch now," the button goes green, Hold greys out, and the agent takes it from there. No typing, no voice, one tap.

When the agent just asks — Virtia spots the either-or for you

The custom buttons above need the agent to attach them on purpose. But agents often close a card with a plain either-or question and no buttons at all — "holding for your one-word call: open or blocked for Jul 20–22?", or a short "ship or hold?", or two bulleted options "Want them open? / Want them blocked?". Before, those fell back to a typed reply. Now Virtia reads the question and offers the same one-tap buttons automatically — you'd see [open] [blocked] right on that card, under the same "One tap sends your answer — I act on it" hint.

It's the identical safe mechanic: a tap sends your chosen word (e.g. "open") through the normal send path, the agent reads it and acts with its usual judgment, and the button never runs anything itself. Once you tap one it turns green (✓ open) and the other greys out — one decision, one answer, reflected on that same card and sticky across refreshes.

Virtia only does this for a genuine either-or — a real question with two (up to four) short, parallel options, ideally the ones the agent emphasised in bold. Ordinary prose that merely contains the word "or" ("faster or slower depending on input") does not sprout buttons; when it isn't sure, it stays out of the way and you just reply as before. This works on cards already in your history, not only new ones — reopen an older card that posed an either-or and you'll find the buttons waiting on it.

Example: the Strassi agent posts "Calendar's ready except one thing — holding for your one-word call: open or blocked for Jul 20–22?" and attaches no buttons. Virtia notices the "open or blocked?" call and shows [open] [blocked] on the card. From your phone you tap open — it sends "open" to the agent, the button becomes ✓ open, blocked greys out, and the agent carries on. If the agent had explicitly attached its own buttons (or the card already has the ✓ Approve / ＋ Build cart), those win — this auto-detection is only the fallback for a decision that would otherwise have no one-tap answer.

supersedes/cuts: this is purely additive and cuts nothing. It only adds buttons to a card that posed a plain either-or and previously had none; cards with the fixed ✓ Approve/＋ Build cart, with numbered-option chips, or with the agent's own custom buttons are untouched (those already had one-tap answers and take priority). What a tap sends, and the safety model, are exactly the same as every other quick action.

Nested threads & breadcrumbs

Replying to a part of a message can open a child thread, so a side-discussion doesn't derail the main line. A breadcrumb trail shows where you are in the hierarchy, and you can walk back up it at any time. Deep conversations stay navigable instead of turning into one flat scroll.

♡ Done is permanent — cards never come back on their own

♡ Done seals a card. Once you settle a card — you tap ♡ Done, or an automation rule moves an answered-and-seen card to ✅ Done — it never returns to Active on its own. New output on the same topic can't resurrect it, and neither can the automation.

The tap is instant. The card leaves Active the moment you tap ♡ Done — you don't wait for the little heart-to-check animation to finish. The animation is just a flourish; the card is already gone. (Each card is sealed by its own stable identity, so a card you've settled stays settled even as the board reshuffles around it — it can't quietly pop back into Active.)

A follow-up starts a fresh card. Ask about the same topic again — or the agent posts more output after you sealed the card — and that lands as a new card in Active. When Virtia is confident the new card continues a sealed one (the same question re-asked, an explicit card reference, or a confirmed same-question match), the new card carries a small ↩ continues: … chip linking back to the sealed card — tap it to open that card in ✅ Done. When it isn't sure, there's simply no chip: a missing link is harmless, a wrong one is confusing. A continuation card is its own card: it's titled by its own content (the ↩ chip is what points at the old card), and Reply on it always binds to it — never silently to the sealed parent.

Example: you ask "why is the deploy failing?", get an answer, and tap ♡ Done. An hour later you ask it again. The old card stays sealed in ✅ Done; a fresh card opens in Active with "↩ continues: why is the deploy failing?" — one tap away from the earlier answer.

Want the old card back? Reply to it. An explicit reply — from the ✅ Done lane or a search result, using the card's ↳ Reply — is the one thing that reopens a sealed card: it returns to Active with your reply nested inside it. You reopen cards; the system never does.

Virtia never switches you to the ✅ Done lane on its own. You land in Done only when you ask to go to a settled card — you tap a search result, open a permalink, or tap a chip/link that points at a sealed card — or when you open the Done tab yourself. Background activity (a live answer arriving, an earlier question resurfacing, a re-render after you settle something) never moves the lane: if the thing it references is settled, you get a quiet "That card is settled — it's in the ✅ Done tab" note and stay right where you are. Example: while you're reading Active, the agent auto-recalls an earlier answer that has since been sealed — you see the note, but the screen does not jump you into Done.

✓ Resolved — a card that was already sorted out links to the outcome

Some cards get decided and acted on in later turns, not right below the question — so they can sit in Active still looking open, quietly inviting you to answer again or wonder where your input went. The worst case is a screenshot card: you drop in a couple of images with a one-word prompt like "Analyze", and the analysis, your follow-up, and the final decision all land as separate turns further down. The little image card floats up top looking untouched.

When Virtia can see a card like that was in fact carried through to a conclusion — with no question still waiting on you — it puts a green ✓ Resolved · what happened › chip at the top of the card (it reads ✓ Resolved · you replied + outcome › when your own reply is part of the thread). Tap it and Virtia jumps you straight to the outcome turn and flashes it, so you can see your input landed instead of re-answering. The card also stops wearing any "unanswered" marker — the ✓ Resolved chip is now its status.

Example: you post two screenshots with "Analyze". Virtia reads them, you add a clarifying comment, and a few turns later it reports "verified — the counts now match and it's regression-locked" and ships the fix. Your "Analyze" card up top now shows ✓ Resolved · you replied + outcome ›; one tap drops you on that "verified + shipped" message.

This is conservative by design: if a card still has a question waiting on you (it's in ⚡ Needs you, an open approval, or an unanswered pick), it never gets the chip — a missing chip is harmless, a wrong "resolved" would be misleading. Done and Reply stay exactly as before — the chip only points you to the outcome; it doesn't settle the card for you.

→ answered here — an open question whose answer floated off to another card

The ✓ Resolved chip above catches a card carried through to a conclusion. This one catches the opposite miss: a question you asked that never got an answer right below it — because the answer got written as its own separate card further down. The original question sits in Active looking untouched, and you have no way to find where the reply actually went.

When Virtia can see that a later reply is unmistakably about this exact card — the reply literally names the card — it puts a green → answered here › chip at the top of the open question. Tap it and Virtia jumps you straight to that answer and flashes it, so you never have to hunt the scroll for where your question got addressed. Like ✓ Resolved, the card also stops wearing an "unanswered" marker once its answer is one tap away.

Example: you ask "Is Kaya's window broken?" and, instead of a reply landing under it, the analysis gets posted a while later as its own card ("Found it — you caught a real drop…"). Your original "Is Kaya's window broken?" card now shows → answered here ›; one tap drops you right on that analysis.

This is conservative by design — even stricter than ✓ Resolved. Virtia links only when a later reply explicitly refers to the card (it carries the card's own reference); it never guesses from a topic looking vaguely similar, because a wrong link is worse than a missing one. If a card already shows ✓ Resolved, it never also shows → answered here — you get one clear chip, never two.

supersedes/cuts: nothing is removed. This complements ✓ Resolved — ✓ Resolved links a settled card to its outcome; → answered here links a still-open question to the reply that answered it elsewhere. Together they close the "where did the answer go?" gap from both sides, so no card is ever left an orphan.

↳ Replies attach to the message they actually answer

When you send several messages in a row while the agent is still working on an earlier one, its reply used to land under whichever card was most recent — so an answer to your first question could show up buried under your third, unrelated one. Confusing.

Now Virtia reads the content of each reply and attaches it to the message it actually answers — even if you sent other messages in between. The reply carries a small dashed ↳ chip naming the card it was matched to, so the move is never silent and you can see why it landed where it did.

Example: you ask "fix the auto-redirect to the Done tab", then immediately add "the mic cuts off my long pauses", and the agent — a minute later — replies "Fixed the auto-redirect…". That reply now snaps under your auto-redirect card, not under the mic card it happened to arrive after.

This is careful on purpose: Virtia only re-aims a reply when the content is a clear match for a different card. If it's ambiguous — the reply could fit either message, or matches nothing in particular — it stays exactly where it landed (under the most recent card), the same as before. A missing re-aim is harmless; a wrong one would be worse, so Virtia never guesses. An explicit reply you sent yourself (via a card's Reply button) always wins — its thread is never second-guessed by content matching. This also cleans up existing cards: replies that were already mis-filed by timing re-attach to the right message on their own.

The chip never lies about where a card sits. If a reply was re-filed under a different card than the one its original tag named, its ↳ chip leads with the card it's actually under and keeps the old address as a small strikethrough afterthought — e.g. ↳ card cznfh7z ~~was card c10g8ur7~~. So a correctly-refiled card can never keep reading as misattributed: what the chip says and where the card lives are always the same thing. (Tapping the chip still jumps to the original tag, so the history is one tap away.)

Tricky cases now get real understanding. Word-matching alone misses a reply that answers your message using none of the same words — "Fixed the wrong-tab jump" clearly answers "the Done tab keeps opening on its own" even though they barely share vocabulary. When the quick word check can't tell (two of your recent cards both look plausible, but neither is a clear match), Virtia now asks its AI which message the reply actually answers, and moves it there if the AI is confident. The reply still lands instantly under the most recent card first, then quietly snaps to the right one a moment later — you never wait on it. If the AI is unsure or unavailable, nothing moves: the safe word-matching behavior above is always the floor, so this only ever adds a correct catch, never a wrong one.

↦ Move — re-file a card or a single reply under the right card

Sometimes a reply lands under the wrong card, or two discussions really belong together. Tap ↦ on any card and choose "↦ Move here — pick a card". The timeline stays exactly where it is and a ↦ here button appears on every other card — so you file the card by pointing at where it belongs, not by hunting through a list. Virtia highlights its best guess (your newest still-open question — usually what a stray card is really about) with a gently blinking ↦ file here ✓ and scrolls it into view, so the common case is one tap. Prefer a different home? Tap ↦ here on that card instead. A bar at the bottom shows what you're filing, with ＋ New card (split it out on its own) and ✕ Cancel (or Esc).

The card — with its replies — moves into the chosen card, in the right chronological spot, and stays there across reloads and devices. The toast has ↺ Undo. Every move is also recorded so Virtia keeps learning your filing from your own corrections. (Prefer the old searchable list? It's still there as "☰ List view…" in the same ↦ menu, and "→ another project" still sends a card to a different project entirely.)

→ another project — the card moves with you

Choosing "→ <Project>" sends the card to that project. The moment you pick it, the card leaves the project you're in — instantly, no refresh needed (before, it lingered in the old project until you reloaded). It disappears from every surface at once: the stream, the Priority and Suggest strips, the ⚡ next queue, the inbox, the cross-project banner and search.

The move toast offers → Continue in <Project>: one tap switches you to the destination project and lands you right on the moved card, so you keep working while it's fresh. Over there the card reads as a real card near the top, wearing an ↪ from <origin> chip so you always know where it came from. Reply on it lands in the destination project (not the old one), and ↩ move back returns it home.

A moved card is never stuck: from the destination you can ↦ move it on again to a third project, or move it back — it always resolves, never dead-ending.

Example: you're in Strassi and realise a "read baton" card really belongs in AltaGrade. Tap ↦ → → AltaGrade. The card vanishes from Strassi immediately, and the toast shows → Continue in AltaGrade. Tap it — you're now in AltaGrade, looking at the card with an ↪ from Strassi chip at the top. Realise it's actually a Cockpit thing? Tap ↦ on it again → → Cockpit, and off it goes — no "couldn't find that card", no reload. Every hop is display-only and reversible; the original transcripts are never rewritten.

⚑ Flag a card — "wrong place" or "other bug"

Moving a card yourself (↦ above) is the precise tool. But when you just want to point at a problem and move on — you're skimming on your phone and a card is clearly under the wrong discussion, or something about it looks broken — tap ⚑ Flag on the card. Two small chips appear right on the card: ⚑ wrong place and 🐞 other bug. Tap one and you're done — the card shows ⚑ Flagged and the architect gets an instant notice with the card's id and where it currently sits, so it knows exactly what to examine. Flagging never moves or changes the card itself; it's a report, and the architect does the re-filing.

Changed your mind, or it got sorted out? Tap ⚑ Flagged again to un-flag. A flag never rots silently — an independent watcher keeps count of open flags and nudges if one sits unhandled too long.

Example: you're reading on your phone and notice a "payouts payment" card threaded under a completely unrelated question. You don't need to find the right parent yourself — tap ⚑ Flag → ⚑ wrong place. The card shows ⚑ Flagged, the architect is told "card c… is under the wrong parent — examine and re-file," and you keep reading. When it re-files the card, the flag clears on its own.

＋ Promote — split a reply out into a brand-new card

Sometimes a reply doesn't belong under its card at all — it started a whole new topic. Tap ↦, then ＋ Promote: instead of filing the reply under another card, it becomes its own brand-new card, in the right chronological spot, and stays there across reloads.

When the reply you tapped has more turns after it in the same card, Promote offers two choices:

• ＋ Promote just this — only the tapped reply moves out into the new card.
• ＋ Promote this + everything after it — the tapped reply and every turn that follows

it in that card move together into the one new card.

Example: a "Deploy pipeline" card drifts — halfway down, a reply asks "should we switch to blue-green?" and the next several turns are all about blue-green, not the deploy. Tap ↦ on that reply, choose ＋ Promote this + everything after it, and the whole blue-green tail lifts out into its own "Blue-green?" card while the deploy card keeps its earlier turns. If the reply is the last one in its card, only the single ＋ Promote to new card option shows (there's nothing after it to carry). Changed your mind? The toast's ↺ Undo puts every moved turn right back.

Your reading is protected — the screen never jumps on its own

While you're reading (scrolled up), the screen never moves unless you move it — new messages and "needs you" moments don't yank you away mid-sentence. Instead they collect quietly in small pills above the composer: ⬇ N new on the jump pill, and a muted ⚡ needs you pill when something is waiting on you. Tap a pill when you're ready and you make the jump; while you're at the bottom live-following, the view keeps flowing with new messages exactly as before.

"👀 What did I miss?" — only after a real absence

When a lot happened in a session while you were truly away, a 👀 what did I miss? · N new chip offers a one-tap AI catch-up: tap it and Virtia summarizes the turns that arrived since you last read, with jump links to each. It's a return-from-absence affordance, not a running counter.

Because of that, the chip only appears when you come back after being away for more than an hour — a genuine absence, not a quick check-in. If you glance away for a few minutes and come back, no chip: you didn't miss enough to need a digest. It also stays quiet on a brand-new browser that has no record of you having been away (it can't prove an absence it never saw). And when the ⬇ N new pill is already offering the same catch-up, the chip steps aside so you never get two "you missed things" prompts at once.

Example: you close the tab, spend two hours in a meeting, and reopen Virtia — a 👀 what did I miss? · 24 new chip is waiting; one tap gives you the gist instead of scrolling back through everything. Pop out for a five-minute coffee and back, and the chip never shows.

Sticky lanes

Each project has a lane. Pick a lane (say, one project) and you stay filtered to it until you exit — tapping around won't silently drop you into another project's stream. The lane filter is sticky by design, matching the same "stay where I put you" principle as focus mode.

System notices

Not everything deserves a full card. Lightweight status lines — "ADR created", a link, a short heads-up — render as thin system notices rather than heavy message cards, so signal stays separated from chatter.

The Activity strip — work-narration, not cards

Only decisions and questions should be cards you have to settle. Pure work-narration — "merged X", "deploy done", "re-synced sources" — is just the agent narrating what it did; it shouldn't sit in your Active lane demanding a ♡ Done.

So that narration now collects into one compact Activity strip pinned at the top of the lane, instead of scattering between your cards. Collapsed by default, it's a single muted line — for example:

⚙ Activity · 4 · deploy done — cockpit live at … ▸

Tap it and it opens into the full feed, newest first, each line time-stamped and still carrying its 🔗 permalink and 💬 comment — nothing is lost, it's just tucked out of the way. Tap the header again to collapse it.

The play-by-play of the agent working now tucks in here too — you see the result, not every step. When the agent does a piece of work for you it often narrates as it goes ("Reviewing + merging…", "Same divergence pattern…", "Committing + cleaning up…") and only the last message is the actual answer. Those in-between steps now collect into the Activity strip automatically, and only the final answer stays a card.

Example. You say "merge the ready work and tell me what shipped." The agent posts four messages: "Reviewing + merging…", "Same divergence pattern…", "Committing + cleaning up…", and finally "Shipped — the three branches are merged and the images now sit side by side." You see one card — the "Shipped" answer. The three step-by-step lines are folded into ⚙ Activity, one tap away if you ever want the journey.

Housekeeping lines from Claude Code itself — "You've reached your Fable 5 limit", "Run /usage-credits…", update and model-switch notices — also route here instead of becoming cards.

What lands there vs. what stays a card: narration the agent marks as such, its in-between working steps, and Claude Code's own system lines. A real decision, a question, a recommendation (★), options, a carve-out, or anything that needs your answer always stays a full card — never collapsed. Virtia biases hard toward keeping a card: when a message is even borderline, it stays visible, because a hidden answer is far worse than one extra line in the strip. If you'd rather not see the strip at all, "Hide system" (in the ⋯ menu) turns it off; it stays on by default on phone and desktop alike.

Findability, automation & agents

The discussion sidebar (desktop) — every conversation, one tap away

On a wide screen (roughly 1024px and up) a permanent 💬 Discussions panel sits down the left edge: a chat-list of every discussion in the current lane, newest activity at the top — the same shape as a messaging app's conversation list. Each row shows the discussion's topic and the time it last moved, with a small dot (⚡ when something's urgent) on the ones still waiting on you. Tap a row to open that discussion on its own — the center of the screen switches to a focus page showing only that conversation's thread, with a ← Main chat button (or Esc) to go back to the full feed exactly where you left it. The focus page is linkable and refreshable — its address carries both the discussion and its project, so you can bookmark or share a single conversation and it reopens on the right one even if you were looking at a different project when you clicked. If you ever open a discussion link belonging to a project you haven't got open (an older link, from before, that doesn't name its project), Virtia won't quietly show you an empty page: it stays on your feed and tells you plainly — "That discussion is in Strassi — switch to that project to open it." Switching projects is always your move, never one Virtia makes behind your back. No more scrolling back through the whole timeline to find where a thread went.

When a link points at one particular message rather than a whole conversation, opening it takes you to that message — scrolled into view and briefly highlighted, not just somewhere in the right thread. The header names both, so it always matches what you're reading: the conversation first, then the message you came for ("📷 Screenshot › Building it now — banner + header pill…"). Discussions are named after their opening message, so without that second part a link to something said much later in a long thread looked like it had opened the wrong conversation.

The list is built from the very same grouped cards the main view shows, so it never drifts out of sync, and it updates itself as conversations move.

＋ New chat — start a clean page

The ＋ at the top of the Discussions panel (or ⌘N) starts a new chat: an empty page of its own, with the composer already pointed at it. Everything you send there belongs to that chat because you put it there — Virtia never has to work out where it goes afterwards.

You can name it on the spot: type in the "Name this chat…" line and that becomes its title, word for word, no cleaning or guessing. Skip it and the chat is named from your first message, as usual. The new chat appears at the top of the list straight away and stays there while it's empty — it won't disappear because you haven't written in it yet. If you change your mind, the small ✕ on its row discards it.

This is not the same as "✕ New topic" in the composer, and the difference is worth knowing:

• ＋ New chat creates a place — a brand-new conversation to write into.
• ✕ New topic clears a reply link — you were replying to a card, and now you're not; your

next message goes to the main conversation instead of under that card.

One creates a binding, the other removes one.

Searching your discussions

A search box sits at the top of the Discussions panel — the place you'd reach for it in any messaging app. Type and the list narrows as you go, with a small "N discussions" count underneath so you can see how much you've cut it down. Press Esc or the ✕ to clear (the first Esc only clears the search — it won't close the drawer out from under you).

It searches the topic AND what was actually said inside each discussion, so a half-remembered phrase is enough. Example: you remember someone mentioned a lakehouse but not which thread it was in — type lakehouse and the 227-row list collapses to the one discussion that contains it, even though the word appears nowhere in its title. Card ids work too, if you navigate that way.

This is not the same as the full-text 🔍 Search (in the sidebar's TOOLS block, or the command palette), and both are worth knowing:

| | Searches | Use it when | |---|---|---| | Sidebar search | These discussions — titles + their messages, current project | You want to open a conversation you half-remember | | 🔍 Search (TOOLS / palette) | Every message, across all projects | You want to find a message wherever it lives |

On a phone the same list lives one tap away: hit 💬 in the bottom dock and the Discussions list slides in as a drawer (tap a row to open that conversation isolated on its own page, tap outside / ✕ / Esc to dismiss). And tapping a collapsed card's header opens that discussion's focus page directly — no more scrolling to find where a thread went. Nothing changes until you open the drawer or tap into a discussion: your normal feed is exactly as it was, isolation is opt-in per tap.

The chat index is the root view. On a phone the app opens on this list — it is where you start, the way a messaging app opens on your conversations, not on any one thread. When you tap a discussion open, your phone's back button returns you to the list, not out of the app; tap another, back again, and you're browsing without ever leaving Virtia. The list is the home you keep coming back to.

Lanes and tools, right in the panel

Below the discussion list the panel carries two more labelled blocks, so everything you used to hunt for along the top is now a plain list you can read.

• LANES — **Active · Done · Decisions · Overview · Builds · Rules · Backlog · Tasks · Reports

· Legend, each with its live count. Tap one and the center switches to it (on a phone the drawer closes onto the lane you picked). No more "GO TO LANE" wording tucked behind a ⋯ — the lanes are simply named, in front of you. This is now the only lane switcher** — the old row of lane tabs across the top is gone (see "The top bar is just identity + state" below).

• TOOLS — 🔍 Search · 🔊 Read · voice ▾ · 🏷 Tags · ❓ Help, each with its icon and word.

Search opens the full-text search, Help opens the docs, voice opens the read-aloud voice settings. Read is a switch — its label shows Read: off or Read: on and flips live as you use it, so the panel can never show you a stale state. (Tags only appears once a project actually has tags.)

• SETTINGS — the quiet block at the very bottom of the panel, carrying your Model (e.g.

✦ Opus 4.8), your weekly Usage (e.g. 44%), and your Context (e.g. 385k · 39%). They are just as tappable: Model opens the model switcher, Usage opens the command center, Context opens the context detail. A row only appears once its value is known (for example, no Model row until the session reports which model it is on).

The top bar is just identity + state

The bar across the very top no longer carries navigation. It shows who you are and what this is — the Cockpit name, the session / live and prod status, the architect state, and the background-agents 🤖 count — and nothing else. Everything you used to reach up there — Help, Search, Read, voice, Tags, the ⋯ More sheet, the lane tabs, and the Usage / Context chips — now lives in the left column's TOOLS, SETTINGS and LANES blocks above. One column answers "where can I go"; the top bar answers "who am I and what is this".

Prefer the old full top bar? Add ?navfull=1 to the address (it sticks, so you only do it once; ?navfull=0 returns to the slim bar). The slim bar is the default for everyone.

On a phone, fold the groups you're not using

The chat index is your main navigation tool, so on a phone it should get the room. The three bottom blocks — LANES, TOOLS and SETTINGS — therefore fold on mobile: tap a group's header to collapse or expand it. By default LANES stays open (your lanes are the thing you switch most) while TOOLS and SETTINGS start folded, so the chat index fills the drawer. A folded group is one tap from open and nothing is ever hidden away — for example, when LANES is folded its header still shows a glance like LANES · Active 73 · Done 230 so you keep the key counts without unfolding. Your choices are remembered per group, so the drawer opens the way you left it next time. On a wide screen (desktop) there is room for everything, so the groups are always open and never fold.

🤝 Agent talk — the machine-to-machine traffic, kept but out of the way

Your project agents talk to each other. One asks another for a second opinion (a consult), the other answers, and the answer is delivered back into the asking session. That traffic is real and occasionally interesting, but it is not work waiting on you — so it has never appeared in Active, and it still doesn't. What's new is that it is no longer invisible: the 🤝 Agent talk tab (behind More ▾) is where it lives if you ever want to look.

Each consult is shown as one exchange, newest first, with every message in it — including the side that happened in the other project, since a consult by definition spans two of them. A chip tells you how far it got:

• delivered — the answer made it back into the session that asked. Nothing to do.
• answered, not delivered back — the other agent replied but the reply never landed. This is

the one worth noticing: someone did the work and nobody received it.

• awaiting answer — asked, not yet answered.
• unmatched — a message whose consult can't be paired up at all.

Below that, Other hidden plumbing holds the project's remaining background chatter that the cockpit keeps out of Active.

It is a log, not a lane: there is no Done, no reopen, no count feeding Active, and nothing on this tab was moved or reclassified to put it here — these messages were already kept out of your feed, and the tab only gives them a place you can find. Anything you wrote yourself stays in your normal conversation, always. If you ever see one of your own messages on this tab, that's a bug worth reporting with the ⚑ button.

#topic-tags — every card files itself

Every new card gets a short, stable #topic-tag (like #usage-meters or #mic-modes) automatically — nothing to set up, nothing to name. Virtia reuses an existing tag when a new card is about the same topic, so a subject accumulates under one tag instead of sprouting near-duplicates. The tag shows as a small muted chip on the card's header (chat and Cards view alike); tap it to filter the lane to just that tag's cards, tap again (or ✕ Clear) to drop the filter. Moving a card into another card with ↦ files it under the destination — its content simply lives with the destination card's tag from then on.

🏷 Browse everything by topic — across all your projects

The chip on a card filters that lane. To see the whole picture — every topic in play, with how many cards each has, newest use first — across all your projects at once — open the 🏷 Tags view. On a computer it's the 🏷 Tags button in the top-right controls; on a phone it's 🏷 Tags — browse by topic in the ⋯ hub. (It only appears once cards have started earning tags — no tags yet, no button, nothing to configure.)

Tags are global: a #deploy-pipeline in one project is the same doorway as #deploy-pipeline in another, so the list unions them and shows the per-project split under each (e.g. Virtia 6 · cp.altagrade 2). Tap a tag and you get its cards — from any project, newest first. Tap a card and Virtia takes you straight to it, switching projects for you if that card lives in a different one. ← All tags steps back to the full list; Esc or ✕ closes.

Example: you half-remember tweaking image previews but not which project it was in. Open 🏷 Tags, tap 🏷 image-preview — the 11 cards under it appear, each stamped with its project. Tap the one you meant and you land right on it in the Virtia session, no project-hunting first.

The command palette — find or do anything

One surface to jump to any project, card, tag, lane, setting, or action without hunting.

• Open it. On a computer press ⌘K (Mac) or Ctrl-K (Windows/Linux) from anywhere. On a phone, tap 🔍 Find in the bottom dock — it opens full-screen and, because your hands are usually full while travelling, starts listening straight away so you can just say what you want. Whatever you say lands as real, editable text in the search box — touch the box any time to type or fix it instead (your typing is never overwritten by the mic), and the on-screen keyboard never hides the box: it stays pinned in view above the keyboard so you can always see and edit what you searched.
• Type or speak, results group as you go. Matching is forgiving and word-by-word: every word you say has to appear somewhere, but the order doesn't matter and partial words count — so "app builder", "builder app", and just "builder" all find the same cards, and a fat-fingered ovrvw still finds Overview. Results are sorted into sections: Cards (jumps you to that moment in the conversation and flashes it), Projects (switches you there), Tags (filters the lane to that #topic), Go to lane (Active, Done, Decisions, Tasks…), and Actions (Help, background agents, ADRs, preferences, theme, compact, your stats, and more).
• Move and pick with the keyboard. ↑ / ↓ move the highlight, Enter opens the highlighted result. An empty box shows a few useful defaults (⚡ process the next open item, your projects, the common lanes).
• Close it three ways — Esc, the ✕ button, or a tap on the dimmed backdrop (on a computer). Any of them dismisses it completely.

Example: you're on your phone, mid-airport, and want the card where you decided the access-control fix. Tap 🔍 Find, say "access management" — the palette lists the matching cards under Cards and the #access-management tag under Tags. Tap the tag and the Active lane filters to just those cards (with a ✕ Clear to undo); or tap a card and you land right on it. No scrolling, no dropdown hunt.

• The full-text 🔍 Search this session (with author filters and your cross-project prompt history) is still there — it lives in the ⋯ hub and as an action inside the palette itself.
• The 📖 glossary explains the abbreviations that fly by in a technical session (ADR, PR, and the like), so nothing is opaque.

supersedes/cuts: the mobile bottom-dock 🔍 Search button (which opened the plain in-session search) now opens this universal palette — a superset that still reaches full-text search. Nothing is lost; classic search moved one tap into the ⋯ hub and the palette's Actions. The palette's old single-phrase matching (which returned "No matches" for "app builder" unless those two words sat together, in that order) is superseded by the forgiving word-by-word matching above.

Reviewing decisions (ADRs)

An ADR is an Architecture Decision Record — a short document your project keeps for each significant decision (why it was made, what it rules in and out). You no longer have to hunt one down in the terminal.

• Tap it right in the card. When a card says "review ADR-0098", the reference ADR-0098 is a tappable chip. Tap it and the decision opens in a side panel, rendered and readable, right where you are — no asking the agent to fetch it, no switching to the terminal. Paths like docs/decisions/0098-… are tappable the same way.
• Browse them all. Open ⋯ → 📐 ADRs for the full list of this project's decisions, newest first, each with a status badge (proposed / accepted / built). Tap any row to read it; ← All decisions takes you back to the list. On a long list, the filter box at the top narrows it as you type — by ADR number or title (type 92 or hosts to jump straight to the matches).
• Always the project you're looking at. The list follows your active project — Strassi shows Strassi's decisions, AltaGrade shows AltaGrade's, this cockpit shows its own. Switch projects and the panel switches with you.

Example: an AltaGrade card reads "decided in ADR-0092 — hosts can act on behalf of owners." Tap ADR-0092 in that sentence and the full decision opens over the app; read it, tap ✕ (or tap outside the panel) to return to your card exactly where you left it.

🗺 The build queue — see what's stacked

When you tap ＋Build to queue an enhancement it joins a living, ranked plan — the single ordered list your agent keeps and continuously re-sorts for you (highest daily value first). To see it, open ⋯ → 🗺 Build queue: a read-only sheet renders the whole plan — what's queued, in flight, blocked, and in what order — so one tap answers "what's coming next?" without asking. ADR references inside it are tappable chips (they open the decision in place). Tap ✕, tap outside, or press Esc to close.

Example: you queued three UI tweaks earlier in the week and want to know which lands first. Open ⋯ → 🗺 Build queue — the top tier shows the in-flight item, the tiers below show the rest in priority order, and any "blocked on you" items sit up top so you know exactly what one answer would unblock.

🎯 Suggest — only what's genuinely waiting on you

The 🎯 Suggest strip shows open decisions only — never old, already-resolved messages — and it is always on: whenever anything awaits you it renders by itself (nothing waiting → no strip at all; there is no show/hide switch to remember). The header row "⏳ Waiting on you · N" is also its collapse control: tap it (or the 🎯 Suggest tool) to fold the strip down to that one-line count — the fold is remembered per project, starting expanded on desktop and collapsed on mobile. A row is an assistant question you haven't answered yet ("⏳ awaiting your pick"), a pending ✋ needs your approval item (with one-tap ✓ Approve / ✎ Revise and a ▸ full text expander so you read the whole thing before deciding), or a question of yours that never got an answer ("❓ unanswered"); anything urgent ("🔥 urgent") sorts first, then approvals (they block), then oldest-first within each group. Tapping a row lands you on the exact pending question (flashed, with a "⏳ awaiting your reply" chip) with the composer already aimed at that card. When the pending item is a clear numbered pick, tiny answer chips on the row (and on the ⚡ landing action bar) let you answer without typing — and you can choose more than one: tapping a numbered chip selects it (filled = selected; tap again to deselect), an all chip appears on lists of three or more, and once anything is selected a ✓ Send picks chip sends every selected option together as one reply that names each option's text — bound to that exact card. A yes/no question keeps instant one-tap ✓/✗ chips. Items untouched for over a day carry a muted "possibly outdated" tag, and when nothing is waiting the strip doesn't appear at all.

Priority chips on the cards themselves

Every open item's card in the Active stream wears a small chip with the same taxonomy as the strip — 🔥 urgent, ⏳ awaiting your pick, ❓ unanswered — so you can see at a glance, while scrolling, which cards are actually waiting on you. Settled and archived cards never carry one. In Cards view the chip appears as a bare icon on the section header (visible even when the card is collapsed) and in full inside the expanded card.

Aging — old items rise on their own

An open item's priority escalates the longer it sits: an ❓ unanswered question older than 24 hours ranks alongside ⏳ picks, and anything open for more than 48 hours ranks with 🔥 urgent. An escalated chip keeps its true kind but shows a small ↑ (for example "⏳↑ unanswered") so you know the priority rose from age, not from content. This is separate from the "possibly outdated" tag, which only hints an item may already be resolved elsewhere.

⚡ Process next — work the queue head-first

The ⚡ next · N button (bottom dock on mobile) and any Suggest row take you straight to the single highest-priority open item — one landing, every surface. (The old sticky "N need you" banner is gone: it duplicated exactly this queue head.) You land in the main chat (never the focused thread view), on the exact pending turn, with:

• an action bar right at the card: pick chips when the ask is a clean numbered

list (up to 6 options — tap to select several, ✓ Send picks sends them together) or instant ✓/✗ for a yes/no, and ↳ Reply (answer in the composer — the reply is already bound to that card). If the card already shows its own ✓ Done just below (its normal card bar), the landing bar stays Reply-only — so a card or a whole discussion (a "frame" grouping several cards) always has exactly one Done, never two competing ones. When the landing is the only place to settle (nothing else offers a Done), it carries ✓ Done and ✕ Dismiss itself;

• a "⏳ awaiting your reply" chip that also names what is awaited ("pick 1–5", or the

closing question).

Nothing is quoted on your behalf — landing binds your next reply to the card but never stages content you didn't select. Answer it (or ✓ Done / ✕ Dismiss it) and the next tap lands on the new head. Tapping again while still on the head steps to the second item, so you can also walk the whole queue.

Sorting the Cards view

Cards view has a small ⇅ sort control: Priority (open cards first, in the same queue order the chips follow, then the rest newest-first), Newest, or Oldest (chronological). The choice is remembered per project lane. The chat stream itself is never sorted — it always stays chronological.

📍 Screenshots that address themselves

Paste or share a screenshot and Virtia works out — in the background, with no request from you — what it shows: a cockpit shot resolves to the visible project and lane (Active / Done / docs / login / settings / terminal), and when a card's title is clearly readable it resolves to that exact card too; anything else gets an honest app guess ("Terminal", "Cloudflare error page"). Once resolved, the screenshot's message wears a small 📍 Project · surface chip, with ↗ card jumping straight to the pictured card — even in another project. Card resolution is confident-only: a title that can't be matched cleanly just omits the jump rather than guessing. Related: hold (or right-click) a card's 🔗 icon to copy a reference — Project · card <id> — "title" — the same address format reports and annotations use, perfect for naming a card in any session; a quick tap still copies the plain link.

(Admin aid.) On the platform-admin's own view each card also shows a tiny monospace id chip in its header next to the 🔗 link — the card's stable id. Tapping it appends a ready [re: card <id>] reference at the END of your message composer and focuses it, cursor waiting right after the reference — so you can keep typing your update on that exact card, no copy→paste step (toast: "↳ Card ref added to your message"). If you'd already started typing, the reference is added at the end of your text (a single space separator, your draft preserved, never overwritten) — so you can write first and drop the reference in after, exactly where the cursor ends up. Tapping several id chips in a row builds a list at the end in the order you tapped them (e.g. [re: card a] [re: card b] ); tapping the same chip twice won't duplicate it. It still copies the same reference to the clipboard too, so paste-elsewhere keeps working. It's admin-only — regular subscribers never see it (it's internal machine metadata). The 🔗 link and its copy-reference stay for everyone.

Radar — stop re-answering the same thing

The Recurring-Question Radar clusters similar questions that keep coming up. If you have effectively asked the same thing many times, Radar surfaces it so it can be answered once and settled — instead of being re-litigated every few days. Automated system pings are filtered out at the source, so Radar only ever clusters your real questions.

Rules & the playbook

Every session has a playbook — a living list of rules. When you state a preference or a correction, it gets saved so it applies again without you repeating yourself. The rules engine runs your playbook consistently, turning "how I like things done" into something the session actually follows.

The backlog

A per-session backlog captures ideas and follow-ups so they don't get lost in the scroll. Add an item by voice or text; work through it later.

The agents panel

Claude Code can dispatch background agents to do work in parallel. The 🤖 agents panel gives you live status of every agent you've launched — what it's doing and whether it's still running — right from the header, so long-running work is never a black box.

Spawning a worker: pick a type, or hand it to your architect

＋ Spawn a worker opens a small sheet where you name the worker and write its brief. Two controls shape what happens next:

• Type — Research · Verify · Build (default Research). Your pick is prepended to the brief so the worker knows its mode — e.g. choosing Research sends [type: research] … ahead of what you wrote. Research and Verify are read-only-ish jobs (investigate, check) and spawn with no fuss. *Selecting Build shows a warning: "⚠ A Build worker spawned here skips your architect's isolation + review — for live-code edits, hand it to your architect instead."* A worker spawned straight from this sheet runs on its own; it does not get your architect's isolated worktree or review pass, which is exactly what you want for live-code edits.

• ↳ Hand to architect instead. Instead of spawning an independent worker, this sends your brief to your architect through the normal composer path, worded as "Please spec + run this as a worker (isolated + verified): <your brief>". The sheet closes and you get a "Sent to your architect" toast. Nothing is spawned here — your architect picks it up, specs it, and runs it as an isolated, verified worker. Example: you start typing a "refactor the mic caps" build brief, notice the Build warning, and tap ↳ Hand to architect instead — the same text lands with your architect on the safe path. (The button is disabled until the brief has text.)

_supersedes/cuts: nothing removed — this is additive to the existing Spawn-a-worker sheet (adds the Research/Verify/Build type selector, the Build-skips-review warning, and the Hand-to-architect route)._

What the attention cleanup superseded (RULE 5b sweep, 2026-07-17)

Every new surface prunes what it obsoletes. This sweep cut: the separate ✋ approvals strip + header pill (approvals are now a first-class kind inside the one waiting-on-you queue, with the same Approve / Revise / full-text powers everywhere), the sticky "⚡ N need you" banner (the ⚡ next button, the always-on Suggest strip and the 📥 inbox all land the same queue head), the Suggest on/off toggle (always-on, collapsible instead), the duplicate weekly-usage chip (one copy per viewport), and the Overview lane's hardcoded launch-week tiles (live, freshness-stamped numbers or nothing).

Local automation

Virtia leans on local scripts for anything that can be automated without a model: health checks, keeping the connection alive, watching for a stalled agent. The principle is simple — spend the model's effort only on judgment, and let cheap local daemons handle the routine. When something genuinely needs a decision, Virtia wakes the session; the rest runs for free in the background.

The system talking to itself stays out of your cards

Some of that background machinery shows up inside the transcript — most visibly the Rule Guardian, an internal daemon that nudges your agents to keep following the rules (one idea per card, close a reply with a disposition, re-anchor after a compaction). The Guardian's nudges, and your agent's compliance-replies back to them, are the system talking to itself — pure plumbing you should never have to read or decide on. So Virtia keeps them out of your card view automatically. You don't configure anything; they simply never become cards.

The line Virtia draws is deliberately safe: a reply is only hidden when it's answering the Guardian directly, with no message from you in between. The moment you say something, your agent's next reply is a real answer to you — so it always renders. For example, if you ask "what are these guardian cards?", the agent's explanation stays visible (it's answering you), even though it mentions the Guardian by name; only the agent's earlier "fair catch, I'll fix that" back to the daemon is tucked away. Your genuine conversation is never touched.

Context, reactions & installing

The context meter

A long conversation eventually fills the model's context window. Virtia pins a context meter so you can always see how full it is, and alerts you as it approaches the limit. You are never surprised by a compaction. The percentage is the same number Claude Code itself shows — Virtia measures against the window Claude Code actually lets a session use, so the meter and the terminal never disagree.

Compaction

When context gets full it must be compacted — summarized so work can continue without losing the thread. In Virtia the compact button is a request, not an instant action: it tells the session to compact at the next good moment, since only the session knows when it's mid-thought versus safe to summarize. Over time you'll simply be told a compaction is coming rather than having to manage it.

The model chip — and never getting jailed by a limit

The status row shows the live model your session is running on (the ✦ chip). It is always your real current model, never a placeholder — even at the exact moment a session hits a usage wall.

Tap the chip to switch models. Virtia sends the switch to the session and then confirms it actually took: you get a "Switched to <Model> ✓" once it lands, or a heads-up to try again (or that you may be out of credits) if it doesn't.

You are never stranded by a per-model limit. If the model you're on runs out of its quota — the point where a terminal session would freeze on a "you've reached your limit, run /usage-credits or switch models" message — Virtia automatically switches your session to a working model and tells you, so the work keeps going. You can switch back whenever you like; Virtia never switches back on its own, and never reverses a safety change the platform made — it only escapes a quota wall, which is exactly the action the limit message itself recommends. If every model is out of quota, you get one clear notice to add credits.

A whisper before the wall: when a model gets close to its window, Virtia warns you early so you can switch before it walls at all.

If a model is at its cap, the chip tells you. When the model you're on has hit its per-account usage cap, the ✦ chip shows a small ⚠ walled and its tooltip names a model that still has headroom — so switching is one tap on the chip you're already looking at.

Which Anthropic account has room — the headroom strip

If you run more than one Anthropic account and switch login when one nears its weekly cap, Virtia gives you the visibility so you're never surprised. Open the command center (tap the usage figure) and you'll see an Accounts · which has room strip: every account Virtia has seen, side by side, each with its weekly %, 5-hour %, and any model that's walled on that account. The account you're logged into is marked active.

• A heads-up before you wall. When an account crosses ~90% weekly (or one of its models nears its own cap), that row shows a quiet ⚠ ~90% — switch soon so you switch on your timing, not mid-flow.
• "I've switched — re-sync." After you log into another account in your terminal, tap ↻ I've switched — re-sync and the cockpit re-reads your usage immediately, so everything reflects the new account without waiting for the next poll.

This is visibility only — Virtia shows you the numbers and removes the wait. It never handles your credentials, never logs in for you, and never switches accounts on its own. Choosing which account to use, and when, is always your call. If Virtia only knows one account so far, the strip simply shows that one; more appear as you log into them.

Reactions

React to any reply with one tap:

• 👍 Like — good: helpful, correct, yes.
• 🔥 Fire — outstanding: nailed it, do more of this. A stronger positive than a like; it marks your gold-standard moments.
• 👎 Down — off: so the session learns what to avoid.

Think of it as a dial — 👎 avoid → 👍 good → 🔥 outstanding. Reactions feed a satisfaction view so patterns you love get reinforced and patterns you dislike get dropped.

🌃 The skyline backdrop — a different city per project

Behind your cards, the Cockpit paints a city skyline. Each project gets its own, so the background quietly tells you where you are before you've read a word:

• Cockpit — Santiago, looking toward the Andes: the Gran Torre rising out of the

Providencia towers, with the mountain ridgeline and its snowline behind them.

• Strassi — Sydney: the Opera House sails on the point, with the Harbour Bridge arch

beyond them and the Sydney Tower needle over the CBD.

• cp.altagrade — Cape Town: Table Mountain's flat top with its "tablecloth" mist on the

rim, flanked by Lion's Head and Devil's Peak.

They're drawings, not photos — nothing to download, nothing running while you work, and they never animate. Switching projects swaps the city instantly; all three are already on the page, so there is no flicker and nothing on screen moves.

It follows your clock

The sky shifts with your local time: deep night in the small hours, a warm glow low behind the skyline around dawn, a cooler open sky through the day, and an orange-violet dusk in the evening. Stars fade in and out to match. It reads the hour when you open the Cockpit and again whenever you come back to the tab — never on a timer, so it costs nothing to keep open.

It stays out of the way

Cards, replies and the composer all sit on their own solid surfaces, so the artwork is never behind the words you're reading — only around them. Atmosphere in the margins and empty space; your text stays as readable as it was.

Turning it off: ⋯ hub → Appearance → 🌃 Santiago skyline. One tap switches it, and the Cockpit remembers your choice on that device. With it off, the Cockpit looks precisely as it did before — a plain flat background, nothing else changed.

Two things worth knowing. These are night scenes, so they only appear in dark mode — switch to light and the backdrop steps aside rather than smearing a dark picture behind a light interface. (The setting still reads "on (dark mode)" there, so you can tell it's waiting rather than broken.) And on a phone the picture crops to its centre, so each city is composed to put its landmark right there — the Gran Torre, the Opera House sails, Table Mountain's flat top.

Example: you're on your phone at 6am, and you switch from Strassi to cp.altagrade. The Opera House gives way to Table Mountain, the sky carries a low dawn glow behind it, and nothing on the page jumps. Prefer none of it? Two taps in ⋯ → Appearance and it's gone.

Install as an app

On a phone, use your browser's Add to Home Screen. Virtia installs like a native app: full-screen, its own icon, no address bar, no App Store review. Launch it from the home screen and it opens straight into the Cockpit.

Staying connected

The Cockpit streams live. Behind the scenes Virtia keeps its connection healthy automatically and reconnects through drops, so you can lock your phone, walk away, and pick the conversation back up where it was.

Staying current

When a new version of the Cockpit ships (a bug fix, a new feature), Virtia applies it for you automatically at a safe moment — you no longer have to notice a pill and tap it, so you're never left staring at an already-fixed bug on stale code. It reads the moment:

• Composer empty and not focused, no panel open, and you've paused for a moment? Virtia applies the update quietly — and puts you back exactly where you were. It remembers the card at the top of your screen and lands you right on it, whether you were at the bottom of the thread or scrolled up reading older cards. No pill, no tap, no lost place.
• Mid-typing, composer focused, actively scrolling, dictating, or with a panel/sheet open? It waits and shows a small 🔄 New fixes ready — tap to apply pill so you're never pulled away from what you're doing. Tap it to apply right away — or just carry on: the moment it becomes safe (composer empty and unfocused, no panel open, and you've paused), Virtia applies the update quietly for you and keeps your place.

You can never lose typed text to an update: any unsent words in the composer — or even just having the composer focused — force the pill instead of a silent refresh (and your draft is saved regardless). If several updates arrive in a burst, you see one pill, not a flurry, and it's applied at most once.

Example: you're reading older cards near the top of a long thread when a fix ships. Because your composer is empty and you've paused, Virtia quietly applies the fix and drops you back on the same card you were reading — the thread doesn't jump to the bottom, and you may not even notice it happened. If instead you'd been half-way through typing a reply, the 🔄 New fixes ready — tap to apply pill would appear and wait — your draft untouched — until you tapped it or finished and paused.

When your Claude Code CLI is behind

The pill above is about the Cockpit itself. Separately, when one of your watched sessions is running an older Claude Code CLI, Claude Code prints an "Update available" banner in its terminal — which you'd never see from your phone. Virtia catches that banner and shows a small amber chip above the composer:

⬆ Claude Code update available Strassi — run brew upgrade claude-code@latest

It tells you exactly which session(s) are behind and the exact command to run. It is informational only — Virtia never runs the upgrade for you (that's your call, in your terminal). Tap the chip to copy the command to your clipboard; tap the ✕ to dismiss it. Once dismissed it stays hidden for that version — but if a newer update notice shows up later, the chip comes back so you don't miss it. When every session is up to date, the chip simply isn't there.

Example: you glance at the Cockpit and see "⬆ Claude Code update available Strassi — run brew upgrade claude-code@latest". You tap it (command copied), switch to your terminal, paste and run it, and next time Virtia scans that session the chip is gone.

Accounts & plans

Signing up

Create an account at virtia.com and sign in from the header. Your login carries a plan, and your plan unlocks a set of modules — Virtia's features are entitlement-gated, so you turn on exactly what you pay for.

Signing in

There is one sign-in page for everything — the same form whether you arrive at /login or open the Cockpit directly. If your browser supports passkeys, a fingerprint/passkey button appears automatically; otherwise you sign in with email and password. After signing in you land in the right place automatically: Cockpit operators go straight to the Cockpit, everyone else to their account page.

Plans

• Free / Solo — $0. Self-host the Virtia server, connect your own Claude Code, one active session, and community rule-packs. Everything you need to drive a single session from your phone.
• Pro — $19/mo. A hosted relay with a permanent URL (no tunnel fiddling), push notifications, multi-device sync, unlimited sessions, full findability and automation, and private rule-packs.
• Team — $29/seat/mo. Shared, observable sessions, org-wide rule-packs, SSO, and an audit log with roles.

Billing

Checkout runs through Stripe. Upgrading takes you to a secure Stripe-hosted page; your card details never touch Virtia. You can start on Free and upgrade when you want the hosted relay and notifications.

What "hosted relay" means

On Free you run the server yourself and reach it over your own connection. Pro's hosted relay gives your Cockpit a permanent, stable URL that stays up without you managing a tunnel — the most reliable way to reach your sessions from anywhere.

Privacy posture

Virtia never hosts your model or your repository. Your code stays on your machine, your Claude Code runs under your own subscription, and Virtia only relays the conversation between your phone and that session. You own the compute and the data — that's the whole point.

Running several projects at once

Virtia is built for working many Claude sessions in parallel — each project gets its own tab, and everything you need to know about a project is visible without switching into it.

What each project tab tells you at a glance

• ● live state — a pulsing dot while that session is working (green: thinking/writing; amber: running a command), hollow when idle. Hover it to see the session's name and what it's working on right now.
• 🧠 context % — how full that session's memory is.
• Acct _ · wk % — which Anthropic account this project is running on, and that account's weekly usage. The account shows as a neutral Acct A / B / C (see "Accounts" below for why), with its email when Virtia can tell. So a glance answers "Strassi is on Acct B, 65% into its week" — no reverse-engineering. A muted ◐? in place of the % means Virtia is still confirming this session's account (see below).
• ◐ 5h usage % — how much of the 5-hour rolling Anthropic limit that session's account has used. It resets fast. Projects on different accounts show different numbers; projects sharing an account share the meter.
• ⚠ needs-you and unread badges — which project actually wants your attention.
• Dimmed = fully idle — a project whose session isn't working and has no agents running fades to ~70% with an "idle · duration" subline (tab and mobile dropdown alike; the mobile switcher pill gains a small ○ when the active project is idle) — so busy projects pop and sleeping ones recede, with no reordering.

The bottom line (and the weekly figure elsewhere) carries the other window: ◐ wk %, Anthropic's weekly (7-day) limit — the big-picture number. The two usage figures share the ◐ glyph, so each is labelled with its window — 5h vs wk — to keep them apart.

So the tab row answers "who's busy, who's stuck, who's near a limit" without opening anything.

Cross-project attention — another project can reach you

You never have to patrol your other projects for trouble. When a project you're not looking at has something 🔥 urgent waiting (a blocker, an error, a money question), a slim *"🔥 Project needs you · N urgent" banner floats in above the conversation, and the project switcher (the dropdown pill on mobile, that project's tab on desktop) carries a subtle red tint. The banner only fires on fresh, verified urgency: an item must be genuinely urgent in its own words and recent (asked in the last few hours) — items that merely aged, and questions you've already answered (even with a short reply-bound "Go"), never interrupt you. It even re-checks the item the moment you tap: if it was answered in the meantime, you get a quiet "That item was just resolved" instead of a pointless switch. Tapping the project name switches you over and lands you right on the item — same as tapping ⚡ there yourself — and a transient ↩ back to Project chip appears in the same slot, so returning to where you were is one tap too. Tapping the count opens the inbox (below). If several projects burn at once, the banner fronts the one that's waited longest and adds "+N more". Not now? Tap ✕ — that item stays quiet until something new* urgent appears there. The banner floats over the page, so it never shifts what you're reading. (Older or aging-escalated items still surface — in the ⚡ queue and the 📥 inbox — they just don't shout.)

📥 The inbox — process everything from everywhere in one place

The banner shows only the loudest fire; the inbox shows every open decision across every project — the active one included, urgent or not — merged into a single list sorted by priority, then by how long each item has waited. Open it by tapping the banner's count, or anytime from the ⋯ hub → 📥 Everything waiting on you · N. Each row names the project, the kind (🔥/⏳/❓), the question, and its age — and is directly actionable in place: answer chips (multi-select works here too), ✓ Done, ✕ Dismiss, or ↳ Open to jump into that project and land on the item. Anything you answer or settle from a row acts on that row's project — you can clear the whole board without ever leaving the sheet. The list refreshes live while open, and when nothing is waiting anywhere it says so: "Nothing waiting on you anywhere 🎉".

The inbox also flags wasted capacity: a project that's been fully idle for 15+ minutes while it still has open items gets a quiet 💤 idle with work row — ▶ nudge tells that session to resume its queue, ✕ quiets it for an hour (it re-arms at most once per project per hour).

⚑ Report a card — tell the Cockpit team, from anywhere

Every card carries a small ⚑ next to its 🔗/🎯 icons. Tap it when something about a card looks wrong (mis-filed, mislabeled, rendered badly, shouldn't exist) and the composer arms with a report chip naming the exact project and card. Type or dictate what's wrong and hit Send — the report goes to the Cockpit session itself, whatever project you're in, tagged so it can find that precise card. Your in-progress message is safe: anything you'd already typed is set aside while you report and restored the moment the report is sent (✕ on the chip cancels; typed report text stays in the composer if you change your mind).

What the indicators mean — a legend

Every glance indicator is spelled out in the app: open the ⋯ hub → Help → 📖 What the indicators mean. It lists:

• ● live-state dot — green &amp; pulsing = the session is working; hollow = idle.
• 🧠 context % — how full that session's memory is (high → time to compact). The percentage matches Claude Code's own context indicator, so Virtia and the terminal always agree.
• Acct _ · wk % — which account this project runs on (neutral Acct A/B/C) and that account's weekly usage; ◐? = confirming the account.
• ◐ 5h — Anthropic 5-hour rolling usage for that project's account (resets fast).
• ◐ wk — Anthropic weekly (7-day) usage — the big-picture limit.
• ⚡ N — how many items are waiting on you in that project.
• unread badge — new messages since you last looked.

The command center

Tap the status pill (or the bottom bar on mobile) for the full picture of the selected project: live task plan (what the agent is working through, step by step), Anthropic usage bars, context, background agents — and a last completed session summary (duration, lines changed, model mix, whether it exited cleanly).

The composer's status is now one consolidated pill row — project dot, role, activity, weekly ◐ wk % and the model chip (each keeps its tap: command center / model picker) — and the old "bridge connected" line is gone: the bridge speaks only when it's broken, as a red strip with one-tap retry.

Accounts — zero setup

You never register or declare Anthropic accounts. Log into whichever account you like in Claude Code; Virtia notices, meters it, and keeps it fresh automatically. Rotate accounts when a limit maxes out — sessions started earlier keep running on the old account, new ones pick up the new login, and each tab's meter follows its own session's account. When one account runs hot, Virtia proposes a switch on its own.

Which account is each project on? — neutral names

If you run several projects across a few Anthropic subscription accounts and switch logins near a wall, the one thing you need at a glance is which project is on which account, and how much room that account has left. Virtia shows this everywhere a project appears:

• On every project tab / switcher row: a compact Acct _ · wk % chip — the account and its weekly headroom.
• In the command center (tap the status pill / bottom bar): a Projects → accounts · weekly map — all your projects in one short list, each pointing at its account and that account's weekly %, above the Accounts · which has room strip. One view answers "who's where, and which account is near its wall."

Accounts are named neutrally — Acct A, Acct B, Acct C — assigned in a stable order and shown with the account's email when Virtia can read it (e.g. Acct B · me@alanmels…, full address on hover). This is deliberate: an account's raw internal label is sometimes a leftover snapshot filename that happens to look like a project name (for example the literal word "strassi"). Showing that would make you think a project was an account and vice-versa, so Virtia never shows the raw label — only the neutral Acct _ identity. Projects are Strassi / AltaGrade / Virtia; accounts are Acct A / B / C — the two never blur.

Concrete example. You have three projects on three accounts. The command center shows:

Strassi → Acct B · me@alanmels… — 65% &nbsp;·&nbsp; AltaGrade → Acct A · astrik…@gmail… — 2% &nbsp;·&nbsp; Virtia → Acct C — ◐?

You instantly see Strassi's account (B) is two-thirds through its week, AltaGrade's (A) is fresh, and Virtia's account is still being confirmed. If B were near 100% you'd /login Strassi's terminal into a fresher account — Virtia is display-only, it never switches for you.

Best practice — one account per terminal. Keep each project's terminal logged into a single account, and rotate a whole project to a fresh account when its weekly nears the wall. That keeps the tab chips honest (one session, one account) and makes the Projects → accounts map read cleanly.

Each project's usage number reflects a periodic /status check of that session — the reliable way to know which account a session's in-memory login belongs to. Right after you /login into a different account inside a running session (the process keeps going on the new login), that tab briefly shows a muted ◐? — "rechecking" — instead of a percentage while Virtia re-confirms the account on its next check, rather than flash the old account's number at you. It settles back to a real % within a few minutes. A muted ◐? is Virtia saying "confirming which account this is," never a real 0%.

Update & restart — getting every session onto the new Claude Code

When a new Claude Code release lands, upgrading it on your machine is only half the job: sessions that are already running keep using the old binary until they restart. That's easy to miss — nothing looks wrong, and a project can sit on a version from days ago while you assume it's current.

Update & restart does the whole thing in one command:

node scripts/update-restart.mjs --dry-run     # look first — changes nothing
node scripts/update-restart.mjs               # do it

What it takes care of for you:

• It checks each session without disturbing it. It reads which binary each running session

actually has open — it never types into your terminals to find out. Sessions already on the new version are left completely alone.

• It never fights another update. The upgrade runs once, before any session is touched, and

only if one is genuinely needed. If you (or another window) already have an update in flight, it waits for that to finish instead of colliding with it — the classic "a brew upgrade process has already locked…" failure simply can't happen.

• Your conversations survive. Each session is asked to write its hand-off notes, then restarts

with --continue, so it picks the conversation back up rather than starting from scratch. The pane comes back clean instead of full of old scrollback.

• The session you're driving from restarts too. Restarting the session you typed the command

into would normally kill the command mid-run. Instead that one is handed to a small background helper that restarts it a few seconds later, after your command has finished — you'll see exactly which session was deferred and where its log is.

Concrete example. You upgraded Claude Code this morning and want everything on it:

$ node scripts/update-restart.mjs --dry-run

  brew: already latest (2.1.215)

  SESSION    RUNNING  INSTALLED  VERDICT       NOTE
  ─────────  ───────  ─────────  ────────────  ────────────
  claude     2.1.212  2.1.215    will restart
  altagrade  2.1.207  2.1.215    will restart
  virtia     2.1.215  2.1.215    current       this session

Two projects were quietly running week-old binaries; the one you're sitting in is already fine. Drop --dry-run and those two restart onto 2.1.215 with their conversations intact, while virtia is skipped entirely because it has nothing to gain. Run it a second time and it does nothing at all — once everything is current, there's no work left to do.

Two things it does at the end that matter if you're away from the keyboard:

• The session gets back to work by itself. A restarted agent would otherwise come back and just

sit there waiting for you to say something. Instead it's told to re-read its hand-off notes and carry on with the most important unblocked work, without asking you what to do next. You don't have to be there.

• Background agents are rescued. Restarting a session stops any background agents it had running.

Before the restart, their full instructions are saved to a file, and the resumed agent is pointed at it so it can restart the ones with unfinished work. It's told the list may include a few that already finished, so it checks before re-running anything. This is a genuine repair, not a guarantee — the saved list is deliberately generous, and the agent decides what's worth resuming.

Useful extras: --only <project> to update a single session, --no-baton to skip the hand-off-notes step when you're in a hurry, --no-resume to leave the session sitting idle instead of resuming, and --no-fleet to skip the background-agent rescue.

Letting sessions update themselves (off by default)

You can also let a session handle this on its own — but only at a moment when it's genuinely cheap. The setting is off until you turn it on.

The rule is simple: a session only restarts itself once its context is at least 75% full. The reasoning is about what a restart costs you. Restarting a session that's 7% into a fresh, valuable conversation to gain a version number is a bad trade. But at 75% the session is already heading into a compaction — it's about to pause and write its hand-off notes anyway — so the restart rides a cost you were going to pay regardless. It writes its notes once, and comes back both compacted and up to date.

Three other conditions must also hold, all of them about not surprising you: the session must genuinely be on an older version, it must be idle (never interrupted mid-answer), and the hand-off notes it wrote must be substantial — if they look like a stub, it refuses to restart and says so.

Concrete example. Two projects are running a Claude Code version from last week.

Strassi is at 80% context — overnight it writes its hand-off notes, compacts, restarts, and

by morning it's on the new version with its conversation intact.

AltaGrade is at 10% context — it's left completely alone. Restarting it would throw away a

fresh conversation to gain a version number, so it keeps working and stays on the old version until

either it fills up or you update it yourself.

That second case is a deliberate tradeoff worth knowing about: a session that never gets busy can stay on an old version indefinitely. Nothing is hidden from you — it still shows as behind — but the automation won't touch it. If you want it current now, run the command above.

One more thing this never does: it never runs Homebrew for you. It only moves a session onto the version already installed on your machine. Installing a new Claude Code stays your call.

One conversation, clean cards

Every session's output is organized into topic cards. When an agent answers your question and then goes back to its ongoing work, the unrelated updates split into their own card automatically — your question's card stays about your question. Cards you settle move to ✅ Done and stay there — a sealed card never returns to Active on its own; a follow-up on the same topic starts a fresh card with a "↩ continues" link back to it, and only an explicit reply (from Done or a search result) reopens the old card. Tapping a search result that lives in Done takes you straight to it (clearly labeled, one tap restores it).

Getting around on mobile — everything from the bottom

On a phone the conversation is long and you work at the bottom, so the key navigation is right there with you — no scrolling to the top:

• A dock above the message box puts the useful actions one tap away: 🔍 Search, Active (home), ⚡ Needs you (lit with a count when items await you — tap to jump through them), ❓ Help (opens the docs — how Virtia works), and ⋯ for everything else. Help is how the cockpit works, not a project chatbot: for questions about your actual project, talk to your architect in the message box (the Help toast has a one-tap "Talk to your architect" shortcut that drops you right in the composer).
• A compact project dropdown stays pinned at the top — tap it to switch between any number of projects (the list scrolls; it never clutters the screen).
• The ⋯ hub (also the desktop ⋯ More) is one organized panel — slides in from the side on desktop, up as a sheet on mobile — holding project switching, every lane (Active, Done, Decisions, Tasks, Builds, Overview, and the rest), Search, and all your settings grouped by section.
• Search is mic-first on mobile: opening it doesn't pop the keyboard — it goes full-screen and starts listening, so you just speak your query (tap 🎤 to toggle, or the field to type).
• Active is home — Done and the other lanes live in the hub, there when you want them, never in the way.

The Overview lane — live numbers or nothing

The Overview lane shows only stats with a live data feed, each stamped with its data age (a muted "now / 2h ago" under the number). A tile whose data goes a day without refresh dims and says "stale"; past a week it disappears entirely — you will never act on a fossil number. Today that means the Strassi prod deployment tile (SHA + status, polled live), and the lane is labeled with the project the data actually belongs to — it no longer claims to be "global, same for every project." The launch-week hardcoded tiles (ADR range, error-queue count, check-in tally, and the pre-split "two projects 50/50" topology card — the project switcher is the truth for that) are gone, as is the session-turns tile that just repeated the Active tab's count.

🎵 Focus playlist — your music, one tap away

Save your favorite playlist link once (Spotify, Apple Music, YouTube — any link) via ⋯ → 🎵 Focus playlist, and from then on it's one tap in the ⋯ hub to open it in your music app whenever you settle in to work. A small ✎ change item lets you swap or clear the link anytime. Virtia never plays audio itself — your music app does.

Search across everything

Search covers the current session and your own past prompts across all projects — so "I asked this somewhere weeks ago" is one search away. Tap an old prompt to drop it into the composer and reuse it.

Browser automation — every project can drive Chrome

Each project's agent can connect to your Chrome independently: every session gets its own tab group, so several agents can browse, fill forms, and take screenshots at the same time without stepping on each other. Two practical notes:

• Logins are shared (it's one browser profile): if you sign into a site once, every project's agent can use that signed-in state — handy for handing work between projects.
• Agents work in their own tabs and leave yours alone; expect new tab groups to appear while they work.

If a session ever reports its browser connection lost, Virtia reconnects it automatically — no reinstalling, no restarts.

The working agreement — what Virtia guarantees you

Virtia isn't just a chat window onto your coding agents — it enforces a working agreement that makes agents genuinely pleasant to drive from a phone. These are the promises the platform keeps for you, on every project, automatically. You never configure any of this; it's simply how Virtia-managed agents behave.

The promises

1. You can always answer from your phone. An agent will never trap your session in a

terminal-only prompt. Every question reaches you as a plain card with numbered options and a recommended default — answerable from anywhere.

1. Your architect is always available. The main agent you talk to stays responsive — heavy

building and testing happens on background workers while your conversation partner keeps answering you. No more waiting minutes for a reply because "it's busy coding."

1. One idea, one card. Replies stay single-topic, so every card is something you can settle

with one Done. Every issue you raise ends with a clear verdict: ✅ fixed · 🔨 building · 📋 queued · 📐 designed, awaiting your go · ❌ won't, with the reason.

1. Plans, not essays. You never receive analysis without a next step. If you don't respond,

your agent proceeds with its recommendation instead of stalling — and anything sensitive (money, security, deletions) always waits for your explicit yes, no matter what.

1. Your ideas get improved, and never lost. Every idea you drop gets two or three concrete

enhancement offers, effort-tagged so you can green-light from your phone with one word. Whatever you don't pick lands in a reviewable idea ledger — nothing evaporates.

1. You choose the pace of consent. Prefer to approve everything explicitly? Set consent to

ask. Trust your agent to run with recommendations when you're busy? Set it to auto — silence becomes a go, except for the sensitive categories, which always wait.

1. The docs never lie. Every behavior change updates these help pages in the same change.

If a page contradicts the app, that's treated as a bug and fixed like one.

1. The system stays lean. New features replace what they obsolete — you'll never dig

through three overlapping buttons for the same job because someone forgot to delete two.

Kept honest, automatically

Behind these promises sits Virtia's enforcement layer — always-on checks that re-teach every agent its agreement after every restart, watch for drift in real behavior, and steer sessions back on course before you ever notice. When an agent tries to break a promise, the platform blocks it and corrects it. You don't manage any of this; you just experience agents that stay disciplined for months, not minutes.

Curious how a specific behavior works day-to-day? The other guide pages cover every feature — and your agent will happily explain anything: just ask it.

Cockpit — Legend / Glossary

Plain-language definitions of the abbreviations & jargon we use. Grouped by area.

Dev / Engineering

• ADR — Architecture Decision Record: a short doc capturing one significant technical decision + why.
• IDOR — Insecure Direct Object Reference: a bug where you can act on another user's/tenant's data by passing its id; the auth check trusts the client's value instead of the server-verified one.
• PWA — Progressive Web App: a website that can be "added to home screen" and run full-screen like an app (no address bar).
• tsc — the TypeScript compiler; we run it to type-check code without shipping errors.
• HMR / hot-reload — Hot Module Replacement: code edits appear in the running app instantly, no rebuild.
• e2e — end-to-end: a test that drives the whole system like a real user.
• SSE — Server-Sent Events: a one-way live stream from server to browser (how Virtia pushes new messages).
• CI — Continuous Integration: automated build+test on every change.
• CDP — Chrome DevTools Protocol: how we script/screenshot a real browser.
• SHA — the unique hash id of a git commit (e.g. 64d880c).
• fast-forward (ff) — a git merge with no divergence — just moves the pointer forward.
• worktree — an isolated extra checkout of the repo so an agent can build without touching the main tree.
• tmux — terminal multiplexer: keeps a terminal session alive in the background (Virtia's bridge types into it).
• data-URI — a file (image/font) inlined directly into the page as text, no separate download.
• safe-area-inset — iOS padding so content isn't hidden under the notch / home bar.

Product / Business

• COGS — Cost of Goods Sold: what it costs us to deliver the service (e.g. compute).
• TAM — Total Addressable Market: the whole possible customer base.
• MVP — Minimum Viable Product: smallest version worth shipping to learn.
• GTM — Go-To-Market: the plan for how you launch + sell.
• BYO — Bring Your Own (e.g. BYO-compute: the user runs their own Claude Code).
• open-core — free/open base product, paid hosted/premium layer on top.
• SSO — Single Sign-On: log in once across apps.

STR / Strassi

• STR — Short-Term Rental (Airbnb-style).
• OTA — Online Travel Agency: Airbnb, VRBO, Booking.com.
• WL — White-Label: a host's own-branded version of the platform, no Strassi branding.
• PA — Platform Admin: Strassi-staff god-mode role.
• PII — Personally Identifiable Information: guest personal data to protect.
• turnover — the cleaning/reset between one guest checking out and the next arriving.
• payout accrual — a ledger entry recording money owed to someone (owner/cleaner/org).

Virtia

• Radar — Recurring Question Radar: spots when you've asked the same thing before and links the earlier answer. Its "you asked this before" card now has ✕ New topic: this ask is fresh, don't re-surface that older discussion (undoable).
• lane / project jail — each project tab (Strassi · cp.altagrade · Virtia) is jailed: Done, Decisions, Tasks, Backlog and Rules re-scope to the selected source (📌 tag), and the lanes that stay shared say 🌐 global. "Virtia (old)" (the frozen pre-split history) is hidden from the menu; there's no "All" tab once one lane IS the whole source.
• live-agents strip (🤖) — above the conversation: every background agent currently running for this session — name, what it's doing right now, elapsed, tokens — pulled from the agent transcripts; a row vanishes the moment its run closes.
• ⚖️ Decide — the one-tap button on every ❓ OPEN backlog item: sends "Decide: ‹item›" so options come back as tappable choices.
• ⇱ merge-up — folds a card into the card above it (same task); undoable.
• ✓ resolution line — each settled card in Done shows a one-line outcome (its final reply's lead) so you can scan what came of it without opening it.
• staleness horizon — a card silent for 24h leaves the live view automatically (still in Done). The conversation shows only current work: pending / needs-you / awaiting / merging / deploying. Open decisions never auto-leave.
• Kaya is on it… — pulsing dots after you send, until the first reply lands.
• lane — the topic filter inside a split source. "Virtia (old)" = the frozen pre-split Virtia history; the live "Virtia" source is its own dedicated session.
• focus mode / thread jail — WhatsApp-style: open a thread and you stay in it until you exit.
• task (🎯 Tasks lane) — a named thread YOU create and track: status dial ○ open → ◐ doing → ✓ done, one-line outcome captured at done. Tap a task to enter it (its own jail — everything you say stays under it until ← All); 🎯 on any card promotes that discussion to a task.
• [task: …] tag — the invisible prefix Virtia adds to messages sent inside a task so they stay grouped; you never see it raw, just the 🎯 chip.
• 👀 what did I miss? — the catch-up chip that appears when 6+ turns arrived while you were away; tap for a short AI digest, "Needs you" items first.
• TL;DR headline — long replies surface their own bold lead as a one-line headline at the top of the bubble.
• Tips deck — the 💡 Tips sheet is a swipeable deck; cards with a dashed "try it" zone are live demos (they act on nothing real).
• bridge — the link that sends your composer text into the Claude session's terminal (via tmux).
• source / session — one connected Claude Code conversation Virtia is watching.