xonecas.io
8447
Co

conveyor / commit fa6596c

chore: cleanup spikes and docs that are superseeded by the current code

sacenox2026-11-16 fa6596c2003e50612c836f13aa39f13292ad6898 parent 4d3f967

73 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

DESIGN.md+0−379
@@ -1,379 +0,0 @@
1-# Conveyor design
2-
3-> Reduce user cognitive load. The conveyor never stops.
4-
5-Status: draft. Items marked **(spike)** are unproven and get a throwaway prototype before any product code. Linux (x86_64, KVM) and macOS (Apple silicon, HVF). The guest is always Linux, for the host's architecture.
6-
7-## Principles
8-
9-| # | Principle | Problem it removes |
10-| - | --- | --- |
11-| 1 | **Conveyor owns the loop.** The agent is a worker that conveyor starts, feeds and stops. | Managing agents through a terminal chat |
12-| 2 | **The agent never waits on you.** It decides, flags or parks, and conveyor moves to other work. You are present, not a gate. | Agents stopping to offload trivial decisions |
13-| 3 | **A ticket is a contract.** Scope is fixed before work starts. Any change to it is an explicit event, raised the moment it happens. | Finding scope changes only in review |
14-| 4 | **One ticket = one branch = one VM**, created only when the ticket is `ready`. | Shared agent context, scope bleed, manual VMs |
15-| 5 | **The project only ever receives a branch.** Tickets, scope work, logs and attachments live in conveyor's store. | Bookkeeping noise in the repo |
16-| 6 | **Everything is files and a CLI. The UI is a native view of them.** | Lock-in; the app can't be modified by its own agents |
17-| 7 | **Less code.** | Bugs, complexity |
18-
19-## Components
20-
21-```
22- HOST GUEST (one per ticket)
23- ┌──────────────────────────────────────────────┐ ┌──────────────────────────────┐
24- │ conveyord (systemd user service) │ │ base.qcow2 ◀── t-1222.qcow2 │
25- │ ├ store files under XDG data │ │ │
26- │ ├ dispatcher ready tickets → free slots │ ssh │ ~/work clone @ t-1222 branch│
27- │ ├ vm driver qemu: overlay/boot/snap/rm ├────────▶│ agent claude / opencode │
28- │ ├ agent driver launch, parse event stream │ │ ~/.claude ~/.config/... from │
29- │ └ events one jsonl per ticket │ │ the host, copied at boot │
30- │ │◀────────┤ conveyor CLI ── sock │
31- │ conveyor CLI same binary, host mode │ ssh -R │ decide / deviate / block / │
32- │ conveyor app native UI, a client │ socket │ note / done │
33- └──────────────────────────────────────────────┘ │ VNC on a unix socket (qemu) │
34- └──────────────────────────────┘
35-```
36-
37-- `conveyord` runs whether or not the app is open. Closing the window never stops work.
38-- The guest's `conveyor` CLI reaches the host through a unix socket forwarded over the ssh session that runs the agent (`ssh -R`). Each socket is bound to one ticket, so a guest can touch only its own ticket. Socket paths are unique per run, because a restored snapshot brings back the old session's socket.
39-- **No root and no libvirt.** conveyord runs `qemu-system-x86_64` (`qemu-system-aarch64` on a Mac) as your user: user-mode networking with ssh on a localhost port, and the guest agent, QMP and VNC on unix sockets in `/tmp`. Unix socket paths max out at 108 bytes (104 on macOS), so they can't live under deep paths.
40-- The guest clones from the host and pushes its branch back. Nothing else leaves the VM except through the CLI.
41-- **Agent config:** at boot, conveyor copies your host agent folders (`~/.claude`, `~/.config/opencode`, and so on) into the guest. The agents use the login, settings and skills you already manage.
42-
43-## Store
44-
45-```
46-~/.local/share/conveyor/
47-├ images/base.qcow2 installed and configured once, then read-only
48-├ vms/t-<project>-<id>.qcow2 per-ticket overlay, deleted at teardown
49-├ library/ your widget library: a git repo, worked as the `widgets` project
50-├ canvas.json where each widget sits on the canvas
51-└ projects/<slug>/
52- ├ project.toml path, agent, vm profile, slots, enabled mods
53- └ tickets/<id>/
54- ├ ticket.md the contract: frontmatter + scope + acceptance
55- ├ events.jsonl everything that happened, append-only
56- ├ scope/ refine output: notes, images, code. Never in git
57- └ attachments/
58-```
59-
60-- Tickets are plain markdown, so you can edit them anywhere and an agent can read them. State lives in the frontmatter. `events.jsonl` is the timeline the app renders.
61-- Widgets belong to you, not to a project. A project only lists the widgets it uses.
62-
63-### Data volume
64-
65-Measured from the rats store in the VM: 2 projects, 314 tickets, 5 MB in total. Board data is small. The volume to design for is agent event streams: tokens, tool calls and diffs, with 1–3 tickets streaming at once.
66-
67-## Projects and git
68-
69-- A project is any folder. Without git, you can still write tickets, and refine works on a copy of the folder.
70-- **A ticket can't start `running` without a repo.** If the folder has none, conveyor raises a CTA offering to create a local repo, which can be a throwaway.
71-
72-## Dev notes
73-
74-The Ctrl+click of the widget builder, for a project's own running app. `devnotes.js`, loaded by a dev-only tag, outlines what's under the pointer while Ctrl is held, and a click opens a small form: the note, and a **Ready?** toggle (ticked by default, remembered per app). Enter files a ticket in that project, ready or draft, with the page, the element's selector, the point in it, its text, its rendered HTML (cut at 2000 characters, for the agent to find it in the source) and the window size belo …
75-
76-```
77-<script src="http://127.0.0.1:7717/devnotes.js" data-project="<slug>" async onerror="this.remove()"></script>
78-```
79-
80-- conveyord serves the script and takes notes on `127.0.0.1:7717`. Only pages from localhost may post, and only with a loopback `Host`: a ticket runs an agent that holds your keys.
81-- A new project starts with a draft ticket asking for that tag in its dev build. Edit it for the project, Ready it once there's an app, or move it to done.
82-- `data-key="alt"` (or `shift`, `meta`) for an app that uses Ctrl+click itself.
83-- Only the click comes from claudeweaver's overlay. Notes go through conveyor's own loop, like any ticket.
84-
85-## Ticket lifecycle
86-
87-```
88- ┌────────────── you add resources / steer ─────────────┐
89- ▼ │
90- draft ──▶ refine ──▶ ready ──▶ running ──▶ verify ──▶ review ──▶ done
91- │ ▲ │ │ ▲ │
92- │ └────────┘ │ │ └──▶ running (checks failed, agent retries)
93- ▼ send back │ └── parked ◀──┐
94- needs-scope (CTA) ─────────┘ (CTA) │ block
95- you answer → refine ├────────────────┘
96- └──▶ deviate (CTA, keeps running)
97-```
98-
99-| State | Where | Who moves it on |
100-| --- | --- | --- |
101-| `draft` | store | you |
102-| `refine` | throwaway VM, no branch | agent: does discovery and writes scope, acceptance and out-of-scope. Output goes to `scope/` |
103-| `needs-scope` | store | you add resources, answer or steer. **It always goes back to `refine`**, never straight to `ready` |
104-| `ready` | store | dispatcher, when a slot and a repo exist. You can still send it back to `refine` |
105-| `running` | ticket VM + branch | agent. A code ticket starts from main plus every branch in review (the stack), as a widget build starts from the trial |
106-| `parked` | VM kept, suspended | you answer; the agent resumes |
107-| `verify` | ticket VM | conveyor runs the acceptance checks, not the agent |
108-| `review` | host | you |
109-| `done` | store | the branch merged into main and deleted (Keep, for a widget build), with the tickets in review it was built on. A conflict, or a checkout git won't touch, keeps it in review and says why |
110-
111-Only `needs-scope`, `parked`, `deviate` and `review` reach you. Each is a call to action with one line, the agent's recommendation and its attachments.
112-
113-## Agent contract
114-
115-The agent can't ask and wait, and permissions are skipped because the VM is the sandbox. Proven in spikes 2 and 4:
116-
117-```
118-claude -p --output-format stream-json --verbose --dangerously-skip-permissions \
119- --disallowedTools=AskUserQuestion --append-system-prompt "<rules>" < prompt
120-opencode run --format json --auto -m <model> "<prompt>" # rules in ~/.config/opencode/AGENTS.md,
121- # "tools": {"question": false}
122-```
123-
124-- Pass the prompt on stdin. `--disallowedTools` takes a list, and swallows a prompt placed after it.
125-- Agent config copied into the guest: `~/.claude.json` and `~/.claude/{.credentials.json,settings.json,CLAUDE.md,skills,statusline.sh}`, and the opencode binary. Never history or transcripts. API keys go into a 0600 env file through ssh stdin, never on a command line.
126-
127-| Verb | Effect | Blocks the agent? |
128-| --- | --- | --- |
129-| `conveyor note <text>` | adds to the timeline | no |
130-| `conveyor decide <choice> --why` | records an assumption and takes a snapshot | no |
131-| `conveyor deviate <change> --recommend` | records a scope change, takes a snapshot, raises a CTA | no |
132-| `conveyor block --reason --recommend --attach` | parks the ticket and frees the slot | yes, by design |
133-| `conveyor done` | moves to `verify` | ends the run |
134-
135-Rule taught to the agent: **block only for what is outside the VM's control**, such as a missing key, an account, a payment or a legal question. Everything else is a `decide`.
136-
137-## Snapshots and rewind
138-
139-Every `decide` and `deviate` takes a disk snapshot of the overlay. The conversation transcript lives on the guest disk, so restoring the disk also restores the conversation to that moment.
140-
141-```
142-overrule X ─▶ restore snapshot ─▶ boot ─▶ agent --resume <session> "X overruled: Y. continue."
143-```
144-
145-Proven in spike 3: restoring the `decide` snapshot brought the disk, the transcript and even the running agent process back to that moment. Conveyor then kills the resurrected agent and runs `claude -p --resume <session>` with the overrule. The agent redid the work your way and committed, with no trace of the abandoned path.
146-
147-| Step | Measured |
148-| --- | --- |
149-| Snapshot with RAM, while the agent waits on `decide` | 1.6–2.1 s, about 1.3 GB per snapshot |
150-| Restore and continue | 1.0–1.2 s |
151-
152-## VMs and concurrency
153-
154-The base image is built once by `tools/bake.py`, from Debian 13's cloud image for the host's architecture, downloaded once and kept in `images/`. cloud-init, seeded over HTTP from the bake, creates the user and runs the provisioning. The cloud kernel has no GPU driver, so the bake swaps it for the generic one. Besides the agents it installs the pinned Rust toolchain and pre-builds the widget library's preview:
155-
156-```
157-cloud image ──cloud-init + provision──▶ base.qcow2 (read-only)
158- ├─▶ t-1222.qcow2 overlay
159- ├─▶ t-1223.qcow2 overlay
160- └─▶ refine-1224.qcow2 overlay
161-```
162-
163-- Each overlay is a fresh copy of the base at no cost: create it, boot it, delete it at teardown. It does the same job as "restore a snapshot", but several VMs can run from one base at once. An internal snapshot can be restored into only one VM at a time.
164-- Rebuild the base only when you change what goes into it.
165-- RAM is the limit, not CPU. Agents spend most of their time waiting on the model, so vCPUs can be overcommitted.
166-- Host: 24 threads, 62 GB total, about 23 GB in use. The start target is **1–3 slots**.
167-
168-Measured in spike 1, on the host:
169-
170-| What | Result |
171-| --- | --- |
172-| Bake the base from the local ISO: install, provision, verify | **7.2 min**, once. 9.1 GiB image |
173-| Create an overlay | **12–18 ms**, 2.8 MB |
174-| Boot an overlay to ssh | **11.4 s**. The xfce desktop is up a few seconds later |
175-| Three guests booting at the same time | 11.4 s each, no slowdown |
176-| Host memory per idle guest with a desktop | **~1.4 GB PSS**, the same with 4 or 8 GB assigned |
177-| Guest allocates and frees 5 GB | Host PSS goes 6.6 GB to 2.6 GB within 15 s, through free page reporting |
178-| Unique machine id and ssh host keys per overlay | yes, reset in the base and regenerated at first boot |
179-| Guest screen without a VNC client | QMP `screendump` writes a PNG |
180-
181-Measured on a Mac (M5, 10 cores, 32 GB), Debian 13 arm64:
182-
183-| What | Result |
184-| --- | --- |
185-| Bake: download, provision, verify, pre-build the widget library | **5.5 min**, once. 8.4 GiB image |
186-| Create an overlay | **26–31 ms** |
187-| Boot an overlay to ssh | **10.0 s** |
188-| Three guests booting at the same time | 22.4 s each: three 8-vCPU guests on 10 cores |
189-| Host memory per idle guest with a desktop | **~1.9 GB RSS** |
190-| Guest allocates and frees 5 GB | **Not returned.** The guest reports free pages, but QEMU on macOS keeps them: a guest costs its peak until it stops |
191-| Unique machine id and ssh host keys per overlay | yes |
192-
193-On a Mac the guest's `conveyor` CLI is a static Linux build (`cargo guest`), since the host's binary can't run there.
194-
195-**Assigned RAM is a ceiling, not a cost.** Free page reporting returns memory the guest frees, so a guest costs what it is using. Three slots fit easily, and the real limit is concurrent builds. KSM needs root, so it is untested and not needed yet.
196-
197-## App
198-
199-- **Native, not a web view.** Rats' web UI became its performance problem.
200-- Client-side decorations, so the window looks the same on any desktop and never uses ugly server-drawn title bars.
201-- Verifiable by agents: headless PNG, element tree and scripted input (Rune), plus AT-SPI through AccessKit on the real desktop.
202-- **Inbox first**: every CTA across all projects, one line each. This is the main view.
203-- Project → tickets → ticket detail: the contract, the timeline from `events.jsonl`, the branch diff, and VNC.
204-- **Widgets are single files in the library**, `widgets/<name>.rs`, compiled into a library the running app loads in place. A new widget costs one incremental build, and the window stays. The core views are built the same way, so conveyor's own agents can change conveyor.
205-
206-### The widget builder
207-
208-The library is the whole UI. The window draws the library's `root` widget, and its `status` widget over it, and nothing else, so the title bar, the panes, the boards and build status are all widgets, and all of them change the same way: hold Ctrl, click one, and say what it should become.
209-
210-```
211-window ─ core draws ─► root (library) core, drawn above the library:
212- ├ titlebar (library) · Ctrl inspector: outlines the instance
213- ├ sidebar (library) under the pointer and its parents, and
214- └ project_view (library) takes the click, so no control can
215- ├ activity_strip swallow it
216- └ kanban | dashboard · prompt form: that kind's conversation
217- ─► status (library), over root: build pills, replies, Keep / Discard
218-Ctrl+click ─► conveyord: widgets ticket (kind, instance chain, tree, shared, thread)
219- ─► VM: claude starts from the trial, edits widgets/, checks with the preview,
220- `conveyor place <kind> --in <instance>` for free children, `conveyor done`
221- ─► review: trial = main + every build in review ─► cargo app ─► the app loads it in place
222- ─► the user tries it: Keep ─► merged into main, done
223- Discard ─► back to draft, trial rebuilt without it
224-```
225-
226-- **The core owns only the building tool.** No frames, title bars, menus or placement in the core. Even build status (pills, replies, Keep and Discard) is the library's `status` widget, which the app draws over `root`. An earlier cut gave every widget a core frame with a title bar, badge and conversation panel. It boxed widgets into leaves, and inner controls swallowed the Ctrl+click.
227-- **Widgets compose.** `cx.child(kind, key)` renders a widget inside another with its own state and folder. Instance ids are paths (`root.project.board`). `View::mount` lets a widget keep a new kind where the user asked for it. The default canvas keeps a free-floating list; a layout widget usually renders its children itself.
228-- **Widgets read and act on conveyor.** `cx.data` holds projects, tickets and the latest 200 activity events, refreshed every second. Handlers call `set_state`, `new_ticket` or any `server.rs` op. `share`/`cx.shared` pass values such as the selected project between widgets, and survive restarts.
229-- **Widgets are programs**: own state, input, files in `cx.dir`, threads, `curl`, and `cx.animate()` for frame-rate redraws.
230-- **The click is the context.** A build ticket carries the clicked kind, the instance and its parents with the point in each, every instance on screen, the shared values, and the conversation about that kind so far. The form shows the same conversation, so following up is one more Ctrl+click.
231-- **Merges are the user's.** A finished build goes on trial: the app runs from a worktree (`~/.local/share/conveyor/trial`) of main plus every build in review, so a temporary widget lives in the real app until its toast's Keep merges it or Discard sends it back to draft. A build that doesn't compile, or conflicts with those on trial, never goes on trial. A build made while others are on trial starts from them, so keeping it keeps what it was built on.
232-- **The trial's edges are tested**: a branch that doesn't build, two that conflict, a follow-up built on the trial, a discard (`cargo test --release -p conveyor trial`, on a throwaway library and target dir).
233-- **Placement is explicit.** The app places nothing unless the agent ran `conveyor place`. Guessing placed widgets twice, four times over.
234-- **Widgets act from anywhere.** `cx.act(|live| ..)` does from `view`, `update` and `event` what the free functions do from handlers.
235-- **Library changes load in place** (spike 8). The app is a 7 KB binary over `libconveyor_app.so` (app, `api.rs`, Rune, std); the widgets are `libconveyor_widgets.so`, rebuilt in 0.45 s and `dlopen`ed by the running app. Every instance is dropped and made again from its folder, so widgets save as they go and stop their threads and processes in `Drop`. Widgets built against another build of the app wait for its `exec` restart, which now happens only when conveyor itself changes. Both are built wi …
236-- **Hidden work survives reloads.** Instances exist once rendered; `cx.keep_running()` from `update` makes the app bring one back after a reload or restart even when nothing shows it.
237-- **A broken widget can't take the app down** (catching what it can: `new`, `view`, `update`, `event` and `on` handlers). A panic turns that one instance into a red card, Ctrl+clickable. If `root` or `status` stops, or the user Ctrl+clicks the inspector's Safe mode button, or starts with `--safe`, the core runs alone: no widget code, the builds on trial with Keep and Discard, and Leave. The shared value `safe_mode = off` stops offering it, for those who'd rather not.
238-- **Widgets run with every permission the user has.** They are native code in the app, on the host: any file, any program, the network. The agent that writes them is sandboxed in a VM, the code it writes is not. That's deliberate for now, and may be a feature (a widget can drive the whole machine). Revisit before anyone runs someone else's library.
239-- **A starter kit ships in the template**, every widget made with the builder: the title bar's Widgets dropdown (each placeable widget with its description), `board` (kanban by state, drag to move, quick-add), `ticket` (edit, conversation, actions by state, a review's `git diff --stat`), `editor`, `library`, a canvas per project and a taskbar of projects. A first run is an empty canvas: pick from the dropdown, or Ctrl+click to make your own.
240-- **`api.rs` is conveyor's contract**, copied into the library on every start along with `gen.rs`, `CLAUDE.md` and the preview. The preview is the app's own host (`api::Live`) with sample data, so the agent checks exactly what the app runs.
241-- The app restarts (on a conveyor change) with `exec` on the path it read at launch, and conveyord copies itself into VMs from `/proc/self/exe`: after cargo replaces a binary, `current_exe()` names the deleted file.
242-- The base image carries the pinned toolchain and a warm `~/.cache/conveyor-target`, so the agent's first preview build is incremental. The bake builds in `~/work`, where agents build: cargo fingerprints workspace crates by path, and a cache warmed elsewhere rebuilt rune and the preview in every ticket (38 s, against 1.2 s). Rebake when the template's dependencies change.
243-- The library ignores `target/`. Without it, `target/` landed in the first commit and every ticket pushed 713 MB into its VM (32 s, against 0.5 s).
244-
245-#### What spike 5 showed (`spikes/5-builder/NOTES.md`)
246-
247-Four prompts built a project sidebar, a kanban board with an animated activity strip, and a To do / Running / Done dashboard with expandable cards, each first try in 3 to 4 minutes, 426 lines in all. The agents' workarounds name the API to design next:
248-
249-- **Ticket detail through the API.** With no ticket body or full thread in `cx.data`, an agent read conveyord's store files directly. A short API gets routed around, and couples the library to the store.
250-- **A `&mut self` update hook** beside `view(&self)` (one agent used a `RefCell` to remember when events arrived).
251-- **Optimistic writes**, so a dragged card doesn't wait a second for the refresh.
252-- **Drop targets or rects in handlers**, instead of computing columns from drag distance.
253-- **Timestamps on tickets, project settings ops (pause), defaults for shared values.**
254-
255-v4 answered those. Agents now see the app: a build ticket carries the app's state, and `preview --state` replays the user's window with the click outlined. The picker resolves to the deepest keyed element. Tickets carry text, times, files and threads. `View::update`/`View::event` exist, with paste and drop. Spike 6 then built the whole target without hitting a widget limit. What it hit instead:
256-
257-- **Actions belong on `Cx`**, not only in handlers: `update` and `event` can't act today.
258-- **Placement is the agent's call**, not a heuristic: guessing placed two widgets twice.
259-- **The preview needs every input the app has** (paste, drop, clipboard), or agents test by simulation.
260-- **Anything that touches the user's disk goes through a guard** in conveyord. The `project` op once ran `git init` in `$HOME`.
261-
262-## Stack
263-
264-**Decision: Rust everywhere, with [Rune](https://github.com/anomalyco/rune) for the app.** GPUI is the fallback. Checked on the real desktop: see [Checks on the real desktop](#checks-on-the-real-desktop).
265-
266-```
267-conveyord + conveyor CLI Rust, one binary
268-conveyor app Rust + Rune, pinned git rev, a client of conveyord
269-widgets Rust files in your widget library, compiled into the app
270-```
271-
272-Why Rune:
273-
274-1. **I can verify it without a desktop.** `--snap out.png --tree tree.json --script s.json` renders headless in about 0.45 s, dumps the element tree and drives input by key, with no compositor and no D-Bus. Agents working on conveyor inside a VM can check their own UI changes this way. No other candidate comes close.
275-2. **The fastest edit loop.** A mod rebuilds in 0.55 s, and edit-to-visible is about 0.9 s, restart included.
276-3. **The least code (208 lines) and the fastest first frame (284 ms).** Its typography was also the best of the four, and the OpenCode app proves it holds up in a real product.
277-
278-Mods are a **rebuild**, not a runtime-loaded file (since spike 8, the rebuilt widgets load into the running app, but they are still compiled Rust). That changes criterion 2 below. It works because the UI is only a view: conveyord holds all state, so restarting the app costs a frame. Mods get the full language rather than a DSL, at the cost of a Rust toolchain on the host.
279-
280-Risks we accept for a personal tool:
281-
282-- Pre-release, and the project takes no PRs. We pin a rev, and the MIT licence lets us vendor or fork it.
283-- Linux window chrome is thin. Minimize and edge resize need a small patch that we carry, and there is no window menu.
284-- Streaming at 1 000 events/s costs 53% of a core on the real GPU. At a realistic 50 events/s it costs 3.3%.
285-
286-### Spike 0 results
287-
288-Run in a headless KWin with software rendering, so CPU numbers compare the frameworks with each other, not with real hardware. Medians of 3 runs.
289-
290-| | **Rune** | GPUI (gpui-kit 0.9) | Slint 1.18 | Qt 6.12 / QML |
291-| --- | --- | --- | --- | --- |
292-| First frame | **284 ms** | 566 ms | 306 ms | 272–980 ms |
293-| PSS idle / streaming | 140 / 170 MB | 150 / 157 MB | **115 / 134 MB** | 123 / 146 MB |
294-| CPU at 1 000 ev/s | 68% | **20%** | 31% | 45% |
295-| CPU at 50 ev/s | 4.5% | **3.5%** | 8.2% | 4.0% |
296-| Clean build | 121 s | 143 s | 102 s | **3.4 s**, system Qt |
297-| Incremental build | **0.55 s** | 1.3 s | 5.3 s | 8.1 s |
298-| Binary | 37 MB | 58 MB | 38 MB | **0.3 MB** + 12 Qt libs |
299-| Source lines | **208** | 287 | 333 | 309 |
300-| Accessibility | 525 nodes, named | 70; title bar buttons missing | 305, named | 63, named |
301-| Custom title bar on Linux | borderless only | **library TitleBar** | needs `unstable-winit-030` | hand-built |
302-| Mod edit to visible | 0.9 s rebuild | 1.9 s rebuild | **27 ms** runtime, experimental API | 34 ms runtime |
303-| Headless verification | **PNG, tree, scripted input** | no | no | no |
304-
305-Each framework's details are in `spikes/0-ui/<fw>/REPORT.md`.
306-
307-- **Slint and QML** won on runtime mods. But Slint's runtime mods need experimental and internal APIs, and QML needs a C++ or cxx-qt glue layer.
308-- **GPUI** won on streaming CPU and has the best title bar. It loses on binary size, thin docs and crate-name churn.
309-
310-### Checks on the real desktop
311-
312-Run on KWin Wayland with the RTX 3080 Ti, on 2026-11-09:
313-
314-| Check | Result |
315-| --- | --- |
316-| No server-side decorations | ✅ borderless, with the app's own title bar |
317-| Drag by the title bar | ✅ |
318-| Maximize button, restore, double-click title to maximize | ✅ |
319-| Close button | ✅ the app exits |
320-| Typing in the filter box | ✅ filters live |
321-| Minimize button | ❌ no-op. Rune ignores `minimize` on borderless windows (`window/shell_requests.rs`) |
322-| Resize from edges or corners | ❌ none. Rune doesn't call winit's `drag_resize_window` |
323-| IME | not tested: no input method runs on this host |
324-| CPU idle / 50 ev/s / 1 000 ev/s | 0.4% / **3.3%** / 53%, with 154–182 MB PSS |
325-
326-The two ❌ are both small changes in Rune, and winit supports both on Wayland. Rune takes no PRs, so we carry them as a `[patch]` on the pinned rev, about 30 lines. At 1 000 ev/s the cost is CPU-side layout rather than rendering. Real agents emit tens of events per second, so this is not urgent. If it ever matters, batch log rows harder.
327-
328-Criteria the stack was chosen on, in order:
329-
330-1. Native performance with 1–3 live event streams and a VNC view.
331-2. Mods are cheap to write and fast to see: edit to visible in about a second.
332-3. An agent can debug it: readable stack traces, AT-SPI, logs, and a headless test mode.
333-4. One build command, few toolchains. No Zig pinned to an exact version.
334-
335-### UI landscape, November 2026 (research before the spike)
336-
337-Gathered from web research. Claims about young projects come from their READMEs or news posts, so spike 0 verifies them.
338-
339-| Candidate | Status | Accessibility | How a mod would work | Risk |
340-| --- | --- | --- | --- | --- |
341-| **GPUI** (Zed) + gpui-component / gpui-kit | Runs Zed. Pre-1.0, frequent breaking changes. Linux backend moved to wgpu | AccessKit merged on Zed `main` in May 2026. Not in the crates.io release (0.2.2, Oct 2025), so it means a git dependency | Rust only. A mod is a source change plus an incremental rebuild | Linux is "less polished" than macOS. One report of a Linux crash after the crate split |
342-| **Slint** | Stable 1.x. Rust, C++, JS, Python APIs | Passed a 2025 accessibility and IME test | **A mod is a `.slint` file**, loaded at runtime by `slint-interpreter`. Live reload keeps state | Its own DSL. GPLv3 or royalty-free licence, both fine here |
343-| **Qt 6 / QML** | The most mature. KDE uses it | AT-SPI built in | **A mod is a `.qml` file**, loaded at runtime | Heavy C++ toolchain. Rust binding through cxx-qt |
344-| **Rune** ([anomalyco/rune](https://github.com/anomalyco/rune)) | Pre-release, a git dependency pinned to `dev`. The OpenCode desktop app runs on it. wgpu, winit, Taffy, Parley | AccessKit, and the same tree is the agent's inspector | Rust only | Young, takes no pull requests. **Built for agents:** any app runs headless, renders to PNG, dumps its element tree and takes scripted input |
345-| iced / libcosmic | iced 0.x, COSMIC desktop | Experimental `a11y` feature | Rust only | Slow upstream |
346-| Damascene, Fenestra | Months old | AccessKit | Rust only | Watch list. Headless like Rune, with less behind them |
347-
348-Ruled out: web views (Tauri, Dioxus desktop, zero-native), and egui, which doesn't look native.
349-
350-**Shortlist for spike 0: GPUI, Slint, Qt/QML, Rune.** They also test two mod models against each other:
351-
352-```
353-mod = a UI file loaded at runtime (Slint, QML) no rebuild, limited to the DSL
354-mod = a source change + fast rebuild (GPUI, Rune) full power, needs a rebuild in seconds
355-```
356-
357-
358-## Spikes
359-
360-Each spike is a throwaway script that answers one question with numbers. They ran on the host, where conveyor will run. Code is in `spikes/`.
361-
362-| # | Question | Status | Result |
363-| - | --- | --- | --- |
364-| 0 | Which UI stack? | done | Rune, checked on the real desktop. Minimize and resize need a small patch. See [Stack](#stack) |
365-| 1 | Base image + overlays | done | 7.2 min bake. 15 ms overlay, 11.4 s to ssh, ~1.4 GB per idle guest. See [VMs](#vms-and-concurrency) |
366-| 2 | Headless claude, verbs over `ssh -R` | done | 2 `decide`, 1 correct `block`, no questions, committed. 28 s, $0.17 |
367-| 3 | Snapshot, restore, resume | done | Restore 1 s, `--resume` redid the work your way. See [Snapshots](#snapshots-and-rewind) |
368-| 4 | Spike 2 for opencode | done | Same behaviour with DeepSeek v4.1 flash, 45 s |
369-| 5 | What API does a self-modifying client need? | done | 4/4 builds first try, 3 to 4 min each. Gaps ranked in [The widget builder](#the-widget-builder) |
370-| 6 | Where is the builder's ceiling? | done | 3/3 hard builds first try (blur, vector diagram, paste → ticket). Limits are in the harness. See `spikes/6-ceiling/NOTES.md` |
371-| 7 | Audio, video, text editing, a layout per project | done | 3/3 first try, 7 to 11 min each. ffmpeg into `rune::Pixels` plays 30 fps video. The limits are app restarts and instances that only exist once rendered. See `spikes/7-media/NOTES.md` |
372-| 8 | Library changes without reopening the app | done | Widgets are a dylib the app `dlopen`s: a build or discard shows up in the same window, 0.45 s build, 0.5 s after Discard. See `spikes/8-reload/NOTES.md` |
373-
374-### What the spikes taught us
375-
376-- **Test isolation is mandatory on the host.** A nested KWin, Spectacle or accessibility bus that shares your `HOME` or `XDG_RUNTIME_DIR` writes into your live session. One spike replaced the session's accessibility bus socket and added a virtual output to `kwinoutputconfig.json`. `spikes/0-ui/measure.py` now runs everything in a throwaway HOME, XDG dirs and D-Bus session.
377-- Qt logs to the systemd journal, not stderr, unless `QT_FORCE_STDERR_LOGGING=1` is set.
378-- Restoring a snapshot with RAM also brings back old processes. Conveyor must kill the stale agent and its ssh session, and use a new socket path, before resuming.
379-- The base image needs `StreamLocalBindUnlink yes` in sshd and no CachyOS Hello autostart. Both are fixed in `spikes/1-vm/vm.py` for the next bake.
HANDOFF.md+0−73
@@ -1,73 +0,0 @@
1-# Handoff
2-
3-State as of 2026-11-10, after v1 and the commits below. The app is stable and in daily
4-use. Read DESIGN.md for how conveyor works; this file covers where things stand and what's next.
5-
6-## The loop
7-
8-```
9-Ctrl+click ─▶ ticket ─▶ VM boot ─▶ push ─▶ agent ─▶ done ─▶ merge check ─▶ trial ─▶ Keep / Discard
10- ready 12 s 0.5 s 30–250 s │ "Not done yet": app reloads
11- (waits if │ agent merges the in place
12- no image) ▼ trial, done again
13- first build ~12 s
14-```
15-
16-## Run it
17-
18-| What | Command |
19-|---|---|
20-| Daemon | `cargo build --release -p conveyor && ./target/release/conveyor daemon` |
21-| App | `cargo app && ./target/app/release/conveyor-app` (`--safe` opens safe mode) |
22-| Tests | `cargo test --release -p conveyor trial` |
23-| Base image | delete `~/.local/share/conveyor/images/base.qcow2`, then `tools/bake.py bake` (about 6 min) |
24-| Guest CLI, on a Mac | `rustup target add aarch64-unknown-linux-musl` once, then `cargo guest` with every daemon build |
25-
26-Rebake when the template's dependencies change (`templates/library/preview/Cargo.toml`, `Cargo.lock`)
27-or the bake's package list does: the image's warm cargo cache must match, or every ticket rebuilds
28-rune (38 s, against 12 s).
29-
30-## Next
31-
32-1. **Boot from a RAM snapshot.** Boot is 12 s of every ticket. Spike 1 measured 1.0–1.2 s to restore
33- a snapshot with RAM. `spikes/1-vm/vm.py` has the QMP `snapshot-save`/`snapshot-load` code.
34-2. **Make `--at 1` jump ahead.** The preview renders a full second at 60 fps on the CPU (2.6 s), and
35- an agent renders 8–25 times a ticket.
36-3. **Raise-on-click needs Rune.** Canvas cards can't come to the front on click until Rune supports it.
37-4. **The taskbar's armed ×.** In the user's library, the red "press again to forget" state doesn't show
38- while the pointer stays on the ×, probably because the hover fill covers it. A second press still
39- forgets. A Ctrl+click on it can fix it.
40-5. **The snapshot re-reads every ticket's events twice a second.** Fine at 20 tickets. Revisit if the
41- app's poll gets slow with hundreds.
42-
43-## Loose ends
44-
45-- **Ticket #20** (widgets) is a QA build, discarded, left as a draft. Conveyor has no delete op.
46-- **Library branches `t-12` and `t-20`** belong to builds that will never be kept; delete them with
47- `git -C ~/.local/share/conveyor/library branch -D t-12 t-20`.
48-- **Repo branches** `spike/builder-api`, `spike/builder-ceiling` and `spike/hot-reload` are merged
49- history and can go.
50-- **Backups to delete when you're confident:**
51-
52- | Path | What |
53- |---|---|
54- | `~/.local/share/conveyor/images/base.qcow2.old` | The previous image (20:07), 13 GB |
55- | `~/.local/share/conveyor-before-slim-20261109` | The library before `target/` was removed, 4.1 GB |
56- | `~/.local/share/conveyor-before-v1-20261109-1642` | State before the v1 wipe |
57- | `~/.local/share/conveyor-kit-test-20261109-1640` | Starter kit test install |
58- | `~/.local/share/conveyor-before-clean-20261109-1358` | State before an earlier clean |
59- | `~/.local/share/conveyor-spike` | The spikes' VM state |
60-
61-## Since v1
62-
63-| Commit | What |
64-|---|---|
65-| `4ea51c5` | Helper modules, rune_kit and a shared image cache for widgets; Keep deletes the build's branch |
66-| `a08bae5` | The library ignores `target/` (the push went from 32 s to 0.5 s), and the bake warms `~/work` |
67-| `1e898fa` | A build that conflicts with one kept meanwhile merges it before `done` |
68-| `3c10db6` | Tickets wait as ready while the base image is missing or baking |
69-| `10cc698` | Ponytail pass: serde over hand-rolled formats, dead code removed |
70-| `a1a5277` | Widgets get serde in the app, a secrets store, and failed builds resume their branch |
71-| `9f8c1e2` | The keychain reaches agents as env vars; `cx.secrets()` lists it |
72-| `land.rs` | Done from review merges a code ticket's branch into main, as Keep does for widgets |
73-| `stack` | A code ticket starts from main plus every branch in review; landing it lands those too. A retry note reaches the agent |
conveyor-idea.md+0−80
@@ -1,80 +0,0 @@
1-# Conveyor
2-
3-This is an idea that I've been shaping and trying a lot:
4-
5-- https://github.com/statico/claudeweaver the skill I started using that inspired me
6-- ../rats it was a different thing, that I re-steered into this, it prooves the weaver concept
7-
8-## Problems
9-
10-> The congnitive load to manage agents via a chat in the terminal is too much.
11-
12-The constant back and forth, series of questionaires, etc. Times this per multiple projects and it gets worse.
13-Meanwhile I have a chat with co-workers, company ticket board, git issues, and have to monitor commits and diffs, review task output and ensure the agents are not causing issues.
14-
15-> The kanban approach ended with me always checking on why the agent stopped.
16-
17-Maybe 1% are real blockers, other are the agent offloading minor decisions, like an engineer asking the CEO to pick a coding library. Even running in a vm with SANBOX set, this was a constant failure, the anthropic blocker, blocking actions in the sandbox with no external consequence.
18-Another kanban issue was only discovering deviations when the code was in review, with a decision documented that changed the scope. This defeats the purpose of scoping a ticket.
19-
20-> Agents working on projects need their own vm per project. For isolation, and autonomy.
21-
22-See ../automate-me/vm.sh I currently do this by hand, and it's a crude process. And something that this idea can
23-solve. Another issue was the same agent context for all tickets, or agents stepping outside the scope of the tickets. The more time the agents worked in that folder the more confusing the ticket history and it's memories and internal features got lost. A vm per branch or a defined unit of work, would likely be the best. We would likely create an optimized image with all the required packages for dev and computer use ready, as well as loading all my host configs and keys.
24-
25-## Solutions
26-
27-They all address the same goal:
28-
29-> Reduce user cognitive load, conveyor never stops.
30-
31-Tickets, or work orders, or tasks have existed forever, and they are pretty fundamental. Operating a kanban board,
32-triaging, discovery, implementation, and review is not. Even with strong heuristics, there's always deviation.
33-
34-> Ticket as the base fundamental. One ticket one defined piece of work.
35-
36-
37-Drift, overacting, spamming commits and tickets are symptoms of ambiguous and unexplicit tickets. Most of the times the user's ticket is a one liner, assuming context, this then devolves is a chat via notes, not a process.
38-
39-> Tickets have a clear process, including failure and recovery routes.
40-
41-
42-Humans are incredibly slow, and need sleep, agents are fast and don't need sleep. A human should never block the work loop. If a task can't progress, it should surface to the user to act. This should be a call to action, not a wall of text, with several multiple choices, thats the chatbot bleeding in. Like `#1222 doesn't have enough scope, left a recommended path, and discovery files/images/code attached to the ticket for review.`. Call to my action to review why the ticket is ambiguous and fix. …
43-
44-> The conveyor can't need a human to keep looping and working.
45-
46-## Shape
47-
48-A linux/mac desktop app, where:
49-
50-- I can open a folder on disk as a "Project".
51-- This can be any kind of directory with files, that need something done to them.
52-- A project view where I can manage tickets, write new ones, see and react when a agent needs me.
53-- Allow me to see (vnc or whatever) into the vm's desktop, so I can see the agent working.
54-- Manages VM creation/teardown for me, per project. and ensures good communication between host and vm
55-- Wraps the coding agent, `claude-code` and `opencode`. (opencode is cheap for testing with deepseek v4.1 flash, claude for when we need to since thats what I use).
56-
57-### Self modifying software
58-
59-- The app itself should be as extensible as possible, with the ability to modify it in any way, so I can create dedicated widgets and gadgets for each project.
60-- Build from the ground up to be modifieable.
61-- The apps starts with an empty canvas and the window chrome.
62-- Everything else is widgets, customizable and swappable.
63-- We can later provide some basic widgets. But I rather build my own as we go.
64-
65-Starter widget: CTRL+left click -> floating form to submit a prompt into the loop.
66-This is the building tool, it needs to allow me to create widgets of all shapes and sizes. So I can build widgets for: listing my projects, tabs, tiling panes, a text editor, a graphic visualization, etc...
67-It needs to be a closed loop, click to create, click to edit. This mod click is the basic building tool.
68-
69-Why: in some projects I need the agent to render modeled data, others might be a video game. Both cases might need dedicated widgets that we build for that scenario.
70-
71-## Legal
72-
73-There is no comercial or business intent with this app. It's for personal use.
74-The code will be visible online, in a git repo, but not as a distribution and only a personal project hosted on my own domain and server.
75-
76-As far as I understand, there is nothing wrong with using the claude-code binary unmodified, and resulting from my input. The restrictions are around CI, distilations, and others.
77-
78-## Todo for human
79-
80-- Check if this is using my subscriptions.
spikes/0-ui/SPEC.md+0−84
@@ -1,84 +0,0 @@
1-# Spike 0: UI stack
2-
3-One small app, built the same way in four frameworks: **GPUI**, **Slint**, **Qt/QML** and **Rune**. The numbers decide conveyor's UI stack. This is throwaway code: make it honest, not pretty.
4-
5-## The app
6-
7-A window of 1400×900, with no server-side decorations.
8-
9-```
10-┌ Conveyor ─ conveyor ▾ ─────────────────────────────────────── _ □ × ┐ custom title bar: drag moves the window,
11-├────────────┬───────────────────────┬────────────────────────────────┤ the buttons work, double click maximizes
12-│ INBOX (8) │ [filter… ] │ #1003 Title of ticket │
13-│ #1012 ... │ #1000 ready Title… │ state: running · project · upd │
14-│ #1044 ... │ #1001 done Title… │ body text… │
15-│ … │ … 300 rows, virtual │ ── live log ────────────────── │
16-│ │ scrolling │ 4211 text the agent reads … │
17-│ MOD │ │ 4212 tool … │ newest at the bottom, sticks
18-│ [mod card] │ │ … │ to the bottom while streaming
19-└────────────┴───────────────────────┴────────────────────────────────┘
20-```
21-
22-- **Title bar**: drawn by the app. It shows the app name and project name, and has minimize, maximize and close buttons.
23-- **Inbox**: the `ctas` from the fixture, one line each. A click selects that ticket.
24-- **Ticket list**: all 300 tickets, as id, state and title. A filter box filters by title as you type. The list must virtualize.
25-- **Detail**: the selected ticket's title, state, project, updated time and body.
26-- **Live log**: events from stdin. Keep **every** event in memory, and render only the visible rows. Each row shows `seq`, `kind` and the first line of `text`. While the view is at the bottom, new events keep it there.
27-- **Mod card**: see [Mod](#mod).
28-
29-## Inputs and outputs
30-
31-- `argv[1]` is the path to the fixture, `../tickets.json`. It is made by `../fixture.py`.
32-- **stdin** carries newline-delimited JSON events: `{"seq":0,"ticket":1003,"kind":"text","text":"…"}`. Read it on a background thread and batch the events into the UI. Don't post one UI update per event. The harness sends 1 000 events/s.
33-- **stdout**: print `FIRST_FRAME` once, followed by a flush, as soon as the first frame has been presented. Use the framework's first-frame or after-render hook. Write with `println!`, `std::cout` or `write(1)`. **Don't use Qt's `qDebug` or `console.log`**: Qt sends those to the systemd journal when stderr isn't a terminal.
34-- On EOF, keep running.
35-
36-## Mod
37-
38-A mod is a small user-written widget that the app loads. It proves how conveyor's mods would work in this stack.
39-
40-- The mod is a card that shows a heading and the live event count, read from the app.
41-- **If the framework can load UI at runtime**, which applies to Slint (`slint-interpreter`) and QML (`Loader`/`QQmlComponent`):
42- - Load the mod from `<fw>/mods/hello.<ext>` at startup.
43- - Watch the file and reload it on change.
44- - Print `MOD_RELOADED <ms>` after each reload, where `<ms>` is the time from detecting the change to the reload being done.
45-- **If it can't**, which applies to GPUI and Rune: make the mod a separate source file or crate. The mod model there is "edit the source, rebuild, restart". Measure that loop: touch the mod file, run an incremental release build, start the app, and wait for `FIRST_FRAME`.
46-
47-## Rules: read these first
48-
49-You run on the user's **host** machine, as user `xonecas`. Their real desktop session is live. Breaking it is the worst outcome.
50-
51-- **Never open a window on the real desktop.** Start the app only through `../measure.py`. It runs it inside a throwaway HOME, XDG dirs, D-Bus session and headless KWin. For a quick look, run `../measure.py <fw>-try -- <cmd>` and read `results/<fw>-try.png`.
52-- **No system changes**: no `sudo`, no `pacman`, no `rustup default`, no `rustup toolchain install`. Rust 1.99.1 is installed. Use a `rust-toolchain.toml` with `channel = "1.99.1"`, or `cargo +1.99.1`.
53-- Write only inside `spikes/0-ui/<fw>/`. The cargo caches in `~/.cargo` are fine. Keep `target/` inside your folder.
54-- Builds run four at a time on one machine: use **`-j 6`** for every cargo or cmake build, so the build times are comparable.
55-- To stop a process, kill it by **pid**. Never use `pkill -f` or `killall`. Broad patterns have already killed the wrong process here.
56-- If the framework can't do something, such as CSD, accessibility or runtime loading, don't fake it. Write it down. That is a result.
57-- If the framework fails at a basic level, say it won't build on Linux or can't open a window under KWin Wayland, spend at most about 30 minutes on it. Then stop and report.
58-
59-## Measure and report
60-
61-Write `spikes/0-ui/<fw>/REPORT.md` with this table, filled in with real numbers:
62-
63-| Metric | Value |
64-| --- | --- |
65-| Version used (crate, git rev or Qt version) | |
66-| Clean release build, `-j 6` (s) | |
67-| Incremental release rebuild after editing one UI source file (s) | |
68-| Binary size, release (MB) | |
69-| Source lines, excluding generated code | |
70-| `first_frame_ms` | from `results/<fw>.json` |
71-| PSS idle / streaming (MB) | |
72-| CPU idle / streaming (%) | |
73-| `stdin_blocked` (true means the UI couldn't keep up) | |
74-| Accessibility nodes, and do list rows and buttons have names? | from `results/<fw>.a11y.txt` |
75-| Custom title bar works, with no server-side decorations? | from the screenshot |
76-| Mod: edit-to-visible time (ms or s) and how it works | |
77-
78-Get the run numbers with `../measure.py <fw> -- <path-to-release-binary> ../tickets.json`, run from `spikes/0-ui/`. Run it **3 times** and report the median. Look at `results/<fw>.png` yourself and say whether it looks right.
79-
80-Then add short notes:
81-- What was hard.
82-- How readable the compile errors and docs were for an agent.
83-- Anything that would make this stack painful for conveyor: Wayland, IME, text, theming, packaging.
84-- A one-line verdict.
spikes/0-ui/dbus/services/org.a11y.Bus.service+0−3
@@ -1,3 +0,0 @@
1-[D-BUS Service]
2-Name=org.a11y.Bus
3-Exec=/usr/lib/at-spi-bus-launcher
spikes/0-ui/dbus/session.conf+0−14
@@ -1,14 +0,0 @@
1-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
2- "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
3-<!-- Isolated session bus for spikes: only the accessibility bus can be activated. No portals, no systemd. -->
4-<busconfig>
5- <type>session</type>
6- <listen>unix:tmpdir=/tmp</listen>
7- <auth>EXTERNAL</auth>
8- <servicedir>./services</servicedir>
9- <policy context="default">
10- <allow send_destination="*" eavesdrop="true"/>
11- <allow eavesdrop="true"/>
12- <allow own="*"/>
13- </policy>
14-</busconfig>
spikes/0-ui/fixture.py+0−22
@@ -1,22 +0,0 @@
1-#!/usr/bin/env python3
2-"""Writes tickets.json: 3 projects, 300 tickets, 8 CTAs. Deterministic."""
3-import json, random, sys
4-random.seed(7)
5-STATES = ["draft", "refine", "needs-scope", "ready", "running", "parked", "verify", "review", "done"]
6-WEIGHTS = [20, 8, 4, 30, 3, 2, 3, 10, 220]
7-WORDS = "vm overlay ticket branch snapshot agent refine scope inbox mod widget daemon socket stream render layout title bar diff review verify parked deviate decide block note done store events image base clone push".split()
8-def sentence(n): return " ".join(random.choice(WORDS) for _ in range(n)).capitalize()
9-projects = ["conveyor", "rats", "dotfiles"]
10-tickets = []
11-for i in range(300):
12- state = random.choices(STATES, WEIGHTS)[0]
13- tickets.append({
14- "id": 1000 + i, "project": random.choice(projects), "state": state,
15- "title": sentence(random.randint(3, 9)),
16- "body": "\n\n".join(sentence(random.randint(8, 30)) + "." for _ in range(random.randint(1, 5))),
17- "updated": f"2026-11-{random.randint(1, 9):02d}T{random.randint(0, 23):02d}:{random.randint(0, 59):02d}:00Z",
18- })
19-ctas = [{"ticket": t["id"], "kind": t["state"] if t["state"] in ("needs-scope", "parked", "review") else "deviate",
20- "line": f"#{t['id']} " + sentence(random.randint(5, 10)).lower()}
21- for t in random.sample([t for t in tickets if t["state"] != "done"], 8)]
22-json.dump({"projects": projects, "tickets": tickets, "ctas": ctas}, open(sys.argv[1] if len(sys.argv) > 1 else "tickets.json", "w"), indent=1)
spikes/0-ui/gen-events.py+0−21
@@ -1,21 +0,0 @@
1-#!/usr/bin/env python3
2-"""Writes newline-delimited agent events to stdout: gen-events.py RATE SECONDS [TICKET]."""
3-import json, random, sys, time
4-rate, secs = int(sys.argv[1]), float(sys.argv[2])
5-ticket = int(sys.argv[3]) if len(sys.argv) > 3 else 1003
6-random.seed(3)
7-KINDS = ["text"] * 6 + ["tool"] * 2 + ["result", "note"]
8-WORDS = "the agent reads file src main rs and runs cargo build then checks the overlay boot time inside the guest vm".split()
9-end, n, t0 = time.monotonic() + secs, 0, time.monotonic()
10-out = sys.stdout
11-while time.monotonic() < end:
12- kind = random.choice(KINDS)
13- text = " ".join(random.choice(WORDS) for _ in range(random.randint(6, 60)))
14- if kind == "result": text = "\n".join(f"+ {text[:80]}" for _ in range(random.randint(1, 6)))
15- out.write(json.dumps({"seq": n, "ticket": ticket, "kind": kind, "text": text}) + "\n")
16- n += 1
17- if n % 50 == 0:
18- out.flush()
19- lag = t0 + n / rate - time.monotonic()
20- if lag > 0: time.sleep(lag)
21-out.flush()
spikes/0-ui/gpui/Cargo.lock+0−8561
@@ -1,8561 +0,0 @@
1-# This file is automatically @generated by Cargo.
2-# It is not intended for manual editing.
3-version = 4
4-
5-[[package]]
6-name = "accesskit"
7-version = "0.24.1"
8-source = "registry+https://github.com/rust-lang/crates.io-index"
9-checksum = "d3b7f7f85a7e5f68090000ed7622545829afd484d210358702ae4cb97dd0c320"
10-dependencies = [
11- "enumn",
12- "uuid",
13-]
14-
15-[[package]]
16-name = "accesskit_atspi_common"
17-version = "0.19.1"
18-source = "registry+https://github.com/rust-lang/crates.io-index"
19-checksum = "023da0e5097f46df7092d5280b02efb9bbf8d93298daeced42652463e357d636"
20-dependencies = [
21- "accesskit",
22- "accesskit_consumer",
23- "atspi-common",
24- "phf 0.13.1",
25- "serde",
26- "zvariant",
27-]
28-
29-[[package]]
30-name = "accesskit_consumer"
31-version = "0.38.0"
32-source = "registry+https://github.com/rust-lang/crates.io-index"
33-checksum = "5d10a236f96f87d70732e44520046785431ef01d5bcd6b041317bfadd2f88245"
34-dependencies = [
35- "accesskit",
36- "hashbrown 0.16.1",
37-]
38-
39-[[package]]
40-name = "accesskit_macos"
41-version = "0.26.3"
42-source = "registry+https://github.com/rust-lang/crates.io-index"
43-checksum = "ce02dc63b43f0c9296af9ac946312a2dc8814427d7a64d2d600971dac55b6076"
44-dependencies = [
45- "accesskit",
46- "accesskit_consumer",
47- "hashbrown 0.16.1",
48- "objc2 0.5.3",
49- "objc2-app-kit 0.2.2",
50- "objc2-foundation 0.2.2",
51-]
52-
53-[[package]]
54-name = "accesskit_unix"
55-version = "0.22.1"
56-source = "registry+https://github.com/rust-lang/crates.io-index"
57-checksum = "03e156ed3802e35eefe894ef2671bc6c889303d8a7e110b5e1b48f504b91362f"
58-dependencies = [
59- "accesskit",
60- "accesskit_atspi_common",
61- "async-channel",
62- "async-executor",
63- "async-task",
64- "atspi",
65- "futures-lite",
66- "futures-util",
67- "serde",
68- "zbus 5.19.0",
69-]
70-
71-[[package]]
72-name = "accesskit_windows"
73-version = "0.34.0"
74-source = "registry+https://github.com/rust-lang/crates.io-index"
75-checksum = "106c2b961215864d1c2e703ee63269c25c4e80a577ffb2c1017b9c17dcdf83a1"
76-dependencies = [
77- "accesskit",
78- "accesskit_consumer",
79- "hashbrown 0.16.1",
80- "static_assertions",
81- "windows 0.62.2",
82- "windows-core 0.62.2",
83-]
84-
85-[[package]]
86-name = "addr2line"
87-version = "0.27.1"
88-source = "registry+https://github.com/rust-lang/crates.io-index"
89-checksum = "e567177890eb1617b1f774005b66b26b2377afd138a2ca37aae7d8f0c81429d4"
90-dependencies = [
91- "gimli",
92-]
93-
94-[[package]]
95-name = "adler2"
96-version = "2.0.1"
97-source = "registry+https://github.com/rust-lang/crates.io-index"
98-checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
99-
100-[[package]]
101-name = "aes"
102-version = "0.8.4"
103-source = "registry+https://github.com/rust-lang/crates.io-index"
104-checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
105-dependencies = [
106- "cfg-if",
107- "cipher",
108- "cpufeatures 0.2.17",
109- "zeroize",
110-]
111-
112-[[package]]
113-name = "ahash"
114-version = "0.8.12"
115-source = "registry+https://github.com/rust-lang/crates.io-index"
116-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
117-dependencies = [
118- "cfg-if",
119- "const-random",
120- "once_cell",
121- "version_check",
122- "zerocopy",
123-]
124-
125-[[package]]
126-name = "aho-corasick"
127-version = "1.1.5"
128-source = "registry+https://github.com/rust-lang/crates.io-index"
129-checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
130-dependencies = [
131- "memchr",
132-]
133-
134-[[package]]
135-name = "aligned"
136-version = "0.4.3"
137-source = "registry+https://github.com/rust-lang/crates.io-index"
138-checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685"
139-dependencies = [
140- "as-slice",
141-]
142-
143-[[package]]
144-name = "aligned-vec"
145-version = "0.6.4"
146-source = "registry+https://github.com/rust-lang/crates.io-index"
147-checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b"
148-dependencies = [
149- "equator",
150-]
151-
152-[[package]]
153-name = "allocator-api2"
154-version = "0.2.21"
155-source = "registry+https://github.com/rust-lang/crates.io-index"
156-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
157-
158-[[package]]
159-name = "android_system_properties"
160-version = "0.1.6"
161-source = "registry+https://github.com/rust-lang/crates.io-index"
162-checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
163-dependencies = [
164- "libc",
165-]
166-
167-[[package]]
168-name = "annotate-snippets"
169-version = "0.12.17"
170-source = "registry+https://github.com/rust-lang/crates.io-index"
171-checksum = "b2a5b0a5ab8561c603f16c3b78c24a386b1f70e7fc1b1b1e8c15738828e4a176"
172-dependencies = [
173- "anstyle",
174- "memchr",
175- "unicode-width",
176-]
177-
178-[[package]]
179-name = "anstyle"
180-version = "1.0.14"
181-source = "registry+https://github.com/rust-lang/crates.io-index"
182-checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
183-
184-[[package]]
185-name = "anyhow"
186-version = "1.0.104"
187-source = "registry+https://github.com/rust-lang/crates.io-index"
188-checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
189-
190-[[package]]
191-name = "arbitrary"
192-version = "1.5.0"
193-source = "registry+https://github.com/rust-lang/crates.io-index"
194-checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
195-
196-[[package]]
197-name = "arc-swap"
198-version = "1.9.4"
199-source = "registry+https://github.com/rust-lang/crates.io-index"
200-checksum = "db4c94f57a570fce5d381be3289b3f79aef6332d72948fe82ab5772e423ccf92"
201-dependencies = [
202- "rustversion",
203-]
204-
205-[[package]]
206-name = "arg_enum_proc_macro"
207-version = "0.3.4"
208-source = "registry+https://github.com/rust-lang/crates.io-index"
209-checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
210-dependencies = [
211- "proc-macro2",
212- "quote",
213- "syn 2.0.119",
214-]
215-
216-[[package]]
217-name = "arraydeque"
218-version = "0.5.1"
219-source = "registry+https://github.com/rust-lang/crates.io-index"
220-checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
221-
222-[[package]]
223-name = "arrayref"
224-version = "0.3.9"
225-source = "registry+https://github.com/rust-lang/crates.io-index"
226-checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
227-
228-[[package]]
229-name = "arrayvec"
230-version = "0.7.8"
231-source = "registry+https://github.com/rust-lang/crates.io-index"
232-checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
233-
234-[[package]]
235-name = "as-raw-xcb-connection"
236-version = "1.0.1"
237-source = "registry+https://github.com/rust-lang/crates.io-index"
238-checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
239-
240-[[package]]
241-name = "as-slice"
242-version = "0.2.1"
243-source = "registry+https://github.com/rust-lang/crates.io-index"
244-checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516"
245-dependencies = [
246- "stable_deref_trait",
247-]
248-
249-[[package]]
250-name = "ash"
251-version = "0.38.0+1.3.281"
252-source = "registry+https://github.com/rust-lang/crates.io-index"
253-checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f"
254-dependencies = [
255- "libloading",
256-]
257-
258-[[package]]
259-name = "ashpd"
260-version = "0.13.13"
261-source = "registry+https://github.com/rust-lang/crates.io-index"
262-checksum = "fb8421aaa9644a5faf26735f258b669b15f063313ef8f8e2bdb28912a1a6f111"
263-dependencies = [
264- "enumflags2",
265- "futures-channel",
266- "futures-util",
267- "getrandom 0.4.3",
268- "serde",
269- "serde_repr",
270- "wayland-backend",
271- "wayland-client",
272- "wayland-protocols",
273- "zbus 5.19.0",
274-]
275-
276-[[package]]
277-name = "async-broadcast"
278-version = "0.7.2"
279-source = "registry+https://github.com/rust-lang/crates.io-index"
280-checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
281-dependencies = [
282- "event-listener",
283- "event-listener-strategy",
284- "futures-core",
285- "pin-project-lite",
286-]
287-
288-[[package]]
289-name = "async-channel"
290-version = "2.5.0"
291-source = "registry+https://github.com/rust-lang/crates.io-index"
292-checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
293-dependencies = [
294- "concurrent-queue",
295- "event-listener-strategy",
296- "futures-core",
297- "pin-project-lite",
298-]
299-
300-[[package]]
301-name = "async-executor"
302-version = "1.14.1"
303-source = "registry+https://github.com/rust-lang/crates.io-index"
304-checksum = "f426a31126c735126297bc5ea7a521263c9faff4f63ca415267ee625651c4f37"
305-dependencies = [
306- "async-task",
307- "concurrent-queue",
308- "fastrand",
309- "futures-lite",
310- "pin-project-lite",
311- "slab",
312-]
313-
314-[[package]]
315-name = "async-fs"
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/Cargo.toml+0−13
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/REPORT.md+0−33
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/rust-toolchain.toml+0−2
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/src/data.rs+0−51
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/src/hello_mod.rs+0−17
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/gpui/src/main.rs+0−219
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/measure.py+0−199
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/Backend.cpp+0−33
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/Backend.h+0−32
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/CMakeLists.txt+0−10
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/Main.qml+0−112
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/Models.h+0−68
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/REPORT.md+0−31
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/main.cpp+0−45
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/qml/mods/hello.qml+0−9
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/real-desktop.py+0−41
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/Cargo.lock+0−4485
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/Cargo.toml+0−14
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/REPORT.md+0−48
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/headless/after.json+0−7625
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/headless/after.png+0−0
Binary file, not shown.
spikes/0-ui/rune/headless/drive.json+0−5
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/headless/ev.json+0−29020
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/headless/ev.jsonl+0−300
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/headless/ev.png+0−0
Binary file, not shown.
spikes/0-ui/rune/headless/snap.png+0−0
Binary file, not shown.
spikes/0-ui/rune/headless/tree.json+0−7334
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/mods/hello.rs+0−10
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/rust-toolchain.toml+0−2
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/src/main.rs+0−15
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/src/state.rs+0−67
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/src/titlebar.rs+0−21
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/rune/src/ui.rs+0−96
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/Cargo.lock+0−5934
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/Cargo.toml+0−17
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/REPORT.md+0−48
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/build.rs+0−5
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/mods/hello.slint+0−9
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/rust-toolchain.toml+0−2
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/src/main.rs+0−163
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/ui/app.slint+0−144
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/slint/ui/widgets.slint+0−12
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/smoke/smoke.qml+0−8
Cut short: this commit's diff is over 1000 lines.
spikes/0-ui/tickets.json+0−2451
Cut short: this commit's diff is over 1000 lines.
spikes/1-vm/vm.py+0−384
Cut short: this commit's diff is over 1000 lines.
spikes/2-agent/conveyor-guest+0−26
Cut short: this commit's diff is over 1000 lines.
spikes/2-agent/host-listener.py+0−39
Cut short: this commit's diff is over 1000 lines.
spikes/2-agent/rules.md+0−15
Cut short: this commit's diff is over 1000 lines.
spikes/2-agent/run.sh+0−51
Cut short: this commit's diff is over 1000 lines.
spikes/2-agent/ticket.md+0−12
Cut short: this commit's diff is over 1000 lines.
spikes/5-builder/NOTES.md+0−100
Cut short: this commit's diff is over 1000 lines.
spikes/6-ceiling/NOTES.md+0−82
Cut short: this commit's diff is over 1000 lines.
spikes/7-media/NOTES.md+0−82
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/.cargo/config.toml+0−3
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/Cargo.lock+0−4497
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/Cargo.toml+0−9
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/NOTES.md+0−68
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/host/Cargo.toml+0−7
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/host/src/main.rs+0−58
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/rust-toolchain.toml+0−2
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/shared/Cargo.toml+0−11
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/shared/src/lib.rs+0−18
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/widgets/Cargo.toml+0−10
Cut short: this commit's diff is over 1000 lines.
spikes/8-reload/widgets/src/lib.rs+0−54
Cut short: this commit's diff is over 1000 lines.