Klide v0.6.3 — Coordination and Documents

Two things the v0.6 line gained after the 0.6.2 cut. Runs can address each
other — Harness conversations and Delegate CLIs alike, through one Rust-owned
journal — and a Run can now produce a real document instead of describing one:
a spreadsheet it creates, recalculates and revises, and that Klide opens itself.

The v0.6 orchestration milestone is unchanged: Missions as outcomes, budgets,
capacity, capability routing and validation contracts are still open. The macOS
bundle is still ad-hoc signed rather than Apple-notarized. This is a patch cut
on the v0.6 line, not that milestone.

Agent coordination

• Runs talk to each other. A Rust-owned coordination journal
  (.klide/coordination/events.jsonl) gives every Plan/Goal Run a stable id,
  a state, and an inbox. Native Tools agent_list / agent_send /
  agent_wait / agent_cancel / agent_read_result let one conversation
  address another in the same Workspace; peers see thread titles, not raw ids.
  Another agent's words never reach a conversation unreviewed: the receiving
  side's operator gets the same inline card as a shell command, can welcome a
  peer for the rest of the run, and approval wakes an idle conversation with a
  no-text turn. Replies to a question the receiver itself asked skip the card.
  Delivered mail travels as a user turn labelled as agent mail, never as
  system. (PR #84, 2026-09-05.) Since 2026-09-10 every conversation with a
  Workspace is on the plane whatever its Mode or model: Chat carries the
  coordination tools and nothing else, so a Chat thread can be asked something
  and answer it.
• Delegate CLIs are on the same plane. Claude Code, Codex and OpenCode
  sessions Klide launches now carry Klide's embedded MCP server
  (klide mcp coordination, same binary as the app) and see the same five
  operations as MCP tools — agent_list, agent_send, agent_wait,
  agent_read_result, plus agent_publish_result since a CLI has to say when
  it is done. The MCP child owns nothing: every call is relayed over loopback
  to a bridge in the app that binds the caller's Run id and Workspace from the
  PTY session it was spawned with, so no tool argument can speak as another
  agent or reach another journal. A Delegate registers as a delegate Run at
  spawn (its conversation id, the same id the panel uses), its status hooks
  move its state (working / blocked / waiting), and process exit settles
  it (done / failed / cancelled). Mail addressed to a Delegate shows the
  same review card in its panel; the CLI reads approved mail when it calls
  agent_wait — pull, not push, because Klide owns no turn boundary inside a
  foreign CLI. Focus conversations on a Delegate get the same tools: the
  Harness hands each headless turn the wiring, and the turn's process acts as
  the conversation's Run. A Klide restart no longer costs a running CLI its
  agent tools: the MCP server is told where to find the bridge rather than a
  port, and the bridge rebuilds a session it never bound from that session's
  spawn record. Per-CLI wiring: Claude Code --mcp-config <per-session file>,
  Codex -c mcp_servers.klide.* overrides, OpenCode OPENCODE_CONFIG; Oh My
  Pi and custom CLIs run unchanged.

Documents

• A run makes a real workbook, and the app opens it. Asking for a budget
  used to end at a shell with no Excel in it. Two native Tools close that:
  write_spreadsheet creates or patches an .xlsx — IronCalc recalculates, a
  formula error blocks the save, and the exported bytes are produced before the
  change is ever proposed — and the read-only inspect_spreadsheet returns
  paginated cells, formulas, results, errors and the hash an update has to
  present. A create never overwrites; an update rechecks the exact bytes at
  apply time. Neither Tool needs a shell, an Excel install, or the network.
• Workbook bytes ride the write path that already exists. DiffProposal
  carries an optional binary payload beside its readable cell diff, so a
  workbook goes through the same approval, the same rejection memory and the
  same checkpoint as any other edit; rollback restores the original bytes and
  refuses when the file has moved on since. A repeated edit that leaves Git
  status unchanged is still announced, so the second revision of a workbook
  does not quietly drop out of the evidence.
• .xlsx and .sheet.json open in Klide. A built-in sheet surface —
  worksheet tabs, formula bar, keyboard navigation, paste, undo — loads lazily
  behind its own vendor-spreadsheet chunk that the entry never preloads.
  Add to chat hands a cell's reference, input and calculated value to the
  focused composer without sending a message. This is local recalculation of
  common formulas, not Excel parity: charts, pivots, macros and full layout
  fidelity are out, and the limits are written down in
  src/spreadsheets/README.md.
• A completion card lists documents, not only artifacts. A workbook written
  by an ordinary edit tool keeps its change evidence and still appears as
  something to open, and agent_run_document_references recovers files an older
  transcript only mentions — opened from where they actually live, and never
  claimed as an edit the run made.

Klide v0.6.2 — Memory, Routing, Recovery

Hardening after the 0.6.1 cut. Project Memory becomes a Harness capability
rather than a panel, the Harness starts choosing its own model and its own
reasoning level, and a run that loses its view — a reload, a panel switch, an
app restart, a CLI that never announced itself — now heals from what was
written down instead of reading as stuck. The v0.6 orchestration milestone
itself is still open: Missions as outcomes, budgets, capacity, capability
routing and validation contracts are unchanged. The macOS bundle is still
ad-hoc signed and not Apple-notarized.

Project Memory

• Project Memory is now a native Harness capability. Durable entries use a
  versioned schema with kinds, review state, tags, source references, and
  supersession. Plan and Goal runs can call memory_search and memory_read;
  deterministic offline ranking returns match reasons and provenance, normal
  recall excludes stale/superseded knowledge, and the Transcript stamps both
  Tools with read_project_memory instead of pretending they read Workspace
  files. Markdown remains the local source of truth; no external provider or
  network service is involved.

Harness

• A model's reasoning levels come from the CLI, not from a list Klide keeps.
  Every picker offered the same five levels — minimal, low, medium, high, xhigh
  — to every model. For a Codex run that was wrong twice over: gpt-6-astra
  publishes low, medium, high, xhigh, max and ultra, and no minimal at all,
  so Klide showed a level the CLI rejects and hid two it has. Worse, the level
  a Codex run was given went nowhere — it was saved into harness settings,
  which only the Klide-wire adapters read. The set is now a backend fact per
  provider and model, read from the Codex CLI's own model manifest for a Codex
  run and from the provider registry for a wire run, and a CLI with no such
  switch shows no dial at all. The choice reaches Codex as a -c model_reasoning_effort= override for that launch, leaving the user's
  config.toml alone. A level saved against another model reads as Auto
  instead of being sent, and the legacy max→xhigh rewrite now runs only
  where max was merely an old name for it: a Codex max sits one step above
  xhigh, and folding it would have quietly run the task weaker than asked.

• Auto picks the model. A new Auto Provider at the top of every picker
  leaves the choice to the Harness. At run start Rust rules out what cannot do
  the job — no API key, local server down, no tool support when the Mode needs
  tools, a context window the prompt won't fit — then takes the user's starred
  models cheapest-first, falling back to what Ollama has installed. The pick is
  locked for the conversation (a continuation reuses its transcript's origin,
  never re-routes), RunStarted carries the resolved pair so every surface
  shows what actually ran, and a new RouteResolved Transcript line records
  the reason plus every candidate ranked above it and why it lost. Delegate
  CLIs are never candidates. Deterministic, no classifier, no network beyond
  the probes it already had. See docs/MODEL_ROUTING.md.

• A huge tool output is retained on disk, not carried in context. A tool
  result over 20 KB is written once to <runs>/<run id>.values/<call id>.txt
  and the provider sees a [retained #id] stub with a head-and-tail preview
  instead of the full text. A new peek_value tool reads numbered line ranges
  (up to 400 per call) or searches the stored text by substring; its output is
  capped at 16 KB, below the retention threshold by construction, so a peek can
  never itself be retained. The Transcript keeps the full result, so Mission
  Control and the UI show everything, and both replay shapes rebuild the
  identical stub from the Transcript — a resume sees exactly what the live turn
  saw, and a stub only ever points at a file that exists. If the disk write
  fails the result stays in context verbatim. Value files land owner-only like
  transcripts, and travel with the run when the runs folder moves. Compaction
  remains the second line of defense; a retained result is no longer lost when
  it runs. (Prime Agent, arXiv 2608.23552.)

• The command gate can be waived per conversation. A Goal run dispatched
  with autoApproveCommands executes run_command as if allowlisted — even
  over a rejection remembered earlier in the run, since escalating is the
  override. The waiver is chosen per conversation and never persisted (every
  panel reverts to prompting on reload); network targets, Mission attempts,
  and subagent runs keep the normal gate.

• "Validate all" on the diff card covers the rest of the run. The apply
  decision can carry scope: "run": the pending edit applies, every later
  edit of the live run auto-applies without pausing (still proposed and
  checkpointed), and the conversation's policy flips to auto-accept so later
  turns arrive already reviewing nothing.

• A run near its turn cap finishes instead of stopping. Three turns short
  of the cap the model is steered to stop exploring and save what it has; on
  the final turn the harness withholds the tool schemas, so the only reply it
  can produce is a written one. Both steps ride the steering seam and land in
  the transcript, so a run that answers ends Done — no more max_turns
  error on work that was one sentence from finished.

• A turn that reasons itself empty gets another try. A reasoning model can
  spend its whole reply budget in the private reasoning channel and return a
  successful turn with no answer and no tool call. That turn is now dropped
  from the provider history and resampled at half the budget, instead of the
  run settling Done having said nothing under a notice blaming the wrong
  number (num_ctx, when what ran out was the reply budget).

• A truncated command keeps its verdict. Long tool output now keeps both
  ends and gives up the middle — a test run states its result in its last
  three lines, and the old head-only cut removed precisely the lines the
  command was run for. web_fetch stays head-only on purpose: a page's tail
  is footer, not verdict.

• The agent can search previous conversations. A read-only
  search_conversations tool (Plan and Goal modes) ranks matches from prior
  Harness conversations in the current workspace, excluding the current run
  and its children.

• MLX keeps its prompt cache. TODO snapshots append on change instead of
  rewriting an early system message, so the reusable prompt prefix — file
  contents included — survives across turns; future MLX-LM launches get a
  1 GB --prompt-cache-bytes budget so retained prefixes can't grow without
  bound. Synthetic replay measured first streamed delta dropping from ~3.8 s
  to ~0.6 s.

Delegate runs and Mission Control

• Terminals no longer paint � across a read boundary. A PTY read can end
  in the middle of a multi-byte character — an accent, a box-drawing line, an
  emoji in a spinner — and decoding each read alone replaced both halves.
  pty_frame.rs holds the incomplete tail back for the next read, in both the
  Delegate PTY and the shell terminal, and the scrollback ring trims to a
  character boundary so a replay never opens on half a glyph.
• Historical delegate runs settle. Lifecycle state is inferred from each
  CLI's own turn markers (Claude Code, Codex, OpenCode, omp) instead of
  transcript recency alone; Klide-hosted PTY hook and exit state join onto
  that history, and provider session ids persist into scrollback metadata so
  blocked/completed/failed/interrupted survive startup races and app
  restarts. This closes the v0.5.1 lifecycle item.
• A replayed tool call says what it did. The transcript now carries a
  delegate call's arguments and its result (bounded on the way in — read_run
  streams instead of slurping 90 MB files), so reopening a Claude Code session
  shows the same rows a live turn draws instead of eight rows reading "Bash".
  Every replayed delegate result says which CLI produced it: Klide applied no
  capability, permission prompt, or diff review to it.
• A resume lands where you are looking. Mission Control admissions reuse
  the panel a one-slot surface (Focus, anchored, grid) is already showing
  instead of appending an invisible one. "Resume in Claude Code" moves to the
  workbench, where the interactive session can actually render; a new
  "Continue in Focus" turns the run's transcript into a Klide thread pinned to
  the same agent and runs the CLI headless with the history folded in. The
  detail pane's three continue actions each say what they do.

Conversation view

• Each step of the plan carries its own history. The todo strip above the
  composer numbers its steps instead of drawing hollow dots: a pending step
  shows its number in mono, the step in hand wears a thin accent arc sweeping
  around it, a finished step closes to the check. Click a row and what
  happened to that step drops down on the same thread — Planned, Reworded with
  the earlier wording, Reopened, Done in 34s — as offsets from the start of
  the plan. The active row counts up live in the same figures the Working row
  uses, a finished row keeps its span, and a step that was ticked and reopened
  says "2nd try". The fold from the store's mutation log to a per-step timeline
  is a pure module (src/todoHistory.ts) with its own tests; the strip stays a
  view. No new data: the Rust store already recorded every mutation.

• The + menu picks the Mode; the foot bar decides the Goal policy. The
  menu is back to three rows — Chat / Plan / Goal — and the policy (reviewing
  edits · auto-accept edits · full auto) became a standing note beside the
  branch in the conversation foot bar: one click cycles to the next, the
  label morphing in on the soft curve. Review wears the branch label's
  monochrome; a silenced gate wears the accent so it never reads as default.
  T...

Klide v0.6.1 — Subscriptions and Reach

Klide 0.6.1 — Subscriptions and Reach

Every agent visible. Every change reviewable.

This is the current release on the v0.6 line, and it supersedes v0.5.0 as the download.
Read What is still open below before you rely on it: the v0.6 orchestration
milestone is not delivered here, and the macOS bundle is still not Apple-notarized.

Highlights

• Your subscription runs in Focus. Claude Code, Codex, OpenCode, and Oh My Pi were filtered out of the Focus picker, which left the chat-first surface able to run only what an API key could reach. Pick one now and it starts a Focus conversation authenticated by its own CLI login — no key anywhere in Klide.
• A delegate shows its work. Klide asks Claude Code for stream-json instead of plain text, so the CLI's own Read / Edit / Bash steps render as tool rows in Klide's design, streaming token by token. They arrive as a separate observed_tool_call pair and every row says via Claude Code — Klide dispatched none of them, so validation can never mistake a delegate's Bash for a command Klide verified.
• Around forty more providers, through one gateway. Klide can run the opencodex proxy (ocx) as a managed localhost server registered as a single self-hosted endpoint, putting ~40 upstreams — API-key or OAuth — behind the normal model picker and the full Rust tool loop. No fourth wire adapter: the proxy speaks the OpenAI wire the custom-provider store already drives. Starting it no longer hijacks the Codex CLI.
• Subagents belong to the harness. spawn_subagent used to park in Rust while the AI panel ran the child, so closing the panel mid-subagent lost the report. Rust now owns the role, the child prompt, and reading the report from the child's durable transcript — a subagent survives a panel unmount, a reload, and a reattach.
• Durability hardening from the 2026-08-04 architecture review: the Transcript is now as durable as the Mission log (atomic replace + flushed appends through one module), and validation no longer misreports allowlisted command tools.
• One sidebar, one icon vocabulary. The rails, menus, and Focus shell were consolidated: Phosphor Light behind a single Icon primitive, the shell docked under the Focus canvas so run subscriptions keep streaming while you shell, and a sage theme pass including the dark-mode comment colour.
• GitHub identity is pinned. Klide applies the account from ~/.klide/github_account.json per command; it never follows or mutates gh's global active account.

The full list is in the changelog.

What is still open

The v0.6 milestone itself — Missions as outcomes, visible budget and capacity, capability-based routing, automatic validation contracts, durable background execution — is not delivered here. budgetLedger.ts and capacityPlanner.ts exist as models but are not yet in the dispatch path. Klide remains under active development: expect the orchestration surfaces to change shape before v0.6 proper.

Download

Klide_0.6.1_aarch64.app.zip is an Apple Silicon macOS build.

This release is ad-hoc signed and not Apple-notarized. On first launch, macOS may say the developer cannot be verified. Unzip the archive, move Klide.app to Applications, then Control-click the app, choose Open, and confirm Open. Only install builds downloaded from this repository.

SHA-256: c27a75b70b63528dbd7eaa7d50a4352a55541b2fa50782a3576df0f3cc15533e

Requirements

• macOS on Apple Silicon.
• Optional: Ollama or MLX for local inference.
• Optional: Claude Code, Codex, OpenCode, or OMP for delegate sessions.
• Optional: npm install -g @bitkyc08/opencodex for the provider gateway.

Klide v0.5.0 — Agent Operations

Klide 0.5.0 — Agent Operations

Every agent visible. Every change reviewable.

Highlights

• Mission Control for Klide Harness runs and Claude Code, Codex, OpenCode, and OMP delegates.
• Same-task agent races in isolated Git worktrees with side-by-side evidence comparison.
• Diff review, line feedback, command permissions, checkpoints, validation evidence, and evidence export.
• Git and pull-request workbench, persistent delegate scrollback, reviewed Project Memory, skills, subagents, mission chaining, and advisor escalation.
• Local inference through Ollama and MLX, plus hosted and OpenAI-compatible providers.

Download

Klide_0.5.0_aarch64.app.zip is an Apple Silicon macOS build.

This release is ad-hoc signed and not Apple-notarized. On first launch, macOS may say the developer cannot be verified. Unzip the archive, move Klide.app to Applications, then Control-click the app, choose Open, and confirm Open. Only install builds downloaded from this repository.

SHA-256: 76a9e37c1c9799d215bed478f55827ec61641a1ad759c127ce6d86e9bf98c558

Requirements

• macOS on Apple Silicon.
• Optional: Ollama or MLX for local inference.
• Optional: Claude Code, Codex, OpenCode, or OMP for delegate sessions.

Klide remains under active development. Please report defects through GitHub Issues.