Skip to content

Releases

v0.2.2

Choose a tag to compare

@github-actions github-actions released this 13 Nov 12:54

Fixed

  • A chat is free again once Claude's reply is over, also while a background
    agent it started runs. Claude's adapter holds the prompt open until that agent
    ends, so the chat looked busy and messages queued "for when done" waited for
    the background agent, sometimes for an hour.
  • A background agent that Claude runs again with SendMessage is back in the task
    bar until it ends, also one from before a server restart.

Full Changelog: v0.2.1...v0.2.2

v0.2.1

Choose a tag to compare

@github-actions github-actions released this 10 Nov 23:26

Build your own apps without leaving the chat. An agent writes the app package,
shows you its views live in the conversation, and loads it into your running
server once you approve.

Added

  • bt_load_app loads an app package into the running server, from the chat
    that wrote it, without a restart. Every load waits for an admin to approve it
    on a card in the chat, and the agent can't answer that card. Its tile then
    appears on the open dashboards, and chats started from then on get its tools.
    It works from the server's own machine: in the desktop app, and on any server
    that can write its Julia environment.
  • The dashboard's Apps section follows the server's apps, so a new app's tile
    shows up without a reload.

Changed

  • The README and the documentation lead with building your own apps. The Apps
    guide, now Build Your Own Apps, starts with a prompt to paste into a chat.
  • At startup the server runs only the apps of packages marked as plugins, not
    every app some loaded package registered.

Fixed

  • An app returned into the chat failed with a MethodError when it showed
    changing state, an Observable holding DOM. It renders now, so an agent
    building an app can show the app's views in the chat.
  • A Windows bundle unpacked by hand starts: its launcher creates the app's data
    folder, which v0.2.0 left to the installer.
  • The README's links into the documentation pointed at pages that don't exist.

v0.2.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 13:21

v0.1.0 was a good chat for Claude Code on your own machines. This release turns
BonitoAgents into a self-hosted workspace for any coding agent, on every
machine you own, for a whole team, with everything the agents make rendered
live.

Highlights

  • Bring any agent. Codex and Kimi Code join Claude Code, OpenCode and MiMo.
    Switch a chat's agent in its header at any time: the next turn runs under the
    new agent, which gets the conversation so far. The BonitoAgents tools render
    as the same cards whichever agent calls them.
  • Every machine, one connection each. Workers keep one resumable,
    multiplexed link to the server that survives sleep and network switches. From
    one chat, an agent can run Julia on another machine, move Julia values between
    machines and sync folders. Continue on opens a chat on another worker with
    the project's files and the agent's memory.
  • Teams and the open internet. install_server.sh sets up a server with a
    passkey login (Authelia), behind a tunnel or with Caddy and Let's Encrypt.
    Admins invite people, put them in groups and share workers with groups.
  • Share with a link. Reports, files and live apps open in any browser, with
    an optional password; Settings lists every link.
  • Everything it makes, in place. A 3D viewer with textures, notebooks,
    tables, video that behaves on phones, markdown with its pictures, and code
    highlighting for 90 languages.
  • Server apps. Apps are Julia packages with their own chat pane and tools
    for every agent; the bundled To-do app keeps one list for the whole server.
  • Review the agent's diff line by line, ask about a change right away, or
    bundle notes into one instruction.

Agents and providers

  • Codex through the managed codex-acp adapter. Discover finds Codex
    sessions on a worker, and Codex chats resume after a restart.
  • Kimi Code provider. Kimi, OpenCode and Codex tool calls are normalised, so
    bt_julia_eval, bt_show and the other tools look the same for every agent.
  • Switching providers is transactional: the choice is kept once the new agent's
    session is up, otherwise the chat goes back to the previous agent and says why.
    The new agent receives the conversation so far.
  • Managed adapters: workers install Node and the Claude Code and Codex adapters
    into a private prefix, at the versions the server declares, and update them
    while no chat runs. A Node mirror can be configured.
  • Provider failures reported at the end of a turn (Codex's usage limit, for
    example) show as a Provider error notice in the provider's own words.
  • Yolo mode leaves only on purpose: the agent says it is done, then confirms
    it. A failed, refused or repeating turn, or several turns without a tool, stop
    the loop and switch Yolo off. Losing the agent connection pauses the loop and
    keeps Yolo on, with the connection error shown in the chat.
  • Stop spares background subagents, and the agent is told about tasks a
    stop interrupted. Pending cancellation is visible after reload too, with a
    Force stop action for an agent that does not respond. The next message
    reconnects without needing the chat's Restart action.
  • Message queues are explicit: queue for when the agent is done, after the
    current message, or interrupt and send.
  • Passwords for sudo and ssh are typed into the chat. bt_sudo runs a
    command as root, on the worker or, with ssh, on a server through a
    connection that bt_ssh opened. That connection's control socket also lets
    later ssh, scp and rsync calls log in without asking. Each question sudo or ssh asks shows as
    a card naming the command, and also appears after a reload. The answer goes
    from the card through the worker to sudo or ssh, never to the agent.

Machines and workers

  • WorkerLink: one resumable, multiplexed connection per worker. MCP traffic and
    eval bridges ride it through the worker's relay, so no extra ports or paths
    are needed.
  • Run Julia on another worker from the same chat (bt_julia_eval(...; worker = "name")), switched on per chat by an admin with Remote julia.
  • remote_session moves Julia values between machines; bt_sync_folder
    streams folders between workers through the link. Use direction="pull"
    to retrieve results or paths to batch selected files and recursive folders
    in one call. Transfers automatically report progress in the chat and sidebar.
  • Successful progress jobs show “Completed”, then clear from the chat and
    sidebar after five seconds and stay hidden after reload. Running jobs at
    100% remain visible until completion is confirmed; failures wait for dismissal.
  • Peer coordination uses bt_chat and a separate Chat messaging switch,
    off by default in both chats. Dev mode never grants messaging. The server
    immediately enforces permission revocation, including stale dev-tool calls;
    queued peer input is paused until explicitly retried.
  • Continue on another worker: a new chat there with the project's files and
    the agent's own record of the conversation.
  • A worker that crashed mid-turn tells exactly the chats it cut off to carry on
    when it is back.
  • Background Julia runs: bt_julia_eval(...; background = true),
    bt_julia_wait, run rows in the chat and continue cards that lead back to
    their eval.
  • Workers update themselves once no chat runs on them, or right away with
    Update now, and their cards show the progress. A reinstall keeps the
    machine's credential.
  • Every process a chat starts, on every worker, is recorded and ended with the
    chat.

Files, media and apps

  • The 3D viewer reads the original files with three.js, textures included.
  • Media on phones: no flicker while scrolling, no download again when enlarged,
    buttons that are visible on touch screens.
  • Worker files stream as links; markdown shows its pictures; links to markdown
    files open in the workspace.
  • bt_show takes a title for what the file shows. The card wears it, with
    the file's name and size beside it, the full path on hover, and a click on it
    opens the file. A picture shown bare keeps it as its caption.
  • Re-showing an overwritten image requests fresh pixels even when Read or
    another preview already displayed that path. The browser can no longer reuse
    the first decoded image without contacting the worker-file route.
  • Code views are static and highlighted in a background worker, with Monaco's
    grammars for 90 languages. A 10,000-line result opens without freezing the
    page and stays searchable and copyable.
  • Server apps with tiles on the dashboard, and the To-do app.
  • bt_share: links for a markdown report with its pictures and videos, any
    file in its viewer, or a Julia file's live app with one copy per visitor.
    Optional password; listed and ended in Settings.
  • Review changes: the project's git diff as a workspace tab, compared with
    any branch, tag or commit, with Ask and Feedback.

Login, teams and servers

  • install_server.sh installs Caddy and Authelia, asks its questions once and
    remembers the answers, and checks DNS and ports before it asks for a
    certificate.
  • Run behind a tunnel: the server asks Authelia about every request itself, so
    no certificates, DNS records or open ports are needed on the machine.
  • Passkey-first sign-up; a password plus an authenticator code for whoever
    cannot use a passkey. No mail server needed.
  • Accounts, invites and groups. Members see their own chats and the workers
    shared with their groups; admin-only menus stay hidden from them.
  • Login sessions live in a private, persistent Valkey store, so logins survive
    restarts and one device's login no longer ends another device's.
  • All tabs of a browser share one login: when it ends they wait, and one login
    in any tab brings them all back.
  • Updating keeps the running server serving until its one restart near the end,
    and Authelia restarts only when something it runs changed.
  • Without a login: bonito-agents server for this machine only, or
    --host 0.0.0.0 for a network you trust. Uninstalling keeps the data.

Chat and workspace

  • Delete a chat for good. From the chat's ⋯ menu or its card in the recent
    chats overview: removes the transcript and shared links, with options to delete
    the agent's saved session and wipe shared project memory. Project files stay.
  • Faster page loads. A worker's list of past sessions is built when you open
    it, not with every page. A page with hundreds of past sessions, on a phone
    especially, no longer waits for rows it isn't showing.
  • The transcript opens at its newest messages and loads older ones as you
    scroll, keeping a bounded number of rows in the page; the reading position
    is anchored to content.
  • Switching chats and workspace tabs keeps their layout and scroll positions
    instead of rebuilding them.
  • A mobile composer and a phone sidebar; a resizable sidebar in recency order.
  • A tab whose server session is gone reloads itself, or asks first when a draft
    would be lost.
  • Readable file search hits; colour-matrix eval results as real PNGs.
  • Export as Markdown in the chat's ⋯ menu downloads the whole chat as one
    readable .md, every tool call with its full output and diffs. It is also a
    BonitoBook notebook: each Julia eval is a cell you can run again (thanks
    @sbordt).
  • A bt_process card now says what the call did and how it went, such as
    "Wait for Build docs · failed · exit 3", with a red pill when the job failed.
    Opening it shows the command, folder, worker and output.

Developer tools

  • Debug BonitoAgents opens an agent on a BonitoAgents checkout on the worker
    you choose. Dev mode adds tools for the running system: server and worker
    state, logs from every machine, browser tabs and their consoles, timings and
    memory.

Fixed

  • The desktop app starts on macOS and on a fresh Windows install. macOS killed
    v0.1.0's bundled Juli...
Read more

v0.1.0

Choose a tag to compare

@SimonDanisch SimonDanisch released this 21 Jul 11:02
7a77ab9
bt show removal and julia tool cleanup (#17)

* remove bt_show_app

* Hold the reading position across type toggles (filter_scroll)

Hiding/showing a message type re-anchored the scroll on whatever row the
generic anchor found after the toggle, drifting the viewport by up to a
full row (worse while the async re-window was still settling).

setKeyHidden now captures the first SURVIVING row at the viewport top in
virtual order and holds it sticky through the settle: the row's DOM offset
is used when it is rendered (immune to the height estimates unrendered
rows carry), with the virtual coordinate as the hole fallback. The sticky
anchor expires after 1.5s or on user scroll input.

The e2e test additionally waits for scroll geometry to stabilize before
capturing its baseline and tolerates sub-gap probe overhang.

* Replace @mcp_msg/@builtin_msg macros with Message composition

The macro-generated tool-message structs duplicated nine header fields
into every type behind unreviewable codegen. Now the shared state lives
in one mutable struct Message (id, kind, name, title, status, summary,
started_at, finished_at, chat) composed as .message into every ToolMsg
variant, and each variant declares only its OWN typed fields, parsed
from the streamed rawInput via apply_input!(m, raw) at build time and on
every tool_call_update (claude streams tool arguments incrementally).

Only the unknown-tool fallbacks (GenericToolMsg / GenericMCPToolMsg)
still carry a raw_input Dict. Known MCP tools store no wire name; the
type is the name (tool_key(::JuliaEvalToolMsg) == "bt_julia_eval").
Reads go through accessors (tool_id/tool_status/msg_id/...), writes
mutate m.message directly. content_summary keeps dispatching on the
kind-derived type so e.g. a Bash mv still gets the move summary.

Test fixtures and assertions converted to the composed constructors and
accessors across unit and e2e suites; full suite green (1764/1764).

* Harden bt_julia_eval render coverage; fix ANSI in returned strings

The types e2e asserted on whole-card innerText, which the CODE ECHO also
satisfies (Monaco renders the eval source, and most markers appear
literally in it) — so the plain-value cases never proved the RESULT
rendered. Assertions now scope to the .bt-embed result mount, images
must actually LOAD (naturalWidth > 0 proves the asset served over the
eval bridge proxy, not just that an <img> tag exists), and markers that
would appear in the code are built by concatenation in the eval source.

New corner cases (31 -> 44): missing, NaN/Inf, unicode/emoji, multiline
strings, SVG mime, text/latex -> KaTeX, raw Base.HTML passing through as
real elements (regression for the session_dom App(value) wrap), HTML
escaping (a returned string with <script>/<b> stays text, no element is
created and no script runs), ANSI in a RETURNED string, nothing return
(no result box mounted), stdout+result landing in their own sections,
colored stdout pinned to the Output section, @warn -> stderr capture,
worker session state persisting across evals, and a value whose show
throws (inline error page, tool still completes).

The ANSI case exposed a real gap: returned strings render through
Bonito's plain-text child path (jsrender(::Session, ::String) returns
the string), never reaching render_mime's ANSI handling — escape codes
showed as raw text while identical stdout rendered colored. RemoteProxy
now routes ANSI-carrying result strings through RichText.

* RemoteRef: eval results as worker-held values, serialize-on-mount

Replaces the inlined-html eval result flow, which broke the session invariant
(serialized == delivered to the owning page) three ways: html baked at EVAL
time and shipped via the message store, a singleton parent session outliving
pages, and serialization decoupled from mounting. Every reliability bug of
the collapsed-plot investigation (permanent spinners, missing glyphs,
dangling objects, dead-bridge assets) traced back to those shortcuts.

Now (spec: docs/superpowers/specs/2026-07-15-remote-ref-design.md):
* the worker PARKS the value in a page-invisible holder session
  (RemoteProxy.remote_ref) — the session tree is the registry, no render at
  eval time; the final content block is a tiny {"remote_ref": id} descriptor
  (the model no longer sees html blobs either);
* mounting is the stock update_session_dom! recipe via one "mount" control
  op: a FRESH disposable render-subsession per mount, delivered as one atomic
  UpdateSession (the page polls for the placeholder node, so replies racing
  DOM insertion are safe); RemoteRef's jsrender is static-first — snapshot/
  note immediately, the live mount replaces it, every failure degrades to the
  same visible state and nothing can hang;
* ownership rides the session tree: each mount's LOCAL session closes ITS
  render-sub on_close (Julia-first deletion), the holder is untouched, so
  collapse -> re-expand loops and page GC cannot race each other; the
  swap_mount!/take_mounts!/eb.mounts bookkeeping is deleted.

Eval bridge reliability (the pinned everyday-hang causes):
* the relay PARKS worker->browser frames while no browser connection is
  attached (bounded 64MB, oldest-dropped) and flushes in order on attach —
  it silently DROPPED them before (lost init bundles = permanent spinner);
* root_conn rebinds on EVERY attach and on ws reconnect (the attach-once
  guard used to pin the relay to a dead connection);
* call_ctrl waits out a redial grace (injectable; fails fast with grace=0)
  instead of erroring instantly while the worker redials — asset fetches
  during a redial used to strand fragments without their JS module.

test/evalenv gains WGLMakie (dev/Makie) so eval e2e can cover live figures.

* bt_julia_eval live display + filter_scroll anchor fix

Display (the running-eval card):
* the code preview IS the editor now: eval cards use the edit-tool
  compact-body Collapsable (server-typed compact_body) — the body, whose
  first section is the full Monaco Code editor, eager-mounts while the code
  runs, height-capped to ~4 lines; the old <pre> preview is deleted. Compact
  bodies re-render once at terminal status (editMode never re-fetches, so
  completed content used to stay stale).
* stdout streams while running: BonitoMCP tees each session's output to a
  DETERMINISTIC per-env log (eval_log_path) and the chat live-tails it over
  the worker file protocol (the bash bg machinery), shipping ANSI-stripped
  stream_tail updates into a ~4-line auto-scrolled pane under the header;
  removed at completion (the Output section owns the text then).
* a completed eval that RETURNED a value auto-expands the body
  (auto_expand_full -> client expand_full); nothing-returns stay compact.
* mock fidelity: the dispatcher announces bt_eval_open BEFORE running the
  handler (real claude opens the tool first), so in_progress lasts as long
  as the eval — which is also what makes the streaming e2e possible. New
  e2e testset covers the whole triple live; streamed_tool_input ported to
  the new contract.

filter_scroll (#48 soak flake, root-caused from the new anchor debug dump):
* _captureKeyAnchor now requires the same 4px bottom-overhang the top-marker
  probes use — it anchored rows hanging <=3px into the viewport (not the
  reading position), and that sliver's reflow arithmetic produced the
  constant one-row drift. Capture decisions are stashed (_anchorDebug) and
  the test probes atomically with the toggle + dumps evidence on failure.
Verified: filter_scroll 5x isolated + 2 full-suite soaks green (1801/1801
and 1798/1801 with only unrelated new-sighting intermittents).

* Fix scroll_anchor + filter_scroll soak intermittents (probe semantics, not anchors)

Three independent test-side hazards plus one real capture-side gap, all
caught with the new failure instrumentation:

* _captureAnchor (generic scroll anchor): apply the same 4px bottom-overhang
  tolerance the probes and _captureKeyAnchor already use, so a row with a
  1-3px sliver hanging into the viewport is never pinned as "the reading
  row" (sliver reflow arithmetic drifts the view a full row under load).
  Stashes _anchorDebugG {st, idx, off} for post-mortems.

* scroll_anchor height-churn testset: wait for virtual-scroll geometry to
  SETTLE (scrollHeight|scrollTop stable across 4 polls) after the mid-history
  scroll, and take the reference probe + INFLATE in ONE atomic JS execution.
  Under full-suite load a ResizeObserver re-measure between two separate
  round-trips shifted the transcript ~11 rows and was blamed on the toggle.

* scroll_anchor hidden-pane backfill testset: gate on request quiescence
  (no msgs.request for 800ms) before hooking the request counter, so
  in-flight range fetches from PRIOR testsets don't leak into the
  "hidden pane must not prefetch" count (the 116 == 0 failure).

* filter_scroll: assert the true invariant "the READING ROW keeps its
  screen offset" (OFFSET_OF the marker captured at toggle instant) instead
  of "the top-visible marker number is unchanged". When a to-be-hidden tool
  row straddles the viewport top edge, collapsing it necessarily slides the
  previous marker's bottom into view, so the top-marker identity changes
  while the view holds pixel-perfectly (full-soak dump: anchor held marker
  9 at +30 exactly; marker 8's bottom landed at +30 and won the probe).

Verified: e2e:scroll_anchor 4x isolated green, e2e:filter_scroll 5x
isolated green, three consecutive full-suite soaks 1803/1803.

* improve bt_show_eval

* bt_eval refactor

* Add usage_update context meter and available_commands_update slash autocomplete

Wire usage_update (tokens used / window size / cumulative cost) through
AgentClientProtocol into a header context pill ("21.8k/200k · 11% · $0.42").
Hidden until the first turn reports; at mobile width it lives in the ⋯ panel.

Wire available_commands_update into a composer autocomplete popup: typing a
lone /query token opens a filtered list (prefix matches first), ↑/↓ cycle,
Enter/Tab accept into "/name ", Escape closes without cancelling the turn.

Also add explicit keep_in_history=false for ConfigUpdate/ModeUpdate so a
replayed metadata message no longer throws a MethodError in the reconciler.

Includes unit tests (parse, observable wiring, label formatting) and e2e tests
(pill text assertion, popup open/filter/accept/escape).

* Eval result: bt_show_app output handling + three-state Collapsable sections

Two things the eval-result display lost / never had, from Simon's review.

## Live result embeds get bt_show_app's output handling (detach / pin / keep-alive)

The whole infrastructure survived the bt_show_app removal (keep-alive
parking LRU, ⤢ detach → workspace-panel adoption via move_dom_node,
restore-on-close, wrap_for_detach around every result) — it was just
unreachable because nothing set kind=bonito_app for eval results anymore.

A typed `live_embed` flag (completed + a result descriptor — values AND
errors) is emitted on all three server paths (live snap update, terminal
arrival, fresh-page header dict) and consumed by the existing machinery:
`data-bt-app` → the card parks display:none on scroll-off instead of
being removed (removal closes the sub-session and disposes the WebGL
context — a WGLMakie plot came back dead), plus the ⤢ detach button.
New e2e `eval_embed_park` proves it with instance identity: a counter
clicked to 13 survives scroll-away/back (never re-rendered) and detach
into a floating panel and back, still round-tripping clicks through the
eval bridge.

## Collapsable is now the default three-state widget

`Collapsable(...; summary_lines=4)`: the header cycles full → summary →
collapsed. `summary_lines` is the restricted-preview height in lines; the
Collapsable BODY owns the scrollbar (overflow-y:auto) so the summary is a
scrollable window onto the full content, never a truncation. `pin_end`
keeps that window on the newest line.

This fixes the styling jump Simon flagged: the running stdout pane
(scrollbar, pinned to end) used to switch to a different, scrollbar-less
clamp once done. Now streaming and completed Output are the SAME pin_end
console in the same Collapsable body — the JS stream_tail writes into that
console and pins its scroller. Deletes the old `.bt-subsection-more`
"show all" bar, `data-full`, `.bt-clamped`, and `section_lines`.

## Also

- scroll_anchor "hidden panes stop backfilling" testset hid onHidden() on
  a still-visible pane — a synthetic state the chat-LRU visibility resync
  (only reachable in a full soak) flipped back mid-count (the 188==0 /
  0>0 intermittents). Now navigates to the dashboard to hide for real.

Verified: e2e:bt_eval 29/29, e2e:eval_embed_park 18/18, e2e:scroll_anchor
18/18, full suite 1913/1913.

* COVERAGE: add eval_embed_park e2e row

* Eval display: concise App echo, remove dead fullwidth toggle, harden section cycle

Three issues from Simon's review of the eval card.

* Output showed the App's struct dump. `format_value` echoed
  `show(text/plain)` for the result, which for a value with a rich
  display but no text repr (a Bonito App, a Makie figure) is the default
  struct dump — `App(<opaque closures / Refs / nothings>)` — that a REPL
  would never print (it would DISPLAY the object). In the chat that
  display IS the live result embed, so the dump was both ugly and
  redundant. `result_repr` now echoes a concise `summary` ("Bonito.App")
  for rich-but-unreadable values, while plain data structs keep their
  informative struct dump and everything with a real repr (numbers,
  arrays, DataFrames, strings) is untouched. e2e asserts the dump never
  leaks back into Output.

* Removed the `.bt-tool-fullwidth` (`»`/`«`) header button. It did
  nothing useful on eval/tool cards (the workspace owns width now; embeds
  detach to panels) and its stray icon in the header was confusing.
  Dropped the button, handler, `.bt-tool-wide-active` CSS, and the
  session_changes wide-mode testset.

* The three-state subsection cycle handler now stopPropagation()s so a
  subsection toggle can never bubble to a card-level handler.

Verified: e2e:bt_eval 32/32, e2e:session_changes + e2e:eval_embed_park
green, full suite 1907/1907.

* Eval display: zero Output for displayed results; restore + fix full-width toggle

Corrects two things from the previous commit that were wrong.

* ZERO Output for a value that's DISPLAYED in the result pane. Previously
  the result repr was appended to the output stream, so even a returned
  App (shown live as the result embed) produced an Output section — first
  the struct dump, then (last commit) a stray "App". The result echo now
  rides in the descriptor's `repr` field instead: the AGENT reads it there,
  the chat renders the live embed, and the Output section shows captured
  STDOUT only (absent entirely when the code printed nothing). Errors keep
  their echo in Output — a failure must be prominently visible to the agent.
  `format_value` returns `echo=nothing` + `{"remote_ref","errored","repr"}`
  for a parked ref; the no-bridge fallback still echoes the repr as text.

* RESTORED the `.bt-tool-fullwidth` (`»`/`«`) button — removing it was
  wrong; it's how you give a result/message full chat width. It was "not
  functional" because the embed card's `:has(.bt-embed)` max-width cap
  (1100px) out-ordered `.bt-tool-wide-active`; the wide rule now comes
  after it and uses `max-width: 100% !important`, so the card actually
  spans the column (verified 902→1049px and back). The subsection cycle
  handler stopPropagation()s so toggling a section never touches the card.

e2e now asserts an App result has NO Output section, and the wide toggle
actually WIDENS the card (not just flips a class). test_stability updated
to the current format_value NamedTuple API.

Verified: e2e:bt_eval 32/32, e2e:session_changes + e2e:eval_embed_park
green, full suite 1915/1915; helper checked directly (App→"Bonito.App",
42→"42", descriptor JSON-escapes).

* bt_julia_eval: REPL-style eval (soft scope + world age), distinct 3-state markers

Two things Simon hit while testing the live tool.

## REPL-style evaluation

The worker spliced the parsed code block straight into a function argument
(`format_value(<whole block>, …)`), which flattened multiple top-level
statements into ONE expression. That broke REPL semantics two ways:

  * Soft scope — `acc = 0; for i in 1:n; acc += i; end; acc` errored
    "acc not defined in local scope" (hard/file scope), instead of summing.
  * World age — a `function f … end; f(x)` in one eval warned "access to
    binding `f` in a world prior to its definition" (Julia ≥ 1.12), because
    the call ran in the same world as the definition.

The worker now evals the code STRING REPL-style: `repl_eval` →
`include_string(REPL.softscope, Main, code)`, which evaluates each top-level
statement separately in Main (advancing the world age between a definition
and its use) with soft scope (top-level loops may assign to globals), and
returns the value of the last statement. `execute` sends the code string to
`eval_and_format` instead of splicing the AST.

## Distinct marker per collapse state

The three-state Collapsable (collapsed → summary → full) had only TWO
markers — summary and full both showed ▾. Now: ▸ collapsed, ▿ summary
(hollow = partial), ▾ full (filled = all), keyed off `data-state`.

Verified: e2e:bt_eval 38/38 (adds soft-scope/world-age testset + marker
asserts), full suite 1920/1920, unit test in test_stability, and
`include_string(softscope,…)` checked directly (15, 4.0, no warning).

* docs + walkthrough: foreground bt_julia_eval and its live-result features

Docs rewritten around bt_julia_eval (there is no separate bt_show_app):
* mcp-tools.md — full rewrite. bt_julia_eval as a shared live REPL:
  streaming stdout with the soft-timeout checkpoint model,
  continue/interrupt/restart, the live result embed (any value — including
  an interactive App — rendered live and still wired to the worker), ZERO
  Output for a displayed value, the three-state Code/Output sections,
  detach/keep-alive, full-width toggle, REPL semantics, output discipline.
  bt_show kept for files; a live app is "just a value bt_julia_eval returns".
* index.md / chat.md / concepts.md — Live results / Media / tool-pill /
  walkthrough wording updated to the same model.

Walkthrough re-recorded to match. The revive now RETURNS the Lorenz app
from bt_julia_eval (RemoteRef live embed) instead of the removed
bt_show_app; the tour keeps every previously-shown feature (dashboard
cards, the live WGLMakie surface + slider, detach into a float, dock into
the plotpane, file tree + Monaco editor, fractal gallery, GoL refactor
chat, parallel subagent audit) with the first half now centered on the
bt_julia_eval result.

Recorder ported off drifted ElectronCall APIs: ECT.wheel (removed) →
scroll_by! driving the chat's own spring scroller (it ignores synthetic
wheel); ECT.real_click (removed) + the now-synthetic cursor can't set CSS
:hover → open_lorenz_file! animates the cursor then trips the hover-gated
files hint through the DOM. The two old-chat browsing steps are wrapped so
a replayed-edit flake on un-reseeded history can't abort the recording.

* walkthrough: regenerate stills to bt_julia_eval world + clean GoL diff step

Regenerated both doc screenshots from the current build:
* screenshot-chat.png — the Game-of-Life torus diff rendered in Monaco.
* screenshot-workspace.png — the Monaco editor (lorenz.jl) + file tree with
  the live Lorenz app RETURNED from bt_julia_eval docked beside it.

GoL diff step: the replayed edit renders fine in the lighter stills path
(hence the still above) but this deep in the video tour the accumulated
WebGL/bridge load can starve its tool.render — a content-independent,
load-dependent flake (re-seeding the chat wouldn't change it). So the tour
now attempts the expand with only a short grace instead of stalling the
camera 20-45s waiting for a render that won't arrive, keeping the take a
tight ~60s. The bt_julia_eval centerpiece + every previously-shown feature
are intact; the diff is documented in the still.

* improvements

* Walkthrough videos: dashboard workflow + focused bt_julia_eval demo

Two start-page clips, both driven by 100% trusted input (ECT.real_click /
ECT.wheel) so the video shows exactly what a user does:

- examples/walkthrough_dashboard.jl -> the multi-project dashboard tour: every
  chat a live card with a plot thumbnail, opening projects from their cards,
  switching projects straight from the sidebar, back to Home. Replays the
  persistent rig (no tokens, no agent prompts).
- examples/walkthrough_mock.jl -> the focused bt_julia_eval demo: a curve-fitting
  dashboard, degree-slider sweep from underfit to overfit with RMSE updating
  live, a streaming k-fold cross-validation, the three-state section collapse,
  and detach/dock/steer. MockACP scripts the conversation while the REAL
  bt_julia_eval runs the code.

Fix streaming stdout rendering: the live tail is written as a raw text node into
.bt-console, which had no white-space rule, so newlines collapsed onto one line
while the completed .terminal-output <pre> kept them. pre-wrap both so streaming
and completed render identically.

docs/src/index.md embeds both clips (dashboard hero on top, plot demo under);
development.md documents both recorders. examples/walkthrough.jl general tour
refreshed (streaming-eval demo + async revive).

* walkthrough dashboard: drop the aimless cursor glide over project cards

move_to only repositions the cursor overlay; it never emits the trusted
mouseMove that fires .bt-ov-card:hover, so the glide slid over every card with
no visual response. Open on a still dashboard instead and make the only motion
the purposeful move that opens a project (its real_click sends the trusted
mouseMove, so the card being clicked does light up).

* docs: house-style pass, fix walkthrough links, cover session config

- Drop em-dashes across index/chat/mcp-tools/development to match the
  em-dash-free house style in the rest of the docs.
- Point the walkthrough links at the two purpose-specific scripts: the mock
  bt_julia_eval demo (walkthrough_mock.jl) and the dashboard tour
  (walkthrough_dashboard.jl), not the retired combined walkthrough.jl.
- Document session config (permission mode / effort / model pills + the
  dashboard Session defaults bar), the sidebar toggle (Ctrl/Cmd+B), and the
  responsive/phone layout.

* test env: git-pin Bonito to master, not a local path

BonitoAgents/test/Project.toml [sources] pinned Bonito to
{path = "../../../Bonito"}, a checkout that only exists on a dev machine. On CI
the manifest is gitignored, so instantiate resolves from [sources], hits that
path, and dies before any test runs (setup job red since a42b35b). Match
BonitoAgents own [sources] (rev = master), which is what the file header already
mandates for the forks. Local Bonito dev repoints this to a path uncommitted.

* test env: git-pin Bonito sd/media-proxy + Makie sd/electroncall for the render tests

The render/app e2e items and the render unit test (test_remote_proxy "ship full
objects to proxied roots") need Bonito sd/media-proxy (the proxied-root fix) and
WGLMakie sd/electroncall (GlyphSync). Both were path-pinned to local checkouts
absent on CI, and master Bonito predates the proxied-root fix, so those tests
could never pass on CI. Pin the test env Bonito to sd/media-proxy and the evalenv
Bonito+Makie stack to the pushed render branches (Makie via monorepo subdir).

* CI: fix stale e2e matrix suites (bt_show_app rename left dangling names)

commit a42b35b ("remove bt_show_app") consolidated the live-app e2e items but
left the tests.yml matrix listing the old names, so `embedded_app`/`app_detach`/
`app_scroll` matched no @testitem ("No test items found"). Point the matrix at
the current items: app_reload (embeds survive a page reload), eval_embed_park
(keep-alive parking on scroll), bt_eval_types (eval render-type coverage) —
which is also what exercises the newly-pinned evalenv Makie/Bonito stack.

* CI: drop bt_eval_types from the e2e matrix (times out; not a curated item)

bt_eval_types renders every value type through a WGLMakie eval worker and blows
the per-job time budget (exit 124). It was never in the matrix; app_reload +
eval_embed_park already cover the live-embed path and pass.

* eval bridge: re-dial on dev_server close, not a test-side session refresh

The eval worker is shared per env_path and dials its render bridge back to the
server ONCE (bound to s.dialed_back). A dev_server that goes away left the worker
bridged to a dead server; the next dev_server's eval reused that stale dial-back
and the live result never rendered. Tests papered over it with
refresh_eval_session!, which restart!-ed the whole worker at each test's START —
racy, and it threw away warm compile state (aggravating the app_reload /
eval_embed_park "initial out" 10s flake).

Fix it at the lifecycle level, mirroring production (where each agent's MCP child
owns its eval session and dies with it):

- RemoteProxy: track the dial_loop task (DIAL_TASK) and add start_dial! /
  stop_dial!. stop_dial! clears BRIDGE[], closes the socket, and WAITS
  (bounded > max_backoff) for the loop to exit, so a re-dial can't run a second
  loop against the same driver.
- BonitoMCP: reset_eval_dialback! drops the bridge via stop_dial! and flips
  s.dialed_back, keeping the warm Malt worker so the next eval re-dials the
  current server without re-paying compile.
- TestKit: Base.close(::TestServer) now resets the eval dial-back alongside the
  ctrl one, so eval sessions are re-pointed on dev_server close (deterministic,
  worker stays warm). Deleted refresh_eval_session! and all callers.

* e2e: cold-start budget for the first live-value wait (was 10s)

app_reload / eval_embed_park wait for the embed to render (static PARK-APP /
RELOAD-APP string, 180s) and then for the first LIVE observable value (RAPP=0 /
PARKAPP=0). The static string lands before the embed finishes its WGLMakie/Bonito
live-init (shader compile + observable subscribe + first frame), so that first
live value is actually the coldest step in the test, yet it had the SHORTEST
budget (10s) while renders/reloads/interactions get 15-180s. Bump to 30s so a
cold CI runner does not trip it; the round trip completes (eval_embed_park proves
it), this just stops under-budgeting the slowest step.

* copy projects

* e2e: faithful eval isolation + render warmup; fix cross_worker form order

Replace the last timing/isolation masks in the e2e harness with fixes that
mirror production, and fix a real test-order bug.

- cross_worker: create_on_worker picked the folder BEFORE switching the
  Worker <select>. Switching a worker resets the folder picker to that
  worker's projects_root (the folder is worker-specific — dashboard.jl
  on(np_worker) -> reset_to_worker!), wiping the selection, so Create on a
  non-default worker failed "Source path is required" and the chat never
  opened. Select the worker first, then pick the folder (the real user
  flow: choose the machine, then browse its folders).

- new_chat: reset the eval dial-back per chat. In production each chat is
  its own agent -> own MCP child -> own worker/bridge, so chats never share
  a dial-back; the harness runs ONE in-process MCP manager, so a second
  chat's bt_eval reused the first chat's dial-back and mounted its live
  embed against the wrong page. Dropping the dial-back (worker kept warm)
  makes each chat re-dial for itself — the correct behavior refresh_eval_session!
  was papering over by cold-restarting the worker.

- SharedServer: warm the live-render path once per worker with a throwaway
  live mount, so the first real live embed doesn't pay ~5s cold Julia JIT.

- app_reload / eval_embed_park: revert the first-live-value wait 30s -> 10s;
  with the warmup the value lands well under 10s, so the wide budget is no
  longer needed.

* e2e: revert warmup + per-chat dial reset (they regressed eval_embed_park)

0afb382 added a SharedServer render-warmup chat plus a per-chat
reset_eval_dialback! in new_chat, meaning to kill cold-start JIT and
simulate per-chat eval isolation. On CI that regressed E2E — eval_embed_park:
the warmup introduces a SECOND eval chat, and the per-chat reset then
re-dials the shared worker's bridge for the park chat — a re-dial that
races on a slow CI runner, so the park embed never mounts (180s timeout on
"app mounts live"). Green locally, red on CI.

It was also LESS production-faithful, not more: in production every chat
owns its worker/bridge from birth and nothing resets a dial-back mid-life.
The warmup created the only two-eval-chat scenario that needed the reset.

Restore the 07688e6 state for these four files — which CI proved green for
BOTH app_reload and eval_embed_park (only cross_worker was red there):
no warmup, no per-chat reset, and the 30s cold-start budget for the first
live-value wait. That budget is honest accounting of a real one-time JIT
cost of the render path, not flakiness; the proper follow-up is a precompile
workload in BonitoMCP so even it can go. The dev_server-CLOSE reset stays.
The cross_worker reorder fix from 0afb382 is kept.