dotbot (editor panel)

The DotBot panel: one dock tab, DotBot, in the right dock under the Agents menu beside the terminal agents' tabs.

A conversation runs on an account, and the account is a setting of the conversation, shown on the composer's account chip and changed from it:

Account	Pays
OrigoZero credits	the agent included with OrigoZero
each connected Claude account	that Claude plan
each connected ChatGPT account	that ChatGPT plan

Several accounts of one provider connect side by side. Each is one of the plugin's agents: dotbot-claude runs on the first Claude account and dotbot-claude~2 on the second, so moving a conversation to another account is sending its next turn as that account's agent. A conversation keeps its history when it moves.

• Toolbar: DotBot, then conversations, new chat, whether DotBot reacts to engine events, the community setting, and overflow.
• Community setting: how much community work DotBot does without asking the person: off, rate, rate and report, rate, report and contribute, or full (also answering comments and reviewing contributions on their content). The menu reads and sets the engine's community module (@builtin::modules.community), which keeps the level in the person's home folder, so it goes with them from world to world; the engine's community notices and DotBot's own rules both read it. Until a home folder is mounted, a level set holds for the engine session, and the menu says so.
• Conversations: every conversation, whichever account it ran on, named with that account. Opening one opens it on the account it ran on.
• Look: the panel draws in DotBot's own palette (View.palette(): charcoal neutrals, DotBot orange for its mark, Send, what is active and the context bar), with prose in the editor's sans and code, tool names and figures in JetBrains Mono (View.MONO). The editor's own controls (the text field, the chips, menus) keep their look.
• Transcript: the person's messages as rounded bubbles on the right, the answer as plain text across the panel, and between them a turn's work (its thinking and tool calls) as one rounded card, a step per row. Under each turn, a quiet usage line: model, thinking level, the context it read, tool calls, duration, and which account paid, said on the conversation's first turn and whenever it differs from the turn before. A turn's usage line stays under its own turn when the stored history catches up with what the panel watched live. A switch of account says so in the conversation where the next turn will appear.
  • Turns started elsewhere: a turn the panel did not start (a run the engine starts with a prompt, the page's agent_prompt, the engine waking the agent) shows the message it answers as it starts, above what the turn says, in that turn's conversation, which the panel moves to. What the engine delivered reads as the engine's row, the way a reopened conversation reads it.
  • Thinking is folded, never hidden: a row that says Thinking… 4 s while the model thinks and Thought for 4.2 s once it has, with a chevron that opens the thoughts (streaming live while it thinks). A turn's thinking phases fold into one row when the turn ends, and a reloaded conversation shows the thinking it stored.
  • Tool calls are a line each: a dot for how it went (green done, amber running, red failed, grey stopped), the tool's name, and what it was called on (its first argument, a path or a query), or why it failed. A call opens to its input and answer. A run of carrier calls names what a tool_exec actually ran, from the trace in its answer, for a live answer (cut at 2000 characters by the host) as well as a stored one. A picture whose file is gone says so.
  • Pictures: every picture a tool call returned (a capture, a read_file of an image, an execute that answers one) shows as a thumbnail under the call's card, live and in a reopened conversation. Clicking a thumbnail opens its larger copy beneath the card; clicking it again closes it. The plugin keeps a thumbnail (at most 240 px) and a larger copy (at most 1280 px) of each, and the panel draws only those.
  • Answers wrap: a markdown table is drawn as a table whose cells wrap, and a fenced code block wraps at the panel's edge instead of running past it.
  • Selection: text can be highlighted with the mouse and copied with Ctrl+C: user messages, thinking, tool details, error cards, code blocks, and (where the renderer supports selectable on a richText) every styled paragraph, list item and table cell of an answer.
• Composer: where a message is written. Files go with it: the attach button opens the person's file picker, Ctrl+V (Cmd+V on macOS) with an image on the clipboard attaches the image, and files dropped anywhere on the panel attach while a line in the composer says they will. Each shows beside the input (a thumbnail for a picture the model reads, its name for any other file) with a button that takes it back out, and goes with the next message, which needs no text of its own. A file over the size ui.maxFileBytes() states, or one that cannot be read, is named under the composer, and the others attach.
• Agents: the agents a conversation's turns started (start_agents), as cards between the transcript and the composer, newest first, under a heading counting them by state, with what they used together (input, output, cache hit rate, summed from their statuses as they arrived) at its right. The section is about three agents tall until a person drags its top edge to another height (kept for the tab), scrolls past that, and folds to the heading once every agent has ended (a press on the heading opens or folds them). Each agent is one line: a dot and its state (queued, starting, working, waiting, done, failed, cancelled) in its own hue, its name, the tool it is in right now (or that it waits for the person's answer, for engine work, or once it ends its answer or why it failed; a phase that only repeats the state is left off), how long it has taken (counting while it works), its Stop and the arrow to its transcript. A press on what it is doing opens the line to the rest: its task, the whole of what it is doing, what it has used (tool calls, input, output, cache hit rate) and thumbnails of the pictures its calls returned. The square stops that agent alone. The arrow, or its name, opens the agent's own transcript in place of the conversation: its state above every row of its conversation, stored and streaming, opening on its task, with its pictures and a Working row, and Back returns. While the turn runs wait_for_agents its Working row names the agents it waits on. The agents are held by the source, so the panel opened again shows them as they stand.
• Workflows: every workflow run in the engine, whoever started it, opened from the toolbar's count of the runs still running (shown while any runs) or from More > Workflows. A card per run, newest first, names its workflow, its state (Working, Waiting, Running, Finished, Failed, Cancelled), the DotBot conversation that started it (and the agent a turn started, when one of those did), how long it has run, its phases and how many of its requests are answered, and why it ended. Opening one shows each phase with its requests: each one's state, the agent working it (a button opens that agent's transcript) or the runner holding its claim, how long it has been claimed or waited, the claims that ran out and its error; a press opens its answer. Under them, the run's log. A running run can be cancelled; Cancel asks once first. Everything moves as the runs do, read from the engine's workflow runtime, and only what changed is drawn again.
• Composer: the account chip, a model chip and a thinking chip offering only the levels the chosen model accepts, attach, send, and a line naming what is left of the account's usage.
  • Context: under the composer, one line: how much context the conversation holds against its model's context window (184K / 1M), the bar, and an info button. Hovering the button shows the rest (where it compacts, and what the last turn and the conversation used); a press keeps those lines open under the bar. The bar is filled as the plugin measures it after each model call and dropping after a compaction. A handle on the same bar stands where auto-compaction triggers (compacts at 600K) and sets that threshold: drag it, click the bar, or with the bar focused use the arrow keys (10K a step, Shift for 100K), Page Up / Down, Home and End. The value it lands on is shown while it moves; once let go (a key: once pressed, or once let go after it is held) it is the person's auto-compact setting, the one Settings… shows. It stays between the least a threshold may be and the most it takes effect at, never past the window. A model that states no window reads max unknown and says so; its handle keeps its own range.
  • Tokens: on the context line's info button (as lines under the composer for a conversation with no context bar), what the conversation's model calls used, for the latest turn and for the whole conversation: uncached input tokens, output tokens, and the cache hit rate (cache-read input over all input: cache read, cache written and uncached). The plugin records them as each turn ends, so they read the same when the panel or the engine is opened again. A provider that states no cache figures is said to state none.
  • While a turn runs (one the person sent, or one DotBot woke into on its own) the Working row shows and Send becomes Stop. Enter queues the message for when the turn ends; the interrupt button stops the turn and runs the message once it has ended. Queued messages sit above the composer, each one editable and droppable. Stop holds them: a stopped conversation starts nothing until the person sends a held message.
• Account picker (the account chip): every account DotBot can run the conversation on, with its state and usage, then "Connect another Claude account", "Connect another ChatGPT account" and "Connected accounts…".
• Connected accounts: one card per account with its plan, its own usage windows, and Use, Rename, Sign in again and Disconnect; Connect on an account that is not connected starts its sign-in in place.
• Connect flows: ChatGPT's device code, and Claude's sign-in then paste, for the first account of a provider and for each further one.
• Usage states: a notice under 25% of a window left, a warning under 10% offering a cheaper model only when that model is one this account can run, and a spent window naming the connected accounts that still have room, with a button that moves the conversation to the first of them. Nothing moves on its own.
• Failure states: an expired sign-in, an expired code, a provider not issuing codes, an engine not linked to an OrigoZero account, and an account disconnected while a conversation was on it, which then asks for an account rather than sending anywhere.

Everything it shows comes from the plugin through source.module, and every word it puts on screen for a reading comes from view.module. The panel holds only what is on screen right now: which view, which popup is open, which account the open conversation runs on, how far a connect flow has run, and the unsent draft.