A Cockpit Comes of Age: Elyra Conductor 0.5.0

Some releases are a single feature. This one is a threshold.

Version 0.5.0 closes the original idea list we started with back at 0.1.7 — and the feature that closes it is, fittingly, the one that points back at Conductor's whole reason for existing.

Let's start there, then take the long way home.

🤖 Send to Elyra: runbooks you can ask

Conductor has always had a clear identity: it's a host, not an agent. It runs your terminals, browses your databases, watches your ports, renders your runbooks — but it never reasons. The reasoning lives in Elyra, the actual AI agent, which Conductor simply hosts in a panel.

For a while, runbooks could do two things. They could be run — every shell block has a ▶ Run button that fires it in the project's terminal. And they could be linked — [[other-note]] jumps between notes, [[task:build]] runs a discovered task.

0.5.0 adds the third verb: runbooks can now be asked.

Every shell block grows a small 🤖 Elyra button (when the Elyra CLI is installed). Click it, and an agent panel opens with that snippet already waiting in the composer:

🤖 Elyra
┌────────────────────────────────────────────┐
│ ```                                        │
│ pg_dump -Fc app_prod | gzip > backup.gz    │
│ ```                                        │
│                                            │
│ ▏  ← your cursor, ready for the question   │
└────────────────────────────────────────────┘

You add the part only a human knows to ask — "is this safe to run against prod on a Friday?", "rewrite this to exclude the audit table", "what do the -Fc flags mean again?" — and hit enter. Elyra takes it from there.

The lovely part is what doesn't happen. Conductor doesn't interpret the command. It doesn't add a prompt. It doesn't phone an API. It hands Elyra a block of text and gets out of the way. The button is pure plumbing — a courier, not a thinker. That's the whole architecture in one click: Conductor orchestrates, Elyra reasons.

Runbooks are now runnable, linkable, and askable. The triangle is complete.

How it's wired (the boring-on-purpose part)

The implementation is deliberately thin, because thin is the point. The agent panel already knew how to start with a question and auto-send it. For "Send to Elyra" we wanted the opposite: open the agent, drop the snippet into the composer, and stop — let the human steer.

So the panel learned a second mode: pre-fill, don't send. The runbook's Elyra button wraps the block in a fenced ``` and seeds a fresh agent's input with it. No prompt templates, no system messages, no cleverness. Just text, placed where you can edit it.

It's maybe forty lines across three files. The restraint is the feature.

The long way home: 0.1.7 → 0.5.0

A milestone deserves a look back. Conductor started as a terminal grid with a file tree. Here's the arc, told as the problems we kept running into:

• "Shift-enter should make a newline, not run the command." So terminals learned to speak the Kitty keyboard protocol, and tabs got ⌘1–9 and drag-to-reorder.

• "The window beachballs when I focus it." So git status collapsed to a single porcelain call behind a small worker pool — and focus became instant again.

• "I keep re-typing the same setup steps." So runbooks arrived: living .md notes with runnable blocks and links.

• "Just start the dev server already." So ⌘R became a universal project runner that knows your stack.

• "Tell me when the long build finishes." So finished-command notifications landed, with a sound.

• "I want to see my database without leaving the cockpit." So the database browser grew — and grew: MySQL, PostgreSQL, ClickHouse over native TCP, SQLite. Multiple connections per project. Editable cells. TLS. Excel and CSV export. Connection groups. Query history. Secrets in the macOS Keychain, never in a file.

• "It says the app is damaged." So we went all the way to Developer ID signing and Apple notarization — downloads now open with no scary dialog.

• "What's running on port 3000?" So a port dashboard and per-project health badges appeared in the sidebar.

• "I know I saw that error scroll by." So global scrollback search and pane navigation/zoom arrived.

• And finally: "I want to ask Elyra about this step." Which brings us to today.

Every one of those started as a small friction in a real day's work. None of them was a grand plan. The cockpit grew the way a workshop does — you add the hook where you keep reaching for the tool.

A pause to tidy

One more thing went into 0.5.0 that you'll never see: before cutting the milestone, we stopped and swept the floor. cargo fmt, a clean cargo clippy, every event listener checked for a matching cleanup, every fire-and-forget call guarded. No new behaviour — just the quiet confidence that the foundation is square before we build the next storey.

It felt right to reach a round number with the house in order.

What a milestone means

0.5.0 isn't "done" — software never is. But it's the moment the original sketch became a real thing. A local cockpit where your terminals, files, git, runbooks, ports, and databases all live in one window — and where, when you need to think, Elyra is one click away, fed by whatever you're looking at.

The boundary held the whole way: Conductor never grew a brain. It grew hands. And now those hands can pass a note to the one part of the system that's allowed to think.

Open a runbook, click 🤖 next to a step, and ask. The cockpit will hand it over. 🪵🔥

Elyra Conductor 0.5.0 — Send to Elyra from runbooks, capping a run that includes runbooks, a universal runner, a four-engine database browser, signing + notarization, a port dashboard, scrollback search, and per-project health. Signed and Apple-notarized. Conductor hosts, runs, and displays; it never reasons.