Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
183 KB
Raw Blame

Changelog

Notable changes per release, newest first. Some releases also have longer narrative notes under docs/releases/, graff --version prints a short what's-new, and the releases page has the full commit history for every tag.

The release workflow uses a tag's section here as its release notes (a hand-written docs/releases/<tag>.md wins if present), so keeping this file current is part of cutting a release.

v0.302.74.1

  • A provider or model switch expands opaque compaction state from its exact checkpoint instead of replaying it to a seat that did not mint it. Switches after compaction no longer fail against ciphertext the new backend cannot decrypt, and the conversation after the window is kept (#1829, ADR 0317). Sessions with no checkpoint still stop once with history unchanged.

v0.302.74

  • Rejected encrypted compaction state can recover from a private pre-compaction checkpoint without losing later conversation. New server compactions retain exact input before replacing it; unavailable or invalid checkpoints leave history unchanged (#1822, ADR 0316).
  • Short TLS-construction outages receive a longer bounded recovery window. Ordinary network retries, cancellation and certificate verification remain unchanged.

v0.302.73

  • ACP clients can mark explicitly selected commands with per-prompt intent metadata. Literal slash-prefixed prose now reaches the agent instead of being consumed as a command, including goal, review, issue, loop and side-request expansion. Clients that omit the marker retain their existing command syntax (#1817, ADR 0315).

v0.302.72

  • Compaction recovery now retries rejected encrypted state once with the full compacted window when the failed request used a chain. If the rejection persists, graff stops instead of repeatedly resending the same state, preserves history, and explains how to recover (#1823).

v0.302.71

  • Computer use on macOS is now nanocua, an app graff ships. Signed macOS releases carry nanocua.app beside graff, and install.sh and graff update place it in ~/Applications. graff offers it as an MCP server below every config file, so your own nanocua entry wins and graff mcp disable nanocua turns it off (#1816).
  • graff computer and /computer: see what's on, stop every agent at once, turn a switch off, ask to turn one on, or open macOS's permission prompts. Turning something on only asks: a real click in nanocua's window answers it (#1816).
  • graff no longer loads Codex's computer-use and unified-computer-use plugins, and the adapter behind them is gone. graff shows no forms, so every MCP elicitation is now declined (#1815).
  • Retains all changes from v0.302.70.

v0.302.70

  • Claude Agent: a reply the model starts while graff refreshes its tool list arrives whole. graff dropped what Claude Code sent during the re-list, so the reply lost its start and the turn failed with "unparseable response" (#1804).
  • A turn that ends after the provider returns empty replies 6 times in a row now says so over ACP: the turn stopped, the conversation is kept, and sending again retries. It used to end with a bare EmptyCompletion (#1802).
  • Simulator tests no longer overwrite the Mac's clipboard. With the Simulator app open and Edit > Automatically Sync Pasteboard on, a command that runs simulator tests (xcodebuild test, xctest) or writes a simulator pasteboard (simctl pbcopy/pbsync) is refused with steps to fix it. graff never changes the setting or touches the clipboard; GRAFF_ALLOW_SIM_PASTEBOARD=1 turns the check off (#1801).
  • Large request bodies are no longer cut off while they are still uploading. Connecting, uploading and waiting for the response each have their own time limit; the upload limit grows with the body and follows its progress, and a peer that stops reading still fails (#1785).
  • An ACP chat that was loaded or forked is a peer under its own session id, so mail addressed to it reaches it (#1803).
  • Retains all changes from v0.302.69.

v0.302.69

  • Reading peer mail no longer rewrites history the model was already sent: only wake lines it was never sent are removed. On Claude Agent every woken turn used to start a fresh Claude Code process; on other providers the cached prefix changed after each inbox read (#1799).
  • graff login kimi signs international accounts in on kimi.ai and mainland China accounts on kimi.com (from the saved login, or clock and locale); graff login kimi.ai|kimi.com choose outright and refresh returns to the issuing site. Sign-in links are copied to the clipboard, over SSH too, and no browser opens where it can't be seen (#1733).
  • OpenAI Responses GPT-5.6+: GRAFF_OPENAI_CACHE_TTL=12h / openai_cache_ttl puts a 12-hour breakpoint on the stable prefix; the default stays 30m until a live probe confirms it. Usage parses cache writes by TTL (#1698, ADR 0312).
  • Workers can use gateway models and name their own provider: --subagent-model with --subagent-provider codegraff accepts a gateway model the built-in catalog does not list, a persona's model: <provider>/<model> pin runs on that provider, and its calls report cost (#1769).
  • graff harness-tree show|digest|check|apply|diff reads the instruction file, skills, subagents, scripts and hooks graff loads as one tree (#1770).
  • MCP over HTTP retries a cancel notice when local ports run out (#1796, #1794).
  • ADR 0308: a cheaper scout worker is an opt-in persona, not a default route (#1771).
  • The tier-2 review-checkpoint case reads a different file each call, so the identical-call guard no longer ends it (#1722).
  • Retains all changes from v0.302.68.

v0.302.68

  • Claude Agent compaction sends its summary request as the request. Cut mid tool loop, the request was folded into the conversation checkpoint and followed by "Continue from where the checkpoint ends.", so in a long chat the model carried on with the task or asked a question, and that reply was installed as the summary (#1792, #1793, #1797).
  • Claude Agent: a prompt sent after a turn that ended on a tool call keeps its text and images instead of joining the checkpoint as text (#1792, #1793).
  • Retains all changes from v0.302.67.

v0.302.67

  • Claude Agent refreshes a changed tool list in place. Removing and re-adding graff's tools (to make Claude Code re-read them) failed the load_tool_schemas call that caused the change with "Connection closed", and the model often ended its turn or got "No such tool available"; graff now sends tools/list_changed and keeps the connection (#1789, ADR 0311).
  • A turn started by unread peer mail has peer_message loaded with its first request (#1789).
  • A task that ended with attempt_completion still hears mail addressed to it, as a task that ended with an ordinary answer does; room mail still waits for the next prompt (#1789).
  • Retains all changes from v0.302.66.

v0.302.66

  • A one-shot (-p) answer built on the provider's hosted search is kept. Hosted search runs inside the model call and never counted as a local tool call, so graff took a search-backed answer for a described change, printed "[described a change with no tool call — asking once more]", and the follow-up reply replaced the answer (#1786, #1787).
  • Retains all changes from v0.302.65.

v0.302.65

  • Claude Agent models report and use their 1M context window. Claude Code runs the current Claude models at 1M natively, but graff listed every claude-agent model at 200k, so it compacted at a fifth of the window and clients showed "200k context". A <id>[1m] name now resolves to 1M as well (#1783).
  • Retains all changes from v0.302.64.

v0.302.64

  • An expired Anthropic Console sign-in that can't be renewed is skipped instead of sent. With no refresh token stored, ant auth print-credentials exits 0 and prints the same expired token; graff took that as a refresh, so the dead token was used (or kept as the fallback behind a Claude plan) and every request came back 401. Errors now say "Anthropic Console sign-in has expired: run graff login console again", including after a plan handoff, and a spent plan whose fallback was skipped says why (#1781, ADR 0310).
  • Retains all changes from v0.302.63.

v0.302.63

  • An authentication failure names the credential that was rejected. A sign-in says " sign-in was rejected: sign in again ()"; an API key says " API key was rejected (): replace or remove the key. Your sign-in is not affected."; and a key graff fell back to after a plan ran out says " plan is out of usage, and the fallback API key was rejected ()". Before, every case read "provider authentication failed: sign in again or check the API key", so a client showed "Log in" when the key was the problem (#1779, ADR 0310).
  • Over ACP a rejected key carries {"kind":"api_key_rejected","provider":"<id>"} (v1 error data on -32603; v2 _meta["graff/recovery"]), so clients can offer "Update key" instead of a sign-in. reauth_required is unchanged.
  • Retains all changes from v0.302.62.

v0.302.62

  • rlm's llm_query works on Claude Agent. Each sub-query runs on its own short-lived, tools-off claude process, the way titles and recaps do, so the chat's claude process and its prompt cache carry on untouched. Before, it answered "llm_query is not available on Claude Agent" (#1777, ADR 0309).
  • Retains all changes from v0.302.61.

v0.302.61

  • Claude Agent: Claude models through your own Claude Code (claude) and its login. Sign in with graff login claude-agent (or /login claude-agent); graff checks claude auth status, never reads Claude Code's credentials, and runs your installed claude with graff's tools, prompt, history and loop. Calls are flat-rate on a Claude plan (#1773, ADR 0309).
  • Once chosen it is your Claude plan: /model lists claude-opus-5-5, claude-fable-5-1, claude-sonnet-5-5 and claude-haiku-5-5 under Claude Agent, and those names route to it. anthropic/<model> still reaches the API route (#1774).
  • Without a terminal (a client such as the desktop app), graff login claude-agent says to run claude auth login instead of starting it.
  • Lean mode keeps agent_output once a subagent request loads it, so a turn that starts background workers can wait for them instead of ending early.
  • Catalog tests wait for the workers they abandon, which crashed the Linux test job with SIGIO (#1772).
  • Retains all changes from v0.302.60.

v0.302.60

  • A resumed session keeps the provider's count of its Responses compaction state. A restart no longer re-estimates that opaque state from its size, which could show the context meter far over 100% and force a compaction the session did not need. The count is saved with the session and reapplied only to the same state, provider and model (#1686).
  • The count is learned from chained (WebSocket) replies as well as full requests, so chatgpt-new sessions are counted during normal use.
  • WebSocket accepts events as large as SSE does (128 MiB). A large compaction item over WebSocket previously failed, retried, and fell back to SSE, re-running the turn each time.
  • GRAFF_CHATGPT_URL points chatgpt-new at a local mock for testing.
  • Retains all changes from v0.302.59.

v0.302.59

  • Large, steadily arriving SSE events no longer trigger false stream stalls or replay a request merely because the next newline has not arrived (#1765).
  • Genuine stalled streams still time out. Unfinished events have bounded assembly time and size, and local assembly-limit failures are not retried.
  • Retains all changes from v0.302.58.

v0.302.58

  • ACP startup and graff/models no longer wait on slow model-catalog requests. A cached catalog, fresh or stale, loads immediately and refreshes in the background; only a provider with no cache waits, at most 800ms in total. A cold DNS lookup or slow host can no longer make a client report that model discovery timed out. The Kimi account catalog is now cached for 6 hours.
  • note_constraint states its 240-byte limit in the tool description and the text field, so a model learns it before writing a rule rather than from a rejection (#1764).
  • Retains all changes from v0.302.57.

v0.302.57

  • Images are typed by their bytes rather than their file extension. A WebP saved as .png is sent as WebP, and a file that is not PNG, JPEG, GIF, or WebP is refused before it reaches the transcript instead of failing every later turn (#1762).
  • A turn that fails before any reply records the failure in history, so resending the same prompt makes a new request instead of being skipped as a duplicate. The boundary is saved with the session (#1729).
  • Streams that carry only an error event surface the provider's error type and message on every wire instead of being retried as truncated bodies; deterministic invalid-request errors are no longer retried (#748).
  • Checklist items the user withdrew or delegated can be marked cancelled with a required, visible reason, and the completion gate accepts them without counting them as verified. An ask_user answer counts as the user's scope change (#1520).
  • ACP clients receive session_info_update as soon as workspace use moves the session, with the new folder as _meta["graff/cwd"], so client-served tools can follow the switch within the same turn (#1737).
  • Retained workers remember the folder their checkpoint was saved under, so subagent_resume still finds it after a workspace switch; refusals now explain what happened and what to do (#1724).
  • The repeated-tool-call guard no longer counts polls of a background subagent that is still running (#1706).
  • Retains all changes from v0.302.56.

v0.302.56

  • Native file tools can follow dependency symlinks whose targets remain inside their selected tool root. Reads, directory listings, edits, and writes share the same confinement policy.
  • Escaping, dangling, and cyclic links remain denied. Missing ordinary paths remain available for new writes, and explicitly allowed extra roots keep their own boundaries.
  • Retains all changes from v0.302.55.

v0.302.55

  • Command-line help, release history, and bundled playbooks are compressed until requested, reducing duplicated runtime text without removing content or changing the build's safety settings.
  • Long home paths no longer prevent installation of the macOS background-launch shim.
  • Includes the quiet terminal startup and live thinking controls from v0.302.54, and retains all changes from v0.302.53.

v0.302.54

  • Normal terminal startup keeps background connection receipts and legacy-listener diagnostics behind GRAFF_REPL_DEBUG=1; boot timing stays behind GRAFF_BOOT_DEBUG=1. Explicit /mcp and graff servers inspection remains available, and listener ownership protections are unchanged.
  • Live thinking shows Ctrl+T collapse and Ctrl+T expand beside its header. Enable it with /thinking on; completed terminal scrollback remains read-only.
  • Retains all changes from v0.302.53.

v0.302.53

  • Embedded runtime resources are compressed, prompt variants share their common text, and optional tool catalogs are built on first use to keep release binaries smaller without changing their contents.
  • Release builds retain runtime safety checks while sharing library code more efficiently. Local learning remains available in development builds rather than being included in release binaries.
  • Routed requests use stable session affinity, and usage prices follow the router's published catalog.
  • Workflow synthesis preserves its tool catalog at the final report-only boundary while refusing further tool execution.
  • Retains all changes from v0.302.52.

v0.302.52

  • The terminal REPL has a clearer session strip, a subtle divider, and distinct styling for active and completed checklist items. The bare prompt, scrollback, and plain output remain intact; no native window or graphical toolkit is required.
  • Operational modes stay visible before workspace metadata when a terminal pane is narrow.
  • The line REPL uses a warm amber palette with cream text and muted status metadata.
  • Markdown emphasis renders in streamed replies and agent reports instead of leaving single-marker formatting literal.
  • /workers opens a read-only subagent browser with clickable rows, live activity, Markdown reports, and keyboard navigation. /agents still lists agent types.
  • Includes independent conversation forks for subagents and workflow fan-out, optional retained workers, and bounded workflow synthesis that preserves earlier findings.
  • Release binaries are built ReleaseSafe: an out-of-range index or overflow stops graff with a clear panic instead of silently corrupting state, and the stripped binaries are about 17-20% smaller.
  • graff learn is no longer part of the release binary, which is about 300 KB smaller for it; sessions no longer start background learning trials.
  • Release binaries are another 50-120 KB smaller: the MCP installer and two HTML pages ship gzipped, the sign-in page's images are WebP, and graff's own code on Windows drops its unwind tables like the other platforms.
  • Release binaries are about 100 KB smaller again: the system prompt's variants share one copy, subagent tool lists for gated sessions are built when first needed instead of compiled in, and the MCP task page ships gzipped.
  • Retains all changes from v0.302.51.

v0.302.51

  • Kimi works again with an API key or graff login kimi. Every Kimi request had been failing with network error: RstStream (or a 400 over HTTP/1.1) because graff sent a corrupted device-id header; graff no longer sends a device id or keeps ~/.kimi/device_id.
  • A used-up Kimi plan window (exceeded_current_quota_error) stops at once as a quota cap instead of being retried as throttling.
  • Retrying the same prompt after a connection failure works again, including after loading the failed conversation. Earlier work stays in history; reconnecting does not require a new chat.
  • Includes independent conversation forks for subagents and workflow fan-out (fork_from), with optional retained workers for later continuation.
  • Includes bounded workflow synthesis that returns earlier findings when the final report cannot complete.
  • Retains all changes from v0.302.50.

v0.302.48

  • oMLX is a built-in local provider (omlx, 127.0.0.1:8000). Set its key with graff key set omlx <key> or OMLX_API_KEY. graff models lists the models it serves, --model omlx starts on the first one, /effort is sent as reasoning_effort, and it is billed as local (#1695).
  • Live model catalogs read a max_model_len context window, which oMLX and vLLM-style servers report.
  • When a local server refuses the connection, the failed turn names its URL, so a stopped server is easy to spot.
  • Compaction state is counted by the provider's own measure after the first full request that carries it, so a large state blob no longer reads as far over the compaction point and compacts every turn (#1686).
  • Retains all changes from v0.302.47.

v0.302.47

  • When a compaction can't get the context under the compaction point, the next one waits for real growth instead of running on every step (#1686).
  • The shared-tree checkpoint covers every live peer at once and forgets exited ones, so a re-issued call goes through (#1622).
  • peer_message send takes fyi: true: an informational update stays in the inbox without waking the recipient, and the inbox no longer asks for a reply to everything (#1137).
  • A transient shell-handle reservation failure is retried and names its cause; only storage faults point at HOME's permissions (#1619).
  • --json mode pairs every model_call_started with a model_call_finished; a retried attempt closes with retried: true (#1665).
  • Retains all changes from v0.302.46.

v0.302.46

  • Images attached over ACP now reach the hosted default models; graff dropped them before the model saw them.
  • A worker that ran and reported keeps its report and usage when its state can't be saved for follow-ups, instead of coming back as only an error (#1671).
  • A cancel an ACP client marks as its own (_meta["graff/cancelSource"] = "client") ends the turn as stopped by the client, not as interrupted by the user (#1611).
  • Computer Use says that an app owned by a bare process can't be selected, so agents don't read the rejection as a failed launch.
  • Retains all changes from v0.302.45.

v0.302.45

  • Reports what graff kept out of the model's context (tool output kept in handle files, tokens freed by compaction, provider cache reads) on the ACP context meter as _meta["codegraff/savings"]; Harness shows it next to its context meter.
  • render_html now reports a page as saved and ready to open, never as displayed, and its description no longer promises inline display.
  • workspace use says project instructions follow the tree; the instructions update names the directory its file came from, and a switch is noticed even when both files match in size and time.
  • Retains all changes from v0.302.44.

v0.302.44

  • Adds an experimental Worker-native Zig/Wasm chat step with explicit host tools and remote sandbox cleanup.
  • Adds managed-device SDK sessions with persisted receipts, bounded reconnect and device event replay; prompt submissions are never automatically retried.
  • Adds a shared opt-in, metadata-only OTLP exporter for managed and Worker-native execution.
  • Ships SDK 0.5.0 with managed, tracing, Worker and sandbox entry points. Worker-native conversations do not yet have durable checkpoints; managed trace storage requires a separately deployed collector.
  • Retains all changes from v0.302.43.

v0.302.43

  • Uses the updated subscription context default instead of the older blanket cap, avoiding premature compaction.
  • Reports consistent context capacity through the model catalog and ACP usage updates; smaller catalog limits remain respected.
  • Retains all changes from v0.302.42.

v0.302.42

  • Keeps reasoning-only output-limit replies out of subsequent requests and saved history while preserving partial answers and valid tool-call reasoning.
  • Shows each subagent's resolved worker model in ACP activity, including fallback selections, without breaking older activity records.
  • Retains large-session loading, bounded MCP task deadlines, streamed progress, oversized tool results and parked-command outcomes.
  • Reports compaction failures without ending the session and bounds repeated runaway replies.
  • Integrates current main with the existing release fixes; release builds verify cached artifact restoration before packaging.

v0.302.41

  • Adds native subscription browser sign-in with shared CLI, REPL and ACP credential recovery; metered-key access remains separate.
  • Preserves independent MCP structured results, displays resource links and embedded text, and answers inbound pings during initialization and tool waits.
  • Gives loopback inference request-local deadline allowances without extending unrelated remote requests.
  • Adds repeatable isolated native-CLI fixture comparisons with explicit routing checks and separately labeled task subsets.
  • Retains all changes from v0.302.40 and current main.

v0.302.40

  • Integrates the pending stream recovery, claim inventory, workspace skills, stored conversation, MCP configuration, companion update and typed ACP sign-in recovery changes.
  • Preserves partial replies and unread tool results, secret-free configuration listings, and atomic installer replacement.
  • Hosted compaction remains explicitly opt-in; existing local-summary and provider-owned compaction defaults are unchanged.
  • Includes the unattended-run recovery and one-shot result contracts from the unpublished v0.302.39 draft.

See docs/releases/v0.302.40.md for the release summary.

v0.302.39

Unattended runs

  • Output limits continue with bounded recovery and incremental file writes; incomplete tool calls are never executed.
  • Empty replies retry with cancellable, jittered backoff. Account-limit and sign-in failures stop with distinct exit codes instead of wasting retries.
  • -p --output-format stream-json emits a session handle at startup and a final result with status, usage, cost completeness and checkpoint status. Forced budget landings report partial work, not completion.
  • Buffered generation gets request-local silence allowances, and raw MCP startup exceptions are debug-only. Recovery still uses session checkpoints, not exactly-once journal replay.

v0.302.38

Windows

  • graff finds programs on PATH the Windows way. Lookups split PATH on :, so on Windows (where the delimiter is ; and entries hold drive colons) they probed fragments of entries, and one that read as a network path cost seconds at every start before graff acp answered; a bare name also never matched the .exe, so the code-intelligence companion was never found. Lookups now split on the platform delimiter and try .exe, .cmd, .bat and .com (#1637).

v0.302.37

Sign-in

  • A returning ChatGPT sign-in no longer puts the saved ID token in the sign-in URL. The browser opener received that URL as a process argument any local process could read. The issued app id still skips the consent screen, and the URL is now always printed, so the sign-in for a headless machine can be opened on another computer (#1635).
  • A ChatGPT token renewal that comes back for a different account is refused and recorded, not used (#1635).

v0.302.36

Workspaces

  • New task worktrees honor the tool-neutral .agents/ setup. Each gitignored path .agents/linked lists becomes a symlink to the main checkout's copy, so a .env edited once is current in every worktree; tracked paths, .., globs and missing paths are skipped and nothing is moved or deleted. .agents/prepare runs from the new checkout when .graff/workspace.toml names no setup script. graff worktree create reports the linked count (#1633, ADR 0283).

v0.302.35

Hosted gateway

  • Gateway models are priced from the gateway's own catalog, which now publishes each model's rate. A model the gateway adds is priced on day one, and a changed rate bills correctly without a graff release; the baked snapshot stays the offline fallback (#1631).
  • graff models shows gateway models at the gateway's rate. It had looked them up by their direct-provider price, so many showed (unpriced) or the wrong number (#1631).

Models

  • --model on a model whose direct provider has no credential now also names the hosted route, --model codegraff/<model>, when the gateway serves it (#1630).
  • Flag errors say graff --help (#1631).

v0.302.34

Google Gemini

  • Signing in with a Gemini API key works again. The endpoint now rejects role-shaped history ("use step_list input format instead of turn_list"), so every request failed on its first message; graff now sends the prompt, image prompts, resumed sessions and compaction summaries as Interactions steps (#1628).
  • /effort minimal and none run as low: current Gemini models accept only low, medium and high.
  • Gemini 4 Argon is listed with its 1M context, its effort levels and its price, so the usage footer shows its cost.

Reliability

  • An in-stream timeout from the hosted gateway, which says to retry, now takes the server-error retry ladder instead of ending the turn (#1628).

v0.302.33

Claude

  • On the Anthropic API, a new repo reads graff's tools and instructions from the prompt cache instead of rewriting them. The system prompt goes as two blocks with the same text, and the cache breakpoint now ends before the project instructions and layout. The first session in a repo the cache had not seen wrote 1.2k cache tokens instead of 10.1k on Claude Sonnet 5.5, about half the session's cost (ADR 0282).

v0.302.32

ACP

  • A yield_turn handoff is delivered once. Clients showed the agent's closing message twice, and the handoff's tool row stayed "in progress" (#1615).
  • After /resume or --branch, the prompt result reports the save the session moved onto (_meta["graff/durableSessionId"]), so a client restoring after a restart loads the right conversation instead of failing with "Unknown session ID" (#1529).
  • graff acp login signs in instead of starting the ACP server, for clients that run ACP Terminal Auth's login argument after acp (#1601).
  • A client named t3-code… gets a profile: slash commands as the first prompt block, the client's working folder kept as given, a model option listing reachable models (#1603).

Sign-in

  • graff login anthropic works when no browser on this machine can finish it: driven by a client such as the desktop app, over SSH, or on a server without a display. It used to wait forever for a browser callback; it now has Anthropic's page show a code to paste back.

Installing and running

  • graff tui finds a client installed by the desktop app and, with none installed, offers to download and verify one (#1444).
  • The Linux MCP service unit is valid: its working directory was quoted, which systemd rejects (#1593).
  • When something stops graff with SIGTERM, graff names the sending process on stderr before exiting (#1596).

v0.302.31

ACP

  • Tool rows for tools whose only end is a finish event (peer_message, load_tool_schemas, todo_write) now get their completed or failed status. They stayed "in progress" in clients such as the desktop app. Ordinary tools still end once, on their result (#1600).

Updating

  • graff update works on Windows. It ran install.sh through /bin/sh, which Windows does not have, and failed with "could not launch installer". It now runs the release's install.ps1, which verifies the download and replaces the running graff.exe, also when graff runs inside PowerShell 7.
  • The Windows installer no longer reports "graff.exe did not start" after a successful install.
  • graff --help lists graff login anthropic.

v0.302.30

Releases are now tagged with three parts (v0.302.N). graff update treats v0.302.30 as newer than every v0.0.302.N.

MCP servers

  • Every configured MCP server now reports its state: ready, starts on first use, failed (with the server's own error), needs sign-in, off, or optional. graff mcp status [--json] reads it without starting anything, and /mcp shows the same rows inside a session. /mcp only suggests /mcp trust when consent is what's missing (#1606).
  • graff mcp reconnect <name>|--all and /mcp reconnect <name> run a fresh handshake and refresh the server's cached tool list. A failed reconnect shows the server's last stderr line.
  • graff mcp enable|disable <name> switch a server on or off without editing its config (kept in ~/.codegraff/mcp-state.json). Entries their own file marks "enabled": false are no longer started.
  • Fixed: servers that share a launcher command and differ only in cwd no longer advertise each other's tools; a server's env now adds to graff's environment instead of replacing it, so npx servers with an env var start; a transient start failure is retried once. The last failure is remembered until the server starts.
  • GRAFF_NO_BROWSER=1 makes graff mcp login print the sign-in URL instead of opening a browser.

Anthropic

  • graff login anthropic signs in with an Anthropic Console account through Anthropic's ant CLI, so requests bill to that account's API credits. graff reads the profile ant auth login writes, sends it as a Bearer token, and refreshes it through ant. An ANTHROPIC_API_KEY still wins (#1607).
  • Claude Haiku 5.5 replaces Claude Haiku 4.5 in the catalog: 1M-token context, long-context pricing above 100k prompt tokens, adaptive thinking and effort (#1608).

v0.0.302.29

Codegraff gateway

  • Streamed requests to the Codegraff gateway now carry graff's version (User-Agent: graff/<version>) as well. In v0.0.302.28 only the device and app reached the usage page for them.

v0.0.302.28

Codegraff gateway

  • Requests to the Codegraff gateway now say which graff build sent them (User-Agent: graff/<version>), which device they came from, and which app launched graff. The usage page on codegraff.com shows them on each request.
    • The device is the computer's hostname. A launcher can name it instead with GRAFF_DEVICE_NAME; the desktop app passes the name the computer has there.
    • The app comes from GRAFF_HOST_APP. The desktop app sets it to its own version.
    • GRAFF_CLIENT_TAGS=off sends neither the device nor the app. Other providers get none of these headers.

v0.0.302.27

Compaction

  • You can choose where automatic compaction starts, as a percent of the context window (default 80%, allowed 10-95%). The first of these that is set wins:
    • --compact-at PCT on the command line, or the SDKs' compactAt / compact_at option.
    • GRAFF_COMPACT_PCT. The desktop app passes its setting this way.
    • /compact-at PCT in a chat. It applies at once and is saved for the workspace. /compact-at alone shows the current point, and /compact-at default resets it.

v0.0.302.26

Desktop app and ACP

  • The reply to a compaction request no longer shows up in the chat. It is internal bookkeeping, and on its own it could read as the agent saying its terminal and file tools were unavailable.
  • An informational question no longer restarts the checklist of an earlier, unfinished task. The checklist is kept as it was.
  • A request to explain something and file an issue is no longer turned into a repository overview. Scope reminders say they are internal and never replace the user's request.
  • Switching a session to a model from another provider no longer starts a blank conversation when the original provider's sign-in or stored key was not loaded. When a saved session can't be restored, the error names the real cause instead of blaming the save.
  • A message sent while a blocking job wait is running is picked up at the next step, not after the job finishes (ADR 0262).
  • The final session save on exit no longer reads a freed workspace path.

Tools

  • The shared-tree checkpoint holds every file edit in a parallel batch, not just the first one.
  • gh pr checks --watch and similar finite watchers are waited on instead of being treated as servers.
  • A newer user message can cancel verification items left over from an earlier task.
  • write_file counts a file as read when it was read through a different spelling of its path.
  • rlm says why a projection or len() statement failed; a failed claim names its cause.
  • graff -p asks again after a text-only first answer only when the request asked for an action.

MCP

  • Computer-use tool calls send one _meta, so the first call no longer closes the connection.
  • A closed stdio server restarts on its next call (ADR 0270), and a closed service is reported the same way everywhere once its tools are withdrawn.
  • mcp_search_tools only searches; it no longer loads what it finds. Transcript messages are no longer slimmed down to their ids.

Issue reports

  • Agents search existing issues before reporting a harness bug, and every report opens with the graff and Harness versions it was seen on.

v0.0.302.25

Compaction (hotfix)

  • On the ChatGPT-plan sign-in, the OpenAI API and Codegraff's GPT models, a long session no longer compacts before every tool call. The context meter read the provider's encrypted compaction state as text, so a session anchored on it looked over the window on every step, and each compaction produced state of the same size (ADR 0259).
  • These routes now compact only with the provider's own compaction. A failed compaction reports the error instead of falling back to a local summary; GRAFF_SERVER_COMPACT=0 still opts out.

Hosted models

  • Fewer requests per task for one hosted model family: chained shell steps, no read-backs of a file just written, and the completion may share the final response (ADR 0256).
  • On the stateful hosted chat route, the project instructions and layout are sent once per conversation instead of with every request (ADR 0258).
  • An empty tool result is sent as "(no output)" on every wire, so one empty result no longer makes every later request in a hosted chat conversation fail.

MCP

  • A slimmed comment list keeps the issue its rows belong to, so results fetched in parallel say which issue they describe (ADR 0257).

v0.0.302.24

Codegraff sign-in

  • Models on the Codegraff sign-in that use the Messages wire now speak it natively instead of going through Chat Completions. Reasoning carries across turns, thinking summaries show, images inside tool results work, the longer cache lifetime applies, and long answers are no longer cut at the chat limit.

Goals

  • A goal set from the desktop app starts immediately, in the same turn — it no longer waits for the next prompt.
  • When the agent asks for missing input, unfinished work and its checklist survive the answer instead of completing early or restarting.

v0.0.302.23

Prompt caching

  • The ChatGPT-plan sign-in (chatgpt-new) caches the prompt again, for every model on it. graff sent the cache key in the request body but only sent the matching session_id header on the codex route, so this route's requests were not read from the cache. Both the HTTP and WebSocket requests now send session_id, set to the same value as the body's cache key; the Codex-only identity headers stay on codex.

v0.0.302.22

Sessions

  • /import-claude (or graff mcp import) now also imports the current project's Claude Code conversations, so /resume can continue them in graff. Imports keep the text, tool calls and results, titles, timestamps and the source model; signed thinking and sub-agent sidechains are left out. Saves are named claude-<session-id>, and importing again never overwrites an existing save. graff mcp import-session <id> imports one conversation without copying any setup.
  • A resumed import runs on the provider and credentials graff is configured with, not the route the conversation came from; the source model is kept as history. When the wire format differs, earlier tool calls and results come through as labeled text receipts. No Claude credentials are read, and no imported tool call runs again (ADR 0254).

v0.0.302.21

Windows

  • graff installs natively on Windows from PowerShell: irm https://codegraff.com/install.ps1 | iex. The installer picks the x86_64 or ARM64 build, verifies it against the release's SHA256SUMS, installs graff.exe under %LOCALAPPDATA%\Programs\graff\bin and adds that to your user PATH. Releases attach install.ps1 next to install.sh (#1508).
  • install.sh run from Git Bash, MSYS or Cygwin points to the PowerShell installer and stops. It used to tell Windows users to use WSL2, and because the check ran in a subshell, it then went on to clone the repo and build it (#1508).
  • graff mcp install sets up a macOS or Linux background service. On Windows it now says so, instead of failing with FileNotFound (#1508).

Sign-in

  • graff login prints the approval link with your code in it (…/cli/auth?code=XXXX-XXXX), and on Windows it opens the browser. Before, the printed link had no code, and on Windows the browser never opened, so copying the link led to a page with nowhere to enter the code.
  • When a ChatGPT sign-in lapses in an interactive session, graff opens the browser sign-in and retries the request once you have signed in, instead of failing the turn. ChatGPT sign-ins currently last about an hour because renewals are refused upstream. -p, piped and --json runs, ACP sessions and sub-agents never open a browser (ADR 0253, #1507).

v0.0.302.20

v0.0.302.19 was tagged but not published; this release ships its changes (listed under v0.0.302.19 below) together with the following.

Fixes

  • A stdio MCP server that sent one message over the 1 MiB line limit no longer fails every later call with McpResponseTooLarge. The oversized line is skipped: an oversized notification is ignored and the awaited reply read after it, and an oversized reply fails only its own call (#1504).
  • On Windows, an empty HOME or USERPROFILE no longer counts as a home directory. An empty HOME used to hide %USERPROFILE%, so saved keys, sign-ins and sessions resolved against the root of the drive.

Experimental

  • GRAFF_COMPACT_MIX=1 turns on a two-pass compactor for comparison runs: a low-effort pass extracts a short state ledger (decisions, ruled-out approaches with reasons, in-flight values verbatim, next step, open asks) and the handoff summary carries it as a checklist at the session's effort. Off by default; any extract failure falls back to the single-pass summary. evals/compact_ab gains a mix arm.

v0.0.302.19

Speed and cost

  • Tool results come back inline up to 64 KiB instead of 16 KiB, so a whole-file read of an ordinary module arrives in one piece instead of as a handle preview the model pages through. The threshold is still clamped to half the context window, GRAFF_TOOL_HANDLE_BYTES still overrides it, and the codedb small-read exemption follows the same number (ADR 0251, #1502).
  • A commentary heads-up no longer tightens the stall budget. The server holds such a heads-up open while the model composes a batch of tool calls and releases the calls together, so a long compose was cut off as a stall and generated again. Final-answer prose still tightens the budget, on the WebSocket and SSE readers alike (ADR 0248, #1497).
  • A spec task ends at its own tests. The work note no longer says a green public test is not the whole spec, a sentence that made the model write a second, ad-hoc check script after the task's tests passed (ADR 0249, #1498).
  • Logged in to Codegraff, graff asks Jev for a turn's effort itself, alongside the turn's first request, when the turn starts at the session's default effort on a model Jev serves; GPT-6 on the ChatGPT-plan sign-in is now one of them. The pick applies from the turn's next request, holds for that turn only, and never overrides an effort you chose. Jev sees a summary built locally with code, paths, file names and identifiers removed. GRAFF_JEV_AUTO=0 turns it off (ADR 0246, #1494).

Terminal

  • Parked background work is named above the prompt: ↻ waiting on <work> — graff continues when it finishes while a shell command or agent whose exit wakes the session runs, and ↻ <command> exited 0 — continuing when it resumes. Before, the yield printed a generic line and a parked turn read as graff stopping mid-task (ADR 0247, #1496).

Pull requests

  • PR publication is no longer gated. gh pr create and gh pr ready run like any other command: no local-check, head-CI or claim-review preflight, no wait on pending CI, and a draft completes like any other task. A mutation of a branch, issue or PR that another live session has claimed is still refused. Sessions saved by earlier versions still load, and their recorded publication state is ignored (ADR 0250, #1500).

Build and tests

  • graff builds with the stable Zig 0.17.0 release: build.zig.zon, CI, install.sh and the cloud-agent installer all pin it. graff learn init no longer hangs on Windows (#1493).
  • graff learn init pins evaluator programs up to 256 MiB, which leaves room for the Linux debug build (#1501).
  • Two integration tests no longer race the removal of their temporary directories (#1499).

v0.0.302.18

Terminal UI

  • The fullscreen UI is now a separate client. graff tui launches an installed graff-tui (the sibling binary first, then PATH) with its arguments unchanged, and never downloads one. In a terminal, graff and graff repl start the line REPL. The embedded renderer, its adapters and fixtures are removed (ADR 0245).

Speed and cost

  • Heads-ups are one short line in the same response as their tool calls, and a script that computes an answer is its own proof, so the model no longer recomputes it a second way. read_file is required only before editing an existing file. A call's time follows the tokens it writes (ADR 0239, #1478).
  • rlm: a slim view names the fields the whole value holds, the slim rule says to compute over results inside the same script, and an unbound call or each() prints its result (ADR 0240, #1479).
  • On the Responses wire, prose tightens the stall budget only while its output item is open. A model that writes a heads-up and then composes its tool calls in silence gets the full budget instead of a false stall and a repeated generation (ADR 0241, #1480).
  • The shell tool names the python3 the shell runs, read from where python3 on PATH resolves and never by running it, so scripts stop using features that version lacks (ADR 0242, #1481).
  • On the ChatGPT plan and the OpenAI platform, the project instructions and layout ride as their own input item. The instructions are then identical in every repo and are read from the cache on a new repo's first call (ADR 0243, #1483).

Sessions

  • Live sessions show meaningful activity age, deterministic recent-first ordering, and separated rows without repeated identifiers. Resume errors distinguish live identifiers from saved keys. (#1459–#1464)
  • Saved workspaces remain discoverable after their processes exit. Workspace-qualified targets distinguish same-named conversations, and cross-project resume enters the selected workspace before restoring history (ADR 0244). (#1457, #1458)

Recovery

  • Empty or format-only terminal pastes recover an available clipboard image or show a warning instead of a misleading pasted-text chip. (#1468)
  • Explicit account-backed model selections tolerate omissions from dynamic catalogs while preserving credential validation. (#1466)
  • Stale MCP registrations and closed connections return recovery guidance; disconnected tools are withdrawn from the next catalog without automatically replaying calls. (#1465, #1467)
  • Added screen-level coverage for long blockquotes; the published reproduction already renders correctly. (#1470)

v0.0.302.17

Code mode

  • An MCP call inside an rlm script binds the tool's whole result (ADR 0238). Before, a script bound the slimmed cut and could not reach a field it dropped, such as a priority or an estimate; the model had to leave the script and page the stored result back in. print() still shows the slim view and now says so, project(x, field) reads any field (over an each() bind of comment lists, n and latest_author still read the fold), write_file saves the whole result for a script, and inside rlm read_tool_result("tr_N") binds a stored result whole. Direct calls are slimmed as before. (#1473)

Evals

  • evals/graff-vs-pi-codemode: graff and Pi 1.0, each with its code mode on and off, on harder tasks, with new mcp-hard and aggregate suites, a Pi 1.0 wrapper (pi1, pi1-codemode, pi1-direct) and an rlm-off arm (graff-gateway-repl-norlm). (#1475)

v0.0.302.16

License

  • The LICENSE gains a funded-company term for every version after 0.0.302.15. A company that, with its affiliates, has raised more than US$500,000 (equity, convertible notes, SAFEs or similar, at any valuation) may use graff only under a commercial license granted jointly by the Licensors, including on its own computers, CI and networks. A company that crosses the line has 30 days to get a license or stop. Individuals and organizations that are not funded companies keep the AGPL-3.0 terms, and versions up to and including 0.0.302.15 keep the license they shipped with. Components under their own license, such as the Apache-2.0 SDKs, keep it; a copy of graff they include or download stays under the LICENSE. Contact [email protected]. graff itself is unchanged from v0.0.302.15. (#1447)

v0.0.302.15

Models

  • DeepSeek's default effort thinks at DeepSeek's low level (ADR 0237). graff's default (medium) used to send reasoning_effort: medium with thinking on, and on DeepSeek V4 Pro the first request of a turn planned the whole job before its first tool call. The default now sends low with thinking still enabled. /effort low still turns thinking off (ADR 0054), high and above are unchanged, and the flash models' default stays thinking off. The picker, status line and ACP still call the default Medium. (#1456)

Evals

  • DeepSeek V4 Pro at graff's default effort: v0.0.302.14 against this release, with thinking off and deepseek-harness alongside, in evals/graff-vs-deepseek-harness/DEFAULT-EFFORT.md. See docs/releases/v0.0.302.15.md.

v0.0.302.14

Models

  • MiMo thinks only at high effort and above (ADR 0235). graff's default effort is medium, which used to turn MiMo's thinking on for every call; MiMo then thought at length before each action, and that was most of a task's time. minimal, low and medium now send thinking Off; /effort high, a worker's effort pin or Jev's high turn it on. The picker, status line and ACP show the default as Off. (#1453)

Speed

  • MCP servers connect in the background in every session but --json (ADR 0230), so a slow server no longer holds the first message. Each request merges the servers that have finished connecting, /mcp names the ones still connecting, and ACP session/new waits at most 250 ms for a client's servers. (#1445)
  • Shell waits and todo_write replies stop costing turns (ADR 0233). Interactive sessions ignore a shorter shell timeout, so a quick command is no longer parked after a second and the turn no longer ends; unattended sessions keep a shorter wait but not below 5 s. todo_write replies with counts instead of repeating the list. (#1451)
  • The shell tool names the OS its commands run on, so models write BSD sed -i '' on macOS. The codedb guard (#626) lets in-place sed edits and pipe-free whole-file reads up to 16 KiB through; searches and bigger reads still go to codedb (ADR 0234). (#1452)
  • rlm takes JSON array and object literals as arguments and binds, each() maps plain values as well as objects, a lone object argument is the keyword arguments, and a refused statement lists the forms that work (ADR 0236). (#1454)

Sub-agents

  • Sub-agents at parity with the codex route (ADR 0232): write_file creates a missing directory, agent_output takes ids, a child starts with the user's prompts from its parent's history at the parent's live effort and can ask Jev for its own, read-only children on macOS run any command under a sandbox that refuses writes in the project and network access, and each finished child writes a subagent trace line. Unattended prompts leave out the todo_write nudges. (#1445)

Evals

  • graff-evals gains a subagents suite of five delegation tasks and its subagents-solo counterfactual, with subagent_split.py to split parent and child time. (#1445)
  • MiMo v2.6 Pro and Flash: v0.0.302.13 against this release and OpenCode 2, in evals/mimo-v2.6/. DeepSeek V4 Pro on DeepSeek's own API, graff against deepseek-harness, in evals/graff-vs-deepseek-harness/. gpt-6-astra beside the Codex app server, in evals/graff-vs-codex-app-server/ASTRA.md. See docs/releases/v0.0.302.14.md.

v0.0.302.13

Speed

  • Fewer model calls per task (ADR 0231). An MCP server the message names loads with the first request when its schemas are small, and the folded subagent and agent_output tools load when the message asks for subagents, so no load_tool_schemas round trip comes first. The note on what loaded repeats how results are slimmed and says one rlm script can fetch, save and build a file in a single step. (#1449)
  • write_file will not replace a file the session has not read, edited or written unless the call passes replace: true, and its result says whether it created or replaced the file and whether a .json file parses. The prompt drops the existence check before a write and the read-back after it. (#1449)
  • A child's inherited MCP tools are callable from its first request: they are no longer deferred behind hosted tool search on the codex route. (#1449)
  • -p and piped sessions skip reasoning summaries at low effort; nothing displays them there. (#1449)

Scripted sessions

  • A piped graff repl reads a bracketed paste (ESC[200~ … ESC[201~) as one prompt, so a multi-line task is one turn. Without the frame each line is still its own prompt. (#1449)
  • ask_user is offered only when someone can answer: not under -p, and not in a piped session outside --json or ACP. With no git identity configured, commits use git's defaults instead of asking. (#1449)

Evals

  • graff, the Codex app server and pi on the same model and ChatGPT account, and graff, Claude Code, OpenCode 2 and pi on one gateway model, in evals/. The runner gives every harness an empty stdin. (#1448, #1450)

v0.0.302.12

Sign-in

  • Every ChatGPT login is the sign-in for open-source apps, chatgpt-new, because the login through the Codex CLI's client no longer works: graff login chatgpt, graff login codex, openai, gpt and oai, /login, graff logout chatgpt, and the model picker's login for a Codex model all run it. With both routes signed in, a bare model name and the startup default pick chatgpt-new. An existing Codex CLI auth.json still works on the codex route. Renewals of the new sign-in are still refused, so a sign-in lasts about an hour (#1422) (ADR 0229). (#1442)
  • Browser sign-ins wait for their own redirect. The codex login answered only the first connection to its callback port, so a connection the browser opened early and dropped ended it, and the real redirect found the port closed ("connection refused"). A tab from an earlier attempt now gets a page saying so instead of ending the sign-in, and a new sign-in takes the port from one still waiting. The ChatGPT and MCP server sign-ins share the fix. (#1442)

Sub-agents and MCP

  • One load_tool_schemas call loads natives and MCP tools together, and on the routes that announce loads a child keeps the tools its root loaded. (#1438)
  • A spawned child gets the MCP tools its root loaded, with full schemas (ADR 0227). (#1439)
  • A read-only child may call the MCP tools their server declares read-only (readOnlyHint), and inherits only those (ADR 0228). (#1440)

Codex

  • On the codex provider, the default effort is the model catalog's level, and requests carry the catalog's verbosity (ADR 0226). (#1439)

Evals

  • graff side by side with the Codex app server on the same model and account, in evals/graff-vs-codex-app-server/. The app-server driver follows the root thread and runs at the model's default effort. (#1441)

v0.0.302.11

Prompt cache

  • With a ChatGPT account, the codex prompt cache is partitioned by account instead of by repo. The system prompt and tools carry no cwd, so the first request in a new repo reads the prefix another repo warmed. Children keep their role lanes, and other providers keep the project key (ADR 0223). (#1431)
  • A tool loaded mid-session is announced in an item instead of growing tools, so the cached prefix survives the load: an additional_tools item on the Codex and OpenAI routes, and a system or user message on the chat-completions models that take one. (#1429)
  • Six rarely used native tools load on demand: render_html, agent_message, install_agent_tool, read_tool_result, subagent_resume and schedule_task. They stay listed by load_tool_schemas, and a confident call still runs them (ADR 0224). (#1432)

MCP

  • Every MCP load, search and select result says how large list results are slimmed (identity fields; a comment list becomes {n, latest_author}), so a fresh project no longer codes against fields it will never see (ADR 0225). (#1433)
  • A direct call's slimmed result keeps the full payload as a tool-result handle and names it, so read_tool_result reads any dropped field. Inside an rlm script, binds stay plain slim JSON. (#1433)
  • The first request carries every MCP server that is ready, and loaded schemas outlive the arena that loaded them. (#1429)

GPT-6 on the Codex WebSocket

  • A follow-up typed while a GPT-6 reply streams is sent as response.steer instead of cutting the stream and resending the turn. A refused steer waits for the next turn, and the root turn leaves server compaction off while well below its threshold, because the backend will not steer those requests (ADR 0222). A queued follow-up no longer crashes when it is freed. (#1427)

Sign-in

  • graff login chatgpt, openai, gpt and oai are the codex login on the command line, as they already were for /login, and an unknown name is refused with the valid ones. (#1428)
  • Opt-in chatgpt-new provider: the ChatGPT plan through the sign-in for open-source apps, with WebSocket turns, chaining, steering and async tools (ADR 0221). The route refuses refresh-token renewals, so its sign-in lasts about an hour (#1422). Codex stays the ChatGPT login. (#1429)

rlm

  • rlm scripts are call-only, not Python, and the tool says so. A bound name passes its text as an argument, write_file takes (path, content) so a script can save a result for the shell, and shell("…") passes its argument as command instead of being refused. (#1430)

Scripted repl

  • A scripted graff repl composes each turn on the base system prompt; the constraint block was sent twice. (#1434)
  • A scripted graff repl waits for the background work its turn started instead of exiting at end of input with a subagent still running (ADR 0215). (#1435)

Sessions

  • A session holding only a compaction blob still saves, and a chat turn closes the Responses socket it opened. (#1429)

Evals

  • graff-evals gains a Codex app-server arm, per-call usage traces, and run.py --interleave for A/B runs that meet the same backend conditions. (#1436)

v0.0.302.10

Tool calls

  • A response that stops mid-output (an output-limit stop, or a stream that ends before its terminal event) no longer runs its unfinished tool call. On the Anthropic wire a tool_use block that never got its content_block_stop is refused; on chat completions the last call of a length-stopped or cut-off stream is refused unless its arguments already close as a JSON object. The refusal names the cause and asks for fewer or smaller calls per response, instead of a malformed-JSON error the model retried as-is, and a call whose name streamed without arguments no longer runs as an empty call. (#1218)

Prompt cache

  • On the Anthropic API, and for Anthropic models through OpenRouter, a request whose predecessor began three or more minutes earlier asks for the 1-hour cache TTL, so a slow call no longer comes back to an expired prefix. (#1320)
  • The per-response usage trace line says why a request read nothing from the cache: gap_ms, cache_ttl, prefix_changed with the named bust reason, and cache_miss (prefix_changed, first_request, idle_gap or unknown). (#1320)
  • OpenRouter requests carry session_id for sticky routing, and Anthropic models there get OpenRouter's top-level cache_control, so their prefix is cached instead of billed at full price every turn. (#1284)

Autonomous runs

  • /loop holds for its own background work. A turn that only started or waited on a background shell job or subagent no longer ends the run as idle: the work's completion continues it as a loop turn with the run's credits, pacing and steering. Typing takes over, as before. (#1278)

Serve, remote control and ACP

  • A resent request no longer starts a second turn. message_id on a graff serve or remote-control request, or messageId / _meta["graff/messageId"] on ACP session/prompt, makes a resend of a finished request return that request's events (serve, remote control) or stop reason (ACP). (#1285)
  • ACP: a completed tool update whose result saved a rendered view or an MCP app carries _meta["graff/view"], and graff/models rows name each model's maker. (#1385, #1386)

Line REPL

  • A paste during a running turn is framed as one steer line, and dropped images are bounded. (#1367)

PR publication

  • A failed local check is resolved by a passing rerun that only changes the toolchain (PATH=…, RUSTUP_TOOLCHAIN=…, cargo +nightly, another zig by path), including a dynamic PATH prefix. (#1375)

Traces

  • Each model response writes a usage event with the server's own token split (input, cache read, cache write, output), so a cache hit rate is cache_read_tokens / input_tokens. (#1387)

Repository

  • The in-repo iOS app is removed, and the README is shorter and points desktop users at Harness.

v0.0.302.9

This is the first published release since v0.0.302.6. v0.0.302.7 and v0.0.302.8 were only published as a pre-release and a draft, so their sections below are part of this release too.

Release artifacts

  • The macOS CLI tarballs are Developer ID signed and notarized in the release workflow before upload, so SHA256SUMS covers the final files. (ADR 0210)
  • No desktop packages are built here any more. The desktop app is Harness, which drives graff over ACP; the in-repo Tauri and Electron apps and the Sidecar Chrome extension are removed. apps/chrome-native-extension stays.

MCP

  • Local (stdio) MCP servers start on first use. When a server's tool list is already cached, a session advertises those tools and spawns the process only when a tool is called, so a chat with many configured servers no longer runs them all. A server with no cached list still starts at once to learn its tools. "startup": "eager" on an entry, or GRAFF_MCP_EAGER=1, keeps the old behavior.
  • "shared": true on a stateless stdio server runs one process per machine, shared by every session through a local broker (not on Windows). Sessions that attach at the same moment share one initialize: a second one waits for the first answer instead of reaching the server again.
  • The tools/list cache is written under a lock. Servers connecting at the same time could overwrite each other's entries, so a server could look uncached and start eagerly every session.
  • graff mcp add … --everywhere (alias --global) saves to the user-level ~/.codegraff/mcp.json, which every workspace already merges, so one add applies to every project and to Harness. The verify step, the "saved to" message and live join follow the file that was written.
  • ADR 0211 records how MCP servers are named, scoped and synced: a bare name resolves from the codegraff.com catalog and then the MCP registry (only for a matching namespace owner), and cross-device sync carries non-secret rows through Harness while env values, headers and OAuth tokens stay on each device.

ACP rooms

  • A line another agent posts in a shared Harness room (_meta["harness/room"], from_user: false) reaches the model as one framed line marked as advisory information, not the user's instruction. Framing runs before slash-command handling, so a room message cannot run a command. A person's line, or a prompt without the tag, stays a plain prompt.
  • A delivery from another account's agent is named as such, and the note adds that the project's files, secrets and credentials are not shared with it unless the user asks. Any from_account other than "same" is treated as another account.

v0.0.302.8

Context and prompt cache

  • A mid-session edit to AGENTS.md / HARNESS.md / CLAUDE.md, or a UTC date rollover, reaches the model as one keyed <context> message before the next prompt instead of rewriting the cached system prompt. The update uses a role that outranks the stale prompt on each wire (developer on Responses, system on Chat Completions, user elsewhere). Compaction drops those messages and folds the latest values into the new system prompt, and a /model switch across wires keeps them. /cache shows hot-context updates. (#1333, ADR 0208)
  • After compaction, the handoff says the recent messages kept verbatim outrank the summary, so a stale "next step" in the summary no longer makes the model redo finished work. (#1286)

Pull requests

  • /pr-acceptance is removed. A run that published a draft PR completes as an unverified handoff ("Draft handoff — CI is not verified.") instead of stopping to ask for a command; a ready PR still needs passing current-head checks. (ADR 0120)
  • The ready-for-review claim review reserves every changed hunk before adding complete sources, keeps only the diffs when the packet would be too large, and reviews an oversized single-file diff (such as a new fixture) as a marked excerpt. A small edit in a large file no longer makes publication impossible. (#1341, #1343, #1345, #1337)
  • A local check that finished in the background resolves publication readiness, and checks are keyed by what they run, not how the command was spelled. (#1326, #1337)
  • A non-draft gh pr create right after pushing no longer falls back to a draft: the head's pending run is re-read for up to a minute, a run that fails meanwhile still refuses, and a create still pending afterwards proceeds while completion waits for the checks. (#1189)
  • Publication refusals state the rule plainly: a failure that also happens on the base still blocks non-draft publication; disclosure explains it but is not a way around it. (#1197)
  • The claim gate no longer blames an unrelated claim when an explicit gh pr edit N / gh pr ready N target can't be looked up: a different numbered PR claim does not block, a conservative refusal says what could not be resolved, and nobody is asked for a handoff. More gh pr edit/close/comment/merge options are recognized. (#1340, #1344)

Shell jobs

  • A finite command that outlives the foreground wait, or is started with run_in_background, stays awaitable: action=output with wait_ms>0 waits for exit. Only server-like commands (dev servers, watchers, tunnels, followed logs) are parked as persistent. (#1324, #1349)
  • rlm says when a sleep_ms was capped and points to blocking waits.
  • Deciding whether a job is a server reads only the command the shell runs, not heredoc bodies or quoted strings, so an inline script that mentions a server program or --watch stays awaitable. (#1361)

Subagents and tools

  • A subagent given an informational task (read-only, investigate, summarize) keeps its read, search and read-only shell tools and is refused only writes. It used to get no tools at all and finish without inspecting anything. (#1360)
  • On the Anthropic wire, a tool call whose streamed input was cut off is refused with the truncated-arguments error instead of running with empty arguments. (#1218)

Sessions

  • Two sessions started at the same moment in one checkout no longer both stay on the primary working tree: a startup claim taken before deciding makes the second one isolate into its own worktree. (#1200)

ACP

  • The context meter uses the standard usage_update (used, size, and cost only when every call was priced) instead of a graff-only update. (#1290)
  • Clients that opt in get compaction_update (in_progress, then completed with the summary, failed, or cancelled) when the agent compacts.
  • An ask_user question the client returns without an answer is no longer reported as a user cancel. (#1322)

MCP

  • The MCP client follows tools/list pagination, refreshes on list_changed (including subscriptions/listen), relays notifications/progress, sends notifications/cancelled when a call is interrupted, answers input-required (MRTR) rounds, and resumes a Streamable HTTP stream with Last-Event-ID.
  • graff mcp add <x> works out the entry: a URL becomes Streamable HTTP named from its host, @scope/pkg runs through npx -y, uvx:pkg through uvx, and a pasted Claude/Cursor/VS Code JSON block (or - for stdin) saves every server in it. A bare name is looked up in codegraff.com's curated list, then the official MCP registry, where only a server whose verified namespace owner matches the name is picked; anything else is listed to choose from. An entry that needs an env var or header saves nothing until it is given.
  • Every add connects and lists the server's tools; OAuth signs in on the spot at a terminal, and a failure keeps the entry with what to fix (--no-verify skips the check). A server added while a session runs is connected before its next request.

Desktop

  • The desktop app no longer has computer use: the computer tool, the Computer use… menu item and its permission prompt are removed. Previews go through the project's own launch or preview command, or the browser pane for localhost pages. graff's bridge for the Codex Computer Use plugin is unchanged. (ADR 0209, #1334)

Constraints

  • note_constraint accepts a standing rule the user typed into an ask_user answer, under the same verbatim rule as the user's message. (#1342)

v0.0.302.7

Safety

  • Functions an rlm script calls on the host (bash, write_file, edit_file, MCP tools) go through the same approval prompt, plan mode and subagent destructive-git block as direct tool calls; before, only the outer rlm call was gated.

  • Tool shells honor an explicit git -c core.editor=… or -c sequence.editor=… again, so scripted rebases and rewords work, and a user's own Git askpass helper is kept.

  • Shell commands called by the tool's current name (shell) now go through the approval prompt, the subagent destructive-git block and the publish gate. Only the legacy bash name was gated before; plan mode was already enforced separately. (#1292)

  • Commands the agent runs no longer inherit provider API keys from graff's environment, so env in a tool call can't copy them into transcripts. GRAFF_TOOL_ENV_PASS keeps named variables when a tool genuinely needs one. (#1267)

  • Tool shells get non-interactive editor, pager and prompt defaults, so git commit without -m, rebase -i or a pager can't hang a call until its deadline. (#1268)

  • The destructive-git check tokenizes commands instead of matching substrings, catching spellings such as git clean -df, git restore -- ., git checkout -f, git -C dir reset --hard and forced push refspecs. (#1269)

  • A shell command containing a NUL byte is refused instead of silently running only the part before it. (#1270)

  • .graff/ gets its own .gitignore when graff creates it, so sessions and traces never show up in git status or a model-run git add -A; project config such as workspace.toml and tools/ stays committable. (#1273)

Model and tool reliability

  • Tool calls whose arguments a server lost (empty, {} or cut off) are rebuilt from the call markup in the same reply and the markup is removed from the message. The affected model family gets plain parameter types instead of nullable unions, and a turn whose last three tool batches all failed on unusable arguments ends instead of looping. (#1276)
  • Over-cap tool output keeps its head and tail around a truncation marker, so test summaries and final errors survive. (#1271)
  • Images read with read_file are downscaled to the provider-safe size, or refused with a reason, instead of failing the next request. (#1272)
  • When a reasoning model spends its whole reply reasoning without answering, the retry asks for brief thinking and a direct answer instead of repeating the identical request. (#1293)
  • Retry backoff adds bounded jitter so parallel workers don't retry in lockstep; a server's Retry-After is never shortened. (#1274)
  • Tool calls an OpenAI-compatible server leaves in the reply text as <tool_call><function=…> markup now run. A block runs only when it is wrapped in <tool_call>, sits outside backtick code, names a tool the request offered and its parameters parse; anything else stays text. The markup still appears while the reply streams. (#1247)
  • ask_user reads the question when a model names it prompt or message, sends a questions list, or JSON-encodes its arguments, instead of showing "(no question)" above the options. A call with no question text goes back to the model as an error. (#1308)
  • A router model whose provider has no credential reports the missing key instead of "unknown --model", and a transient macOS Keychain failure is retried once. (#1296)
  • The MCP result-shape cache is freed at session end. (#1196)

ACP

  • File tools report locations, edits carry ACP diff content that the completion keeps, the shell tool is kind execute, and each call sends one terminal update instead of two. (#1287, #1288)
  • Permission requests include the tool's kind, input, locations and diff, so clients show what is being approved. (#1289)
  • A mistyped slash command is answered locally with a suggestion ("did you mean /resume?") in the terminal, the TUI and over ACP, instead of going to the model. (#1275)
  • An image block's uri no longer becomes a bare line in the prompt text.
  • Provider citation markers from hosted web search are stripped from ACP answer and reasoning text, including markers split across streamed chunks and replayed history.
  • session/new and session/load wait at most 3 seconds for the MCP servers a client passes. A server whose host cannot be resolved or reached keeps connecting in the background and joins on a later request, instead of holding the reply until DNS gives up. (#1291)

MCP

  • graff mcp serve answers MCP 2026-07-28 clients (server/discover, versioned requests without initialize) beside the legacy handshake.

Pull requests

  • Publication review charges changed hunks with committed context instead of whole unchanged head files against its budget, and loads test roots before broad workflow files.

v0.0.302.6

ACP

  • ask_user no longer freezes clients that cannot show a question. A client that advertises clientCapabilities.elicitation.form gets a standard elicitation/create form request; the desktop app opts in to Graff's own question update; any other client gets an immediate result so the model continues instead of waiting for an answer that cannot arrive.
  • A running subagent streams its work onto the parent's tool call as ordinary tool_call_update content: a bounded log of its tool calls, failures and the tail of its message. Any ACP client shows it without changes. GRAFF_ACP_SUBAGENT_PROGRESS=0 turns it off.
  • ACP v2 draft preview: with GRAFF_ACP_V2=1 and a client that asks for protocol version 2, prompts are acknowledged with a messageId on insertion and the outcome arrives as state_update, chunks carry message IDs, tool rows are created by tool_call_update, and session/close and session/resume are available. Every other connection keeps v1 unchanged.
  • An empty JSON-RPC result (for example session/cancel with an id) is now {} rather than [].

Agents on one device

  • graff peer list|send|inbox|read lets any agent on the machine, not only graff sessions, list live agents, post to a worktree room, or send a direct message.

Logins

  • graff keys syncs provider logins between your devices through an end-to-end encrypted vault: status, enable, devices, approve, remove, push, pull, put and get. Rotating logins refresh under a vault lease so two devices cannot race a refresh.
  • Kimi requests identify graff as the platform, and Kimi console keys are billed as plan usage.

v0.0.302.5

Session and transport fixes

  • Loading a saved ACP session now keeps an explicitly selected launch model, matching command-line resume. Switching the selected model no longer requires discarding the saved conversation.
  • WebSocket prewarm sends the selected model in its first frame and records a bounded rejection reason when the server refuses it. A rejected prewarm can still fall back through the existing transport recovery path.
  • WebSocket turns deliver response deltas as they arrive, including before a slow completion frame, and flush held text once at completion. Mock transport checks cover live output, retry, fallback, and duplicate-output prevention.
  • ACP and --json input accept records larger than 64 KiB, such as long pasted prompts or image payloads. An oversized line used to end the session silently; now records up to 64 MiB are read and anything larger is dropped with a warning.
  • xAI WebSocket turns send full history again instead of chaining on the previous response, and the generate:false warmup is off by default. Chaining without server-side storage could stall after the first frame. GRAFF_XAI_WS_CHAIN=1 and GRAFF_WS_PREWARM=1 opt back in.
  • ACP clients can pass MCP servers in session/new and session/load, and GRAFF_NO_PLUGINS now applies before those servers connect.
  • Opted-in ACP clients can preview child-agent activity live, and background workers stream through a Graff extension across turns. Session teardown waits for background agents, and deferred MCP startup joins run under the registry lock.

Workspaces over ACP

  • ACP sessions now use the folder the client asks for on session/new and session/load, as the protocol requires, instead of the folder graff was launched in. A relative or missing folder is rejected.
  • The worktree a session runs in is reported as _meta["graff/worktree"] (name, path, branch, base, owning checkout, and whether graff generated it), or null in a main checkout. The non-standard top-level cwd in the session/new reply is gone; the desktop app reads the new field and still accepts older builds.
  • Reopening a session works from the repository root when the process runs in a -w tree, and from a main checkout when the save lives in one of its worktrees. Switching workspace mid-session sends session_info_update.
  • -w sessions record their real worktree path. They used $PWD, which names the host's own folder when an app launches graff, so their saves pointed at a path that did not exist.
  • graff worktree exits 1 when it refuses or fails and 2 when it does nothing, instead of always 0. Merging a workspace that does not exist now says so.

Image input

  • Every OpenAI gpt-* model is treated as image-capable (gpt-oss and gpt-3.5 excepted), and so is every model on the openai and codex providers, including o-series and codex-* ids. New releases no longer ship text-only by omission.
  • ACP clients can send standard image prompt blocks, and promptCapabilities.image is now advertised. Images join the next model request when the model accepts them and are skipped for text-only models. An image with no caption is sent with a short note, since some providers reject an empty text part.
  • Graff no longer crashes at startup when its presence socket path would exceed the platform limit (a long $HOME); that best-effort listener is skipped instead.

Optional formal evidence for local learning

  • Bounded lifecycle models cover effort changes, asynchronous tools, permission ownership, and connection leases. Deliberately weakened configurations provide counterexamples for the invariants those models are meant to guard.
  • Prompt evolution and local learning can require pinned formal-check evidence before scoring, checkpoint restore, or promotion. Drifted inputs or missing evidence stop that optional path; ordinary learning keeps its prior defaults.
  • Formal evidence remains separate from held-out task evaluation: a model check cannot make an incorrect candidate pass, and these finite models do not claim proof that the implementation matches them.

Desktop, browser and routing

  • Dry-run route checks preserve an explicitly qualified selection while checking whether it is available. This keeps the reported route aligned with the route the next request would use.
  • The CLI no longer installs, invokes, or advertises the Kuri companion. webfetch uses the built-in HTTP client and returns bounded HTML or text instead of companion-generated Markdown.
  • The desktop browser remains embedded. The web-only Browser pane now uses an explicitly paired Chrome extension; the retired browser endpoint returns 410 instead of starting a sidecar. Existing user-installed companion files are left in place.
  • Desktop chats restore their open tabs and selected workspace after a page reload, and a restart or reload warns before interrupting active work. Saved conversations remain discoverable across linked worktrees.
  • New chats and splits start from the owning project root, avoiding nested generated checkouts. The workspace switcher distinguishes projects from generated checkouts, and the visible folder label names the project.
  • Browser panes begin closed and do not reopen merely because the user switched chats. Returning to an unchanged chat does not replay the latest text animation. Resized chat dividers rebalance panes consistently.
  • Pull-request claim review accepts observed local checks, follows bounded test-runner reachability, and reports when evidence exceeds its input limit instead of presenting it as an unsupported claim.

Updates

  • graff update --beta opts into beta builds explicitly: it picks the newest numeric release branch, verifies the pinned archive against its checksums, and activates on the next launch. graff update stays on the stable channel.

v0.0.302.4

Harness execution and recovery

  • Independent, read-only lookups can start while a supported response is still streaming. Each job owns its arguments, cancellation and result; the harness joins jobs before the next request and delivers each result once.
  • RLM preserves dependent tool order and stopped results. Only leading read-only work may run speculatively; mutations retain their order. Unsupported script output expressions return a recoverable error.
  • Completion waits for terminal tool results and retains failed background verification status. Pending work cannot be reported as completed verification.
  • Positive agent_output waits now wait for a worker to finish, including unattended ACP sessions. A zero wait still returns a snapshot, and cancellation remains interruptible.
  • Background command completion resumes the owning session with its exit status and output. Durable shell handles prevent a stale reference from targeting a newer job.
  • Worker resume preserves conversation ownership and settings. Queueing a message and explicitly resuming a worker remain distinct operations.
  • Aggregate tool limits apply across descendants. Dependent workflow stages share their intended workspace; independent workflow items stay isolated.
  • Streamed tool calls retain their explicit identities when numeric indexes are reused. Incomplete predecessors remain invalid instead of absorbing a later call's arguments.
  • Batched edits validate every span before replacing a file, so a later invalid span cannot leave a partially applied batch.
  • Directory scans count examined entries before filtering and mark truncated results as partial. Bounded tool previews retain useful whole diagnostic lines from the original source ranges.
  • Empty-input, whitespace and record-framing rules come from the task's contract rather than a global interpretation.
  • Loaded MCP tools are callable through tools.server.tool(...) in RLM. Loaded tool ordering survives session save and restore.

Transport and request errors

  • Streaming HTTPS, bounded buffered POST requests and model-catalog GET requests use the shared HTTP/2 transport where supported. GRAFF_HTTP2=0 retains the HTTP/1.1 opt-out.
  • Active streams exclusively lease their connections. Transport allocations outlive individual request arenas, completed connections can be reused, and unfinished or failed streams are discarded safely.
  • Request deadlines join their work before cleanup; cancellation, body-size limits and flow-control handling are covered by local transport fixtures.
  • Ambiguous send failures return to the request retry policy instead of silently replaying the request in the transport. Attempts without reported usage remain uncertain.
  • A trailer timeout after a valid completed response no longer replays the completed generation. Missing usage remains explicitly unknown.
  • Catalog redirects have bounded hops and pages. Credentials remain scoped to the original origin.
  • Unavailable-model errors stop across retry paths instead of repeatedly sending a request that cannot succeed.
  • WebSocket-capable routes retain their supported connection and cache behavior, with observable HTTPS streaming fallback where applicable.

Model selection and effort controls

  • Opening the model picker refreshes its gateway catalog through a bounded request with a cached fallback. graff refresh is a short form of graff models refresh.
  • Saved and explicit model selections retain their provider route even when a refreshed catalog omits the model. Fallback remains an explicit selection rather than a silent route change.
  • Default and worker model preferences stay within the selected provider. Catalog results and startup selection remain scoped to the current workspace.
  • Model guidance is composed for the current request, with delegation guidance limited to the root agent and stable repeated prompt prefixes.
  • Effort controls reflect the active model's supported values. Binary thinking models expose Off/On rather than an artificial intensity ladder; legacy positive settings normalize to On.
  • Explicit Off requests on unsupported routes are rejected before inference, including worker overrides. Switching to an incompatible model visibly resets an unsupported saved Off setting.
  • Worker effort schemas and generated SDK types match the supported control values.
  • The optional effort-selection tool replaces the general judgment tool. It accepts a short task summary, selects only a supported effort value, and queues the change for the owning session; it does not judge answers, approve actions or run automatically on every turn. Failed or malformed selections leave effort unchanged.

ACP and desktop integration

  • The ACP compatibility contract records the stable protocol target, supported capabilities, extensions and client acceptance checks.
  • ACP initialization and embedded resources follow protocol v1. Initialization metadata is validated per response, and duplicate live session creation cannot replace existing history.
  • session/new and session/load expose supported effort options. session/set_config_option changes the same effort state as /effort; updates during a prompt apply after the active turn.
  • Agent-originated model and effort changes publish configuration updates for clients. The desktop picker uses capability-derived values and labels.
  • Loading a saved ACP session restores its workspace and conversation without rerunning historical tools. Tool permissions belong to the active client and request; cancellation never grants approval.
  • Tool outcomes survive protocol updates. Connection usage notifications preserve unreported usage rather than presenting a partial subtotal as complete.
  • Superseded desktop session bootstraps redirect their waiting callers to the replacement session.
  • Chat selection and navigation restore composer focus and caret position; closing a chat returns to the most recently used chat. Reopen-tab shortcuts require the intended modifiers.
  • Transcript selection and response copying are supported without copying extra interface text. The redundant sidebar toggle is removed, and effort controls use a compact layout.
  • A completed browser navigation no longer shows a stale aborted-load error over the replacement page. Real navigation failures remain visible.
  • Composer send/stop controls retain their circular shape. Optional interface sounds are off by default.
  • Linux desktop startup, local service installation and package handling have platform-specific recovery paths.

Workspaces and accounting

  • Desktop task workspaces use separate Git checkouts. Update and garbage-collection operations retain dirty, unique or actively written worktrees; archive and landing checks require current repository evidence.
  • Workspace switches remain aligned with the ACP session. Windows worktree removal runs from a stable Git directory.
  • Usage views distinguish reported tokens, cache hits, unreported attempts and incomplete totals. Cost estimates use the actual request route and leave unknown tariffs unpriced.
  • Optional effort-selection charges are recorded as settled only when an authenticated response includes a validated settlement receipt. Missing receipts remain unknown; mock requests do not affect billing totals.
  • Saved prompt-cache identities are restored safely, and supported request paths retain their cache controls.

Release and verification

  • Notarized macOS distributions can omit optional platform-passkey configuration; supplied profiles remain strictly validated.
  • Pushes to the latest versioned release branch build beta prereleases. Publication checks the current branch head again so an older queued build cannot replace a newer beta.
  • Beta release pages include the matching changelog section and identify their exact source commit. graff --version shows current release highlights.
  • Beta versions remain separate from the stable update channel. Packaging includes CLI archives and checksums across supported targets, plus the Linux desktop package; a macOS build artifact alone is not a signed installer.
  • Offline checks cover formatting, source limits, test reachability, the test-count floor, generated SDK consistency, terminal behavior and desktop regressions.
  • Scripted harness behavior cases and local HTTP/2/ACP fixtures exercise ordering, identity, retries, cancellation, usage uncertainty and effort configuration without requiring live service calls.

v0.0.302.3

  • Desktop first launch: one MCP install (no overlapping flock / “MCP setup incomplete”), and graff on login-shell PATH (zsh/bash login+interactive, Homebrew and ~/bin shims).
  • Ctrl-V screenshot paste is not killed by a leftover Esc (clipboard helper unavailable).
  • Desktop auto-update accepts 4-part hotfix versions (0.0.302.3), not only 0.0.xxx.
  • Task workspaces are graff-native (.graff/workspace.toml, .worktreeinclude, GRAFF_WORKSPACE_*). Copy gitignored files and run setup/run/archive scripts (ADR 0153). Desktop Tools: New task workspace, Run, Land, Archive. The agent does not delete a named tree.

v0.0.302.2

  • Persistent shell / bash_output jobs snapshot immediately (wait_ms ignored) and stay on /jobs; the 15s still-running poll no longer holds the turn (ADR 0152). Finite jobs still wait until exit.
  • graff login zai (aliases glm, z.ai) signs in to a Z.AI Coding Plan and routes chat to /api/coding/paas/v4 without ZAI_CODING=1 (ADR 0151).
  • Native: clickable browser/chat links, folder-picker repeat submissions, composer history recall layout, prompt-history session/attachment scoping, saved-snapshot reopen, worktree path wrapping. Shutdown-fixture stalls dump renderer/backend/worker state (#1080, #1103, #1105, #1108, #1109, #1112, #1113).

v0.0.302.1

  • #1092: claim ledger lives under the Git common directory, so a worktree switch still sees and can release the same claim. Per-worktree .graff files are imported, not bypassed. CLI-only hotfix.

v0.0.302

  • Line REPL boxes GFM pipe tables (including |---| separators and pipe-less a | b rows) when the stream ends.

  • #1088: claims own one artifact. Conflicts ping Accord; acquire/release/handoff also replicate as replaceable Accord progress (file ledger stays canonical). Staging is not a lock.

  • #1084: gpt-6-astra /effort medium sends medium (no longer remapped to low).

  • Empty Enter-Enter while a turn is running interrupts (or steers the next queued prompt). It no longer required a queue to arm.

  • Desktop ACP workers can park after a quiet period (GRAFF_ACP_IDLE_MS, default 30s) and --resume with the saved cache id. Parking is skipped while a prompt or session/idle subscriber is live; tab close still reaps immediately.

  • Turn chrome shows local tok/s while writing (and at settle); MCP tools/Apps wait instead of looking like slow generation (#1017).

  • MCP App frames answer ui/initialize; app-initiated mcp__ tools/call is forwarded through ACP (session/mcp_call). Native tools stay refused (#1018).

  • The folder picker can sort by name or modification time, filter Git repositories, and create folders.

  • Available rlm tools are listed from the first turn rather than waiting for a batch or context threshold (ADR 0140).

  • Desktop fonts are bundled locally; syntax highlighting, diagrams, and secondary panes load when needed.

  • Desktop appearance notes no longer alter slash commands. Clipboard image staging retries absolute paths through their parent directory when needed.

  • Resuming a saved conversation restores its persisted session identity even if startup already generated one.

  • GUI usage replies show grouped metrics and plan limits; inline editing keeps the message bubble and grows with its text. Subtle transcript reveals respect reduced motion.

  • #1013: keep the first answer after a no-tool retry without allowing older turns to replace a later answer (ADR 0139).

  • GUI usage replies show grouped metrics and plan limits; inline editing keeps the message bubble and grows with its text. Subtle transcript reveals respect reduced motion.

  • #1013: keep the first answer after a no-tool retry without allowing older turns to replace a later answer (ADR 0139).

  • GUI follow-up bar is a pill over the transcript with CSS frost; working subagents sit on the dock.

  • ask_user round-trips over ACP so the desktop can show an ApprovalCard mid-turn.

  • #1011: live replies keep the typewriter and block caret; the caret hides when the turn is done, and the first chunk reveals instead of painting in as one blob.

  • #1009: queued follow-up row does not paint a surface bar while a turn is working.

  • Drawn HTML uses the live desktop palette unless the turn already names colors (ADR 0137).

  • Accord Unix 0600 is a standing duplex per live session (GRAFF_ACCORD=0 opts out); JSONL stays the durable room (ADR 0134). /debug reports Accord session count and RSS.

  • Engine messaging (idle peer mail, #1007) is the same latch on line REPL, TUI, and graff acp.

  • #1001: idle TUI and line REPL start a turn when the durable peer room has new unread mail (one auto-turn per batch; inbox consume resets).

  • #1007: idle graff acp sessions start that same turn; peer_message no longer claims delivery waits for a step boundary.

  • #1006: rendered views sit in the transcript without product chrome; desktop appearance tokens ride the turn (ADR 0137).

  • Live 12-PR board on grok-4.6 SuperGrok (n=3, no SPEC.md): graff / Pi / OpenCode 12/12, grok 11/12 (#727), exo 9/12 (gemini + two turbos — no-token check-greens do not count). Honest list$ $21.48 / $18.47 / $25.71 / $33.69 / $16.01. Receipt and site-palette card in artifacts/graff-evals-live/.

  • #722: remote control. graff remote-control is graff serve with no listener: it dials out to your Codegraff account and takes commands from the account's relay, so nothing on the machine is ever bound. From anywhere the same graff login is valid, graff remote lists the machines and their sessions; graff remote new / send / answer / tail / cancel / close drive them, with the same NDJSON events a serve client gets. The machine keeps the complete tape; the relay keeps a recent window and a viewer that falls behind gets a replay from the machine. Gated on the new remote key scope, so neither a plain api key nor a history-only sessions key can reach a machine, and a viewer cannot start an unattended session unless the machine was started with --yolo. docs/remote-control.md, docs/remote-control-security.md.

v0.0.302

  • Packaged Codegraff.app uses com.codegraff.app. A dev.* bundle ID fails the desktop tests and distribute.sh (ADR 0143).
  • Graff commits may include Co-Authored-By: Codegraff <[email protected]>; vendor attribution stays banned.

v0.0.299

  • The MCP run_task result view uses the codegraff.com paper palette (paper, rice, ink, coral, cobalt, gold) instead of the desktop emerald chrome. Host light/dark still applies. No webfonts.
  • One catalog shell tool (action=run|output|kill) replaces advertised bash / bash_output / bash_kill. The old names still dispatch. Not a PTY.
  • A follow-up typed during a foreground shell wait promotes the command instead of blocking or killing it, so you can talk while it runs.

See the release notes for details.

v0.0.297

  • Native tools continue while MCP connections finish; explicitly configured optional project servers participate after the normal trust checks.
  • Desktop turns retain final replies and completed tool results after errors.
  • Chat tabs support combined split layouts, saved layout restoration and improved motion; large conversations render a bounded recent section.
  • Queued prompts can be edited with attachment previews. Draft edits pause sending and survive navigation until saved or cancelled.
  • Inline HTML explanations persist with saved conversations, and the terminal launcher opens projects in the desktop app.
  • Clipboard image reads are more reliable; completion text removes fragmented citation control markers.
  • PR completion checks retain current-head verification obligations, and peer handoffs update publication ownership atomically.
  • Desktop regression checks use bounded execution and verified input targets.

See the release notes for details.

v0.0.295

  • #812: a mid-turn native image follow-up no longer sends empty text with the image, which some Chat Completions providers reject (Z.AI 1210). The caption is Attached image.
  • Muse Spark models accept image inputs on the Meta/Muse vision path.
  • Bare codedb context <task> defaults to on-device retrieval. Remote reranking remains an explicit opt-in and is refused under local-only policy (ADR 0084, ADR 0092).
  • Project layout selection favors breadth across directories, with explicit truncation notices. Missing codedb list_dir paths suggest close siblings without relaxing confinement (ADR 0093).
  • #794: the tier-1 suite ratchet counts skipped Zig tests with passed ones.
  • Provider citation annotations no longer leak as private-use glyphs in copy-ready text (TUI and line REPL). The GUI strips the same control markup from ACP assistant text (#805).
  • ACP session/cancel applies to the live turn instead of waiting behind the active prompt (#807).
  • wait_ms>0 on a persistent background server is a timeout, not wait-until exit (ADR 0091, #808). Finite auto-backgrounded jobs still wait for exit.
  • Oversized tool-result previews are first/last windows plus explicit read_tool_result paging (#809).
  • Desktop mermaid fences render as diagrams instead of code blocks.
  • Working agents show occupancy, peer talk, and Stop; queued follow-ups can be steered.
  • Updates settings: Check for Updates and a six-hour auto-download switch sit above the split panes. Restart stays explicit (ADR 0079).

v0.0.294

  • Streaming stalls are no longer silent: a watchdog reconnect now prints one bounded stream stalled — reconnecting notice instead of a bare spinner, and the trace names which stall regime fired (pre-first-token ceiling vs between-lines).

  • Codex Responses requests stream reasoning summaries (summary: auto), so silent reasoning emits traffic the reader already parses instead of looking like a dead socket.

  • Codex WebSocket prewarm (generate: false, openai/codex parity): a fresh socket prepares instructions+tools state before turn 1, which chains onto the warmup response id. Best-effort; falls back to a cold turn.

  • Responses WebSocket frames omit the transport-only stream field (xAI WS spec conformance); the frame buffer is freed at its full allocated length.

  • #768: the Computer Use node_repl bridge no longer dies on createElicitation is unavailable during a read-only sky.get_app_state({ disableDiff: true }). Graff advertises MCP form elicitation, accepts that inspect mid-call, and otherwise returns an actionable fallback that names the desktop computer tool. ADR 0036, ADR 0071.

  • #773: /update checks a GitHub release and, after an explicit human confirm, installs it for the next launch. The live process, conversation, and permissions stay on the original version; /new and /resume do not activate it. The in-session service pins the tag, verifies SHA256SUMS, and writes atomically — it does not run install.sh or restart. graff update --check shares the same running/latest comparison. ADR 0085.

  • #765: native codedb context honors local-only repository policy. Project instructions and .graff policy files that forbid transmitting working data, or a per-call local_only argument, dispatch codedb context --local (on-device BM25/symbol/graph) and never invoke remote advisory rerank. If local-only cannot be guaranteed — including an explicit --hybrid/--semantic under that policy — the call is refused before spawn. Ordinary reads stay native codedb (ADR 0040). ADR 0084.

  • #751: Meta / Muse Spark requests send tool_choice: auto only, and fold reasoning_effort: max to xhigh. The gateway rewrite stays a safety net. ADR 0083.

  • #750: the resize-anchor PTY probe waits for a stable frame after a width change instead of asserting on the first (possibly stale) repaint.

  • #748: an error-only SSE event is reported as that error, not retried as a truncated gateway body.

  • #747: edit_file / write_file / read_file share one absolute path from the posix session cwd (not a stale Io cwd or a disagreeing display cwd), so a worktree switch cannot report success on the previous tree.

  • #761: read_file optional fields stay out of required[] (path only). Null or empty contains / null bounds / null compact are a whole-file read, so strict tool calling can omit unused mutually exclusive fields. Nonempty contains still cannot combine with bounds or compact.

  • Desktop code highlighting uses a bounded cache, saved conversations avoid loading discarded tool payloads into the renderer, and split resizing avoids rerendering the full conversation on each pointer event.

  • Desktop drafts and attachments survive tab changes and split zoom. Stop stays available while writing a follow-up, and completion menus respect pointer input, IME composition and window shortcuts.

  • Desktop dialogs keep keyboard focus, settings switches wait for Save, and Files provides loading and retry states without accepting stale responses. First-reply streaming respects the reader's position.

  • #776: the native Open a folder picker keeps listing candidates while you type, ranks them like /model (closest name first), and shows a resolved directory with a trailing / (never //). Exact-path Go / Open folder and row selection are unchanged.

  • Prompt-cache affinity is the git root, or one scratch seed when there is no .git. Eval sandboxes and worktrees can reuse a warm system+tools prefix instead of paying it on every leaf cwd. An offline test fails if two scratch trees mint different prompt_cache_keys. ADR 0069.

  • #753: a background-agent handle survives a recoverable API interruption. agent_output replays a finished report, or says the launch ended with the parent turn, instead of "it may never have started". The ids ride in the session file. An ACP API error is a failed turn (saved), not a dead process. Backtested as the issue's three-handle sequence (persist → new process → agent_output) and as three live launches that still replay after reap. ADR 0068.

v0.0.288 (2026-09-06)

  • GPT-6 Astra is the default Codex model (gpt-6-astra, 272k context). ChatGPT login surfaces it; /model codex picks it. Mid-turn response.steer, vision, hosted tool_search / web_search, and OpenAI server-side compact all run on the Responses wire. Astra working guidance attaches only while Astra is selected.
  • Recorded user constraints ride the root prefix as live ledger JSON, including the empty set, so a compaction recap cannot invent a recording. A write refreshes instructions in the same turn and drops a cached Responses continuation.
  • A second bracketed paste in the same input batch no longer turns its first newline into Enter after the previous paste ends.
  • #752: a truncated tool-call argument stream can no longer poison later requests in the same turn.
  • #745: a plain final reply with unfinished current work gets one reconciliation request; a remaining stop is explicit.
  • #746: hosted search is not emitted until deferred tools are ready.
  • GPT-6+ on Codegraff uses OpenAI compact; Grok keeps the client summarizer.
  • Native composer: real @ files, image paste and drop.
  • Gemini is a first-class provider, on Google's own Interactions API. GEMINI_API_KEY serves gemini-* directly instead of falling through to the gateway as an uncatalogued model, and graff --model gemini-3.8-flash picks it up. This is a fourth wire format beside Anthropic Messages, OpenAI chat, and OpenAI Responses: a turn POSTs one Interaction and reads back execution steps (thought / model_output / function_call), with its own step.start/step.delta event stream.
  • Gemini keeps its real context window. Uncatalogued, it inherited the conservative 200k default and auto-compacted at 160k -- on a 1,048,576-token model, which compacts near 838k now.
  • Fixed two crashes found while wiring it up, both of which took down the whole process rather than reporting an error: the response root was dereferenced as an object, which a top-level JSON array (how Google's compatibility layer returns errors) turned into a panic; and streamed extra_content was stored pointing into the per-request scratch arena that is reset before the next request, so the session held freed memory and walked it on the following turn.
  • A harness-authored note (budget landing, repair grant, empty-completion bounce, compaction handoff) now follows the wire's shape. Interactions rejects a bare {"role":"user"} entry, so those notes ended the turn with a 400.

v0.0.287 (2026-09-04)

  • The macOS desktop app updates itself. It compares the newest release tag with its own stamped version, and installs only after the download verifies, carries the same Developer ID team as the running app, and is accepted by Gatekeeper as notarized. GRAFF_NATIVE_NO_UPDATE turns the check off. Releases carry the app as Codegraff-macos.zip.
  • Native app: a paginated conversation library, searchable and scoped to the workspace, alongside the existing sidebar list (#723).
  • #737: one paste stays one prompt. A paste larger than a terminal read arrives in several reads, and a chunk ending at a line boundary was read as Enter, sending half of it and steering the live turn with the fragments.
  • #729: a rendered bare URL no longer carries trailing emphasis markers into its click target.
  • #721: the workspace switch resolves paths through an opened directory rather than libc, which this binary does not link.
  • #717: a Codex websocket transport error retires the socket instead of carrying a half-dead connection into the next request.
  • #739: outbound writes are sanitized by default. Anything published off the machine carries what the task needs, not the local context a debug session collected, and a detail that identifies the user is asked about before it is published.
  • #738: a compaction summary may no longer claim a constraint was recorded — recorded constraints live in a ledger injected separately, so an asserted one is indistinguishable from an invented one. A constraint recorded mid-turn now says it takes effect immediately.
  • README leads with the desktop app and documents how the project measures itself.

v0.0.286 (2026-09-04)

  • Native harness gains a browser pane: a headless Chrome tab per chat, driven by Kuri, started only when the pane is opened and stopped again after a quiet spell or past a memory cap. Browse forwards clicks, scrolling and typing; Annotate pins the element under a click, with an optional note, and the pins ride with the chat's next message so the agent can act on the page the reader is looking at.
  • Split view: another chat beside the ones on screen, up to four columns, each with its own transcript, composer, model and folder.
  • Tab names are written by the model from the first prompt rather than chopped out of it, and a session open in a tab lends its name to the sidebar.
  • Saved chats can be archived (the file moves aside, the conversation survives) or deleted from the sidebar.
  • Keyboard: new chat, close, reopen the last closed chat with its session resumed, add a split, and jump between tabs.
  • Picking a workspace now changes the folder in front of you when the tab is empty, instead of leaving it behind a second tab.
  • The desktop shell ships as a signed, notarized macOS app with the project's icon, and no longer serves a stale page from WebKit's cache.
  • Native app moves to Next.js 16.3.
  • GUI declares its esbuild dependency so a clean build resolves it.

v0.0.285 (2026-09-03)

  • Native transcript follow-tail only while the reader is at the bottom. Scrolling up mid-stream no longer yanks the thread (#724).
  • Follow-ups typed while a turn is running queue and drain in order when it ends. The composer stays usable; stop stays on an empty draft.
  • Native tools interleave with the answer instead of stacking above it; settled tool batches fold; ACP patches paint once per frame.
  • #721: workspace switch stars and reports the process cwd.
  • #717: Codex WS type:error retires the socket immediately and keeps a one-request marker for the bounded diagnostic. Re-anchor only when the rejected body actually sent previous_response_id. Unparseable Responses envelopes no longer copy raw bytes into last_api_error.
  • TUI mid-turn steer / /btw bakes composer [Image #N] chips into the queued payload as @[path].
  • TUI streams the live answer instead of a Thinking placeholder while tokens arrive; codedb folds as “Looked up N items”.
  • 284 stays published as-is. This is not a retag.

v0.0.284 (2026-09-01)

  • ACP turns stage GUI @[image] attachments as native vision blocks so pasted images reach the model.
  • #708: peer-inbox wake is advisory (parked; peer_message action=inbox when relevant), never a command that displaces the turn.
  • #711: a failed parallel bash result (gh 404 JSON + exit code) cannot poison the next Codex body. function_call.arguments and function_call_output.output that arrived as objects are coerced to strings before send.
  • #712 / ADR 0059: bare /resume and /sessions list cwd saves, then ~/.graff/sessions. Cross-workspace rows name their origin. Resume restores history here; file tools stay in the current cwd.
  • #714 / ADR 0060: the “named a source file” nudge is per unanswered mention, not the whole history. A host re-submit that ends on the same user row is skipped; three copies fail closed as stuck replay. The same words after an answer still run.
  • #716: fullscreen /goal uses the shared lifecycle (set / pause / resume / clear). A typed TUI goal is not standing, so recorded completion retires it and /resume does not steer the next prompt.
  • The gateway is a fallback seat, not the startup default.
  • In-house remasure on this tip (run-20260901-121759-composite): all three harnesses 12/12. Graff 220s / 53 calls / $0.32 / 8.7M vs OpenCode 235s / 77 / $0.68 and grok 490s / 60 / $1.07. Unique frontier on pass / wall / calls / tokens / list$ / RSS. A 115s symlink stall (same 4 calls) was remasured at 67.8s, same pattern as
    1. Hosted x_search stays on.
  • No tag until asked.

v0.0.283 (2026-08-31)

  • Next cut after v0.0.282 landed on main. First fold: #702 / ADR 0056 — deleting a composer image chip drops that queue slot and reuses #N. clipboard_paste no longer stores MIME or byte count for drafts abandoned before submit.
  • Suite floor 1868 (was 1861). Tournament E2E parent timeout 300s and 45s default barrier so CI cannot flake on #467 rendezvous. Tuiguard probes have a per-probe deadline and a parent wave budget so one wedged PTY child cannot hang pre-push (#704). peer_message resolves a live session by its visible title or saved-session base (#700). Presence is still device-local. In-turn compaction stops after the same unresolved pin fails to shrink twice (#706). Credential files fsync their directory after rename (#405 / #705). No tag until asked.

v0.0.282 (2026-08-31)

  • Next cut after v0.0.281 landed on main (#670). First fold: atomic paste spans (#674), terminal Codex WS API errors (#693), and recoverable HTTP client generations (#694 / ADR 0048). #694 follow-up hardens lease teardown.
  • #697 / ADR 0049: --resume SOURCE --branch DEST clone-on-write so two processes cannot clobber one .session.json. #698 follow-ups: 160 MiB learn-pin headroom for debug builds, source-nudge suffixes no longer match .json / .jsonl as JavaScript, Codex compaction probe reads Responses input_text blocks.
  • #679 / ADR 0050: MCP HTTP/WSS reuse the warmed TLS client; MCP HTTP accepts gzip catalogs.
  • #695: an empty tool catalog omits the tools field instead of serializing "tools":, (0.0.280 HTTP 400).
  • #694/#697/#679 numbered records 0042/0043; those slots are TUI claims and Pi SWE. Remapped to 0048–0050.
  • #677 / ADR 0051: /teleport restores a snapshot tar onto another CLI backend; /snapshot gc keeps the newest n trees. Leftover of #554. #677 numbered this 0042; remapped (0042 is TUI claims).
  • #675 / ADR 0052–0055: lean -p bounces a prose-only first "done"; short Codegraff flakes retry twice; DeepSeek family default low sends thinking.type=disabled; lean bash auto-backgrounds at 15s. #675 numbered those 0048–0051; remapped off 282's 0048–0051.
  • #277 (Smolify OAuth) and #200 (idle localhost) closed as abandoned vs tip; issues stay parked.
  • Suite floor 1861 (was 1849). Scratch helpers live in agent_request_scratch.zig so the request loop stays under 600.
  • 12-task in-house remasure after #697 still unique vs grok / OpenCode: 12/12 · 201s · 52 calls · $0.34 (run-20260831-021035-composite).

v0.0.281 (2026-08-29)

  • Next cut after tagged v0.0.280. Headline is the hardlink graff-pinned + detached learn init (#687 / #688): -p and the REPL share one path, no 127M copy. The earlier oneshot-only skip (ADR 0044) is not the tip behavior.
  • README is ~200 lines (was ~1700) and carries the same-model 12-task in-house table: graff 12/12 · 192s · 52 calls · $0.35 vs OpenCode 236s / 74 / $0.79 and grok-build 462s / 63 / $1.12 (run-20260830-141658, #690).
  • graff tui / TTY graff repl claim the alt-screen before credentials and paint live markdown on the cached tail (ADR 0042, #666).
  • pi-xai runs Pi on the SuperGrok seat the same way as graff-dev (ADR 0043, #667). Do not steal Pi's 4-tool catalog or 165M heap.
  • Codegraff glm-5.3-flash SWE (ADR 0045 / 0046, #669 / #671): omit still thinks; default flash effort is low. -p streams so a hung POST dies on the 30s stall, not a 5-minute watch. SWE 5/6 in 286s (Pi 5/6 in 758s). Same miss (label-sort). Do not steal Pi's catalog.
  • Same SWE suite on other Codegraff models (ADR 0047): Gemini graff 5/6 in 103s; Kimi 4/6 in 583s; DeepSeek flash still one-shots (Pi 5/6). Do not steal Pi's catalog.
  • Interactive --yolo queues companion MCP and names the boot phase (mcp: / companion: receipts) so first paint is not the handshake (#664). Mid-turn stall/reconnect and model call N pulses stay off the transcript; a ⚠ prints only when the turn ends (ADR 0021, #665).
  • Eval frontier (#687): OpenCode --dir / dsh harnesses, in-house PR suite, hardlink graff-pinned + detached learn init, scripted-REPL usage footer. Fair same-session grok-4.6 A/B stays on the PR.
  • No tag until asked. Download / notarization ids land after the build.
  • Test floor 1791 (slack 25).

v0.0.280 (2026-08-28)

  • Next cut after tagged v0.0.279. Carries the #645 continuation already on main plus #646–#649 leftovers from release/v0.0.279. Not a retag.
  • Experiment pool: forced fan-out, graff worktree list tags, deliver-back. Still opt-in --experiment N / /experiment (ADR 0037, #647 / #629).
  • TUI stall HUD, resize, MCP config polish (#646 / #549). Native Anthropic output_config.format json_schema (#550).
  • TUI /tell and /peek use the existing peer mailbox (#648 / #563).
  • ACP initialize advertises terminal graff-login (#649 / #613 leftover). Local tools are .graff/tools/ scripts (ADR 0039). /schedule due-claim plus TUI idle wake. Channel workers are JSONL outbox + wake only.
  • Same-process embed libgraff + graff-core.wasm + createGraffAgent() (ADR 0038, echo turn). Live coding stays graff acp.
  • Native codedb and read_file stay the default readers when codedb-pro is licensed, including rlm codedb. Do not use mcp__codedbpro__read for ordinary files (ADR 0040, #652).
  • TUI is an in-process ACP client (ADR 0041): thought/tools/text from session/update, no child graff acp.
  • Pager inset like grok-build; overlay panels stay full-width and docked.
  • Test floor 1745 (slack 25).

v0.0.279 (2026-08-26)

  • Native Beautiful UI app (apps/native) is an ACP client. Next.js /api/acp spawns graff acp --yolo; thinking and tool chips stream from the first call. graff serve is not required (#637).
  • graff acp emits mid-turn session/updates for thought, text, and tool_call / tool_call_update (ADR 0032). Protocol version stays 1. After session/new it advertises /never via available_commands_update.
  • A user can retire a standing constraint from ACP or the REPL (ADR 0033, #638). On a TTY, bare /never opens a searchable picker (text prominent, id secondary) and requires two confirmations; Esc/Keep leaves the ledger unchanged. /never rm <id-or-text> and an explicit forget/override in the next message still work. The model cannot retire a rule. /never rm without a needle lists (or opens the TTY picker) instead of recording rm as a constraint; a failed tombstone write says the rule is still active; traces record never_retire {id, ok} with no text (#644).
  • bash_output / agent_output wait_ms>0 always waits for exit (10h). Mid-range values like 60s–240s are no longer a bounded deadline (#640).
  • Host embed path: docs/embedding.md names the two stdio APIs (graff acp and @codegraff/sdk Harness), with a Node JSON-RPC recipe and a thin @codegraff/sdk/acp helper (spawnAcp / acp). Not WASM / libgraff.
  • TUI composer: a multiline paste stays one unsent draft. Embedded \n / \r\n from a bracketed paste (or a wrap-less burst) cannot steer or queue one prompt per line; Enter after the paste submits exactly one (#643).
  • Existing Tauri gui/ is unchanged.
  • First-turn tool delay: live chips paint immediately (no 300–450ms fade), ACP tool_call is in_progress and flushed, and the first model call no longer waits for a deferred MCP handshake (ADR 0035). Running tools show elapsed from the moment they start.

v0.0.278 (2026-08-26)

  • Composer image pastes are marker-gated (#634). Deleting [Image], [Image #N], or a TUI chip before submit drops that payload; a text-only prompt no longer leaks native input_image blocks. Identical b64 collapses so two pastes cannot become four blocks.
  • /image and /paste stay sticky for the next text-only line. /image clear clears the whole queue.
  • TUI: backspace on an empty composer drops the last chip; Ctrl+U / Cmd+Delete clears chips with the draft; overlay backspace/x detaches the previewed chip.
  • Bundled Smolify is gone: no reserved smolify name, no GRAFF_SMOLIFY auto-connect, no CI boundary E2E. Add it like any other remote MCP (graff mcp add smolify --url https://app.smol.ly/mcp). A local secret-egress gate still rejects recognizable credentials on mcp__smolify__* if you do. Schema-gate tests keep smolify-tools.json as a fixture.
  • Test ratchet: unit suite 1683 (floor 1683; dropped the bundled-Smolify registration test).

v0.0.277 (2026-08-26)

  • MCP tools that load_tool_schemas has unfolded are rlm host functions (each / len / project). Return shapes (keys + broad types, never values) persist in .graff/mcp-shapes.json and splice onto the next load result, never the catalog prefix (ADR 0029).
  • Fat MCP JSON arrays auto-slim after remember(): identity keys on issue-like rows; comments fold to {n, latest_author}. Two stored shapes add a # muscle: playbook on the load result.
  • Full-harness SuperGrok grok-4.6 (graff-dev-nolean): L (warm slim) 14.8s / 31k / 5 and N (cold slim) 20.8s / 30k / 5 dominate the pre-slim H/I/J front. Lean catalog (R) is a different prefix and is not on that front.
  • Default -p connects a workspace .mcp.json and folds schemas; it no longer skips MCP. --no-lean is eager schemas, not the MCP on-switch.
  • Licensed codedb-pro: one read/search surface (hide native read_file / codedb, omit companion writes, keep native edits) (#626/#627).
  • Long turns and transport retries pulse without a default 16-call cap (#624/#625).
  • Smolify / deepwiki / mobbin stay out of the default catalog unless opted in (GRAFF_SMOLIFY) (#628).
  • xAI Responses splices hosted x_search onto tools turns (ADR 0031). Not a catalog tool. GRAFF_XAI_X_SEARCH=0 opts out. Same-prompt SuperGrok A/B vs scrape: 101s / 7 calls / 64k in → 37s / 1 call / 28k.
  • Small turns hide rlm / sPTC (ADR 0030). Showcase on --rlm, a ≥4 native batch, context ≥50% of compactAt, or an explicit load — never MCP fan-out, never the prefix. Tools head stays cache-stable.
  • Test ratchet: unit suite 1677 (floor 1664).

v0.0.276 (2026-08-25)

  • rlm (Zhang/Khattab RLM + alexzhang13 spec-ptc, Zig — not Prime's IPython kernel) is the default loop. --old / --no-rlm (or GRAFF_OLD=1 / GRAFF_RLM=0) restore the structured-only catalog. --rlm stays as an explicit on. Last CLI flag wins; env does not clobber --old / --rlm.
  • The spec stays folded behind load_tool_schemas. --schema / the 64-cell tool-catalog kernel do not grow a new tool.
  • Prompt-cache max: GRAFF_STABLE_CATALOG is on by default so load_tool_schemas (including rlm) does not rewrite tools JSON. Spawned subagents inherit it. Children share four role-lane x-grok-conv-id / prompt_cache_key values (official xAI sticky routing — same id, same server). rlm's subagent("task") uses label subagent, so siblings hit one lane. They do not reuse the root id. Opt out of stable catalog with GRAFF_STABLE_CATALOG=0 or GRAFF_NO_STABLE_CATALOG=1.
  • Measured default-RLM vs --old on grok-4.6 SuperGrok (one rlm suite rep): both 5/5, $0.0000 / $0.0000 (flat-rate). Persist bind-reuse 99.6s / 135k in → 39.2s / 25.3k in. Suite totals 161s / 203k in → 136s / 105k in. Scatter wall is a wash this rep (#619's 86.8s → 23.7s did not reproduce). See ADR 0022.
  • Root foreground bash no longer waits forever: after 120s (or timeout ms) a still-running command is moved to the background and the model gets a job id, matching grok-build. Esc still kills; the cancelled result tells the model to use run_in_background. Subagents keep the #93 120s kill. (#620)
  • Kimi Coding keeps User-Agent graff/<version> (Moonshot forbids spoofing) and matches kimi-code's X-Msh device fields: hostname, Windows ${release} ${arch} / macOS ${product} ${arch}, kernel os.release() (#617)
  • Codex session_id header is the same value as prompt_cache_key (openai/codex ModelClient default), not a per-process random UUID
  • Codex high-effort thinking no longer trips the 45s stall watchdog after in_progress (encrypted reasoning is silent). A stall notice no longer says "ending turn" while reconnect still has retries. Interactive sessions print a dim graff update line when GitHub has a newer release.

v0.0.275 (2026-08-24)

  • OpenRouter requests carry app attribution (categories: cli-agent, programming-app).
  • TUI: Esc with a draft in the composer never kills a live turn.
  • Agent retries degenerate empty completions and keep-alive-only bodies.

v0.0.274 (2026-08-23)

  • Rate-limit and 5xx retries no longer dump the provider's raw error JSON onto the REPL (user ids, BYOK/settings links, routing docs). The line is [rate limited (429) — retrying in 1s (1/5)] and nothing else. Quota classifiers still read the captured body internally.

v0.0.273 (2026-08-22)

  • Long-running tool calls no longer read as a hang: after 15s of silence (then every interval) a dim · bash still running · 2m10s pulse prints on the line REPL and the TUI — for foreground bash and for blocking bash_output waits alike.
  • CI: scripts/test-pty-repl.py follows cwd back onto the prompt meter.
  • Test ratchet: unit suite 1586.

v0.0.272 (2026-08-22)

  • Windows: the line REPL prompt (readline / pickers) and standalone graff-repl also switch the console to UTF-8 (CP 65001). 0.0.271 did this at process start and in the fullscreen TUI; the › editor path did not (#607).
  • Test ratchet: unit suite 1582.

v0.0.271 (2026-08-22)

  • Windows: line REPL and fullscreen TUI switch the console to UTF-8 (CP 65001) before any chrome is printed, so box-drawing and icons are not decoded as CP437/1252 in PowerShell 5.1 (#607). zigzag's graff repl already did this; graff and graff tui did not.
  • Test ratchet: unit suite 1580.

v0.0.270 (2026-08-22)

  • OpenRouter is a built-in OpenAI-chat seat (OPENROUTER_API_KEY, graff key set openrouter …, default anthropic/claude-sonnet-4.6). Chat goes to openrouter.ai/api/v1; live /models overlays the catalog. Attribution headers http-referer + x-title. Provider kernel 21.
  • Windows: edit_file/write_file no longer panic the session on Zig 0.17's unimplemented path chmod (dirSetFilePermissions). Mode restore uses handle chmod (#606).
  • Line REPL transcript is the task, not the event bus (ADR 0021).
  • TUI markdown paints numbered lists, quotes, tasks, rules, and _italic_.
  • Test ratchet: unit suite 1578.

v0.0.269 (2026-08-20)

  • codedb pairing (ADR 0019): advertise five one-shots — context <task>, around <name> (def+callers), callpath A B, list_dir <path>, status. Hop verbs stay callable, not on the catalog menu.
  • Vercel AI Gateway is a built-in OpenAI-chat seat (AI_GATEWAY_API_KEY, graff key set vercel …, default alibaba/qwen3.8-27b). Chat goes to ai-gateway.vercel.sh/coding-agent/v1 (docs: marks harness traffic; GRAFF_VERCEL_URL rewrites to generic /v1). Live /models overlays language rows only; image/video/embedding are not chat seats. /effort becomes reasoning.effort (max/ultra → xhigh). Attribution headers http-referer + x-title.
  • Z.AI's existing seat now defaults to GLM-5.3 (1M context) with live /api/paas/v4/models, thinking.type=enabled, and /effort remapped onto low/high/max (graff medium → high). Pay-go stays on api.z.ai/api/paas/v4; GLM Coding Plan keys use ZAI_CODING=1 or GRAFF_ZAI_URL. Prompt-cache max: implicit prefix reuse (cached_tokens) plus thinking.clear_thinking=false so replayed reasoning_content stays in that prefix. This is the GLM chat API, not image/video.
  • Test ratchet: unit suite 1531.

v0.0.268 (2026-08-20)

  • Cerebras Inference is a built-in OpenAI-chat provider (CEREBRAS_API_KEY, graff key set cerebras …, default gpt-oss-120b). Live /v1/models overlay; this is api.cerebras.ai, not the WSE CSL SDK.
  • imagegen's Codex engine uses a private features-only config.toml so codex exec no longer dies with input contains invalid characters at line 1 column N from the user's MCP/skills overlay (#576).
  • /resume restores the peer-channel byte cursor and parked inbox instead of replaying the last 10 room lines (ADR 0014). Peer wakes are not a human turn for title or meaningful-state.
  • Directory listing is codedb list_dir (in-process BFS, gitignore, 10k cap), not a new always-on catalog tool (ADR 0013).
  • Custom subagent files can be Codex-shaped TOML: name, description, developer_instructions, plus model / model_reasoning_effort / isolation / tier. Loaded from ~/.codex/agents, ~/.harness/agents, .codex/agents, and .harness/agents (a graff file of the same name wins). Markdown frontmatter still works; /agents promote still writes .md.
  • Foreground bash streams as bash_output_chunk frames (16 KiB) onto a raw terminal buffer, not the prose stream. Background jobs inject a grok-build-style completion wake at the next step and, in the TUI, start a turn while idle. Do not poll.
  • ask_user pasted images reach the next model request as real vision blocks (a follow-up user message after the text tool result). Nine [Image] placeholders with no pixels was #580. If nothing staged, the tool result says so and names path / paste-text / next-prompt fallbacks.
  • Compaction and emergency trim stop before an unresolved current user prompt and keep its image blocks verbatim (#581). A retry does not move that cut. If the live prompt is the whole history, compact fails explicitly instead of summarizing attachments to text. Traces emit compact_cut with the boundary and preserved image count, not pixels.
  • Test ratchet: unit suite 1486.

v0.0.267 (2026-08-19)

  • Background jobs wait like grok-build: bash_output(wait_ms>0) and agent_output(wait_ms>0) block until exit (10h cap), not until the next byte or 30s of silence. The old 1–30000 poll values are promoted to that cap so a gh run watch loop is one tool call, not hundreds of model hops (ADR 0010).

v0.0.266 (2026-08-19)

  • Peer talk is pull, not a second copy of the room: peer_message action=list / action=inbox parks bodies in a ring and injects one [peer] wake line. Named pings are DMs to the agent doing the work (ADR 0004).
  • --goal / /goal is one [standing goal: …] prefix line. The long coaching essay injects on first sight and on change only — not every N turns (ADR 0005). Bundled jspace skill stays on-demand.
  • Mid-session worktree switch is a real workspace tool (action=list / action=use). A skill cannot move file-tool cwd (ADR 0006).
  • Plugins and foreign MCP are read in place (ADR 0007): Cursor / Claude / Grok / Codex trees, Claude commands/*.md, no copy into ~/.codegraff. cache/ is never walked. Claude/Cursor cache comes from installed_plugins.json; Codex from ~/.codex/config.toml [plugins."name@marketplace"] → plugins/cache/<mp>/<name>/<ver>.
  • Prompt-cache max: the skill catalog is names + triggers only, sorted, pinned once at session start, no file: paths. Bodies load on skill name=. GPT-5.6 OpenAI Platform marks the stable instructions/tool prefix explicitly for 30-minute reuse; Codex and xAI remain on their supported keyed automatic-cache paths (ADR 0009).
  • Cache creation tokens are tracked separately from reads and ordinary input, including the documented 1.25× GPT-5.6 and Anthropic write price.
  • Path confinement, transport, score filing, and terminal mode lifecycles now have executable state-machine references with matching Lean proofs.
  • install.sh appends ~/bin to the login shell so graff is on PATH.
  • Synthetic long-horizon evals (evals/long_horizon/) grade with external deterministic checks (ADR 0008).
  • Test ratchet: unit suite 1444. GRAFF_NO_PLUGINS=1 still hides foreign trees.

v0.0.265 (2026-08-17)

  • The TUI is clickable everywhere it looks clickable: a click on any picker row (models, files, themes, settings, effort, jump, the slash menu) moves the highlight and a click on the highlighted row confirms it, exactly like Enter. Clicking the backdrop around a panel dismisses it. The scroll thumb is live: click the gutter to seek, hold and drag to scroll. A motionless click never starts a copy, and a drag never toggles a fold.
  • Overlays draw as proper panels: a framed, docked pane with the title in the frame, so pickers read as surfaces instead of floating text.
  • /models finally says who serves each model. Every picker row and the REPL table show the provider plus a cost badge (plan, credits, api, local), search matches provider names, and picking one of two same-named models switches to that row's provider, not the first name match. Codex on your ChatGPT plan and the same model on a metered OpenAI key are now visibly different things.
  • Prices and context windows refresh from the community LiteLLM price database (cached a day in ~/.codegraff/prices.json, GRAFF_PRICES_PATH overrides). The baked table remains the offline floor, canonical vendor rows outrank reseller copies, and codex context caps are untouched.
  • New sandbox seam: /snapshot attach puts a Docker container under the session, /snapshot captures its filesystem, /rewind <id> restores it, and /snapshot list shows what you have. The tarball streams disk to disk without entering memory, and the conversation log is never rewound with the sandbox. /rewind <number> still rewinds the conversation.
  • Test substrate: three new live probes (clicks, model picker, overlay panels) join the tier 1 gate; the suites grew to 1400 unit and 415 TUI tests.

v0.0.264 (2026-08-17)

  • The frame painter now guarantees screen == frame: rows that measure full are erased before they are written, every repainted row re-establishes its own style, no frame row can exceed the screen's width or height, and a latched SIGWINCH plus an idle self-heal repair anything that repaints the terminal behind graff's back. stderr is parked on .graff/tui-stderr.log while fullscreen, so nothing can scribble on the alt screen.
  • Scrolling is 120fps-class: the transcript is laid out once and scrolled as a slice (frame build p95 0.23ms on a 10k-line transcript, ~78x faster), a one-line scroll emits one hardware scroll plus the exposed rows, and wheel storms coalesce to one paint per 8ms with typing echoed in under 30ms throughout. A 500-report burst settles in 3 paints.
  • Tool folds read like sentences: "Reading 2 files…" counts up while the run streams and settles to "Read 3 files", with a ›/⌄ disclosure chevron, an indented card gutter when open, and a brief settle flash when the run finishes. "Called N tools" survives only for mixed runs.
  • Clickable rows look clickable: the row under the pointer takes a hover tint one step off the canvas (text untouched) and restores on leave. A double click is one net toggle on a fold header, and a double click on the sticky prompt pin jumps the viewport back to that prompt.
  • A scroll position thumb rides the right edge while scrolled and fades at the tail, and drag-copy also reaches the terminal's own clipboard via OSC 52, so copying works over SSH. Both respect the selection band.
  • Drag-selection copies text rows only: blank screen padding contributes nothing, leading/trailing blanks drop, an interior blank run collapses to one empty line, the toast counts text rows, and a drag over nothing leaves the clipboard untouched.
  • A width resize keeps your place: the entry on the top visible line is re-anchored after the rewrap, and height changes keep bottom-follow while tailing.
  • Unified diffs in tool results and ```diff fences render with add/delete background bands that survive wrapping without bleeding into the next row.
  • Streaming markdown is boundary-proof: carriage returns, raw escape sequences from the model, and UTF-8 glyphs split across deltas are held or stripped, so a chunked answer always lands on the one-shot render.
  • Every animated chrome glyph is pinned to one terminal column, and an open picker or slash menu owns the wheel, one item per notch.
  • Compaction on the Responses route (codex/OpenAI) now defaults to the server-side path for every install: the A/B concluded recall-safe, so the bucketing is retired. GRAFF_SERVER_COMPACT=0 still forces the client summary, and the near-the-wall client fallback is unchanged.
  • Testing: a stdlib-only virtual-screen pty harness (scripts/ptyharness.py) renders the byte stream into a cell grid and can corrupt the screen behind the child to prove self-healing; fourteen live pty probes now gate tier-1, and the spec corpus grew GoalLoop and PromptCache process kernels.

v0.0.263 (2026-08-17)

  • grok-4.6 is the xAI default: 500k context, compact at 400k, published dual-band prices ($2/$0.50/$6 under 200k prompt tokens, $4/$1/$12 at or above). SuperGrok login stays $0; metered XAI_API_KEY uses the bands. grok-4.3 is unchanged.
  • /effort low|medium|high|xhigh now applies on native Grok. The default Responses wire already sent reasoning.effort; the UI no longer claims the model ignores it, and GRAFF_XAI_WIRE=chat sends reasoning_effort. grok-build via the Codegraff gateway still rejects the hint.
  • Prompt-cache affinity is durable per project: a new session in the same cwd reuses prompt_cache_key / x-grok-conv-id instead of minting a process-local id.
  • TUI: crash/suspend/panic restore the terminal; SIGTSTP no longer livelocks a background op; in-app drag selection copies on release; quit cancels and settles the live turn before leaving fullscreen.
  • The TUI is a real client of the REPL engine now. Tool rows come from the engine's typed events instead of re-parsing rendered text (no more phantom tool rows when an answer starts with a status glyph), /thinking actually streams reasoning, and denied tools, notices, and provider failovers show up in the transcript.
  • /plan and /strict are enforced, not footer labels: plan mode denies writes and ! commands through the engine's own gate, and !cmd runs under the same approvals, hooks, and accounting as the model's bash tool, with its output entering the conversation.
  • The session conversation lives in the engine across turns, so a follow-up request carries the previous turn's tool calls and results, and provider prompt caching works again. /context and /session-info report the engine's token meters instead of local character counts.
  • Input hardening: a split or unterminated bracketed paste recovers (bounded holds everywhere, a resting mouse can't stall it), lost escape-sequence debris no longer types itself or eats the next word, the kitty numeric keypad works, and Ctrl+D quits from an empty composer.
  • /models pings every keyed provider catalog live on each listing, so new gateway rollouts appear without a restart.
  • Structured outputs reach Anthropic (schema as a tool) and survive DeepSeek's json_schema reject by degrading to a structured_output tool.
  • Conformance corpus grew to ten Lean kernels (3,642 cells). TUI pty lifecycle guards joined tier-1, and the README documents the full 54-command catalog.

v0.0.262 (2026-08-15)

  • A formal conformance corpus now guards the harness's decision procedures: six Lean kernels (tool catalog, transport, provider table, goal loop, path confinement, routing shapes) prove the invariants, an executable reference model exports every reachable cell (1,770 of them), and zig build test diffs the live implementation against the export — a wrong flag combination fails with the exact counterexample cell. scripts/eval-spec.sh runs the whole triangle offline; lake is optional and never on the test path.
  • TUI /compact now runs the engine's real compaction (same summarizer as the REPL) instead of silently cropping to the last few rows; the model's context and the transcript finally agree about what survived.
  • Thinking no longer pulses the transcript: the flickering live bar is gone from every collapsed "Called N tools" row; liveness is the pending row's steady bar and animated dots.
  • Split escape sequences get a second hardening pass: the input loop now waits ~500ms for a truncated sequence's tail (slow ssh/tmux links complete instead of losing input), and only then drops it — still arming the orphan-debris sweeper. An unterminated OSC/DCS introducer (Alt+] in meta-sends-ESC terminals) recovers the text typed behind it instead of wedging the keyboard until it is destroyed (#516), and a buffer-filling wedge can no longer masquerade as a TTY hangup that exits the TUI mid-session (#517).
  • Mid-turn safety: /new, /compact and /rewind are refused while a turn is running instead of wiping history under the live job (#521); the slash-menu selection clamps to the filtered list and scrolls with the highlight, so Enter always fires the row you see (#522); steering can no longer strand a permanent "thinking" row (#520).
  • Raw mode clears IEXTEN and IXON: Ctrl+V pastes as advertised and Ctrl+S cannot freeze the whole TUI (#523).

v0.0.261 (2026-08-15)

  • The TUI looks and behaves like grok-build where it counts: syntax-highlighted code fences (grok-night/grok-day token colors on a full-width band, hidden markers), a sticky header pinning the prompt you scrolled past, automatic light/dark from the terminal's reported background, and flicker-free synchronized painting.
  • Two dozen rendering and input bugs found by a three-pass audit and a live visual-capture pipeline, headlined by: a half-arrived mouse-hover report could fire a phantom Escape that silently cancelled the running turn and then type its debris (39;7;32M…) into the composer; the orphan-sequence sweeper ate pasted text like 0x1f and 1e5; the first **bold** made the rest of the message bold; emoji and CJK widths bent every box border; /theme left most rows in the old background; /jump hid the very turn it jumped to; clicking blank space toggled the last tool run.
  • Grok requests carry x-grok-conv-id and prompt_cache_key on every wire so xAI's automatic prompt caching actually hits; WebSocket sessions retire before the server's 25-minute cap and classify its error frames instead of burning the stall budget. GRAFF_XAI_WS_CHAIN=1 opts into on-socket delta chaining (experimental).

v0.0.260 (2026-08-15)

  • Fixed the composer silently wiping mid-typing: switching apps with Cmd+Tab latched a phantom Super modifier (the release went to the other app), so the next Backspace acted as Cmd+Backspace and deleted to the start of the line. A plain keypress now clears stale modifier latches.

v0.0.259 (2026-08-15)

  • Grok now defaults to xAI's Responses wire: WebSocket turns (with the SSE fallback ladder), lossless first-party server compaction, and structured outputs work out of the box on a SuperGrok subscription. Set GRAFF_XAI_WIRE=chat to return to chat completions.
  • Fixed duplicate MCP tool definitions when a deferred server start raced the eager codedb-pro companion; strict Responses endpoints rejected every turn over the duplicate.

v0.0.258 (2026-08-15)

  • Full Grok support on a SuperGrok subscription (#502): opt into xAI's Responses wire with GRAFF_XAI_WIRE=responses for first-party server-side compaction (encrypted blob; measured −80% follow-up input tokens on a 9.3k conversation, with the client summary kept as automatic fallback), WebSocket turns over the held socket, and --output-schema '<json>'/@file structured outputs on both wires. grok-4.6's stray <|eos|> after strict-schema JSON is stripped, and structured output runs two-phase — an unconstrained agentic run, then one tools-off formatting turn — so a strict grammar can no longer talk the model out of using its tools.
  • graff-evals: an in-repo, RL-style eval environment — 12 deterministic agentic tasks (debugging, shell, git, refactor, long-context recall, structured output …) with sandboxed checks; run.py --harness graff,grok prints a side-by-side pass/wall/latency/token table.
  • Kitty keyboard overhaul: the real kitty modifier table (Right-Alt/Right-Cmd no longer type Escape), key-release events never double-fire, a stale alt/super latch resyncs, and terminal state (kitty pop, alt-screen, mouse) is restored even on SIGTERM/SIGHUP. Shift+number punctuation and mouse hover for image chips both keep working.
  • REPL parity commands from the grok-build gap review: ! shell prefix, @ file mentions, /jump, /copy, /btw, /vim-mode.
  • Fewer discovery rounds when a prompt names its target file/symbol (#489).

v0.0.257 (2026-08-15)

  • Composer box corners line up with the sides, wrap at word boundaries, and the hint row is clipped so it no longer ends on a stray "E".

v0.0.256 (2026-08-15)

  • Leftover Kitty keyboard CSI (3u7444;9u) is ignored instead of typed or turned into Escape/Ctrl+C (which cancelled the turn).
  • Shift+number keys type the punctuation they should (Shift+9 is (, Shift+0 is )), including via Kitty CSI-u and modifyOtherKeys.
  • Interrupting a turn collapses Thinking immediately (Grok ❙ + static "Thinking"; no leftover spinner next to ■ interrupted).
  • The pager appends raw stdin hex to .graff/tui-traj.jsonl and the last visible frame on exit so the next leak can be replayed.

v0.0.255 (2026-08-14)

  • The fullscreen pager no longer prints raw SGR mouse reports (39;33;23M) into the thinking line. Hover-motion tracking is off; split/orphan mouse sequences are consumed instead of typed.

v0.0.254 (2026-08-14)

  • graff tui (and TTY graff repl) is a Grok-style fullscreen pager: wrapped composer with Ctrl+Z undo, folded multi-tool cards that click open, image chips, a searchable effort picker, markdown tables, and a headless Term driver for tests. Bare graff stays the line REPL.
  • /import-claude copies Claude/Cursor MCP servers, skills, and hooks into ~/.codegraff and the current repo; first start adopts automatically, the command remains for a later rescan.
  • Hosted TUI tool rows carry the path or a one-line preview so live ⚙/✓ lines stay inspectable without dumping raw JSON.
  • macOS CLI and desktop assets are Developer ID signed and Apple notarized (notary-local); the .dmg and updater tarball ship beside the CLI tarballs.

v0.0.253 (2026-08-14)

  • Explicit /compact uses OpenAI's standalone Responses compact endpoint for direct API-key sessions and supported in-stream compaction for Codex, with transactional history replacement and local fallback; non-OpenAI providers remain local-only.
  • Measured interactive yolo startup falls from 5.85s to 2.76s—53% less waiting, or about 2.1x faster—through Kimi prompt-cache affinity, low-effort lookup routing, concurrent live-catalog fetches, and concurrent/deferred MCP startup, while preserving deterministic catalog and tool ordering.
  • @codegraff/sdk ships its platform harness binary and production embedding APIs for persistent turns, live events, controls, cancellation, and process ownership, backed by packed-install and JSON integration coverage.
  • The normal REPL keeps recovered recap retries and verbose tool/startup details out of the way; /debug provides a content-free HUD, /usage reports spend, read_file contains= handles exact-key lookups in one bounded read, and shared-worktree owners render as a structured callout.
  • The desktop app replaces the persistent agent overview column with compact agent control and adopts the Codegraff emblem across web, desktop, Android, and iOS assets.
  • Run-budget landing, Codex overload retry, xAI OAuth parity, and benchmark fixture validation harden autonomous and release workflows.

v0.0.252 (2026-08-13)

  • Grok models are discovered live: xAI joins the generic /v1/models catalog and always fetches api.x.ai (disk cache is offline fallback only), so new Grok rollouts become routable without a release. SuperGrok login tokens send X-XAI-Token-Auth on chat and catalog requests, matching grok-build.
  • The #469 peer-message spacing bracket is pinned by a unit test on the emitted event sequence, plus a CI-wired PTY smoke test for device-room delivery.
  • release.yml uploads assets onto an existing release instead of failing into an untagged draft (the v0.0.251 updater-404 race).

v0.0.251 (2026-08-13)

  • Peer messages get breathing room in the REPL: the #469 channel block used to render mid-stream with no spacing, clumped against the text above and below; it is now bracketed by a blank line on either side. Render-only — history bytes and the GUI are unchanged.

v0.0.250 (2026-08-12)

  • First-party OpenAI server compaction now installs the complete canonical /responses/compact output transactionally on both the Codex subscription and official Platform Responses routes. Missing, invalid, or empty output leaves history intact and falls back to readable local compaction; other providers remain local-only.
  • The official openai provider uses the Responses API with ordinary bearer authentication, without inheriting ChatGPT backend headers, WebSocket chaining, or Codex-only priority behavior.
  • REPL tool activity is visible again as stable terse start/result rows with human-readable command, path, URL, or description previews instead of raw JSON or cursor-rewriting output.
  • Controlled replay evidence covers 21/21 perfect continuations across the first-party OpenAI host/auth paths, including long paired tool histories.

v0.0.249 (2026-08-12)

  • Folded native tools become callable immediately after their schemas load (#492). The active catalog is rebuilt from the loaded schemas instead of continuing to advertise tools that can never enter dispatch.
  • Turn events expose cumulative input, output, cache-read, and cache-write token usage, with the TypeScript SDKs regenerated from the same schema source (#491).
  • codedb-pro tool paths resolve from the active session worktree rather than the daemon's startup directory, preventing false missing-path reports when Graff changes projects.
  • Piped sessions end an unanswered ask_user cleanly at EOF instead of spinning or hanging (#478).
  • The default prompt carries a capped skills catalog, and the release suite now exercises concurrent interactive WebSocket tool loops across multiple sessions (#480).

v0.0.245 (2026-08-09)

  • Licensed codedb-pro is now the default toolset, not an ornament. The license probe at startup pins the server's schemas eager (no per-session load_tool_schemas toll that steered models back to the built-ins), the system note makes mcp__codedbpro__read/faster_search/batch the stated defaults for reads and searches, and the built-ins they replace are actually refused while the licensed server is healthy: read_file, codedb, and bash lines leading with grep/rg/find get a refusal naming the replacement (shell searches point at zigrep directly; it always skips vendor dirs, so the refusal says when rg -uu is the right call instead). Plan mode is exempt (it denies MCP calls outright), and any codedb-pro failure opens the fallback for the rest of the session — being in charge must never leave the model with no working way to read.
  • codedb-pro failures file their own bug reports: the first failure per signature (cap 3/session, root-only) spawns a background subagent that dedupes against open issues and files on justrach/codegraff under the codedb-pro label. The harness redacts before anything reaches a model or the issue body — absolute/home paths, credential-looking tokens, URL query strings — keeping only the tool name and the error essence. Unattended sessions (or unapproved gh) draft to .graff/issue-drafts/ instead of publishing without consent.
  • Edits go through the persistent daemon instead of spawning zigpatch per edit: edit_file keeps the /rewind snapshot and the on-disk verification, but the byte-splice rides the always-on MCP connection (measured 0.34ms vs 2.37ms per edit on small files — fork/exec was ~85% of the cost). A measured size gate (4 MiB, matching the daemon's cache ceiling) sends big files to the spawn path. Pairs with zigrepper 0.2.21, where the same edits got 2.9x faster still (cache-backed snapshots, light edit loads).
  • /tools shows the session's tool balance: codedb-pro read/search/batch vs zigrep vs native fallbacks, gate refusals, and errors. When suite usage skews (8+ calls, one class ≥80%), the nudge rides the tool result so the model hears it — once per dominant class, not on repeat.

v0.0.244 (2026-08-08)

  • Co-resident sessions see and coordinate with each other (#469): a per-user registry at ~/.graff/live names any live session already in your worktree, probed for liveness on read via proc_identity, so crashed sessions reap themselves — no heartbeats, no daemon. The first index- or tree-mutating git command, file write, or shell move against a peer's tree pauses once for a deliberate re-issue, under --yolo too, where no approval prompt exists. The motivating failure: two --yolo roots in one worktree picked up the same task and one git-staged the other's files mid-write, because neither could see the other. Sessions can also talk — the peer_message tool, /tell, and /peek over a shared per-worktree room plus a device-wide one.
  • Session recaps ride the event stream (#419): a settled turn carries a Completed or Needs-input status and a one-line recap, so a GUI overview can say what each agent did without re-reading the transcript.
  • Subscriptions are billed and routed as subscriptions (#471). A flat-rate login and a metered API key on the same provider are different seats, and nothing in the routing stack knew that: billing was a hardcoded provider-id list, the third of four such lists in the tree, and they disagreed. xAI has had a real device-code login since graff login xai, so a paid SuperGrok session was billed at grok list price and excluded from subscription routing entirely. Now the plan outranks the key on the same provider instead of losing to it by arriving second, contributes $0 to /cost, and the displaced key is parked — taking over, announced, only when the plan hits a quota cap.
  • Worker tiers land on seats you already pay for (#471): an explicit tier ask crosses to a logged-in plan (mid → k3, small → gpt-5.6-luna) rather than a metered rung. The #291 ladder descent had been blocking this by looking like a manual pin, which made subscription routing dead in most sessions — found by running the harness for real, not by the unit suite.
  • A tier rung must be a genuinely cheaper SEAT (#471): the bench sheet ranks by $/task, which folds the seat's rate together with how many tokens a model burns, so an equally-priced older model read as the cheap rung. Every opus generation bills $5/$25, so descending opus-5 → opus-4-8 saved nothing at all. Anthropic now descends opus-5 → sonnet-5, deepseek-v4-flash replaces pro outright, and a mid rung that cost more than its own frontier is gone.
  • graff route with no model lists every provider you can reach, what it bills, and the tiers it offers — including a plan whose displaced key is parked behind it. Detection stats the credential file only: listing providers never refreshes a token or spends anything.
  • Anthropic serves its live model list, like the OpenAI routers: new Claude releases arrive without a rebuild, with the baked rows kept as the no-key/offline fallback.

v0.0.242 (2026-08-06)

  • MCP tool schemas load on demand (#416): a server's tools are advertised by name and one-line description, and load_tool_schemas fetches the full JSON on request, once per session. On a real 13-tool server the served catalog drops 10,505 → 3,696 bytes, a 64.8% cut and roughly 1,700 input tokens off every request for the whole session. Servers under 4 KiB of schema stay eager, so small servers behave byte-for-byte as before and only the expensive ones change. Trust and consent are untouched — deferral is about context cost, not permissions.
  • Tool results above a threshold return a handle instead of their contents (#440): a bounded preview, the path holding the complete result, the byte count, and a measured shape hint (line count, or a JSON payload's top-level keys). This replaces a three-cap stack in which the middle cap made the outer one unreachable, so the #409 spill could never fire for bash, read_file, webfetch or codedb. The bash capture ceiling rises 128 KiB → 1 MiB, since at the old value the handle would have described a result already a quarter destroyed.
  • The session transcript is append-only (#441). The premise shipped in #410 was false: <name>.session.json is one JSON object whose history is rewritten in place, so compaction permanently discarded it. A new <name>.transcript.jsonl records each message as it first enters history and is never rewritten, which makes "what did that error say exactly?" a grep again. At its size cap the generation rotates by rename rather than being truncated in place — an in-place rewrite is the very failure this fixes.
  • Compaction now says what survives, on both sides. Before the boundary the agent spends one budgeted turn writing notes to its future self (#391), drawn from the same ledger as the landing reserve rather than a second one, and refused outright when the session is already being rescued. After it, a note states the durable state that actually persists: active goal and todos, files modified this session, the transcript path, and any live result handles (#411).
  • The durable-transcript prompt line waits for the first compaction (#445). Before one, the live context is a superset of the file, so the line pointed the model at wording it could already see; the measured cost was ~240 input tokens on every call. Short sessions, which is most of them, now pay nothing.
  • Windows: the transcript wrote nothing at all (#441). File.stat on a write-only handle returns ACCESS_DENIED there, so the append offset lookup failed after the file had been created and every transcript was 0 bytes. The same pattern is still live in playbook.zig and serve_events.zig, tracked in #462. .graff/ paths are forward-slashed on every platform by invariant, since those strings are shown to the model.
  • The anyOf test failure was never a flake (#444). The build runner prints a full step-failure report for a successful step whose stderr is non-empty, and records failed command: before the child's exit status is known. Cached test steps do not re-run the tests, so "warm re-runs passed" was vacuous and seed-independence followed for free. Engine stderr is now silent in test builds and the suite emits zero bytes.
  • Engine/REPL separation reached the lifecycle and long-tail clusters (#429): session_start, session_run, providers, hooks, skills, skill_docs, review, imagegen and agent_prompt no longer import the terminal. session_run.zig fell 597 → 450 lines, relieving the cap pressure the epic predicted it would. The inventory also found that approvals.zig was on the ban list as a consent surface rather than for any terminal coupling, so its pure half moved to harness_policy.zig.
  • /btw asks a side question over the live conversation with tools disabled, renders the answer, and adds nothing to the session (#415). It is billed in the [usage] footer, because the cost is real even though the exchange is not kept. There are two persistence paths to stay out of now — the session file and the new append-only transcript — and both are asserted byte-for-byte before and after. A {"type":"btw"} --json control replies with an explicit persisted:false so a client mirroring the stream can tell it apart from a real turn.
  • A GUI panel answers "what are my agents doing" without opening each conversation, sorted attention-first (#419).
  • Child usage is pinned to the bill and kept out of the parent's context math (#418). The audit found no leak — a subagent gets a fresh Agent whose meter starts at zero and a ToolCtx with no pointer back to the parent, so it has nothing to write to — and the invariant is now held by a test rather than by construction alone: eight workers each ending past the parent's compaction threshold leave the parent's context estimate identical to the control, while the bill moves by exactly their usage. Had it leaked, compaction would fire early on every fleet-heavy run.
  • Two eval harnesses became durable rather than living in scratch: the live A/B token-economics rig that produced the numbers above, and the golden byte-identity harness the engine work is verified against.
  • Two silent-failure classes gained guards, each proven by break-and-revert: an environment knob that stops being parsed now fails a test instead of quietly ceasing to exist, and the prompt funnel can no longer arm a process-global from a test build.

v0.0.241 (2026-08-06)

  • The engine separation reached the tool-execution cluster (#422): tool-call announcements, results, rejections, parallel-batch brackets, and the goal/todo notices now travel the typed event stream, with the inventory finding that only agent_tools.zig ever wrote to the terminal — the rest of the cluster was already clean. The wire sink is now provably unable to ship a shapeless durable event or reserve sequence ids for a frontendless agent.
  • A WebSocket 426 refusal latches SSE immediately (#427): the server answered authoritatively, so the session falls back on the same attempt instead of burning a rebuild and a redial before the two-failure latch.
  • The tier-1 gate counts tests off the compiled artifact when a cached build prints no summary, selects the reachability binary by content instead of mtime, and warns when its test-count ratchet goes stale (#439).
  • The system prompt is now assembled from capability-gated segments (#421): an instruction ships only when its capability is actually present, read from the same predicates dispatch uses to refuse a hallucinated call, so the prompt can never disagree with the tool catalog. An embedder session (--no-local-tools) drops 28.5% of the base prompt; the floor config drops 43.2%. At full capability the compose returns the comptime constant itself — zero allocation, byte-identical to what shipped before. Two standing doctrine lines joined the always-on intro: never invent a tool or wrapper API, and run the target project through its OWN environment — a failure there is the relevant result.
  • A durable root session's prompt now names its own transcript (#410): the path to .graff/sessions/<name>.session.json, described truthfully — one JSON object, lags the live turn, rewritten in place by compaction (a resume artifact, not an append-only archive) — so the model can consult it without burning turns on wrong assumptions. Suppressed when local tools are gone (an unreadable path is pure token waste).
  • Context-overflow classification got a guard list and two behavioral detectors (#414). Non-overflow patterns are now checked FIRST, so a throttle whose wording collides with an overflow phrase — Bedrock's ThrottlingException: Too many tokens is the canonical one — keeps riding the Retry-After ladder instead of triggering a compaction that cannot help. The overflow table itself grew from six substrings to the phrasings twelve more providers actually send (Bedrock, Gemini, Copilot, xAI, Groq, llama.cpp, Kimi, Mistral, Ollama, MiniMax, z.ai, Anthropic 413), and now matches case-insensitively. Two shapes that never send an error at all are caught from the reported usage instead: an HTTP 200 with an empty completion whose input is at or over the window (z.ai's silent overflow), and finish_reason: length with zero output while the input fills the window (a provider truncating the input to fit, seen on MiMo) — the latter is now named rather than shipped as an inexplicably short answer.
  • An oversized tool output is now spilled, not destroyed (#409). The per-result cap (#193/#201) used to delete the elided bytes, leaving the model to re-run the tool and guess a better slice; when the session is durable the full output is now written to .graff/sessions/<session>/artifacts/tool-<n>.txt first, and the marker in the transcript cites the absolute path and the byte count, so the next turn can read or grep exactly what it needs. Bounded by a 64 MiB per-session budget (whole artifacts only, so a marker can never overstate what is on disk), and reclaimed with the session: an artifact dir whose <session>.session.json is gone is swept at the next spill. Subagents, whose history is never persisted, keep the plain truncation.
  • Cross-process locks stopped trusting a bare pid (#413): an owner record now carries the holder's process START identity next to its pid (/proc/<pid>/stat field 22 on Linux, proc_pidinfo on macOS, GetProcessTimes on Windows), so liveness is "the pid is alive AND it is still the same process". A recycled pid can no longer look like a live owner forever, and a crashed holder's lock is reclaimed because its identity provably mismatches rather than because a timeout guessed. A record written by an older graff carries no identity and keeps the pid-only contract exactly as before, so an in-flight lock is never bricked, and an identity that cannot be read fails safe: held, never stolen. The #320 worktree lease gets the producer it was missing, and a session save on a filesystem with no working locks (#289) now coordinates through an owner record instead of racing unguarded.
  • A no-progress eval is no longer paid for (#412). A goal/loop run re-verifies on every continuation, so a model that has edited nothing since the last RED re-ran the whole --eval command — plus a --judge model call, plus 1500 bytes of output tail — to re-derive a verdict that could not have changed. graff now fingerprints the verification before running it (the eval command text, git status --porcelain -z -uall, git diff --binary HEAD, and the contents of every untracked file, since the first two are blind to an untracked edit); identical to the tree the last verification failed on means the verifier is not run at all. The attempt still counts, so a stuck loop converges on its iteration cap instead of spinning for free, and the model is steered at the real blocker: the workspace has not changed, edit something first. Fail-open throughout — no repo, no git, a timed-out or truncated probe, an unreadable file all read as "changed" and the verifier runs.

v0.0.240 (2026-08-06)

  • The REPL/engine separation began (#422): agent output now flows through a typed event vocabulary and a strict sink boundary (engine_events.zig / engine_sink.zig), with streamed model output, the codex WS transport notices, and streamed tool-call arguments converted first — the TUI renders and the --json wire serializes the same events, so the two can no longer drift. Proven byte-identical to v0.0.239 by a golden before/after eval harness (the same scripted mock session over both the protocol and a real PTY) plus live one-shot, tool-call, and interactive smoke runs. Groundwork for detached sessions and attach (#420).
  • Loop exit tears down the held codex WebSocket and its response-id anchor (#424): the delta chain deliberately spans user turns, so only exit may free them — and no exit path did. The socket now gets a proper close on quit, and Debug builds finish with a clean allocator report instead of four leak stacks.

v0.0.239 (2026-08-06)

  • A successful /login now reaches the live session (#402): the codex .responses error path runs the same bounded auth recovery as every other wire format — re-read auth.json from disk first (adopting a re-login by this session, a second graff, or the real codex CLI, gated on the ChatGPT account id), then spend the refresh token, then retry once — instead of resending the full request + compaction bodies with a dead bearer forever. One $CODEX_HOME resolver serves every reader and writer of auth.json (subagents included), and the mid-turn refresh persist preserves the fields the codex CLI owns in that co-owned file, 0600, staged + renamed.
  • /save <name> and /resume <name> copy the typed name out of readline's reused line buffer; the next prompt can no longer silently retarget the autosave (or worse) via a stale slice.
  • /rewind never deletes a file it failed to snapshot: a pre-write read failure (oversized, unreadable) now records "no snapshot" and rewind leaves the file as-is with an honest count, instead of conflating read failure with "didn't exist" and unlinking it.
  • graff serve no longer wedges permanently on set_ultracode: the ultracode ack is a terminal event, the ack list is pinned against the emitter by test, and the JSON-controls E2E covers it.
  • Credential and catalog writes are atomic (staged temp + rename via a shared writer): a crash or full disk can no longer truncate the only copy of a refresh token. xAI credentials now land 0600/0700 like kimi's; the MCP OAuth store and the multi-provider key map write through the same path.
  • Codex WebSocket turns no longer sit silent for minutes when the backend goes quiet mid-response. The WS reader armed its stall watchdog with a hardcoded "no tokens yet", so it re-armed the full 120s pre-first-token budget on every frame and never tightened once the model was actually emitting — the SSE reader has always tightened to a quarter. Silence after visible prose now trips in ~30s, while a silent reasoning phase keeps the full budget, exactly as on SSE. "Visible prose" means both things that print on SSE: a response.output_text.delta, and the streamed arguments of attempt_completion / ask_user — which is all a final-answer turn emits, so keying on output text alone would have left the commonest turn shape on the old budget. Mere frame arrival is still not the signal: the protocol events land milliseconds after the send and would stall out a long thinking turn. The trace gains sent <n>b, first frame and first output text notes, so a hang says which half of the turn went quiet instead of stopping dead at reuse (delta) (#401).
  • A REUSED codex WS that answers nothing is now caught in ~30s instead of ~120s, and as a transport failure rather than a stalled turn. Nothing proves a held socket is still alive, and the backend acks a send within milliseconds, so zero frames back is a dead socket: it gets the head budget and re-anchors on a fresh connection (SSE only after a second failure), instead of spending a slot of the turn's stall budget waiting out the full pre-first-token window. A freshly dialed socket is unaffected — its handshake just proved the peer is there, so it keeps the full budget for a model that thinks before it speaks.
  • The WS send and dial are under a deadline too (an unbounded blocking write / an unbounded dial through DNS + TLS + the 101 status line), with Esc live during both. They report the transport-flake error the SSE guard uses, so a wedged socket is retried on a fresh one rather than spending the turn's stall budget; the send deadline scales with the frame so a full-conversation re-anchor is not a false positive. Both name themselves in the trace (send stall / connect stall), so a stalled dial is no longer reported as a bare error name. Under Io-pool exhaustion they follow the SSE guard exactly: a failed payload spawn fails retryable, a failed watchdog spawn degrades to the unwatched call already in flight, so a momentary pool shortage cannot latch a session onto SSE. A socket the idle window condemns is torn down with a plain FIN rather than a courtesy close frame that could block again, and a failed WS handshake no longer leaks its fd and CA bundle.
  • A one-shot that dies (budget exhaustion, a late gateway refusal) still prints the [usage] footer and notes how many tool calls already completed — the runs most likely to be expensive no longer exit with no cost accounting, and an aborted run no longer reads as if nothing happened (#387, #389).
  • Rate-limit errors that say "try again in 350000 seconds" now append a human duration ("~4d 1h"). The provider's exact words are preserved — the hint is display-only (#398).
  • Auto-compaction escalates instead of looping when the model keeps returning empty summaries: two consecutive complete-but-unusable summaries over the threshold unlock the bounded emergency trim, and compaction summary requests run at low reasoning effort so a high-effort reasoner can't complete with reasoning items and no summary text (#379).
  • iOS simulator scripts clean up what they start: the app is terminated and a device is shut down when (and only when) the run booted it; the Simulator window no longer pops open unless SIM_GUI=1, and KEEP=1 preserves everything for debugging (#407).

v0.0.238 (2026-08-05)

  • Tight-budget runs hold back a landing reserve, so they finish, verify, and still deliver the final answer instead of dying mid-narration.
  • A completed run releases the terminal instead of suspending on tty input (#396), and worker activity lines wait for the foreground's line boundary.
  • Completed todo items parked from a prior goal retire at the next ask instead of piling up across prompts (#394).
  • Fleet workers retry transient failures within a bound — one flaky HTTP response can't lose a finished report, and budget refusals never blind-retry.
  • Search roles ride the small rung; landed turns feed local learning, and a learned decline names the policy it came from.

v0.0.237 (2026-08-04)

  • Ultracode redesigned around an escalation ladder: the codeword now means "escalate to the smallest rung that fits" — solo for 1-2 known files, one scout for context-flooding exploration, a fleet only for 3+ independent workstreams or after a failed attempt, full shape + judges only for audit-class asks. An admission gate + budget reservation ledger enforce it; duplicate briefs collapse at spawn; implement phases carry an edit contract (no diff = error + retry); every rung decision writes kind:"orch" rows so the ladder itself becomes learnable. Measured on the 5-eval study that motivated it: old ultracode 80 mean at 133 calls; new: 100 mean at 44 calls (1.22x the single-agent baseline), zero budget deaths, and a genuinely large audit task still fans out (R3, 4 workers) then lands from partial evidence.

  • Vision-aware worker routing: a subagent task that names an image file re-seats automatic workers onto a vision-capable model (source=vision-ask in the routing trace); a worker report that disclaims image-viewing gets a [vision warning] flag the root cannot mistake for observation (#380).

  • Brief-diversity gate: fanning out 3+ near-identical variant briefs (workflow phases or sibling spawns) draws a calibrated warning — reskins of one template are one concept, not N. New concept-fleet shape requires a design thesis and one signature system per variant (#382).

  • Durable user-constraint ledger: /never <text> (or the model calling the append-only note_constraint tool when you reject something) writes to .graff/playbook.jsonl; a HARD CONSTRAINTS block derived from the file at brief-assembly time rides every worker brief and the root prompt — surviving compaction and session boundaries by construction (#381).

  • Learned playbook (ACE-style): after a target-met eval, one bounded reflection call mints up to 3 insight bullets with run provenance, curated by deterministic code (dedupe, caps, tombstones — never model rewrites) and injected as an advisory block below user constraints (#383).

  • The long-standing ubuntu pty CI flake was never a shutdown hang: a Ctrl-D arriving in a canonical-mode tty window is delivered by Linux as NUL and was dropped by readline — the REPL then (correctly) waited forever. Type-ahead bytes are now normalized across the mode switch; 15/15 container hangs became 25/25 passes. Teardown phases are stamped under GRAFF_SHUTDOWN_DEBUG so any future hang names its phase (#364).

v0.0.236 (2026-08-04)

  • Every spawned worker emits a routing trace — shape, role, tier, resolved model, and why (explicit-pin / persona / learned-policy / session-default / ladder) — to the tracer, the local archive, and a new agent_route JSON event (#372).
  • Learned tier policy: scored runs teach (shape, role) cells which model to seat; a learned answer must dominate the ladder's (≥ quality, strictly cheaper) and explicit pins always win (#372). Workflow phases take one learned seat before fan-out, and fitness is stratified by resolved model so genome comparisons never mix rungs (#376).
  • Family-prefixed model spellings route to the direct provider: --model kimi-k3 now bills the flat-rate kimi login instead of silently seating the gateway (#377).
  • graff route <model>… dry-runs provider seating + billing in ~2s with zero API calls, through the same resolution a real session uses.
  • graff acp: Agent Client Protocol agent mode over stdio JSON-RPC — point Zed's agent panel at the binary (#375, ACP half).
  • Blocking pre_tool hooks can name their sanctioned replacement via a suggest field, and hooks got their first README documentation (#369). SDK generation is deterministic by construction — a scrubbed HOME, so local catalog caches can never drift the committed MODELS list (#370).
  • Longer notes: docs/releases/v0.0.236.md.

v0.0.235 (2026-08-03)

  • Eight defects found by turning the harness on itself, fixed same-day with live verification: honest eval-score parsing with exit-code fallback (#367), budget exhaustion that names what ran out and what state survives (#368), unattended denials that explain themselves (#369 first half), a hard gate on the model editing .harness/settings.json (#366), /model re-deriving the worker ladder (#371), Pareto-front rung seating so no tier is dominated by a cheaper one (#373), DGM score feedback re-weighting the bench sheet (#374 follow-on), and pty/autosave test reliability (#364/#365).
  • Longer notes: docs/releases/v0.0.235.md.

v0.0.234 (2026-08-03)

  • The local evolution loop closes: eval scores land in the local trajectory archive, a target-met new best auto-promotes the niche champion and hot-reloads it mid-session, and VERIFIER RED grants a bounded in-loop repair turn instead of scoring an honest run 0.
  • Worker economy: compiled bench priors seat per-provider tier ladders, logged-in flat-rate subscriptions outrank metered models for tier asks, and workers never silently cost more than the model you chose. Personas gain independent effort pins ("Luna Max" = model: gpt-5.6-luna + effort: max) (#291/#292).
  • Codex-parity system prompt upgrade; plan/todo discipline verified against it.
  • Longer notes: docs/releases/v0.0.234.md.

v0.0.233 (2026-08-03)

  • iOS stops inventing outcomes: per-turn outcome in the transcript, liveness that never fabricates success, ordered per-session sync with revision guards and tombstones (#286, #310, #316).
  • MCP companion only falls back to the legacy protocol on a real refusal, with a cold-start-safe probe timeout (#327). GUI emphasis pairing fixed so ** can no longer leak into linkified URLs (#197).
  • Incremental autosave (#273) and per-spawn worker model pins (#292) land.
  • Longer notes: docs/releases/v0.0.233.md.

v0.0.232 (2026-08-03)

  • imagegen: image generation the model can't fake — fresh-artifact verification (mtime, magic bytes, size floor) after Codex was caught fabricating success from a stale file; exit 0 with no fresh artifact is a hard error (#352).
  • Clipboard paste failures become honest and usually recoverable; MCP tool schemas with top-level oneOf/allOf/anyOf are lowered instead of rejected wholesale.
  • Longer notes: docs/releases/v0.0.232.md.

v0.0.231 (2026-08-01)

  • edit_file now verifies every edit actually landed on disk before reporting success: a silent no-op becomes a loud tool error instead of a false "replaced 1 occurrence(s)" (#337, #338).
  • Batched edits to the same file are serialized per path, fixing a race where parallel tool calls could erase each other's writes (#338).
  • Embedder mode part 1: a hard --no-local-tools / GRAFF_NO_LOCAL_TOOLS=1 gate disables local bash/file/codedb tools for the whole process, subagents included, so coding tools can come from a sandbox MCP server instead (#330, #335).
  • Embedder mode part 2: resumable graff serve streams with monotonic seq ids, ?from=N replay after a dropped connection, and durable sessions. --json schema 0.10 (#330, #336).
  • Longer notes: docs/releases/v0.0.231.md.

v0.0.230 (2026-08-01)

  • The bundled skill-creator skill teaches the full authoring loop: capture intent from the live conversation, write trigger-rich descriptions, forward-test with fresh subagents against baseline runs, and iterate on user feedback until it comes back empty (#334).

v0.0.229 (2026-07-31)

  • SKILL.md skills: drop a markdown playbook in .harness/skills/<name>/ (or ~/.harness/skills/ for every project) and graff loads it only when a task calls for it. Only name + description enter the system prompt; .claude/skills/ is read for compatibility; /skills lists, hides, and restores them. Ships with skill-creator and mcp-config built in (#333). See docs/skills.md.

v0.0.228 (2026-07-31)

  • Local learning defaults corrected to the documented privacy posture, with the full write-up in docs/learning-privacy.md (#332).
  • Test-dispatch fixes: modules whose tests were silently never running are now wired into the test root (#331).

v0.0.227 (2026-07-31)

  • kuri, the headless-browser companion that backs webfetch's markdown path and the kuri skill, installs by default now; opt out with HARNESS_NO_KURI=1 (#329).
  • Both the root and subagent system prompts now ask for parallel tool calls, with the dependency caveat that keeps same-file writes from racing (#329).

v0.0.226 (2026-07-31)

  • /images opens image URLs from the last response (for example a gh issue view with attachments) in your browser (#103).
  • The prompt line is width-budgeted so long model and mode badges cannot break interactive redraw (#209).
  • Kimi and xAI OAuth tokens refresh selectively at startup (#274).

v0.0.225 (2026-07-31)

  • Remote MCP supports stateless-core servers, with a legacy fallback.
  • The system-prompt variants are built through one funnel, removing drift between the interactive, subagent, and review prompts (#326).

v0.0.224 (2026-07-30)

  • /goal hardening follow-ups: pinned call-site coverage and a real-PTY regression for goal collapse.

v0.0.223 (2026-07-30)

  • Orchestration hardening: worktree commit-loss fix, JSON tag guards against undefined-behavior derefs, subagent task pinning, and five ultracode audit fixes (retry gating, all-failed abort, phase budgets, worktree rejection in pipelines, shared context slots).
  • Anthropic models stream summarized thinking (#322), and review mode no longer races the background learning writer (#324).

v0.0.222 (2026-07-30)

  • /goal and /loop are one autonomous run: the same engine with or without a standing objective, including time budgets like /goal 30m <text>.

v0.0.221 (2026-07-30)

  • Goal epochs, and a standing --goal that survives compaction via an objective snapshot (#318).
  • Retained reasoning is pinned across all wire formats.
  • MCP servers get a bounded teardown at session exit (#305).

v0.0.220 (2026-07-26)

  • learn auto-initialization fix (#304).

v0.0.219 (2026-07-26)

  • The local learning loop closed end to end: zero-config graff learn init, session-triggered background trials, and the learned genome becomes the root prompt (#302). See docs/local-learning.md.

v0.0.218 (2026-07-26)

  • Workspace router configuration for providers; router cache entries serialize independently.
  • GUI: provider surfaces reachable in QA mock mode, useful sidebar empty states, and narrow-window fixes (#300).

v0.0.217 (2026-07-25)

  • Zig 0.17 nightly compatibility for CI (#298).
  • OAuth refresh is single-flight (#245), clipboard paste gets a vision guard (#258), a provider-routing fix (#294), and the ultracode shape catalog with a slot axis (#290, #293).

v0.0.216 (2026-07-24)

  • /review is bounded correctly without a hard call cap (#280, #281).
  • Subagent harness orchestration (#279).

Older releases: narrative notes for v0.0.211, v0.0.212, and v0.0.215 live in docs/releases/, and graff --version prints highlights back to v0.0.192.