v2.18.0

Release notes for orun v2.18.0.

This release makes the Orun Cloud path one step to onboard and the default to run. orun auth login now authenticates and links the current repo in a single command; orun run --remote-state self-heals an unlinked repo instead of dead-ending; and run coordination flows over a new native, event-sourced wire that adds memoized cache hits and an event-driven status --watch. Publishing the service catalog also gets effortless — orun plan --push-catalog and an opt-in auto-sync — and the README is reframed around the intent-compiler philosophy.

Highlights

• One-step onboarding. orun auth login logs in and auto-links the current repo in the same command — the old "login, then orun cloud link" two-step is gone. If you belong to several orgs, pass --org <slug>; brand-new accounts get a personal org materialized on first link, so there is no dead-end before your first run. --no-link keeps login-only behavior.
• orun run --remote-state self-heals. A logged-in run against an unlinked repo now links the repo on the fly and proceeds, instead of failing with "repo not linked". Disambiguate with --org / --project (or ORUN_ORG / ORUN_PROJECT) when you belong to several.
• Native event-sourced coordination (default). orun run now drives claim / heartbeat / complete and the runnable frontier over the native v2 event-sourced wire. The legacy OP2 relational path is decommissioned; ORUN_COORDINATION=legacy is a temporary escape hatch.
• Memoized cache hits, surfaced. When the backend resolves a prior result for a job's inputs, orun run prints a ✓ memoized … — cache hit, skipped execution line and skips the work instead of re-running it.
• Event-driven status --watch. orun status --watch now long-polls the run's native event stream (up to 15s per wait) and re-renders the instant an event lands, rather than re-polling on a fixed timer. Backends without the stream fall back to interval polling unchanged.
• Effortless catalog publishing. orun plan --push-catalog publishes the just-resolved catalog after planning, and an opt-in autopushCatalog does it automatically on the clean default branch — debounced, best-effort, and never failing the plan. Pushes are also faster (parallel uploads, batched presence scan, unchanged re-push short-circuit) and fail fast and clean when logged out.
• Faster remote state. The state client now uses HTTP/2 and a sized connection pool, cutting latency on coordination, log, and status calls.

One-step cloud onboarding

The Orun Cloud path now has a single front door. orun auth login authenticates and links the current repo:

orun auth login                       # browser login + auto-link this repo
orun auth login --device              # headless device login + auto-link
orun auth login --org acme            # choose the org when you belong to several
orun auth login --no-link             # authenticate only; don't link

After login you'll see the link result inline:

✓ linked this repo → acme/my-service

What auto-link does, by situation:

Situation	Behavior
No git remote	No-op — prints no git remote here — run orun auth login inside a repo to link it
Already linked	Reuses the cached link (✓ already linked this repo → …)
One org, unambiguous	Links automatically
Several orgs, interactive	Prompts once
Several orgs, non-interactive	Errors and asks for --org <slug>
No orgs at all	Materializes a personal org (✓ created your personal org <slug>) and links
OSS / local backend	Short-circuits to the fixed _local/_local scope

orun cloud link still exists for explicit or scripted linking, but it is no longer the command you reach for first. The unlinked-repo and orun auth status messaging now leads with orun auth login, and orun cloud status labels the link as Repo rather than Project. See orun auth and orun cloud.

Backend URL from intent.yaml

orun auth and orun cloud now resolve the backend URL from execution.state.backendUrl in intent.yaml, so a repo that already declares its backend for remote-state runs doesn't need --backend-url on every auth/cloud command. Precedence is unchanged: --backend-url → ORUN_BACKEND_URL → intent.yaml → ~/.orun/config.yaml.

Native, event-sourced run coordination

orun run now coordinates against the backend over a native v2 event-sourced wire. Claim, heartbeat, complete, and the runnable-frontier read all flow through the event log (the same reduction the server runs); run creation, logs, and read-model loads still use the existing REST endpoints. The legacy OP2 relational coordination path is decommissioned.

# Native v2 coordination is the default
orun run --remote-state

# Temporary escape hatch back to the legacy path
ORUN_COORDINATION=legacy orun run --remote-state

Memoized cache hits

When a job's inputs match a result the backend already has, the run adopts that result instead of re-executing — and now says so:

✓ memoized api@prod.build — cache hit, skipped execution (a1b2c3d4e5f6)

The adoption was previously silent; the line makes a cache hit visible so you can tell a skipped-because-memoized job from a skipped-because-filtered one.

Event-driven status --watch

orun status --watch no longer re-renders on a fixed 1-second timer. It long-polls the run's native event stream — each wait blocks up to 15 seconds and returns the instant a new event lands, then re-renders. A lapsed wait still refreshes as a liveness heartbeat, and watch now also stops on a canceled run (previously only completed / failed). Backends that don't expose the event stream (e.g. the legacy path) fall back to interval polling, unchanged. See orun status.

Effortless catalog publishing

Two new ways to keep the org-global catalog current, on top of the existing orun catalog push / orun catalog refresh --push:

orun plan --push-catalog          # plan, then publish the resolved catalog + advance the head

--push-catalog is explicit and fail-loud — it errors if the push fails, just like catalog refresh --push. It requires a configured backend and conflicts with --no-catalog-refresh (there's nothing fresh to push).

For hands-off publishing, opt in to auto-sync and a successful orun plan best-effort publishes the catalog for you:

# intent.yaml — repo-level, team-wide
execution:
  state:
    autopushCatalog: true

# ~/.orun/config.yaml — user-level, personal
cloud:
  catalog:
    autopush: true

Either setting enables it. Auto-sync runs under tight guardrails so it never publishes from a non-canonical state:

• Default branch only, on a clean tree — feature branches, dirty trees, PRs, tags, and non-git checkouts are skipped.
• Debounced by catalog digest — an unchanged catalog is a no-op (no network).
• Best-effort — logged-out / unlinked / unreachable backends are swallowed (silent unless ORUN_VERBOSE); the plan's exit code is never affected.
• Time-bounded so a slow backend can't stall the plan.

A successful push prints a banner (publishing is team-visible). For explicit, fail-loud publishing, use orun plan --push-catalog or orun catalog refresh --push. See orun plan and configuration.

Faster, cleaner pushes

Catalog pushes — explicit or auto-sync — now upload missing objects in parallel, batch the presence scan, and short-circuit an unchanged re-push, so re-publishing a catalog the server already has transfers ~zero bytes near-instantly. Pushing while logged out now fails fast and clean with an actionable error instead of a raw sync failure.

Faster remote state

The remote state client now enables HTTP/2 and a sized connection pool, reducing latency and improving throughput across coordination events, log streaming, and status queries.

Also in this release

• README reframed around the intent compiler. The README now leads with the intent-compiler philosophy: orun has one kind of input — intent, wearing three hats (platform, component, golden-path) — and compiles it into a single deterministic platform state that converges the deviation on every commit. All install / usage / command-reference content is preserved.

References

• orun auth — login + auto-link, --org, --no-link.
• orun cloud — repo ↔ org link, repo-first vocabulary.
• orun run — auto-link, --org / --project, native v2 coordination + the ORUN_COORDINATION=legacy escape hatch, memoized cache hits.
• orun status — event-driven --watch.
• orun plan — --push-catalog and autopushCatalog.
• Configuration — execution.state (backendUrl, autopushCatalog) and cloud.catalog.autopush.