0
Fork 0
mirror of https://github.com/zeronsh/comet.git synced 2026-11-16 18:57:19 +00:00
Commit graph

42 commits

Author SHA1 Message Date
Daniel Katulevskiy
2500e8b34f
CI: one entry workflow with admission, reuse, priority/locks and a fast pull request tier (#1077)
* CI: one entry workflow with run admission and a fast pull request tier

Pull request checks took a median of ~3 hours from push to done, and ~110
minutes of that was jobs waiting for a runner. Each push asked for ~207
runner-minutes on 15-20 jobs, almost all of it compiling, so bursts of
pushes queued hundreds of jobs and every run held a few runners while the
rest of its jobs waited behind other runs.

- ci.yml is the only pull request / main / merge queue entry point. `plan`
  picks the suites a change needs; `admit` waits until every runner the
  run needs is free, then all its jobs start together and each runner is
  released when its job ends (scripts/ci/admit.py, first come first served
  with conservative backfilling, state read from the Actions API so fork
  pull requests work). `CI result` is the one check to require.
- Pull requests get a fast tier: Windows, macOS, voice and Android run only
  when the change looks platform specific (their files, platform
  conditionals or APIs in changed code); `ci:full` or CI_PR_TIER=full runs
  everything. Main and the merge queue run the full tier.
- Voice: 14 `cargo test` builds capped at 2 jobs (~40 min) become core-tests
  additions plus one nextest build for audio and the mobile voice core; the
  workflow no longer runs uncancelled on every push or saves caches from
  pull requests.
- Windows: three test jobs become one nextest build; one shared cache
  instead of four (~4.5 GB of the 10 GB repository cache).
- Linux UI and browser share one job and cache; edge coordinator and vault
  share one job; the macOS app is built with the test dependencies instead
  of a `cargo check` that recompiled everything; iOS no longer waits for
  the frame-source job, which only runs when the GPUI pin can change.
- Only main saves Rust caches.

* CI admission: cap reservations read from other runs, expire unseen ones

A pull request can edit its own ci.yml, so the reservation in its admit job
name is untrusted. Cap it at the largest plan.py makes, and stop counting an
admitted run's never-created jobs 90 minutes after admission, so one run
cannot hold more than a full run's runners or hold unused ones for long.

* CI: reuse passes on unchanged inputs; ci:priority, ci:lock and an emergency workflow

Reuse. plan fingerprints every suite's inputs in the tree under test (the
merge with main for pull requests): workspace manifest, lockfile, toolchain,
CI files, the suite's workflow and non-Rust files, and for Rust suites the
packages it tests plus every workspace package they depend on, plus any file
outside those that their sources name with a ../ path (scanned every run).
Every job records its pass in the Actions cache under that fingerprint as its
last step; a suite whose jobs all passed is skipped and reserves nothing, and
single Windows and voice jobs are skipped on their own. Pull requests trust
their own passes and main's; main and the merge queue trust only main's;
ci:full and manual runs reuse nothing. Callers are split per suite so each
records under its own fingerprint.

Priority and locks (labels, so triage or above). ci:priority puts a pull
request's runs at the front of the admission queue; ci:lock keeps a full
run's runners out of everyone else's budget while the pull request is open
(until unlabelled, merged, closed or CI_LOCK_HOURS), and admits its runs
first. Runs name their pull request in the admit job; the claim counts only
when that pull request's head is the run's commit. ci-emergency.yml (write
access) locks a pull request, cancels the other pull requests' CI runs and
re-runs its own if needed.

* CI reuse: fail closed

The merge queue, the last gate before main, reuses nothing. A pull request
that changes a Rust build file no selected suite's fingerprint covers reuses
nothing. Sources that build a path from CARGO_MANIFEST_DIR's parent in code
make their suite read the whole workspace. concat!(.., "/../x") paths and
.cargo/ count as inputs.

* CI result: fix the result listing (shell quoting)

* CI: run less on pull requests, more on schedule, and merge tiny test binaries

Measured in CI, test execution is a small part of every job; compiling and
starting jobs that run little is the cost. So:

- Voice: only the audio stack (zeron-audio, which nothing else builds yet)
  and the packaged Windows media runtime remain, for their own files. The
  mobile voice/orb tests were a subset of ios-core, the macOS/Windows
  `cargo check` of harness+engine duplicated the platform builds, and the
  voice-media tests join the Windows nextest build.
- Fast tier gating of jobs and steps to their own files: Windows packaging
  (`app`), the iOS simulator tests and their bindings, the Linux and macOS
  browser/preview fixtures. Android builds the APK on pull requests for the
  app, the FFI crate and dependency changes; the iOS mobile-core paths come
  from zeron-mobile's Cargo closure. Gated jobs and optional steps are part
  of the reuse fingerprint.
- GPUI frame-source runs only when the pinned zui revision moves.
- Version bumps (only `version = "..."` lines in Cargo.toml/Cargo.lock)
  select nothing and are left out of fingerprints.
- nextest `ci` profile for pull requests and main leaves out the slow/soak
  tests (48-chat and real-quantum doc_host sync, the codex dying-server
  backoff, preview leak, two sleep-bound discovery tests); the cursor_shim
  stress test runs 14 rounds (ZERON_STRESS_ROUNDS, 100 by default). Preview
  discovery tests run one at a time (fixed port).
- Nightly ci.yml schedule runs everything in full; weekly-tests.yml runs the
  engine integration binaries and crate tests no workflow ran.
- Linux core no longer builds the 8 test binaries that run nothing there
  (Windows-only or all-#[ignore]d). The small harness, engine and preview
  integration suites move into one `tests/misc` binary per crate. The orb
  geometry tests move to zeron-orb (they tested its re-export); the
  assertion-free microbenchmark is dropped. The macOS app builds with the
  tests instead of rebuilding zeron-ui without the fixture feature.

* CI: pass the nextest config to the build-only steps too

NEXTEST_PROFILE=ci names a profile from scripts/ci/nextest.toml; the macOS and
Windows `--no-run` builds did not load that file, so nextest refused the
unknown profile.

* Engine: keep the git identity setup inside the home it is given

configure_git_identity pinned HOME but inherited XDG_CONFIG_HOME, and
`git config --global` writes $XDG_CONFIG_HOME/git/config when that file
exists. With a sandbox or test home, the identity landed in the developer's
real git config: running the engine tests on a machine with XDG_CONFIG_HOME
set replaced the user's name and email with the test's. An XDG_CONFIG_HOME
outside the given home now gives way to the home's own, and the test pins it
for its own git calls too.

* CI: iOS simulator tests in parallel with ios-core; Windows UI tests side by side

- The C header and module map the simulator tests link are committed in
  apps/ios/CoreFFI (outside Xcode's synchronized folders) and refreshed by
  scripts/ios/build-core.sh like the Swift bindings; ios-core checks all
  three are current. ios-tests no longer waits for ios-core's artifact, so
  the iOS path is one job long instead of two.
- The simulator core for the unit tests builds in the dev profile, not the
  optimized `mobile` profile the app ships.
- Windows runs zeron-ui's tests side by side: nextest gives each its own
  process, so the in-process `--test-threads=1` restriction no longer applies.

* CI admission: budget defaults at the organization's runner limits

20 jobs in total and 5 on macOS (the organization's concurrency limits), and
at most 10 on Windows so Linux keeps half the pool. The repository variables
still override them.

* CI: skip the browser steps when the Linux setup failed

They run after a failed UI test on purpose (a separate signal), but without
the system packages (an apt mirror stall) they can only fail too.

* CI: retry the WebRTC terminal path test (a known race)

remote_terminals' network-change test asserts no keystroke goes through the
relay once the path reports Direct; in a loaded run one did. Retried like the
other timing-sensitive tests in nextest.toml until the race is fixed.

* Fix two races that failed CI on loaded runners

- Muse: a crash usually shows first as "Muse stdout closed", racing the
  process exit; `try_wait` lost that race under load and users got the bare
  protocol error instead of "Muse exited unexpectedly" with Muse's last
  stderr lines. Wait up to 250 ms for the exit, as the Pi driver already
  does (a_crash_mid_turn_reports_muses_last_words failed this way).
- Remote terminals: a subscription reported TerminalPath::Direct before
  attaching the direct writer, so a keystroke typed by whoever saw Direct
  could still go through the relay (a_terminal_rides_a_real_webrtc_pair_
  through_a_network_change failed this way). Report Direct once writes
  ride the link. The CI retry for that test goes.

Both tests pass 25 runs in a row under CPU load.

* CI reuse: count only the CI files a suite runs

Every suite's fingerprint included all of scripts/ci and the composite
actions, so a change to the planner or the scheduler (which decide what runs,
not whether it passes) re-ran every suite. Each suite now counts the CI files
it executes: nextest.toml and the Linux or Windows setup for the Rust suites,
test-core.sh for core, the macOS fixture runner for macOS, apt-install.sh for
the installer. ci.yml still counts for all.

* docs: changing the fingerprint inputs reruns everything once

* CI admission: no circular waits

Two ways admission could deadlock (until the fail-open timeout):

- Each waiting run counted every other waiting run's admit job as a busy
  runner, including runs queued behind it. With a full run (16 of 20) at the
  head and five or more waiting behind it, the head waited for their runners
  and they waited for it. A run now counts only the admit runners ahead of it.
- Two ci:lock labels each reserved 16 of 20 runners and counted the other's
  reservation, so neither locked pull request (nor anyone else) could start.
  Locks are now ordered by when their label was added: an older lock ignores
  a newer one's standing reservation.

Every wait now points forward in one order, so no cycle can form. A test
simulates 3000 random queues (sizes, priority, overlapping locks, polling
order) and checks they all drain; the previous scheduler deadlocked in 309.
The fail-open timeout drops from 5 h to 2 h as the backstop for the one case
outside the model (waiting admit jobs taking every runner in the pool).

* CI admission: waiting admit jobs yield when they starve the pool; ignore runs that never take their turn

Waiting costs a hosted runner from the same pool as the suites. With about
20 runs waiting, their admit jobs held the whole pool, admitted runs' jobs
got no runner, and nothing moved until the 2-hour fail-open. When an
admitted run's Linux or Windows job has queued 10 minutes, every running
admit job but the first quarter of the budget now starts its run without a
reservation, giving its runner back. A new test models GitHub's runner pool
as well as admission: without yielding most 30-run queues never drain, with
it all 200 do.

A reservation read from another run is not trusted, but a run whose edited
admit step never finished still held everyone behind it for 2 hours (and a
fake admitted run held a full run for 90 minutes). A waiting run that could
have been admitted for 3 minutes but still waits is now ignored, and an
admitted run's jobs that have not appeared 10 minutes after admission stop
counting, except the late result and publish jobs.

Polling backs off further from the head of the queue (5 min, 10 min under
400 requests left): the GITHUB_TOKEN quota is shared with releases, the
Cursor SDK update and CI emergency.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>

* CI: voice and the Linux browser fixture nightly only; forks reuse only main's passes

Over two weeks the voice jobs left after the move into core-tests (AEC3
and the packaged Windows runtime) never failed, and the Linux browser
fixture's failures were window-timing flakes and package downloads. Both now
run nightly, on manual runs and with ci:full. The zeron-ui tests stay on
every change: 2,046 tests in 29 s, and the only check that caught one real
regression in that window.

A fork's earlier runs could save a pass entry for the fingerprint of a
later, clean-looking commit, so its suites would be skipped and the pull
request would still show a green CI result. Until the merge queue (which
reuses nothing) is the required gate, forks reuse only main's passes;
CI_FORK_REUSE=own turns their own back on (ci.yml passes it to plan in the
workflow commit that follows).

Docs: admission's new yield and unresponsive-run rules and polling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>

* Engine: keep the user's own XDG_CONFIG_HOME when the git identity home is theirs

The XDG_CONFIG_HOME guard replaced any XDG_CONFIG_HOME outside `home` with
`home`'s. When `home` is this process's own, that hid an identity the user
keeps in an XDG_CONFIG_HOME elsewhere, and the machine identity went into
~/.gitconfig, which wins over it. It now only applies to a sandbox or test
home.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>

* CI workflows: Android gets only its own secrets, on pushes to main; CI_FORK_REUSE

secrets: inherit gave android.yml every repository secret, and the merge
queue (code not on main yet) would have signed with the release keystore.
ci.yml now passes the four signing secrets and the R2 token by name, on
pushes to main only; pull requests and the merge queue use the debug key,
as forks always did.

Also: ci.yml passes the CI_FORK_REUSE variable to plan, and the comments in
ci.yml, voice-tests.yml and ui-tests.yml say voice and the Linux browser
fixture run nightly.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* CI: test-core also runs main's crates/doc/tests (attachments_roundtrip is among them)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Wing <44917547+wingleeio@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-01 15:51:25 -07:00
Alexandre V.L
b8ed9d9c27
Providers: a switch to turn native subagents off (#1046)
Settings → Providers → Claude Code gets a Native subagents switch (per device, on by default). With it off, a top-level chat launches Claude Code with --disallowedTools=Agent,Task,Workflow, and Zeron's MCP server (ZERON_SIDE_CHATS_ONLY=1) tells the agent to delegate through side chats. Side chats, and chats whose parent is not known yet, keep their subagents. A parked session is replaced before its next idle turn.

Co-authored-by: Alexandre VARGAS <alexandre.vargas.lopez@gmail.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 23:14:48 +00:00
Wing
cc7da5c2aa
Zeron Cloud, provider switching, and the phone model picker (#966)
Cloud chats on machines of their own (delegation, sleep/wake, durable delete), a credential vault, Stripe billing with Cloud's own portal, per-account Cloud availability, the edge's Cloud model list, provider switching between turns, the phone's tabbed model picker, and desktop/phone/engine polish.
2026-10-22 03:18:13 -07:00
José Gurruchaga
053ce2eac0
Persist embedded browser sessions across tabs and app restarts (#573)
* refactor(browser): define stable device-local profile identity

* fix(browser-linux): persist website data and cookies by profile

* fix(browser-macos): persist isolated website stores on macOS 14

* fix(browser): preserve profile lifecycle across tabs and windows

* test(browser): verify persistent storage across app launches and profiles

* docs(browser): document persistent profiles and session lifecycle

* fix(browser-linux): initialize WebKit without blocking the UI

* fix(browser): correct macOS fixture import and Windows profile test

* fix(browser): invoke macOS storage fixture wrapper through bash

* fix(browser): propagate macOS fixture failures and initialize profile cleanup

Require explicit storage results, validate deletion in every store, and preserve primary failures while attempting all profile cleanups. Add opt-in native cookie and same-process reopen diagnostics.

Validated on macOS 27 arm64: release check/build and native tests pass. Two complete storage runs correctly fail on cookies returning after process restart; all profile cleanups pass. Cookie deletion persistence remains unresolved.

* fix(browser-macos): retain profile stores for the application lifetime

* fix(browser-macos): preserve profile stores through process exit

* test(opencode): remove fixture startup and clock races

* Revert "test(opencode): remove fixture startup and clock races"

This reverts commit dffcec2cdee4d6903649fe156c5b813d91e12376.

* test(browser): verify PR state follows profile identity
2026-10-12 17:53:46 -07:00
José Gurruchaga
4a5fb8b443
Internal session plumbing and packaging cleanup (#819)
* test(codex): document and probe native voice capabilities

* feat(proto): define local voice session contracts

* fix(harness): bound realtime media and prioritize control messages

* feat(codex): attach realtime voice to an idle thread runtime

* feat(engine): own voice leases and enforce subscription eligibility

* feat(mcp): create standalone sessions on selected hosts

Add chat/side kinds with compatible defaults, resolve projects within the selected device, and validate that host's harness and model catalogs before writing. Route transcript reads to the chat host and preserve send baselines across waits so missing session rows and delayed replies cannot return an old response.

Cover invalid requests, remote catalogs, mixed batches, wait races, two-engine execution and interrupt delivery. Add an isolated MCP stdio smoke fixture.

* feat(doc): persist canonical voice transcripts once

* docs(mcp): document standalone and remote session workflows

* feat(audio): add native capture and streaming playback

* feat(audio): handle echo cancellation and voice interruptions

* feat(ui): coordinate voice ownership over local engine RPC

* feat(ui): extract the Bezel orb into a native Zeron component

* feat(ui): replace the composer with a central orb during voice sessions

* feat(mcp): constrain voice orchestration to subscription policy

* build(voice): add microphone permissions and offline audio CI

* test(voice): verify lifecycle, billing boundaries and rollout gates

* fix(voice): preserve text transport and idle billing boundaries

* feat(codex): connect subscription voice through native WebRTC

* feat(engine): activate native voice ownership and preserve delegated work

* feat(ui): enable native voice with central orb and retained drafts

* fix(mcp): keep voice delegation on subscription-backed Codex

* test(voice): document native transport and add opt-in connectivity smoke

* fix(voice): close audit races and validate project subscription context

* Fix Codex voice initialization and macOS microphone permissions

* Allow Codex voice agents to delegate through upstream MCP

* Make voice a persistent orchestrator with a dedicated stage

* Add call controls and elapsed time to the voice stage

* Remove decorative rings around the voice orb

* Add voice selection menu and simplify stage artwork

* Remove voice status labels beneath the orb

* Fix dictation and realtime voice integration after rebase

* Move Codex voice style selection into Voice settings

* Restore window dragging from the voice stage titlebar

* Open the voice stage immediately when starting a call

* Smooth voice orb motion and speaking transitions

* Remove the green audio pulse from the voice microphone control

* Show the live voice orb above the orchestrator chat composer

* Use full chat IDs in MCP reply instructions

* Correlate MCP replies by message IDs instead of remote timestamps

* Keep the voice stage open when launched from Settings

* test(voice): add a split-host Codex voice compatibility probe

* feat(voice): package a standalone desktop media runtime

* feat(proto): define client-media voice control contracts

* refactor(codex): separate voice signaling from local audio

* feat(engine): own remote voice sessions with ephemeral leases

* feat(rpc): route versioned voice controls to execution hosts

* feat(voice): coordinate local media with remote Codex control

* feat(ui): start voice on a selected remote Codex host

* test(voice): cover cancelled preparations and stale session controls

* test(voice): prepare desktop rollout validation and offline CI

* feat(ios): add a pinned native WebRTC compatibility endpoint

* feat(mobile): expose remote voice sessions through UniFFI

* feat(ios): bridge native audio lifecycle to remote voice calls

* feat(ios): add remote voice controls and registered host selection

* test(voice): cover relay and iOS lifecycle and prepare live acceptance

Add half-open and native callback regressions, stage-only diagnostics, complete runtime notices, and development test instructions. Keep real Mac/Fedora/iPhone acceptance opt-in for user validation.

* refactor(orb): share the thinking-orb engine through zeron-orb

Move the renderer-agnostic engine, presets, motion and a new OrbAnimator
(clock, audio response, state crossfades) into crates/orb. The GPUI widget
now delegates to the animator, so desktop and mobile paint identical frames.

* feat(voice): rebuild iOS remote voice around the desktop orb and phone-call audio

- Share the call view (phase, caption, levels, speaking, orb state) in
  voice-session; the client derives speaking because client media has no
  host meter. Keep owner-event headroom so level meters never overflow it.
- Title remote orchestrator chats "Voice session" like local ones.
- UniFFI: typed call state and end reasons instead of JSON, a distinct
  denied-microphone failure, and OrbRenderer frames from zeron-orb.
- iOS: OrbView paints the desktop orb; start voice from the New session bar
  (live strip while a call runs), the session nav bar and the iPad sidebar;
  full-screen call stage with caption, transcript (flagged when Codex waits
  for an answer), mute, route picker and hang-up.
- Phone-call audio: proximity sensor moves output to the earpiece, headsets
  win, calls survive screen lock, headset loss re-routes instead of ending.
  Install the WebRTC audio configuration globally so it is not reverted when
  the audio unit starts.

* fix(voice): install the macOS voice runtime under codex-resources/voice

Codex's helper only initializes from a codex-resources/voice directory and
exits with code 23 on initializeRuntime anywhere else, which the desktop
reported as "Voice could not connect". Bundle the runtime at
Contents/Resources/codex-resources/voice, reject other locations up front,
and report a helper that cannot start as an unavailable runtime.

Ship the runtime byte-for-byte with OpenAI's Developer ID signatures instead
of re-signing it ad hoc.

* fix(ios): reopen the call stage from the live strip and redo voice settings

The live strip in the bottom bar is a plain UIControl, which never sends
.primaryActionTriggered, so tapping it did nothing; listen for touchUpInside.
UI tests cover reopening the stage after the transcript and after minimizing.

Voice settings now follow the Settings list style: the resting orb, the
devices Codex can run on with their status, the voice as a pop-up menu, and
what to expect during a call.

* fix(ios): resume the orb animation when the app becomes active again

At willEnterForeground the app still reports .background, so the display
link never restarted and the orb stayed frozen after returning from Home.

* fix(ios): guard voice preview state in Release builds

* feat(voice): veil streamed caption words in on desktop and iPhone

Move the transcript's renderer-agnostic streaming veil into zeron-veil so
the voice call caption can use the same chunk fades on both platforms. A
new CaptionVeil keeps the veil aligned with the ellipsized tail and fades
the previous utterance out when the speaker turn changes; reduced motion
shows text directly. Desktop recolors GPUI runs; iOS gets UTF-16 spans
through CaptionFader and paints an attributed caption on a display link.
The desktop transcript keeps its behavior; the iOS transcript is untouched.

* fix(ui): step the voice stage aside when opening any session

Opening a session only hid the stage indirectly, when the selection changed,
so clicking the thread already under the stage (or the one you came from
Settings) did nothing. open_chat now hides the stage explicitly; the call
keeps running in the background.

* feat(voice): reuse host orchestrator chats across calls

* fix(voice): reserve orchestrator atomically and preserve rotation retries

* feat(voice): rotate the orchestrator transcript after 1000 entries

* feat(voice): package remote media runtime for Linux and Windows

* feat(voice): use the installed Codex helper everywhere and stop bundling it

Remote voice now plays audio through the client's own standalone Codex
installation, like local voice, instead of a runtime packaged inside
Zeron. The resolver moves to zeron-voice-media and is shared by the
harness and the desktop media endpoint; ZERON_VOICE_MEDIA_DIR remains a
development override. macOS, Linux and Windows packages no longer
contain Codex binaries, GStreamer/GLib or the Visual C++ runtime, so
Zeron takes on none of their redistribution or update obligations.
package-voice-runtime.py stays as a development projection tool.

Missing-runtime messages point to Codex's official installer, since npm
installs lack the voice runtime.

Notices and disclosures:
- THIRD_PARTY_NOTICES: full MIT chain for the orb (Bezel,
  gpui-thinking-orbs, thinking-orbs), Codex NOTICE, OpenAI trademark and
  non-affiliation statement, and WebRTC for iOS.
- The iOS app carries the orb's MIT notice; the Linux tarball now ships
  LICENSE and THIRD_PARTY_NOTICES.md.
- Microphone purpose strings on macOS and iOS state that voice sessions
  stream audio to OpenAI; dictation stays on device.
- Docs describe the voice data flow, and the acceptance checklist lists
  the legal and privacy decisions that block a public release.

* feat(ios): show the voice call in the Dynamic Island and on the Lock Screen

* fix(voice): hide the voice trigger when this device has no Codex

The microphone in the sidebar footer only shows when Codex is installed and
enabled on this device, following the same catalog the composer offers. It
re-reads after Settings → Agents changes and when returning to a window that
hides it. A start without Codex now asks for an install instead of a retry.

* test(voice): seed the real rotation threshold in the remote rotation test

* feat(voice): sound the start and end of a call on desktop and iPhone

A call sounds as it is placed, before the microphone opens, and again when
the user hangs up or a connected call ends. A failure to connect stays quiet
and explains itself. Nothing sounds in between. The iPhone plays them as
system sounds, so they follow the ringer switch.

* perf(voice): skip the rate limits round trip before each call

The pre-call probe read account/rateLimits/read, a ~1 s backend round
trip, and ran twice per call (prepare and negotiate). Its result was never
shown: the native backend makes the final usage decision. Dropping it
saves about 1.7 s per call on desktop and iPhone.

* perf(voice): release the orchestrator runtime 5 minutes after hang-up

The voice orchestrator's Codex runtime and MCP servers hold ~200 MB. Its
idle window was the generic 30 minutes, counted from the runtime's start,
so a call ending late in the window left a runtime reaped right after the
hang-up. It now idles 5 minutes, restarted at each hang-up.

Hang-ups wake the reaper directly, so even a short call restarts the
window, and a reap armed before a call began rechecks for it instead of
cutting the call.

* fix(voice): enable client-owned remote voice by default

* fix(harness): read whole resumed histories and report why stdout failed

509818ed capped every JSON-RPC line at 8 MiB on the transport shared by
text chats. A resumed long chat returns its history in one response
(54-71 MiB measured), so resume failed and was reported as an exit even
though Codex was alive. Lift the cap (voice bounds its own messages) and
keep the read error's cause for every waiting and later request.

* fix(harness): name the rejected request in JSON-RPC errors again

dca9a05f made peer rejections structured but dropped the method from
their message, so chats showed 'JSON-RPC rejection -32600: …' without
saying which request failed. Prefix the method again and render it as
upstream did, keeping the code available for auth detection.

* test: skip POSIX mode check on Windows hosts

* fix: launch Codex batch shims from plain paths and answer account/read in fake

* refactor(engine): remove the superseded local session RPC surface

The client-media protocol replaced these methods; nothing calls them anymore.

* refactor(harness): restore the shared JSON-RPC transport

Return the stdio transport every agent uses to its upstream behavior
(unbounded writes, no timeouts or polling timers) and keep only an
additive notification route that is registered while a subscriber
exists.

* fix(ui): let the full-window stage show the window glass

On translucent appearances the stage painted an opaque fill unlike the
new-thread page. Drop the fill there and fade out the page it covers.

* fix(ui): show the full-window stage over Settings

Settings replaces the workspace layout and never mounted the stage, so
opening it from there did nothing. Mount it beside the settings sidebar
and fade the page it covers.

* fix(voice-session): keep the live caption on the newest turn

Turns arrive interleaved: a user final often lands after the answer has
started streaming. Keep each turn's text separately and caption the
newest one, so a late final never takes the caption back and deltas
never restart it. Desktop and mobile now share this state.

* ci: build the desktop UI only in the UI workflow

The offline-linux job compiled zeron-ui without the WebKitGTK and
JSON-GLib packages its build script requires, so it failed every run.
Drop its UI step; the UI workflow already runs those lib tests and now
also runs the orb geometry test.
2026-10-06 23:47:32 -07:00
José Gurruchaga
c72c66d8ad
Add file tree context actions and drag-and-drop moves (#514)
* feat(proto): define workspace entry mutation contracts

* feat(engine): move workspace entries without replacement

* feat(engine): delete workspace entries and publish mutations

* feat(files): coordinate workspace mutations across open surfaces

* feat(files): reuse context menus for copy path and add to chat

* feat(files): rename entries inline and confirm deletion

* feat(files): preserve workspace drag origin and enable Windows handles

* feat(files): move tree entries with scoped drop targets

* feat(files): polish tree drag feedback and navigation

* test(files): cover workspace mutations and composer drag regressions

* fix(files): style delete menu action as destructive

* fix(files): reuse icons for all tree context menu actions

* fix(files): show only entry name in delete confirmation

* fix(files): give delete dialog more spacing and shorten action label

* fix(files): refresh mutation revisions after completed saves

* fix(files): refresh editor presentation and syntax after rename

* fix(files): show rename caret and preserve text input focus

* fix(files): copy full paths from the owning workspace

* fix(engine): compare canonical workspace paths on Windows

* Route chat drops through the shared dropzone with origin checks

The branch replaced the main chat's chat_dropzone() call from #612 with an
inline copy, so the main chat validated drag origins but side chats did not.
Both now go through chat_dropzone(), which hands workspace payloads to
attach_workspace_drag() for the target composer. The dropzone fixture now
stamps tree/search payloads with a live explorer origin, and also checks that
an origin-less (stale) payload attaches nowhere.

Also correct the Windows drag note: tree rows drag on every platform; there is
no dedicated drag handle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 20:13:10 -07:00
José Gurruchaga
df0cd2980a
Replace Pi ACP adapter with native RPC integration (#630)
* feat(pi): add native RPC transport and compatibility contracts

* feat(pi): implement native harness and event normalization

* feat(pi): resume native and legacy ACP sessions

* feat(pi): support native steering and reliable cancellation

* feat(pi): expose native models commands and skills

* feat(pi): bridge extension dialogs to desktop and mobile input

* feat(pi): preserve Zeron MCP delegation in native sessions

* feat(pi): activate native RPC driver and CLI discovery

* refactor(pi): retire ACP adapter and verify native lifecycle parity

* fix(pi): preserve switched sessions empty resumes and composer drafts

* docs(pi): translate RPC migration research into English

* style(ios): trim whitespace in updated question bindings

* test(acp): wait for scenario progress before steering

* test(pi): compare canonical session paths on Windows

* fix(pi): deliver steering bursts in the same model step

* fix(ios): preserve generated Swift binding whitespace

* fix(pi): scrub nested-agent env and keep dropped-resolver semantics

Pi's native launch skipped owned::configure, so CLAUDECODE and the other
nested-agent variables the ACP launch removed leaked into pi. The engine's
new input-cancellation task also turned a dropped resolver into an empty
answer; keep it an error for harnesses (opencode rejects on error).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: run the native Pi RPC driver tests

pi_rpc needs the native-fixture feature and pi_resume is an engine test;
neither ran in any workflow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(pi): never overwrite a configured Pi steering mode

set_steering_mode persists to Pi's global settings.json. Selecting `all` on
every session start silently rewrote the user's standalone Pi preference and
undid any `/steering` choice on the next run. Select `all` only while neither
the global nor the project settings configure a mode.

PiHarness::with_agent_dir lets tests (and callers) pin PI_CODING_AGENT_DIR for
both the child and Zeron's own reads, so fixture tests never consult the
developer's real Pi settings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(ios): don't trap on duplicate question ids when prefilling answers

Dictionary(uniqueKeysWithValues:) crashes on a repeated key; question ids come
from agents and synced docs, so keep the first instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* style(pi): rustfmt the steering-mode guard and its tests

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(pi): start fresh with a notice when a session can't be restored

The native driver hard-failed a resume whose Pi session file was missing.
The engine injects the chat's stored session id on every dispatch, so one
unwritten or deleted session file left the chat failing every message for
good. The ACP adapter and the Codex driver start a new session and announce
the lost context instead; do the same. Proven-empty sessions still keep
their UUID via --session-id.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(pi): never fail a turn over an attachment Pi can't inline

Composer uploads include SVG, HEIC, BMP, TIFF and AVIF. The native driver
errored the whole run on any of those (or an unreadable path), while the
Claude driver skips them and the retired adapter ignored attachments: the
path refs already ride the prompt text. Load images best-effort instead.

Also give native startup the 120s budget the ACP handshake gave Pi, since
extensions can start cold.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* style(pi): rustfmt the lost-session live test

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Wing <contact@winglee.io>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:14:54 -07:00
wing-anara
0c834f65b4 docs(models): record full validation and live discovery results 2026-09-21 09:15:19 +00:00
wing-anara
f671cb59f2 Drop reference-integration name from ACP comments 2026-09-21 08:14:03 +00:00
wing-anara
65b5c586e6 Preserve Cursor user context through steering and startup interruption 2026-09-18 20:02:53 +00:00
wing-anara
1d00f29606 ci(cursor): automate SDK updates and gate releases on auth compatibility 2026-09-18 19:14:09 +00:00
wing-anara
0682bd6324 test(cursor): verify token refresh against aged live SDK sessions 2026-09-18 18:57:51 +00:00
wing-anara
23bc81834d fix(cursor): preserve SDK failure diagnostics and update to 1.0.31 2026-09-18 18:46:35 +00:00
wing-anara
15a31cf7a8 test(cursor): stress steering bursts and prioritize cancellation 2026-09-18 02:36:41 +00:00
wing-anara
c87daf2448 fix(cursor): recover abandoned runs and stabilize model discovery 2026-09-18 01:20:28 +00:00
Wing
d840f28036
Fix truncated Cursor catalogs and refresh harness models (#436)
Co-authored-by: wing-anara <wing@anara.com>
2026-09-17 16:11:22 -07:00
wing-anara
640906abd0 Merge main into Windows support preserving shared Codex login resolution 2026-09-15 20:00:39 +00:00
José Gurruchaga
9601a24407
feat: render generated images in conversation threads (#367)
* feat(session-doc): add generated image message parts

* feat(engine): import generated images into profile uploads

* feat(codex): normalize image generation results

* feat(ui): render generated images inline

* fix(ui): round generated image corners

* feat(ios): render generated images in conversation threads

* fix(ui): isolate and bound generated image previews

---------

Co-authored-by: wing-anara <wing@anara.com>
2026-09-15 00:26:34 -07:00
wing-anara
c3df662402 Merge origin/main into windows-native-support
Resolve Cargo.toml (keep main's newer Zui/gpui-base pins), crates/ui/Cargo.toml
(keep both the windows-render-fixture and appshots-fixture examples), and
Cargo.lock (main's lockfile plus this branch's windows-sys/embed-resource
dependency entries).
2026-09-14 04:52:05 +00:00
Gaël Cado
0a80fc15c8
Add desktop Appshots with queue-safe delivery and iOS presentation (#216)
Capture application windows on macOS and Linux, stage source-labelled cards, and preserve Appshot context through attachment upload and queue editing. Add dedicated keyboard-accessible settings, bounded native capture and enrichment, stable queue thumbnails, and native iOS presentation.

Co-authored-by: wing-anara <wing@anara.com>
2026-09-12 17:11:25 -07:00
hoangvu12
73b245ccf1 Fix Windows click jitter on draggable controls 2026-09-11 21:23:20 +07:00
José Gurruchaga
b6fed6914e test(codex): verify persistent subagent routing and resume
Exercise the real adapter through document persistence, engine restart, and both live Codex agent protocols. Recover original spawn ownership from resumed thread history and reopen child transcripts on followup turn boundaries without requiring a user-message echo.
2026-09-10 15:37:49 -03:00
Wing
32fd70709a
Fix premature ACP turn settlement during model silence (#298)
Co-authored-by: wing-anara <wing@anara.com>
2026-09-09 17:06:10 -07:00
Wing
4d03fa26e9
Fix browser resizing, sidebar transitions and backdrop blur (#283)
* Keep browser content live through sidebar resize and toggles

* Validate frosted, light and opaque browser menus

* Validate native drag hit testing and update backdrop integration

* Include native fixture backtraces in CI failures

* Dispatch fixture mouse events without borrowing the shell

* Use colorless native blur beneath application menu tint

* Synchronize browser geometry with the GPUI frame

* Use the page background beneath newly exposed native tiles

* Validate synchronized frames and inspect native blur layers

* Use live compositor blur without blocking sidebar animation

* Validate real blur pixels and intermediate native animation frames

* Keep pane animation geometry consistent across each frame

* Align native compositing dependencies for final regression capture

* Keep the native browser host stationary while clipping pane motion

* Present browser bounds with their matching GPUI scene

* Keep native geometry in the Metal presentation transaction

* Back unpainted WebKit tiles with the page background

* Match WebKit native backing to the computed page color

* Refresh native backing when the page background changes

* Prepare v0.2.52 release

---------

Co-authored-by: wing-anara <wing@anara.com>
2026-09-09 02:00:58 -07:00
Wing
c859038f74
Add native browser tabs to the right sidebar (#282)
* Add session browser surfaces with a native WebKit host

* Add browser shortcut handling and native screenshot regression fixture

* Harden native browser lifecycle and exercise the real shell fixture

* Cover browser session ownership, shortcut conflicts and native snapshots

* Document browser screenshot provenance and capture Linux fallback

* Verify address input keyboard behavior

* Evaluate page scripts directly after installing the WebKit delegate

* Use a normal closed localhost port for native error regression

* Attach verified native browser screenshots and validation notes

* Keep WebKit live beneath GPUI tooltips and menus; validate hover and record video

* Pin corrected native overlay renderer

* Bound native parent access to the main-thread webview lifetime

* Keep the hover recording focused on one continuously live page

* Exercise repeated tab tooltip display above the live browser

* Document live browser overlays with native screenshots and attached video

* Remove external app references from browser documentation and copy

* Pin merged GPUI dependencies and prepare v0.2.50

---------

Co-authored-by: wing-anara <wing@anara.com>
2026-09-08 22:23:58 -07:00
wing-anara
057674f56f docs: note Devin resume quirks seen live (stale cancelled prompt, -32015 lock)
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-04 19:08:32 +00:00
wing-anara
f2b5500c87 Merge PR #105 (Devin over ACP) onto main
Resolves conflicts with the opencode native driver (#202): the
SubagentObserver enum keeps only Devin + Grok, and devin_spec drops
the retired http_sidecar field. Refreshes the fallback model rows to
the ids CLI 3000.6.14 advertises (swe-1-7-medium is the server default).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-04 18:54:46 +00:00
gaelcado
6da4e9f9e7 fix: address sidebar view options review 2026-08-23 19:34:42 +02:00
gaelcado
12f9fcc3e9 fix: simplify sidebar view controls 2026-08-23 16:46:30 +02:00
gaelcado
d539c71b5c fix: polish sidebar view options menu 2026-08-23 16:46:30 +02:00
gaelcado
054c17e68a feat: add conversation-aware sidebar views 2026-08-23 16:46:30 +02:00
gaelcado
22f1b55b09 docs: plan sidebar view options 2026-08-23 16:29:02 +02:00
wing-anara
4397c89f1f Merge main and modernize Devin ACP harness
Resolve PR #105 against the native-driver/subagent harness architecture. Advertise Devin's subagent stream extension, correlate nested updates into Zeron subagent transcripts, and settle unfinished child runs safely.
2026-08-19 13:27:54 +00:00
wing-anara
81df4779d8 harness: managed adapter installs, bounded handshake, legible errors
Root cause of #95 ("harness protocol error … Codex exited unexpectedly
(exit code 254…"): the chat-time `npx -y <adapter>` fallback dies inside
the user's npm state. npm encodes fatal fs errors as 256 - errno exits
(254 = ENOENT, 243 = EACCES — npm/cli#4838), often printing nothing, and
a cold cache also meant minutes of silent download before first token.

- adapter_install: pinned adapter packages install once into
  ~/.zeron/adapters/<pkg>/<version> with a zeron-owned npm cache,
  atomically (tmp dir + bin-entry verification + marker + rename);
  launches spawn `node <entry>` directly — npm never runs at chat time.
  Install failures decode npm's errno exits and carry its full output.
- Discovery probes never block on npm (background install, catalog
  fallback); the engine prewarms adapters for present CLIs at boot.
- ACP handshake bounded (120s, tunable): a wedged agent errors with its
  stderr tail instead of spinning "Working" forever (#93's shape).
- Transcript error chip wraps instead of truncating to one line — the
  actionable tail of startup-crash errors was invisible (#95 screenshot).

E2E-verified against the real pinned codex-acp (fresh managed install →
node spawn → SessionStarted) plus a silent-254 fake npm and a hung-agent
fixture.

Closes #95.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-15 14:39:23 +00:00
Nader Dabit
3a05857754
Add Devin agent over ACP (devin acp)
Registers Cognition's Devin CLI as a harness through the shared
AcpHarness spec: native ACP server, turn-boundary steering, no effort
ladder (effort rides the advertised model ids), and the `bypass` mode
value added to the generic no-prompts preference list. Brand mark,
settings row, picker icon, iOS catalog entries, and docs included.

Live-verified against devin CLI 3000.4.25: model discovery (177 wire
models) and a real prompt turn settled cleanly.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
2026-08-15 07:57:40 -05:00
wing-anara
b0be3dea2f rename: comet -> zeron everywhere (binary, crates, env, data dir, iOS)
- binary/CLI `comet` -> `zeron`; crates comet-* -> zeron-*; COMET_* -> ZERON_*
- data dir ~/.comet-native -> ~/.zeron, with a one-shot rename migration
- services: comet-native.service -> zeron.service; launchd sh.zeron.comet ->
  sh.zeron.app; macOS bundle id dev.comet.native -> sh.zeron.app
- release artifacts comet-<ver>-* -> zeron-<ver>-*; drop the Comet.app
  tarball-path compat hack in package-macos.sh
- iOS: Comet -> Zeron targets/dirs, bundle id sh.zeron.Zeron, zeron:// scheme
- clients default to https://edge.zeron.sh; installer + landing on zeron.sh
- kept on purpose: repo name, worker names (comet-native-edge/comet-landing;
  DO storage is bound to the script name), R2 bucket names, and legacy
  comet.zeron.sh routes so 0.1.x clients keep working

zeron-<ver>-* artifacts don't exist until the next release, so curl-install
and landing downloads 404 between this deploy and the 0.2.0 tag.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-14 10:49:19 +00:00
wing-anara
ad3b31d173 ACP polish: configOptions-first models, codex yolo, completion + transcript fixes
Four bug fixes cross-referenced against Zed's ACP implementation:

- Model discovery reads the model config option before the deprecated
  SessionModelState (codex-acp enumerates one entry per model x effort
  there), so effort variants no longer show as model rows. Traits are
  synthesized from wire config options (codex fast-mode/service tier,
  collaboration mode), 1M-context variants collapse into a Context
  Window trait, and Claude's Ultrathink rejoins discovered ladders via
  spec ladder_extras.
- Permission auto-accept: question-shaped now means an option without
  an allow/reject kind; duplicate kinds are legal (codex sends two
  allow_always options per exec approval). The forced no-prompts mode
  also matches codex's agent-full-access.
- Parked sessions only re-open on a steer/input/Done: trailing
  post-turn frames no longer re-arm Working forever (sessions stuck
  running after completing). Hardened string-id JSON-RPC responses,
  moved the mid-turn steering request off the select arm (reader
  deadlock), stamped Errored on failed retry dispatch, re-checked run
  liveness after steer delivery.
- drive_run tracks tool ids across segment resets and drops stale
  tool_call_update echoes that spliced phantom chips mid-word into the
  next segment's streaming text.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-09 20:55:11 +00:00
Wing
a8cdbf617f
Add Hermes and Pi agents over ACP (#29)
* Add Hermes and Pi agents over ACP

Two new AcpAgentSpec entries on the shared harness: Hermes Agent (Nous
Research, native `hermes acp` server) and the pi coding agent (pi.dev,
community pi-acp adapter pinned 0.0.33 with npx fallback). Registry slots
mirror the specs (turn-boundary steering; pi's minimal->max thinking
ladder, no effort surface on Hermes yet), brand marks land in the picker
rail/tabs/sidebar/settings, and COMET_HARNESS gains grok/hermes/pi arms
(grok was a latent gap). Wire coverage rides the existing table-driven
fake-ACP tests plus descriptor and login-shell-resolution mirrors.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ACP as source of truth for models; separate Traits dropdown

models() now runs a short-lived probe (the discover_commands pattern) and
reads the session/new response's first-class SessionModelState, falling
back to the model config option's choices — paseo's preference order. The
static catalogs survive as enrichment for matched ids and as the answer
when an agent advertises nothing (per-model effort ladders don't exist on
the ACP wire; discovered models inherit the probe session's thought_level
ladder unless a curated entry supplies one). Successful discovery caches
per harness instance; failures retry on the next picker open.

The traits picker un-merges from the harness/model popover into its own
composer chip + dropdown (t3code TraitsPicker arrangement): traits are
properties of the selected model, so they follow the pick instead of
sharing the browse surface. The chip hides entirely when a model has
neither a ladder nor options. Media re-captured: discovered Hermes list
(provider-tagged entries), the traits dropdown, both runs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Traits dropdown: t3code menu rows with Default badges

Replace the segmented-chip grid with t3code's TraitsPicker arrangement:
headed sections of menu rows (reasoning ladder + each model option),
hairline separators between sections, a Default badge on the section's
default choice, and the trailing check on the selected row — all reusing
the existing popover menu primitives. Menu stays open for multi-adjust.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Drop selected checkmarks; right-align the Default badge

Selected menu rows across the app (models, branches, spaces, traits,
account switcher) now carry the active wash alone — the trailing check
duplicated what the highlight already said. The traits Default badge
moves to the row end.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Ghost Default badge: bare muted text, no border or fill

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-08-08 18:54:04 -07:00
Wing
ca05336a7c
Convert claude/codex to ACP: one harness for every agent (#28)
Claude Code and Codex now run through the shared AcpHarness like Grok —
claude via @agentclientprotocol/claude-agent-acp@0.66.0, codex via
@agentclientprotocol/codex-acp@1.1.14, resolved from PATH or launched with
npx -y at pinned versions. The bespoke stream-json and app-server adapters
(~4,300 lines: claude/{mod,wire,normalize}, codex/{mod,normalize}, the
fake-claude/fake-codex fixtures and their test suites) are deleted; the
catalogs survive as spec inputs (models, effort clamping, Ultrathink
prompt prefix).

Conversion glue in the shared harness: per-agent spec hooks (prompt
transform, effort preference values), model_options → session config
options (mode → bypassPermissions for unattended parity, model via
family-alias matching against SDK aliases like opus[1m]/sonnet/haiku,
fastMode/thinking booleans, contextWindow → [1m] compose), a
permission-vs-question split so AskUserQuestion-shaped requests bridge to
the input panel instead of auto-accepting, and per-turn Usage from the
settled prompt response.

Verified against the real claude-agent-acp adapter end to end (ignored
test real_claude_adapter_end_to_end: model alias picked, bypassPermissions
set, reply streamed, usage attached). Decision record updated in
docs/research/acp.md.

Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-08-08 00:23:54 -07:00
Wing
c951c3e36e
ACP harness: Grok Build, slash commands, tool output + inline diffs (#24)
* ACP harness: Grok Build, slash commands, tool output + inline diffs

Adds an Agent Client Protocol (v1) harness over the shared JSON-RPC stdio
client (promoted from codex/rpc.rs), with xAI's Grok Build as the first
registered agent. Slash commands advertised by ACP agents surface in a
composer popup (file-mention pattern, new ListCommands RPC), and tool
results now carry capped output text and inline diffs end-to-end
(AgentEvent → doc parts → TS mirror → expandable transcript chips).

Decision record in docs/research/acp.md; claude/codex keep their custom
adapters (settings passthrough, installed-CLI coupling, steering
semantics). Demo media under docs/media/acp/ (fake-acp.sh fixture rig).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ACP follow-up: wire session config options, restyle tool detail blocks

Model + reasoning now apply through session/set_config_option against the
session's advertised configOptions (category model / thought_level, matched
to advertised value ids, skipped when current, never fatal). Grok gets its
real Low/Medium/High effort ladder in the picker and registry descriptor.

Detail blocks read like the changes pane now: full-width add/del washes in
the diff hues, brighter mono output text, and a chevron tile affordance on
expandable chips matching the group header. Demo media re-captured.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Tool details: render diffs with the changes-pane component, outputs as code blocks

The chip detail blocks are no longer hand-rolled capped line rows. Diffs go
through changes::render_file_body — hunk headers, dual line-number gutters,
accent bars, row washes, and synchronous syntax tokens (payloads are
doc-capped, so no background pass needed) — built from the inline ToolDiff
via similar's grouped_ops with 3 context lines. Outputs render as a code
block: verbatim mono lines with indentation intact, 24-line counted-tail
cap. Fold heights stay analytic via changes::body_height. Fixture demo
content upgraded to a real rust hunk + cargo output; media re-captured.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Tool details: fold the detail into the chip's card, unbroken guide rail

An expandable chip is now one card: the chip row is the card's header and
the output/diff body sits under a hairline inside the same border, instead
of a separate card floating below. The guide rail is drawn by the chip
column with no fixed height, so it stretches past open details — expanding
a tool no longer breaks the rail. Heights stay analytic (chip + separator
+ body). Media re-captured.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: wing-anara <wing@anara.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-08-07 22:59:45 -07:00
Wing
6e73bf267f Docs/comments: drop Orbit references
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-31 16:21:18 +00:00
Wing
240b008bd3 Foundation: architecture, research, Rust workspace scaffold, TS edge port
- ARCHITECTURE.md: full design — Loro docs (session + per-org workspace) through
  Durable Objects, TS edge / Rust everything-else split, gpui UI plan with
  mugen/pretext techniques, headed+headless single binary, milestones M0-M6
- docs/research/: feature-parity inventory, gpui guide, mugen/pretext techniques,
  loro Rust ecosystem, DO-language decision (TS, evidence-backed), harness
  integration (claude stream-json / codex app-server)
- Cargo workspace (proto, doc, sync, harness, engine, rpc, ui + comet binary):
  builds green incl. gpui pinned to zed@f14fea9b; comet-proto wire types and
  comet-doc command-ledger rules 1-3, event->parts fold, render-parts privacy
  policy, continuation splitting all ported with tests (15 passing)
- edge/: comet's Worker + DOs ported standalone (session room w/ hibernation +
  two-level compaction + alarms + R2 backups, device room relay, attachments),
  vendored session-doc modules, NEW workspace rooms (ws/{orgId}, org-claim authz),
  absorbed WorkOS auth routes; tsc clean, wrangler dry-run bundles

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-19 18:04:51 +00:00