Remote loops survive a dropped connection now — the pane redials itself instead of dying.

A remote surface used to be a single ssh -t … zmx attach. When the link dropped — a Codespace idle-stopping, the lid closing, a network change — the pane died on screen even though the remote zmx kept the agent running the whole time. Nothing was lost but the view, and getting it back meant closing and reopening the loop's terminal by hand.

• Keepalives on every connection. ServerAliveInterval=5 / ServerAliveCountMax=3, so a dead link is found in about fifteen seconds instead of at the OS TCP timeout — which never read as a disconnect at all, it read as a terminal that had frozen.
• A reconnect loop around the dial. A remote surface is now a retry loop: ssh's own exit 255 retries with capped exponential backoff (1→15s), forever, so an overnight sleep still resumes. Every other exit passes straight through and closes the surface exactly like a local shell exiting, and Ctrl-C during the wait stops the loop.
• A reconnect never relaunches your agent. An agent surface reattaches only a session that still exists, and otherwise closes with a notice. A session that ended while you were disconnected is the loop having finished — recreating it would re-send the opening prompt and start a second pass behind your back. Plain shell tabs have no such side effect, so they come back as a fresh shell in the repository.

Both pieces are drawn on supacode's remote connections (shape, not code).

Also in this release: the glass app icon now draws its graph from geometry rather than a luma matte, so the ghost rectangle behind it is gone and the graph fills the tile at the right scale.

Everything else from the 0.1.11 line is unchanged from 0.1.11-beta1.

Remote loops survive a dropped connection now — the pane redials itself instead of dying.

A remote surface used to be a single ssh -t … zmx attach. When the link dropped — a Codespace idle-stopping, the lid closing, a network change — the pane died on screen even though the remote zmx kept the agent running the whole time. Nothing was lost but the view, and getting it back meant closing and reopening the loop's terminal by hand.

• Keepalives on every connection. ServerAliveInterval=5 / ServerAliveCountMax=3, so a dead link is found in about fifteen seconds instead of at the OS TCP timeout — which never read as a disconnect at all, it read as a terminal that had frozen.
• A reconnect loop around the dial. A remote surface is now a retry loop: ssh's own exit 255 retries with capped exponential backoff (1→15s), forever, so an overnight sleep still resumes. Every other exit passes straight through and closes the surface exactly like a local shell exiting, and Ctrl-C during the wait stops the loop.
• A reconnect never relaunches your agent. An agent surface reattaches only a session that still exists, and otherwise closes with a notice. A session that ended while you were disconnected is the loop having finished — recreating it would re-send the opening prompt and start a second pass behind your back. Plain shell tabs have no such side effect, so they come back as a fresh shell in the repository.

Both pieces are drawn on supacode's remote connections (shape, not code).

The multi-machine release: everything found while running self-improving loops across two Macs and a Codespace, fixed and validated where it was found.

Remote loops are first-class now.

• The launch race that typed a whole zsh/copilot command into a live agent's input bar is gone — a remote session's existence check and launch share one shell.
• Messages and kills reach remote sessions over ssh. graphcode node send to a Codespace loop delivers; stopping or deleting one actually ends its session. (This never worked in any prior version — remote repos and the local-only transport shipped together in 0.1.7-beta.)
• Remote Copilot loops get their goals: an unattended Copilot queues its --interactive goal behind a per-session folder-trust dialog nobody answers, so the launch now pre-trusts the one repository the loop was pointed at, on the host it runs on. Scoped to Copilot, pinned untouched for every other backend and every local launch.

The sidebar can no longer lose a loop.

• Closed cycles (maker↔reviewer pairs) had no root and vanished from the list while both loops ran — the sidebar now anchors them the way the canvas always has.
• The disclosure chevron draws whenever a row has children, not only under the pointer, and expansion survives relaunch. A loop that exists is always visible or exactly one visible chevron away.
• New children auto-expand their parent chain the moment they're created; Local Projects and Remote Repositories fold under captioned headers with real air between sections.

Copilot defaults that match unattended reality. New Copilot loops launch with Copilot's own --yolo — the old tools-only default left loops stalling at URL and path dialogs nobody was watching. The welcome tour's backend choice now applies the moment it's made and can't be silently reverted by the Settings pane.

Everything in v0.1.9 — the self-improving loop machinery itself — is unchanged underneath.

Every loop that exists is now visible in the sidebar — or exactly one visible chevron away.

The reported "two running loops missing from the sidebar" turned out to be three stacked causes, all fixed:

• Closed cycles had no sidebar root. A maker↔reviewer pair — forward edge one way, guarded back-edge the other — has no node without an inbound edge, and the row tree walked only from no-inbound roots: the whole cycle vanished from the list while both loops ran. The sidebar now uses the same startAnchors the canvas always has, which anchors each cycle-only component at its first node — the two views can no longer disagree about which loops exist.
• The disclosure chevron only drew under the pointer. A row with loops beneath it read as a leaf — collapsed children were invisible with no clue they existed. The chevron now always draws when a row has children: dim at rest, brighter on hover.
• Expansion state reset on every relaunch. What you expanded stays expanded — the set persists across launches now.

Everything from beta4 (remote Copilot goal delivery via folder-trust seeding, remote message/kill transport, and the rest of the 0.1.10 line) is unchanged.

The remote Copilot goal-delivery fix.

A fresh Copilot loop in an SSH remote repository booted to an idle screen with its goal never delivered. Root cause, measured against a live TUI: an unattended Copilot queues its --interactive goal behind a per-session folder-trust dialog nobody is present to answer — and --yolo does not cover folder trust. The queued goal fires the instant trust is granted.

The remote launch now pre-trusts the one repository the loop was pointed at, on the host it runs on — an additive, idempotent write to Copilot's own trustedFolders (schema read off a real "remember this folder" answer). Creating a loop in that repo is the consent; the seed just delivers it to the right machine.

Scoped hard, pinned by tests: only Copilot nodes get the seed, a Claude node's remote script is asserted untouched, every local launch path is untouched by construction, and a host without python3 falls back to today's dialog rather than blocking the launch.

Note for loops created before this fix: an existing goal-less session is deliberately never re-prompted — rescue it with graphcode node send <project> <id> <goal> (delivery to remote sessions works as of beta3), or delete and recreate the loop.

Everything from beta3 (remote message/kill delivery over ssh, sidebar section air) is unchanged.

Remote loops can finally be talked to — and turned off.

Messages reach remote sessions. graphcode node send, hand-off nudges, and message edges to a loop in an SSH remote repository were spoken only to the local zmx socket, which has never heard of a session living in another host's zmx daemon — every delivery failed and staged. This was never a regression: remote repositories and the local-only send shipped together in 0.1.7-beta, and no version has ever delivered. This one does: sends ride ssh in one round-trip, keeping the text-pause-Enter dance agent TUIs need, and a genuinely dead remote session still stages to memory exactly like a local one.

Stops and deletes reach remote sessions. The same local-only gap meant stopping or deleting a remote loop left its session running on the remote host forever. Kills now route by project path too, and the parent-kill cascade works across the wire.

Known limitation, stated rather than papered over: the graph briefing and memory wake digest still don't reach remote sessions — they describe a CLI whose socket lives on your Mac, and teaching a remote agent commands that can't work from there would be worse than none. A remote CLI transport is the real fix and stays on the roadmap.

Also: the sidebar's Local Projects / Remote Repositories groups get a clear band of air above their captions, and everything from beta2 (onboarding backend choice, YOLO default, the remote composer fix, auto-expanding fan-outs) is unchanged.

One fix on top of beta1: the welcome tour's backend choice now actually sticks.

Picking Copilot or Codex on the tour's last page saved straight to the settings file, bypassing the live model the Settings window binds to — "New loops use" kept showing the old backend, and the Settings pane's next save quietly reverted the choice. The selection now applies the moment a card is tapped, through the same live model Settings uses, so the pane agrees instantly and a tour dismissed early keeps the choice that was made.

Everything from beta1 is unchanged: the remote composer fix (launch command no longer typed into a live agent's input bar), Copilot's YOLO default, sidebar auto-expand for new children, and foldable Local/Remote groups.

Four fixes from live multi-machine testing of the self-improving loop machinery.

The remote composer bug. Creating a loop in an SSH remote repository could leave the entire launch command sitting unsent in the agent's chat input bar. The daemon's existence check and launch were two ssh round-trips seconds apart, and opening the node's terminal creates the session in that gap — the late zmx run then typed the launch line into the live agent instead of a shell. Check and run now share one remote shell (zmx get || zmx run), create-only either way.

Copilot loops default to YOLO. Copilot confirms tools, paths, and URLs separately, and the old tools-only default left unattended loops stalling at URL and path dialogs nobody was watching. The default is now Copilot's own --yolo; Settings names it in that vocabulary, with "Allow tools only" kept for attended use. A previously saved setting keeps meaning what it said — flip it in Settings → Sessions to adopt the new default.

New children are visible immediately. When a loop fans out, the sidebar now expands the new child's whole parent chain the moment it appears — no more hunting behind collapsed chevrons. Relaunch keeps whatever you had folded.

Sidebar groups fold. "Local Projects" and "Remote Repositories" are captioned headers now; click one to put the whole group away.

The self-improving loop release: cycles that carry what they learn between passes, measure their own progress, and stop honestly when they stop improving.

Every pass is announced. A fired hand-off types a message into its target's live terminal — "Cycle re-entry 2 of 5 — the stop condition is not yet met" — and edges can carry a payload (a note, or a script's output like the reviewer's diff). A still-open session now hears that its next pass started instead of idling while the graph says "running".

Every loop keeps a diary. An append-only memory log per loop: the daemon records facts (passes, resolutions, metric readings, messages staged while away), the agent records lessons via graphcode node memo. A relaunched session opens by reading a digest — round two starts smarter, not from scratch. Children are born with their first entry already written: the exact command for reporting back to their parent.

Measured by. A goal can carry a metric — a command whose last line is a number, plus which direction is better. The loop is handed it in its prompt so it can score itself as it works; the orchestrator independently samples the same command once per pass, so recorded numbers never come from self-report. Cycle guards can act on the trend: stop after N passes without improvement, ending as stalled — the honest word for "kept running, stopped getting better".

Loops can be re-instructed. graphcode node update edits a live loop — goal, predicate, poll/stall bounds, metric, model tier — without delete-and-recreate. One rule has teeth: a loop may not change its own stop condition.

Family rules for fan-out. Children run on their parent's backend (a Copilot loop spawns Copilot children), know how to report back, and die with their parent — stopping or deleting a coordinator takes its spawned descendants, sessions and all. Drawn edges are relationships, not custody: the other side of a maker–reviewer pair you drew is never caught in the cascade. Reports to a parent that already finished are staged into its memory instead of refused.

Also: graphcode node delete (the full teardown from the CLI), the metric and the plateau bound settable in the app's forms, graphcoded answering unknown commands instead of dropping the connection, and the first-launch install fixes stable users already have from v0.1.8.1.

The article grew a part on all of this: https://scgopi.github.io/GraphCode/

Killing a parent loop now takes its spawned children with it.

Stopping a coordinator left the workers it fanned out running headless — still spending, against a plan nobody owned anymore. The graph couldn't even express the cascade: parentage lived only in the already-fired edge drawn at creation, indistinguishable from any hand-drawn handoff.

Loops now record which loop created them, and stop/delete walk that custody chain transitively:

• Stop a parent → every unresolved spawned descendant stops with it: session terminated, its memory log told which parent took it down, downstream edges fired as failure. Children that already finished keep the ending they earned.
• Delete a parent → the whole fan-out tree goes: nodes, edges, sessions, memory.
• Drawn edges are not custody — stopping one side of a maker→critic pair you drew leaves the other side exactly as it was.

Custody is recorded from this version on: children created by earlier betas are grandfathered as independent loops.

Everything in beta4 (backend inheritance, the report-back route in each child's memory, staged delivery to non-live targets, node delete, metric-as-method, plateau in the edge editor) is unchanged.