veyyon
menu
Changelog

What's new.

Veyyon's own releases, newest first, with what's queued for the next one at the top. The /changelog command in the CLI opens this page, and launch can check for a newer version. The full history, including everything inherited from oh-my-pi before the fork, lives in the CHANGELOG on GitHub.

Unreleased

next release
Changed
  • Spawned agents have three states, running, idle and asleep: an idle agent falls asleep after 5 minutes (agent.idleTtlMs, "Sleep Idle Agents After") and frees its session, and any agent with a transcript, including a stopped, failed or killed one, wakes when messaged for the rest of the session instead of being pruned or left unrevivable; an agent that ran in an isolated worktree stays readable at history://<id> but cannot be woken, since the worktree is removed when its run ends.
  • job cancel on an agent and x in the agent dashboard stop the agent and everything it spawned and put them to sleep, so a stopped agent wakes when messaged instead of being terminated.
  • The irc roster lists the 10 most recently active asleep agents and a count of older ones, which still wake by id, and a blocking irc send to a peer that falls asleep before replying ends at once instead of waiting for its timeout.
  • agent.softRequestBudget defaults to Unlimited instead of 200 requests, offers 200, 500, 1000 and 2000, and the bundled scout and sonic agents no longer carry a lower built-in limit.
  • Collab hosts and guests speak protocol 5, which reports closed agents as asleep; a peer on protocol 4 is rejected with the protocol-mismatch error.
  • A text search result keeps only the card rows its card can draw and a count of the matches past them, so a 30-turn session with broad searches writes 4.1 MB to its session file instead of 7.2 MB and 21 MB to disk instead of 31 MB, with the card drawn as before.
  • A session file records a text search's kept card rows as a length of the rows its result redraws, so a resumed card draws the rows it was written with whatever the card's row limits become, and the search codec no longer loads the card limits at launch.
  • A live tool or assistant block's rows enter terminal scrollback once, when final, instead of as copies taken while they scroll off mid-run, so a 20-turn session with parallel tool calls writes 1.0 MB to the terminal instead of 4.1 MB with no whole-transcript replays, and a running tool's rows above the screen reach scrollback when it finishes.
  • The working line and live tool-card spinners advance every 200 ms instead of every 80 ms and repainted rows no longer send their blank padding, so a session waiting 30 s on a model and a tool writes 94 KB in 327 frames to the terminal instead of 197 KB in 548.
  • No user-visible change: /btw and /omfg show, replace, dismiss and fail a request through one SidePanelSlot in modes/terminal/controllers/side-panel-slot.ts instead of two copies, and a /btw answer is held on its request instead of in controller fields cleared on close.
  • No user-visible change: the collab host and guest connect through RelayClient from @veyyon/wire/relay-client instead of a private copy of the relay client, and collab/crypto no longer wraps sealFrame and openFrame.
  • No user-visible change: the memory tools resolve their backend through memory-session, the JS eval host and worker encode errors through one eval/js/error-payload codec, and config get, set and reset report a missing or unknown key through one helper.
  • No user-visible change: the Brave, Firecrawl, Jina, Synthetic, Tavily, TinyFish and Z.AI web search providers no longer export an unused findApiKey.
  • No user-visible change: an MCP OAuth refresh and the credential it stores read the token endpoint, client and resource from one resolveMcpOAuthRefreshTarget.
  • No user-visible change: prompt templates, file slash commands and the legacy loader's extra templates derive a missing description from one firstLineDescription.
  • No user-visible change: the oauth hooks of an extension ProviderConfig and of ProviderConfigInput are one ProviderOAuthConfig type.
  • Tool discovery and the system prompt select MCP tools by name before describing them, and tool examples render without converting each wire schema again, so a print-mode turn reaches its first request in 55.4 ms instead of 57.4 ms and exits in 76.3 ms instead of 80.6 ms.
  • A launch of the installed binary after its first reads the bundled model a custom model id resolves to from cache/model-references.json instead of indexing the catalog's model ids, so a print-mode turn with a custom model reaches its first request in 55.9 ms instead of 59.9 ms and exits in 76.9 ms instead of 81.4 ms.
  • The compiled binary carries the digest of the model catalog it embeds instead of reading and hashing the 2.3 MB catalog on every launch, so a print-mode turn reaches its first request in 54.9 ms instead of 57.9 ms and exits in 73.9 ms instead of 77.8 ms.
  • A launch whose extension, command, rule, prompt, tool and hook directories are missing or empty no longer loads the native addon to scan them, so a print-mode turn reaches its first request in 55.9 ms instead of 60.9 ms and exits in 75.0 ms instead of 79.6 ms.
  • A launch with arguments no longer constructs the stdin stream to describe why it skipped the first-frame replay when VEYYON_REPLAY_DEBUG is unset, so a print-mode turn exits in 79.3 ms instead of 81.8 ms.
  • A launch of the installed binary after its first sends the built-in tools' stored wire schemas instead of building every tool schema, so a print-mode turn reaches its first request in 61 ms instead of 86 ms and exits in 82 ms instead of 116 ms.
  • The first lsp query on a Rust file starts when rust-analyzer reports experimental/serverStatus with quiescent: true instead of after polling rust-analyzer/analyzerStatus for at least 2 s, so a cold definition on a small crate returns in 1.46 s instead of 2.16 s and on a crate with dependencies in 1.88 s instead of 2.42 s.
  • No user-visible change: an abort inside the rust-analyzer workspace wait returns from waitForProjectLoaded, as it does for every other server, instead of throwing when it lands between two analyzerStatus polls.
  • No user-visible change: the collab guest, eval executor, markit registry, launch client, MCP stdio transport, RPC prompt result, extension send, TTS client, IRC tool and memory tools coerce a thrown value with toError from @veyyon/utils instead of nineteen inline copies.
  • Diagnostics after an edit or write are reported when the language server publishes them instead of at the next 100ms poll, so a server that answers in 50ms reports in 51ms instead of 101ms, or in 301ms instead of 402ms when it does not echo the document version.
  • No user-visible change: ZIP central-directory reads, config-file read failures, LSP severity counts, patch line-hint matching, SQLite row updates, GitHub issue and pull request body sections, eval import rewriting, plugin enable and disable, QR penalty scoring and autoresearch loop entry each run through one helper instead of two or three copies.
  • A modal card keeps its padding from 29 rows for large cards and 27 rows for medium and settings cards, instead of 39, 33 and 31, so cards on terminals 27 to 38 rows tall show up to four more list rows.
  • No user-visible change: the lsp diagnostics action and the diagnostics reported after a write merge server reports through one uniqueSortedDiagnostics in lsp/utils.ts instead of two copies.
  • No user-visible change: the /debug performance, dump and memory reports write their bundle through one sequence in debug/index.ts instead of three copies.
  • No user-visible change: the agents and import setup steps take the checklist sentinel, key hints and space-to-toggle input from setup-wizard/scenes/wizard-list.ts instead of two copies.
  • No user-visible change: the prompt history search overlay highlights the tokens historyQueryTokens in @veyyon/kernel/session/history-storage matched instead of its own copy of the tokenizer.
  • No user-visible change: the session-compaction-stall and session-tree-nav benches build their usage records from emptyUsage() instead of restating its zero fields.
  • No user-visible change: the LSP writethrough bench's header describes the event-driven diagnostics wait instead of the 100ms poll it replaced.
  • No user-visible change: each MCP HTTP request builds its headers through one transport helper instead of five inline copies, and the HTTP transport, the legacy SSE transport and callMCP read the JSON-RPC POST headers from one constant in mcp/json-rpc.ts.
  • No user-visible change: the selectors, dialogs, dashboards and the Ctrl+P model cycle step through their rows, tabs and models with wrapIndex instead of hand-written wrap arithmetic.
  • No user-visible change: the pointer-band selectors and the MCP add wizard repaint on the result of HoverController.set instead of comparing the hovered row themselves.
  • No user-visible change: the emoji, internal-URL, GitHub-reference and prompt-action completions return AppliedCompletion instead of restating its shape.
  • No user-visible change: the status producer falls back to the kernel's emptyUsageStatistics() from session/session-entries.ts instead of restating the zero usage record, so the status row evaluates no session-context or compaction module.
  • No user-visible change: the Antigravity, xAI, OpenRouter, Gemini and OpenAI image providers read a refused request's message through one providerErrorMessage in tools/web/image-gen.ts instead of five copies, and the GitHub run watch and run result reports write their header lines through one pushRunHeader.
  • No user-visible change: the assistant message component takes its ImageContent type from the @veyyon/wire presentation contract instead of @veyyon/model, which the package does not declare.
  • The composer reads the draft's queue shorthand and magic keywords once per frame instead of once per drawn row, so a keystroke and its frame in a 400-line draft take about 20 µs instead of about 85 µs.
  • No user-visible change: a modal card is laid out and its chrome planned once per frame, and the body is painted against that plan (layoutModalCard, planModalChrome, renderModalShell).
  • A start with no usable credential reports the missing credential without building the whole model catalog, so it reaches the prompt in 72 ms instead of 112 ms, and the message counts providers instead of models.
  • No user-visible change: compaction model keys and ACP model option values come from formatModelString instead of two private copies of it.
  • The Cursor exec bridge and the commit agent preview read message text through the shared contentText owner, and the commit map phase reads observations through the commit analysis reader instead of a second copy; no user-facing change.
  • Transcript, custom-display and rewind-report text now flatten message content through the shared contentText owner instead of two local copies; no user-facing change.
  • Hooks and extensions now share one definition of the tool_result event types, so a hook's ToolResultEvent.isError is typed boolean, matching what the extension runner delivers.
  • The bash and eval blocks run from the composer draw through one execution block that folds streamed chunks at the next draw and builds its header once, so an eval block drawn after each of 5000 streamed chunks takes 47 ms instead of 575 ms.
  • The tools.format setting takes its dialect list from a table keyed by the catalog's Dialect type instead of a second copy of the catalog's list; no user-facing change.
  • The markit converters share one stream-acceptance rule, one XML parser with the 1,000,000 entity-expansion cap, and one repeated-element reader; no user-facing change.
  • Session memory banks and memory stats readers open their Mnemopi store through one builder, createBankMemory; no user-facing change.
  • AgentParsingError extends SourcedParseError from @veyyon/utils instead of copying its formatting; no user-facing change.
  • The session's terminal-yield tracking and the subprocess executor decide whether a yield ends a run through one predicate; no user-facing change.
  • local:// and memory:// confine a resolved path to their root through one shared real-path check; no user-facing change.
  • The writethrough per-server loop drops a custom-linter check its callers already make; no user-facing change.
  • The RPC client and the agent run monitor recognize agent events through AGENT_EVENT_TYPES instead of their own copies of the list; no user-facing change.
  • Syncing a written file to its language servers and announcing its save share one per-server loop; no user-facing change.
  • The plugin manager runs its bun subcommands through the command runner the git cache refresh uses; no user-facing change.
  • veyyon stats --summary prints the summary and draws the sync progress line through @veyyon/stats, which the standalone stats entry point also uses; no user-facing change.
  • The collab wire and the HTML export build a tool call's display and a tool result's display through the same two functions instead of a copy each; no user-facing change.
  • The hook editor, hook input and MCP add wizard cards pass their whole body to the modal shell, which keeps the rows that fit, instead of planning the card chrome a second time to cut it first; no user-facing change.
  • An MCP tool with a live connection and one waiting for its server send a call, resend it after a reconnect and build its result through the same functions, and a waiting tool's failure names the source of the connection it failed on as its success does; no user-facing change.
  • The reftable HEAD lookup, the LSP document open and the eval kernel's result each have one implementation shared by their sync and async or success and cancellation paths; no user-facing change.
  • The debug adapter client starts every adapter, and kills one that never connects, through one helper; the GitHub issue, PR and diff lookups return the cache's own lookup result type; and the custom tool loader declares its pending-action shape once; no user-facing change.
  • check:types covers bench/, and the code-review-reminder, rendering, session-compaction-stall and session-tree-nav benches compile and run against the current APIs; no user-facing change.
  • The streamed tool-argument preview copies each run of plain characters in a string argument at once instead of one character at a time, which cut the one-shot decode of a 160 KB write call from 1.75 ms to 0.68 ms and its live reveal in 100-character steps from 10.5 ms to 9.2 ms (median).
  • A -p or --mode json run starts background model discovery once its first response starts streaming instead of when its session is created, which sends the first request about 33 ms sooner and cut a run against a provider that answers in 300 ms and streams for 150 ms from 580.8 ms to 560.0 ms (median of 15).
  • A launch with no llama.cpp server running no longer rewrites the llama.cpp model-cache row and syncs models.db four times, which cut a print run against a provider that answers in 300 ms and streams for 150 ms from 558.3 ms to 553.9 ms (median of 15).
  • read and the CLI @ attachment import the entry-kind phrase from @veyyon/utils/fs-error, which adds no module to any import graph; no user-facing change.
  • The config-root, global-config and path-comparison helpers are imported from the @veyyon/utils modules split out of @veyyon/utils/dirs; no user-facing change.
  • The provider-refusal check and the Mnemopi per-bank target dedupe each have one definition; no user-facing change.
  • /todo with an unknown verb in the TUI lists the accepted verbs, the message ACP shows, instead of the full usage.
  • veyyon ttsr scan compiles rule conditions, globs and scopes with the functions a session uses instead of a copy of them; no user-facing change.
  • The secret vault and its key file remove a stale entry through one quarantine-and-recheck helper instead of two copies of it; no user-facing change.
  • The Mnemopi stats command resolves a bank's database path through the function a session uses instead of a copy of it; no user-facing change.
  • The terminal reports a /browser restart that fails after the mode is saved as Browser mode set to <mode>, but restart failed: …, the sentence ACP prints, and shows the /browser usage line as a warning.
  • /effort checks a level through one function the terminal and the text surfaces share, with no change to what either accepts or prints.
  • No user-visible change: /export path resolution moved from the session runtime into the HTML exporter.
  • IRC message delivery moved out of AgentSession into the IrcDelivery session collaborator, with no change to how a message is steered, queued, woken on or auto-replied to.
  • The first shell command of a session no longer compiles the output-stage regular expressions of every built-in output filter; each filter compiles them the first time it applies, so a first ls runs in 5 ms instead of 12 ms.
  • The session_stop hook pass moved out of AgentSession into the SessionStopHook session collaborator, with no change to the event a handler receives, the continuation it queues or the cap that ends a chain.
  • The hidden next-turn message queue moved out of AgentSession into the NextTurnMessages session collaborator, with no change to when a queued message reaches a turn or the order it arrives in.
  • Model switching moved out of AgentSession into the ModelSelection session collaborator, with no change to what a saved switch, a session-only switch or the Ctrl+P cycle records, persists or pins.
  • Esc repaints a frame sooner when it arms no double-press gesture: closing a selector takes 4 ms instead of 35 ms with the kitty keyboard protocol and 54 ms instead of 86 ms without.
  • The /model picker resolves the default model against the models it lists, as startup does, so its first open paints in 4 ms instead of 41 ms and the default mark lands on the model a new session starts on.
  • Views that load after the key that opens them, such as the Extension Control Center, paint up to 30 ms sooner.
  • /cpu-limit status reports the kill policy in force: kill on sustained saturation for the CPU budget and kill when exceeded for the write budget.
  • The tool argument repair registry lists path resolution in the file tools among the tool-local parsing it excludes; no user-facing change.
  • Background job delivery, listing, cancellation and the settle wake moved out of the session class into one session collaborator (#892); no user-facing change.
  • Releasing what a conversation ends with on /new, /resume and a handoff moved out of the session class into one session collaborator (#892); no user-facing change.
  • Routing a finished run through retry, compaction and the stop-time passes moved out of the session class into one session collaborator (#892); no user-facing change.
  • The message a prompt raises when a provider's credential produced no token is built in the credential-message module beside the other missing-credential messages (#892); no user-facing change.
  • Queueing steers and follow-ups, the idle drain that starts a turn on them, and the queue count, chips, clear and pop moved out of the session class into one session collaborator (#892); no user-facing change.
  • Running a shell command or Python cell typed with ! or $ moved out of the session class into the session collaborator that tracks those runs (#892); no user-facing change.
  • The context threshold checks before a prompt and between the provider calls of a tool loop, and the switch to a larger-context model they share, moved out of the session class into the TurnContextCheck session collaborator (#892); no user-facing change.
  • Starting a new transcript with /new or /drop and forking one with /fork moved out of the session class into the SessionSwitch session collaborator (#892); no user-facing change.
  • The session-state block and the eager delegate reminders a turn carries ahead of its message moved out of the session class into the TurnPreludes session collaborator (#892); no user-facing change.
  • The per-family service tiers, /fast and the tier each request resolves to moved out of the session class into the ServiceTiers session collaborator (#892); no user-facing change.
  • The command registries, the resolution of a typed prompt through extension, custom and file-based commands and the prompt templates, and the agents a / command grants for its turn moved out of the session class into the PromptCommands session collaborator (#892); no user-facing change.
  • The display copy of assistant content, tool intents, streamed deltas and rebuilt transcripts, with the stream decoder a streamed reply runs through, moved out of the session class into the DisplayCopy session collaborator (#892); no user-facing change.
  • The normalization of a message's images for the active model, the description a text-only model reads in their place and the latest images a tool addresses moved out of the session class into the ImageAttachments session collaborator (#892); no user-facing change.
  • The response and raw SSE interceptors every request runs with, the raw SSE capture, the side stream function and the preparation of a side request's options moved out of the session class into the ProviderTransport session collaborator (#892); no user-facing change.
  • The redacted tool start markers, the session_exit entry and the process teardown callback that writes it when no dispose runs moved out of the session class into the ExitRecord session collaborator (#892); no user-facing change.
  • The event subscribers, the extension event forwarder and the wire-level agent_end held while a prompt unwinds moved out of the session class into the SessionEvents session collaborator (#892); no user-facing change.
  • The scheduled agent.continue(), the auto-continue prompt a compaction resumes with, their cancel and the recovery wait a prompt runs moved out of the session class into the TurnContinuations session collaborator (#892); no user-facing change.
  • The HTML export, the /copy texts, the /dump text and its request snapshot moved out of the session class into the TranscriptExports session collaborator (#892); no user-facing change.
  • The mode blocks a prompt restates (plan reference, plan-mode rules, goal, vibe mode), the reads of the files it mentions as @path and the before_agent_start extension input moved out of the session class into the TurnInput session collaborator (#892); no user-facing change.
  • The release at dispose of the session's background jobs, owned job manager, eval kernels, session-scoped resources and MCP hold moved out of the session class into the SessionRelease session collaborator, and the memory backends' release into MemoryContext (#892); no user-facing change.
  • How a custom message reaches the conversation, queued, held for the next turn, run as a turn or appended, and the custom-message prompt with its keyword notices moved out of the session class into the CustomMessages session collaborator (#892); no user-facing change.
  • Doc comments left stranded above another declaration's doc comment moved onto the declaration they describe, and the stale duplicates beside a rewritten doc were deleted; no user-facing change.
  • An extension command run on a session with no UI receives the extension runner's no-op UI context instead of a second copy of it; no user-facing change.
  • The theme loader and the status-rail animation read 256-color palette indices through ansi256ToHex in @veyyon/utils/color instead of two copies of the xterm table; no user-facing change.
  • The hook selector behind ask questions and extension ui.select counts the rows its options take once per terminal width instead of on every key, so an arrow key on an 80-option list takes 28 µs instead of 286 µs at 80x10 and 59 µs instead of 341 µs at 80x30.
  • MCP initial connect and reconnect open and wire a server connection through one pair of manager methods, ACP reads the last assistant message through findLastAssistantMessage, vault extend, replaceValue and rename share one narrowest-first edit walk, the conflict warning and the :conflicts index print their scan note and side labels through one function, and the three JS eval worker handles share one close handshake; no user-facing change.
  • The transcript builder and the presentation event bridge state a tool call's arguments through the tool block's own serializer instead of a second copy of it; no user-facing change.
  • The Streamable HTTP and legacy HTTP+SSE MCP transports send every JSON-RPC message through one postJsonRpc with one auth-retry path, and a refreshed credential replaces the transport's headers instead of writing into the configuration object it was created with.
  • The stdio, Streamable HTTP and legacy HTTP+SSE MCP transports classify a server's messages through one routeIncomingMessage, and the two HTTP transports POST the answer to a server request through one deliverServerResponse.
  • The web_search tool guidance treats results that name versions, models or products newer than the model's training as current, confirms one with at most two targeted follow-up searches, and prefers corroborated results over prior knowledge (#882).
  • No user-visible change: --mode json states why it dropped a line through errorMessage from @veyyon/utils instead of an inline copy.
  • No user-visible change: a spawned agent's model list is split by the same normalizeModelPatternList the settings layers use instead of a second copy in the executor.
  • No user-visible change: --models scoping and enabledModels filtering detect a glob selector through one predicate instead of two copies.
Fixed
  • A model with no known context window no longer reports that the session compacts at 1 token; threshold compaction does not run for such a model and the compaction-threshold notice stays silent.
  • A model selector with an effort suffix, such as kimi-code/k3.1-pro:high for an agent, resolves to the model it names at that effort instead of a sibling whose id contains the suffix's letters, such as kimi-code/k3.1-pro-highspeed; an unknown suffix such as :hgh is dropped with a warning instead of picking such a sibling.
  • A spawned agent whose first configured model has no working credentials runs the next configured model that has them instead of falling back to the parent session's model, and a keyless local parent model (Ollama, llama.cpp, LM Studio) is accepted as the fallback.
  • A model list that resolves after extensions load, such as an agent or --model naming an extension provider's model, starts on the first listed model whose provider has working credentials instead of the first listed model or the parent session's model, and accepts a keyless parent model as the fallback.
  • inspect_image with no agent.helpers.vision.model set skips a text-only default or active model and reads the image with an image-capable one, the same order attached-image descriptions use, instead of failing with "does not support image input".
  • inspect_image and the description a text-only session reads for an attached image run at the Vision helper's effort, or a :level on its model, else the session's effort, instead of the provider's default.
  • Eval completion() with no model or with "default" runs at the Eval Completion helper's effort, else the session's, instead of the provider's default; a :off suffix disables reasoning, and an effort the model lacks is fitted down to its nearest offered effort instead of up to its highest.
  • /guided-goal fits its effort to the efforts the plan model offers instead of sending one the model lacks.
  • Session titles, agent labels, unexpected-stop checks, speech rewrites and memory passes run at the effort picked with their helper's model, else the session's effort, instead of with reasoning off or at a fixed low or medium effort; auto-thinking classification runs at its helper's effort, else with reasoning off, and veyyon commit honors a :off on its helper's model.
  • An idle agent with a running background job, its own or one an agent it spawned started, stays awake instead of falling asleep on the idle timeout and cancelling the job.
  • job cancel on an asleep agent stops the agents still running under it instead of reporting the agent already asleep.
  • A background agent that ran in an isolated worktree reports that messages cannot reach it, and a stopped isolated agent's result no longer says to message it via irc, since its worktree is removed when the run ends.
  • A stopped background agent's result offers to message it via irc once instead of twice.
  • The /agents stop confirmation states that the agents a stopped agent spawned also fall asleep, and the job agent listing says cancel stops an agent, which then wakes when messaged, instead of saying it kills it.
  • A message sent while an earlier one is still preparing its images no longer reaches the model ahead of it: a prompt claims the turn before preparing its images, and steers, follow-ups and extension messages are delivered in the order they were sent.
  • --mode json prints every session event instead of silently dropping assistant tool-call messages, turn_end, agent_end and a persisted session's read results, and reports a line it cannot redact on stderr.
  • A collab host with share.redactSecrets on and a configured secret delivers live entries and events that hold provider streaming state or a read's card to guests instead of failing to send them.
  • An eval cell that throws, exits non-zero or times out is reported to the agent loop as a failed tool call, as a failed bash command is, instead of as a success whose text states the exit code.
  • An active goal keeps driving after a turn that ends in prose without a tool call, including the reply to the /goal objective, and stops with a warning only after 3 such turns in a row instead of stopping silently after one.
  • The goal continuation after a turn that ended without a tool call states that the turn did no work and directs the model to start an untried approach, so a model that answers with a status report returns to work.
  • A goal continuation held by a draft or attached images in the composer is sent once the draft is deleted without being sent, instead of leaving the goal idle until the next message.
  • Every process a session spawns (bash and PTY commands, eval kernels, launch processes, MCP and language servers, the managed browser) starts at nice 10 (BELOW_NORMAL_PRIORITY_CLASS on Windows), so a parallel build or media job no longer stalls the terminal and desktop.
  • The advisor no longer receives a configured secret written in the primary model's thinking; thinking blocks pass through the secret obfuscator like text and tool arguments.
  • A jj command ends after 5 minutes with exit code 124 and keeps at most 8 MiB of output, as git and gh do, and truncated gh output is labeled gh instead of git.
  • veyyon plugin uninstall --json prints a JSON record for a marketplace plugin instead of the human success line; uninstall, enable and disable now share one loop that reads --json on every install route.
  • Both MCP HTTP transports report a reply to a server request that the server answers with an HTTP error status, instead of dropping it.
  • A Streamable HTTP MCP notification refreshes a rejected credential and retries once, as a request does, and a failed MCP transport POST or legacy SSE connect includes the server's WWW-Authenticate and Mcp-Auth-Server challenge.
  • An MCP server's error that names no request ("id": null, such as a parse error) fails a Streamable HTTP request with the server's code and message instead of reporting that the server never answered, and on the Streamable HTTP GET stream it reaches the client's error handler instead of being dropped.
  • A Streamable HTTP or legacy HTTP+SSE MCP server message that carries a method and a null id is delivered as a notification, as over stdio, instead of being dropped.
  • An MCP server frame that is not a JSON-RPC message is logged as an ignored message on every transport, where an object with neither a method nor an id was dropped without a log line, and over Streamable HTTP a frame that is not an object failed the request it arrived on.
  • A tool call aborted inside a JS eval cell rejects with ToolAbortError in the worker, the same error the host raises, instead of a plain Error carrying the abort's name.
  • RpcClient.login is defined again; an unterminated doc comment above it had turned the method into a comment, so calling it threw client.login is not a function.
  • A binary update whose download fails before the disk has created the partial file no longer leaves a veyyon.<id>.new beside the installed binary; the removal ran before the file's open landed, and the open then created it.
  • An eval kernel whose runner exits during startup reports kernel exited with code N instead of EPIPE: broken pipe, write when the init request is written after the runner closed its stdin.
  • A JS eval cell that displays or returns a value holding a cycle shows it with "[Circular]" where it loops back, in 41 ms instead of 915 ms, and a value holding a function or symbol shows "[Function: run]" or "Symbol(marker)" in place; both printed [object Object].
  • A tool block whose arguments hold a cycle states them as [unserializable] in 2 µs instead of about 1 s, and arguments carrying code or prose serialize faster, 16.5 µs instead of 28.0 µs for a 50 KB write.
  • The lsp diagnostics action and the diagnostics after a write name a language server or linter that failed, with its error, instead of reporting the file clean; a file no server checked is reported as not checked.
  • The first lsp diagnostics call or rename_file against a project-aware language server returns in about a second instead of 15 seconds: the file opens before the project-load wait, and a server that reports no load progress is waited on only until it publishes or 2 seconds after the open.
  • rename_file on a fresh TypeScript server proposes the import edits of every file importing the renamed one; it opened no file first, so tsserver loaded no project and proposed none.
  • A write reports the diagnostics its language server published for the written text; a publish that arrived before the write's file-change notice was dropped, so the write waited out its diagnostics budget and reported the file clean.
  • A language server that exits during startup is reported with its exit code and stderr, such as pyright: LSP server exited (code 1): ModuleNotFoundError: No module named 'pyright', instead of LSP reader stopped; client torn down.
  • The lsp diagnostics action reports a Rust file's cargo check errors and lints instead of OK for a file that does not compile: it runs rust-analyzer's compiler check and waits for it, and a check still running at the call's timeout is named in the server notes.
  • A discovery.type: ollama endpoint whose /api/tags body is not a model list fails with an error naming the URL instead of a TypeError, and a /api/tags entry that names no model is skipped instead of failing discovery.
  • Fixed the plan review card dropping its option rows off the bottom on narrow terminals where the footer shortcuts wrap.
  • Fixed the settings card cutting its last category tabs off the sidebar on terminals too short to list them all; the sidebar now scrolls to keep the selected tab in view.
  • A bash block's $ command header takes the new theme's colours after a theme change.
  • An expanded bash or eval block no longer states … N more lines under output it shows in full.
  • agent:// and artifact:// completion skips a registered artifacts path that is a file instead of failing, as history:// completion already did.
  • Aborting LSP workspace diagnostics ends the checker and every process it started and returns within milliseconds; it used to end only the checker and wait for its children to release the output pipes, which took 4.3 s with a child that ran for 5 s and never returned while a child kept running.
  • A socket-mode debug adapter such as dlv that exits before it is reachable fails debug launch with DAP adapter exited (code N): <adapter stderr> as soon as it exits, instead of Adapter process exited before socket was ready on Linux and <adapter> did not connect within 10000ms after the whole readiness timeout elsewhere.
  • An MCP transport that closes while the reconnection that produced it is still settling, such as a streamable-HTTP event stream that ends while the tool list is in flight, starts a new reconnection or trips the crash breaker instead of staying listed as connected, and the close of a connection a manual reconnect already replaced no longer tears down the live one.
  • A write, an edit or lsp diagnostics against a language server that answers textDocument/diagnostic pulls returns the pulled diagnostics instead of waiting for a publish, so a tsgo write that broke the types reports the error in 38-123 ms instead of reporting no issues after 3,004 ms, and a warm rust-analyzer or Ruff write drops from 101 ms to 2-16 ms.
  • Python, Ruby and Julia eval kernels cache their runner script in cache/<language>-runner under the veyyon config root (or $XDG_CACHE_HOME/veyyon) instead of <tmpdir>/veyyon-<language>-runner, where another account on the host could create the script first and have every kernel run it; a kernel start writes the script again when it is missing, instead of every later start in the process returning an empty cancelled cell, and writes it with the shared atomic writer so another process never runs a partly written one.
  • An eval kernel whose runner exits during startup fails with <Language> kernel init failed: <Language> kernel exited with code N instead of returning an empty cancelled cell.
  • veyyon completions with no shell lists the four accepted shells in its error again, which the subcommand flag check had dropped, and a bad shell prints the standard USAGE block.
  • veyyon acp fails session/new on a flag neither the launch parser nor the session's extensions recognize, with the flag and the nearest known one, instead of serving every session with the flag ignored.
  • veyyon trust exits 2 on an unknown flag instead of ignoring it, so a typo of --deny such as --denny no longer approves the project, and it accepts several paths and tab-completes them as files.
  • veyyon rollback <version> moves to the named version instead of failing with Unexpected argument, and veyyon rollback exits 2 on an unknown flag instead of ignoring it.
  • --compaction-model tab-completes model ids from the catalog like --model, instead of completing nothing.
  • Hidden context queued for the next turn (an extension's nextTurn message, a parked advisor concern, a reminder) reaches the next turn when a prompt is interrupted or fails before its turn starts, instead of being dropped with that prompt, and an interrupt during that window still shows a parked advisor concern as advice.
  • /force, the executor's final yield reminder and the eager todo require their tool on OpenRouter, Cursor, Devin and GitLab Duo models, where they required nothing and /force failed with Current model does not support forcing a specific tool.
  • VEYYON_EVAL_PROMPTS accepts the tool-choice/any and tool-choice/named prompt ids instead of refusing them as unknown.
  • write to a directory, or to a path ending in /, fails with an error giving the path to use, instead of creating a file named after the directory, replacing the file before the /, or failing with a bare EISDIR.
  • veyyon @<path> naming a directory, named pipe, socket or device exits with Cannot attach <path>: it is <kind> instead of waiting forever on a pipe with no writer or failing with a bare EISDIR, ENXIO or ESPIPE.
  • An update interrupted by closing the terminal, Ctrl+C, quitting the session or a fatal error during its download or checksum check removes its partial <binary>.<id>.new download instead of leaving it beside the binary until uninstall.
  • read of a named pipe, socket or device, directly or through a symbolic link, selector, path list, suffix match or archive, SQLite or PDF member path, fails at once naming the entry's kind instead of blocking the turn until a writer appears or failing with a bare ENXIO.
  • A prompt that @-mentions a named pipe, socket or device no longer hangs on submit; the entry is not attached.
  • A truncated bash, eval, ssh or interactive shell result states the line ranges it shows, counting only whole lines, instead of ranges split evenly from the totals that named lines it did not show.
  • A bash result larger than the inline budget is cut once and references one artifact holding the full output, instead of being cut a second time and naming a second artifact.
  • A truncated eval result shows the first and last lines of its output within the inline budget, as bash does, instead of only its last 32.5KB.
  • Streamed tool output whose chunk boundary leaves the head window less room than the next character keeps its order, instead of placing a later chunk in the head ahead of output already kept in the tail.
  • A tool result whose output ends in a line break puts one blank line between its last line and its truncation or limit notice instead of two.
  • defs() in a Python eval cell shows a list, tuple, dict or set as its type and length, such as list[1000000], and cuts a string before its repr, instead of building each value's whole repr to show 60 characters of it, which took 0.5s over 170MB of values and timed out on larger kernels.
  • A Python or JS eval error shows the frames of the cell and the code it called, without the runner and worker frames that dispatched the cell, names each JS cell <cell> instead of a UUID file, and shows a JS cell that did not parse or a thrown non-Error as its text alone.
  • A Python eval cell that does not compile reports its SyntaxError at its line in <cell> instead of under <unknown> behind runner and ast.parse frames, and a chained exception keeps the blank line after its separator.
  • /todo in ACP and text mode tells the agent the list changed, and after a removal not to re-add what was removed, as the TUI does.
  • /todo copy in the TUI reports a clipboard failure instead of Copied todos as Markdown to clipboard.
  • /todo done, drop and rm, and /todo start in the TUI, match a task or phase named in quotes.
  • /todo export in the TUI creates the directories a missing path needs, as ACP does.
  • The terminal /move command records the directory change for the model, renders request paths against the new directory and rolls the move back when the destination fails to load, as the ACP /move command already did.
  • The ACP /move command strips outer double quotes from its path, and the ACP /rename command prints Session name cannot be empty. for a title with nothing left once cleaned, as the terminal does.
  • ACP and RPC clients receive the new directory's command list after /cwd or the agent's set_cwd tool, and ACP clients its config options, as they already did after /move.
  • /cwd strips outer double quotes from its path, as /move does.
  • In print mode, a slash command after /move or /cwd resolves relative paths against the session's current directory instead of the launch directory.
  • /export and RPC export_html resolve the output path against the session's working directory and report the absolute path written, so an ACP session no longer exports into the server's launch directory.
  • /export keeps a path that contains spaces whole and strips outer double quotes in the terminal, ACP and print mode, as /move and /cwd do.
  • /fast and /browser accept an argument followed by whitespace outside the terminal, as the terminal does, instead of printing the usage line.
  • /session Info and /session info (trailing space) now show session info over ACP and in print mode instead of the usage line, and a mistyped /session verb in the terminal prints the usage line instead of showing session info.
  • /session info over ACP and in print mode prints Title: (untitled) for a session with no title instead of Title: undefined.
  • /yolo with a word it does not know, such as /yolo disable, prints the usage line in the terminal instead of raising the confirmation that turns every permission prompt off.
  • Bare /yolo in the terminal turns the bypass off when it is on, as it already did over ACP and in print mode, instead of reporting that it is already on.
  • /model <query> in the terminal opens the model picker with <query> in its search field instead of ignoring the argument.
  • /force <tool> accepts a tab between the tool name and the prompt instead of treating the whole line as the tool name.
  • Fixed /memory:<action> in the terminal printing the usage line instead of running the action, as print mode and ACP already did.
  • Fixed /mcp:<verb>, /ssh:<verb>, /btw:, /tan: and /omfg: in the terminal reading the colon as part of their arguments, so /mcp:list showed help instead of the server list.
  • /ssh add and /ssh remove read one grammar in the terminal and over ACP, print mode and RPC: text mode accepts desc and compat, the terminal names the replacement for a plain host, port or scope, and an empty /ssh add reports the missing host name on both.
  • A diff or read window of a multi-megabyte source copies the source to the block-boundary lookup in an event-loop turn of its own, so the copy no longer lengthens the turn that built the diff: a one-line edit of a 3.5 MB file held the loop longer than splitting the file.
  • /mcp add and /mcp remove in the terminal refuse a plain scope, project, user or transport, in any letter case, with the sentence print mode and ACP give instead of Unknown argument, and the terminal /mcp smithery-search refuses a trailing scope as it already refused project and user.
  • A whole-file read of a large source file no longer freezes the terminal while tree-sitter summarizes it: the parse runs off the event loop, so on an 18,000-line TypeScript file the longest event-loop stall falls from 69 ms to 1.4 ms, and four 6,000-line files read in one batch finish in 24 ms instead of 95 ms.
  • Shell commands that start together at the beginning of a session share one shell snapshot and one persistent shell instead of each creating a snapshot, one of which stayed in the tmp directory after exit, and a snapshot still being created at exit is stopped and removed.
  • A mid-session change to session.memoryLimitGb, session.maxProcesses, session.writeBudgetGb or session.writeBudgetKill applies to the live session budget at once instead of at the next bash, launch, write or edit call, so an eval kernel or MCP server started in between no longer joins a group with the old caps.
  • A disposed session no longer registers a new budget when its session manager later starts another conversation.
  • A session.memoryLimitGb the host cannot enforce is reported once, at session start, instead of at the first spawned command.
  • The task brief and shared context escaped twice and a yield result sent as a JSON string are repaired once, before validation, so approval, hooks, the tool_execution_* events and the tool receive the same arguments (#896).
  • Fixed a run that failed after one or more tool steps (a credential lookup or provider call that threw) being settled on its earlier tool-use reply, so a transient failure there is now retried and session_stop hooks receive the failure.
  • An @-mentioned image is encoded for the active model, so a model that cannot decode WebP (Ollama, llama.cpp, LM Studio and other stb-backed local servers) receives PNG or JPEG instead of WebP, and with images.autoResize off the mention goes through the same canonical re-encode as the read tool.
  • The shell snapshot, the local:// fallback root, the debug transcript, the /share HTML handed to a custom share script, the LLM request dump, PDF image extractions, git patches, task branch worktrees, screenshots, generated images, external-editor buffers, speech recordings, eval agent artifacts, the debug adapter socket and the /debug work-profile flamegraph are written under <tmpdir>/veyyon-<uid> (mode 700) instead of by a fixed or guessable name in the shared temp directory, where another account could read them or replace them first.
  • A theme color, var or export given as a number that is not an integer from 0 to 255 fails theme validation with "colors.<token>" must be a string or a palette index from 0 to 255 instead of loading as a missing or malformed hex color.
  • A card on a short terminal sheds its padding, tip and spare footer rows before its body, so the ask dialog keeps every option on a 10-row terminal, the plan review its options on a 12-row one, the /mcp add wizard its input row on an 11-row one, and the agent transcript viewer its notice and reply editor.
  • The list cards (/resume, /tree, /copy, /theme, the message picker, history search, the spend-reset, rollback and subcommand pickers, and the thinking, queue-mode and image selectors) size their list to the rows the card shows, so a short terminal shows the rows around the cursor instead of a list the card clips from the bottom.
  • The hook selector behind ask questions and extension ui.select keeps the highlighted option on screen on a terminal 8 to 10 rows tall instead of clipping it off with the options below it.
  • /settings and the model picker on a short terminal show fewer rows instead of cutting the active row or the list off the card, and /copy gives its rows to the list instead of drawing a Preview heading with nothing under it.
  • Stopping the interactive mode stops every spinner, rail, shimmer and loader in the transcript, nested groups included, so no transcript timer outlives the mode.
  • A shell retained for a plain-& background job holds one reap interval, and retaining the same shell again arms no second one.
  • No user-visible change: resetSessionCpuLimitsForTests disposes every limiter it drops, so a limiter's watcher interval ends with the test that created it.
  • Extension tools, hooks and commands in print, RPC and ACP modes redact provider-bound text through ctx.obfuscateProviderText as the terminal does; they used to pass it through unredacted.
  • An extension in a spawned agent reads the agent's context usage through ctx.getContextUsage() and compacts it through ctx.compact(); they used to return undefined and do nothing.
  • A failed abort requested by an extension in print, RPC or a spawned agent is logged instead of exiting the process.
  • No user-visible change: print, RPC, ACP and a spawned agent build their extension actions through one sessionExtensionActions in extensibility/extensions/session-actions.ts instead of three copies.
  • The ask dialog and the plan review shed their padding on short terminals like every other card, showing up to four more body rows at 24 rows.
Removed
  • The agent.prune.enabled, agent.prune.afterMs and agent.prune.waitingAfterMs settings are removed with the agent pruning they controlled; a config that sets them loads with the keys dropped.
  • AgentSession.markMovedFromEmptySessionFile and the dispose step that read it are removed; nothing called the method, so the step never ran; no user-facing change.
  • The terminal's emitCustomToolSessionEvent and showToolError are removed; nothing called them; no user-facing change.
  • The ssr, expandMacro, runnables and relatedTests LSP server capabilities are removed from the built-in rust-analyzer entry and the documentation; no code read them, and a config that still sets them loads unchanged.

1.5.10

2026-10-25 latest View on GitHub ↗
Added
  • The login card sends a browser login's link to the clipboard when it appears, and c (or alt+c while its field holds typed text) sends it again, shown on a copy link key chip.
  • A browser login whose provider takes a pasted callback asks in the login card for the address the browser ended on, so a sign-in over SSH completes without a forwarded port; an address that does not complete the sign-in is asked for again.
  • The account card lists a provider's second way to sign in as its own row named by the method, such as + add with API key (legacy) under OpenCode Go, + add with API key under Nous Research and + add with device code under ChatGPT, which were reachable only by typing their id.
Changed
  • Settings → Agents → Roster lists the subagents before the helpers, in aligned State, Effort and Model columns under a one-line heading with session in an unset cell and the model cut first in a narrow card, shows an overridden row's layer in its Effort and Model columns and what it runs in its detail line, reads a catalog model id ending in :max as that model rather than max effort, drops its duplicate key hints, returns to the opening row on Esc, and the agent page labels its spawn row "Can spawn" (#966).
  • /login <url> completes only an MCP server's OAuth flow; a provider login takes the pasted address in its login card.
  • The startup Codex websocket prewarm resolves its service tier from the session it opens the socket for; no user-facing change.
  • The account card's notice line flattens whitespace through the shared collapseWhitespace; no user-facing change.
  • bench/session-compaction-stall.bench.ts measures the longest event-loop stall and the wall time of a compaction's republish on a large synthetic session; no user-facing change.
  • The no-model sentence a prompt receives is built in config/model-resolution-failure.ts instead of the session runtime; no user-facing change.
Fixed
  • A read that reaches a line longer than its byte budget names that line and continues at the next one, instead of Use :N to continue sending the reader back to the same window, and its truncation notices and card state the read's budget instead of the bytes shown.
  • A resumed or switched-to session whose model exists only in a provider's discovery listing runs on that model instead of the settings default when the discovery cache cannot supply it, as on the first launch after an upgrade that changes the cache format.
  • Codex web search and image generation requests send x-codex-routing-hint, and the startup websocket prewarm states the session's configured service tier, which the first turn on that socket sends.
  • A copy from inside tmux reaches the attached terminal's clipboard through tmux load-buffer -w instead of an OSC 52 escape that tmux drops under its default set-clipboard external, falling back to the escape when tmux rejects the command.
  • r on the account card shows Checking … and then whether the provider accepted the login on the card's notice line, and updates the usage bars from the check's own reading instead of leaving them unchanged until the next fetch.
  • r on the account card's + add another … account row checks the accounts of that provider instead of every stored account of every provider.
  • Selecting, naming, logging out, forgetting and unblocking an account on the account card report their result on the card's notice line instead of only in the hidden transcript.
  • A login started by its alternate id, such as /login opencode-go-api-key, is labelled with the provider it stores under, asks for a name when that provider already holds an account, and reopens the account card on that provider instead of the first one listed.
  • The account card's provider filter labels enter with what it does, enter add <provider> account on a provider with no accounts, instead of always enter switch to this account.
  • A settings submenu opened from a search result shows "enter confirm · esc back" in the card footer instead of the search's "enter keep filter · esc clear search" (#966).
  • A rate limit that states its reset window in words, such as Devin's Your limit will reset in 17 minutes, is retried once that window passes, or ends the turn at once when the window exceeds retry.maxDelayMs, instead of being retried inside the window until the retry budget runs out.
  • A retry stopped by retry.maxDelayMs states both waits as durations, Provider requested a 17m wait, longer than retry.maxDelayMs (5m), instead of in milliseconds.
  • A models.yml that fails to load is stated once with its own Fix: line, without the defaults.. Fix the model configuration splice, the repeated load error, or the API-key advice a print run added, and a prompt sent with no model names that file instead of /login.
  • A YAML syntax error in config.yml, the global config, a --config overlay, models.yml, keybindings.yml, a watchdog or harness profile file, or a swarm file states its line and column instead of Unexpected token, and the settings notice states each file's reason and how to restore it.
  • A print run with a settings file that does not parse states it on stderr instead of running on defaults without a word.
  • A session in a project with no context file no longer logs Context file discovery disabled: caller supplied an empty resolved list when it opens and at every prompt rebuild; an empty list its caller supplies is logged once.
  • veyyon -p and RPC mode write a hand-edited setting of the wrong kind or outside its declared values to stderr as warning: settings: …, with the file and the value the run uses, instead of running on the replaced value without a word.
  • A classifier refusal that ends a turn after the model streamed a tool call no longer writes that call's never-ran placeholder result to the session log, so a resumed session does not send the refusal text back to the model.
  • A --print run whose turn a classifier refused exits 1 and writes the refusal to stderr instead of exiting 0 with no output.
  • A failed auto-compaction summary retries under the attempt count, backoff ceiling and retry.maxDelayMs a turn on the same provider runs under, and a spent usage allowance moves to another account or ends compaction at once as a usage limit, instead of retrying on an uncapped backoff that held the turn for over eight minutes and reporting a 403 out-of-credits response as missing credentials.
  • A todo replan refreshes the session title from the conversation's visible text only, so a provider no longer rejects the title request for carrying the assistant's hidden reasoning.
  • The date and working directory stay in the model's context after a compaction or a failed prompt, and a compaction no longer spends a summary request on them.
  • A recalled memory block that a compaction, a rewind or an abandoned prompt took out of the context is sent again at the next prompt instead of being treated as delivered.
  • A failed command's exit notice in a bash, eval or ssh tool result follows the output after one blank line instead of two.
  • A -p run waits for the agents it spawned and the commands it ran in the background with a timeout, and prints its answer to their results, instead of exiting after the turn that started them and stopping them unanswered.

1.5.9

2026-10-22 View on GitHub ↗
Added
  • The browser tool's open takes context, an isolated cookie jar that every headless tab naming it shares and no other tab sees, closed with its last tab (#947).
  • The browser tool's save_state action and tab.storageState() write every cookie of a tab's context and the localStorage of its open origins to a Playwright-compatible state file with mode 0600, and open's storage_state and tab.loadStorageState() load one into a headless tab before the first request, writing localStorage once so a key the site later clears stays cleared; a spawned or connected browser's session can be saved but not overwritten by a load (#947).
  • The browser tool's open with a url returns the loaded page's aria snapshot, whose refs a run can act on, when it is at most 6,000 characters, so a small page needs no separate call to read it; a larger page's size is stated instead, and the open's card draws its own rows as before.
  • The browser tool's tab.uploadFile takes a button, label or other control that opens a file chooser and hands the chooser the files, refuses an input that takes no files, and fails naming a control that opens no chooser.
  • The browser tool's tab.ref() and tab.id() can be called on without awaiting the handle first: await tab.ref("e5").click(); a call left unawaited on a ref that resolves to nothing no longer ends the tab.
  • The browser tool's tab.ariaSnapshot(), and an open's page snapshot, nest each iframe's content under its line, cross-site frames and frames within frames included, with refs like f1e3 that tab.ref, aria-ref= selectors, fill and click act on inside the frame; a click there is refused, naming the cover, when the page above the frame covers its point.
  • A browser action's selector may be a snapshot line's role "name" form, such as tab.fill('textbox "Email"', …) or tab.click('button "Save"'), or the attribute forms textbox[name="Email"] and role=button[name="Save"], which act on the element with that role and that exact accessible name instead of failing as invalid CSS; input[name="q"] stays CSS.
  • A browser action's selector may be a comma list that mixes CSS with aria-ref=e5, a snapshot line's [ref=e5], role "name" or text/… alternatives, and acts on the first alternative in written order that matches; a list with no match, and a selector that does not parse, fail within 2 s instead of waiting out the action's 8 s; tab.select and tab.press's selector take refs.
  • A browser action's selector may end in Playwright's :has-text("…"), such as button:has-text("Sign in"), which acts on the first element its CSS matches that holds the text, case and spacing aside, or on the innermost element holding it when no CSS precedes it; :has-text() nested in another pseudo-class stays refused.
  • The browser tool's tab.reload() loads the tab's current URL again with goto's waiting and deadline, fetching a page that a form's POST produced with a GET instead of submitting the form a second time; a selector passed as an object names tab.id(n) and tab.ref("eN").
  • A browser run whose fetch fails on a relative URL such as /api/items says that run code executes outside the page and gives the tab.evaluate form that makes the page's own request with its cookies.
  • Added browser.naturalInput (default off): browser clicks, hovers and drags move the pointer along a curved, eased path and rest before pressing, typing pauses between keys, short fills are typed key by key, and off-screen elements are scrolled to with the mouse wheel; off restores the instant input.
  • The browser tool reports a bot challenge it finds after open and run, naming its vendor, whether it clears on its own, needs a person or blocks the browser, and the evidence, once per page.
  • The browser tool waits up to 20 seconds, or the call's timeout when shorter, for an interstitial bot check such as Cloudflare's to clear, and states where the page led or that it did not clear.
  • The browser tool's open takes visible: true | false, which moves a tab between headless Chromium and a browser window with its page, cookies and localStorage, so a person can solve a challenge and the run continues.
  • The browser tool's open takes profile: "<name>", a persistent Chromium profile under the agent directory whose cookies, storage, cache and history survive sessions; a profile another process holds is refused, naming its lock.
  • cursorExecHandlersForAgent in @veyyon/coding-agent/cursor builds the Cursor exec bridge for an agent constructed after it, and throws for a call that arrives before the agent exists instead of running it unprepared.
Changed
  • The bash tool starts an external program with posix_spawn instead of fork, so the cost no longer grows with the agent's memory: one /usr/bin/true takes 0.24 ms instead of 12.6 ms in a 544 MB process and instead of 58 ms in a 2 GB one; a program given a descriptor above 2, nohup cmd &, and every program on glibc before 2.26 still fork.
  • set_cwd and a session moved to another project rewrite only the session file's header and keep every entry line on disk, so changing directory on a 321 MB session takes 117–147 ms instead of 1.9–2.2 s and holds 230–244 MB resident instead of 1.3–1.8 GB.
  • A search call that carries a field another type takes, such as hidden on a text search, runs as if the field were absent and starts its result with a line listing the ignored fields and the fields that type takes, instead of failing with Search type "text" does not accept: hidden.
  • A search of type structure over a tree parses files on one thread per core beside the walk, so the tool returns in 1.1 s instead of 2.2 s over 282,743 cached PHP files and in 5.8 s instead of 18.8 s over 64 PHP files of 2 MB each.
  • A search of type structure holds at most 8 MiB of source in parse at once across every search in the process and returns its syntax trees' pages to the system when it ends instead of at the next idle trim, so after a search over 64 PHP files of 2 MB each the process holds 14 MB of anonymous memory instead of 139 MB; it peaks at 850 MB there, against 445 MB when those files parsed one at a time, and three such searches at once peak at 650 MB against 433 MB.
  • A search of type structure parses and matches files on the walker's worker threads instead of one at a time, so a structure search over 400 PHP files takes 78 ms instead of 275 ms with the same CPU time.
  • A search of type structure asks the disk for 32 files per walk thread at once and walks a parsed tree for error nodes only when tree-sitter marks it as holding one, so over 282,743 uncached PHP files the tool returns in 2.5 s instead of 4.7 s, and in 2.2 s instead of 2.3 s when they are cached.
  • A search of type text asks the disk for 32 files per walk thread at once, so over 3.22 million uncached PHP files (24 GB) the native search returns in 33–36 s instead of 138 s and the tool searches 3.20–3.22 million files within its 30 s limit instead of 785,990, with no change over cached files.
  • A search of type files and a read of a path that does not exist walk the tree on the walker's worker threads and, on Linux, read metadata only for the entries the pattern matches, so a files search for a name that matches nothing in a 400,000-file tree takes 84 ms instead of 715 ms and a missing-path read 89 ms instead of 317 ms.
  • A search of type files, and every glob filter on a walk, whose pattern is a {a,b} group without ** descends only as deep as the group's deepest alternative instead of walking the whole tree, so a search for three named files in a 6.2-million-entry directory returns in 5 ms instead of 1.2 s.
  • A search of type files that reaches its 5 s limit returns the matches its walk found by then, marked incomplete, instead of none, and stops within 10 ms of the limit; the native glob binding's timeoutMs returns those matches with timedOut set instead of failing. On a 6.2-million-entry directory a pattern given 1 s returns 84–116 of its 200 matches where it returned 0.
  • A search of type files whose ;-separated entries share a root reads that root once, through one {a,b} alternation, instead of once per entry in parallel walks that contend for the same directories, so four leading-glob entries over a tree one walk reads in 2.4 s return in 2.6 s instead of stopping at the 5 s limit with a partial result.
  • The first edit of a session builds the tool schemas its context reading needs one tool per event-loop turn instead of all in one, so a key typed 10 ms after the first echoes in 29 ms instead of 35 ms, and a resumed draft no longer holds the loop for the whole build right after the first frame.
  • On Linux, a Python eval kernel returns the memory a cell freed to the system before it reports the cell done, so a kernel that built and dropped a 400 MB working set idles at 26 MB resident instead of 113 MB.
  • A replace-mode edit whose old text is not in the file finds its closest candidate about 18 times faster (1.6 s to 90 ms on a 7,400-line file), and its streamed preview no longer repeats the search on every argument chunk, which held the terminal for seconds while a near-miss edit streamed.
  • A project's launch broker exits three seconds after its last request once it runs nothing that ends with it, whether or not sessions are still connected, instead of living as long as any session that used launch in that directory, which kept one 15–30 MB broker per directory per session; the next launch call starts a new broker in about 60 ms and a request pending when a broker exits is answered by the next one.
  • The browser tool sends a run's displayed and returned objects to the model as one line of compact JSON instead of two-space indented JSON, which is 36–41% fewer characters for a tab.observe() of a real page; the card still lays them out indented.
  • A browser run no longer sends a return value that it already displayed, which was 20% of all run-result text in bench sessions.
  • The browser tool's tab.ariaSnapshot() and an open's page snapshot leave out bare generic wrappers (layout <div>s with no name, text, state or pointer), 7–30% of a real page's snapshot.
  • The browser tool's snapshots leave out a name that a row, list item, column header or other non-control node computes from the children listed under it, and [cursor=pointer] on links, buttons and other roles clickable by definition, 10.9% of the snapshot characters in calibration runs; controls keep their names and every ref stays.
  • A browser run that reaches for document, window or another name the page defines fails with an error that says the name exists in the page and to use it inside tab.evaluate, instead of a bare "is not defined".
  • The headless browser presents the host's own OS, architecture and browser brands, the same in the page, every worker kind, HTTP headers and client hints, instead of claiming Windows on Linux hosts; deviceandbrowserinfo.com/are_you_a_bot now reports it human where it reported a bot.
  • The headless browser's WebGL renderer, screen size, window chrome and mouse-event screen coordinates match the host OS and agree between the page and its workers, and WebGL never reports SwiftShader.
  • navigator.hardwareConcurrency is capped at 8 in the page and every worker alike, and navigator.languages and Accept-Language are the browser's own.
  • A browser click presses a point inside its element other than the exact centre, checked again once the pointer arrives, and tab.fill types a one-line value of up to 24 characters key by key while browser.naturalInput is on, inserting longer values in one edit.
  • A browser tab opened again without visible or profile keeps the window and profile it is on.
  • tab.select selects by the keys a person types at a focused <select> (Chromium's type-ahead, including Cyrillic and CJK labels) and adds a multiple select's further options by a click with Control or Command held, so the page's input and change events are trusted; a disabled option, a value no option has and a customizable select are still set by script, and selecting the options already selected sends no events.
  • tab.fill on a date, time, date-time, month or week input presses each field of its editor and types its digits, and on a range presses Home, End, PageUp, PageDown and the arrow keys, so the page's input and change events are trusted; a colour, and a range more than 40 keys from its value, are still set by script.
  • A reused browser open with a viewport and no scale emulates scale 1.25 as a first open does, instead of 1.
  • The browser tool no longer scans every evaluated script for a sourceURL suffix the pinned puppeteer never appends; no user-visible change.
  • The browser tool description (1,815 estimated tokens, from 1,440) states that run code executes outside the page, that raw page.evaluate cannot see page globals, that a click never presses a cover and that refs chain, that a state file loads only into a headless tab, that iframe content nests in a snapshot with f1e3 refs, which selector forms act, what profile and visible do, and that a Challenge: line needing a person is handed off rather than solved, and asks the model to act on an open's snapshot without reading the page again, to act and read back in one run, and to act through tab actions instead of probing hit targets or page scripts first.
  • The retry recovery helpers moved from session/runtime/retry-runtime.ts to session/failed-turn.ts; no user-visible change.
  • Session switching and its rollback moved from session/agent-session.ts to the session/runtime/session-switch.ts collaborator; no user-visible change.
  • The settings card's agent roster, model-chain picker and shared submenu pieces moved out of settings-selector.ts into agents-submenu.ts, model-chain-submenu.ts and settings-submenus.ts; no user-visible change.
  • Branching, the /btw branch and tree navigation moved from session/agent-session.ts to the session/runtime/session-branch.ts collaborator; no user-visible change.
  • The handoff document and the new session it seeds moved from session/agent-session.ts to the session/runtime/session-handoff.ts collaborator; no user-visible change.
  • The active tool set, the base system prompt with its invalidation record, and the MCP, RPC host, SSH and vibe tool refreshes moved from session/agent-session.ts to the session/runtime/tool-activation.ts collaborator; no user-visible change.
  • The collab guest dialogs, the hook dialog queue and the extension widgets moved out of extension-ui-controller.ts into collab-guest-dialogs.ts, dialog-queue.ts and hook-widgets.ts; no user-visible change.
  • The login, logout, account card and saved-reset flows moved out of selector-controller.ts into account-flows.ts, and the session picker, resume and delete into session-flows.ts; no user-visible change.
  • The /usage and /session panels and the /memory command moved out of command-controller.ts into usage-report-view.ts, session-info-view.ts and memory-command-controller.ts; no user-visible change.
  • The tool-call cards, the compaction and retry loaders with the pinned turn error, the idle compaction and recap, the IRC cards, the replaceable job and todo blocks and the speech hooks moved out of event-controller.ts into tool-call-cards.ts, turn-recovery.ts, idle-follow-ups.ts, irc-cards.ts, displaceable-blocks.ts and turn-speech.ts; no user-visible change.
  • Paste intake, the /queue batch and dequeue, submission routing and the Esc chain moved out of input-controller.ts into composer-paste.ts, queued-submissions.ts, prompt-submission.ts and composer-escape.ts, and a detached abort from those paths is logged under the new module's name; no user-visible change.
  • The composer, plan review, plan annotation, /todo edit and hook-editor external-editor handoffs share one editInTerminal, so /todo edit now runs the editor on the controlling terminal like the composer's ctrl+g instead of on the inherited stdin.
  • Plan mode, the plan-review overlay, plan approval and vibe mode moved out of interactive-mode.ts into plan-mode-controller.ts and vibe-mode-controller.ts, and the local-artifact copy into a fresh approved session moved to internal-urls/local-protocol.ts; no user-visible change.
  • The anchored todo board, the agent HUD, their shared motion clock, the todo auto-clear and the agent-change rebuild moved out of interactive-mode.ts into anchored-blocks.ts; no user-visible change.
  • The ACP plan-approval resolve types its input as ResolveParams, as the terminal plan mode does; no user-visible change.
  • The LSP server selection, diagnostics wait, project diagnostics, rename_file and the edit/write writethrough moved from lsp/index.ts into lsp/servers.ts, lsp/diagnostics.ts, lsp/workspace-diagnostics.ts, lsp/rename-file.ts and lsp/writethrough.ts, so the edit and write tools no longer load the lsp tool; no user-visible change.
  • The extension handler time budget and the lspmux liveness probe use settleWithin from @veyyon/utils instead of their own deadline racers; no user-visible change.
  • The ephemeral side-channel turn behind /btw, /omfg, the idle recap and the composer prediction moved from session/agent-session.ts to session/agent-session-ephemeral-turn.ts; no user-visible change.
  • The synchronous !command and environment config-value resolver moved from config/model-registry.ts to config/resolve-config-value-sync.ts; no user-visible change.
  • The goal-continuation todo context and the magic keyword notices moved from session/agent-session.ts to session/agent-session-turn-notices.ts; no user-visible change.
  • The Julia kernel's execute-request encoder is the exported buildExecutePayload in eval/jl/kernel.ts instead of an inline constructor option; no user-visible change.
  • A prompt, a steer, a follow-up and a synthetic follow-up build their text-and-image content and the text-only model's image description through one session helper; no user-visible change.
  • The model registry's persisted resolved-models.json stage codec moved from config/model-registry.ts to config/resolved-model-stage.ts; no user-visible change.
  • The model registry builds custom-model and provider-override headers through createLiveConfigHeaders directly instead of two single-use wrappers; no user-visible change.
  • The live config-header builder moved from config/model-registry.ts to config/live-config-headers.ts; no user-visible change.
  • Model override, custom model and provider compat application moved from config/model-registry.ts to config/model-patch.ts; no user-visible change.
  • The session appends a custom message without a turn, and merges queue-chip text into a queued message's details, through one helper each instead of four and two copies; no user-visible change.
  • The last-assistant-message readers moved from session/agent-session.ts to session/agent-session-message-shapes.ts; no user-visible change.
  • Doc comments that module splits left above the wrong declaration (stageModels, AUTO_THINKING, ConfiguredThinkingLevel) are back on their definitions; no user-visible change.
  • Source comments that named a moved or deleted symbol's old module now name its current one; no user-visible change.
  • Dropping a failed assistant turn and its never-ran tool results from active context moved from session/agent-session.ts to session/runtime/turn-context-check.ts, beside the function that puts one back; no user-visible change.
  • The status line reads the session's provider and OAuth account through its typed members instead of a reflective record with a fallback for a session shape that no longer exists; no user-visible change.
  • The GitHub cache reads its three settings by their declared paths instead of through an untyped cast; no user-visible change.
  • MCP request params, the reloaded ssh tool and the argument display read through their declared types instead of as unknown as casts; no user-visible change.
  • Settings reads in the status line, extension dashboard, speech input, browser, Hindsight memory, advisor roster, task agent settings, extension wrapper and ACP extension listing use their declared types instead of casts; no user-visible change.
  • Permission intent and memory consolidation parsing read their arguments through the isRecord guard instead of repeating it as a cast; no user-visible change.
  • The inline tool-output budget no longer re-checks for a non-finite tools.artifactSpillThreshold, which the settings read already replaces with its default and reports; no user-visible change.
  • The session composition root drops a redundant field comment to stay within its measured size; no user-visible change.
  • Session creation applies the web search and image provider preferences through the one reader the session scope uses; no user-visible change.
  • Settings reads drop the fallbacks and kind re-checks the typed read already guarantees, and provider preferences read their declared types; no user-visible change.
  • The read tool's default line limit is bounded through the shared clampLow helper; no user-visible change.
  • Internal modules import output notices, tool status icons, formatters, the memory root, the active skill set, the IRC switch and the GitHub fetchers from the modules that define them instead of through compatibility re-exports; no user-visible change.
  • The github tool's Actions run model, fetches, outcome rules and watch reports moved from tools/web/gh.ts to tools/web/gh-run-watch.ts; no user-visible change.
  • Extension and custom slash-command resolution and the command context a session builds without an extension runner moved from session/agent-session.ts to session/agent-session-commands.ts; no user-visible change.
  • The process agent lifecycle manager is rebuilt when the process agent registry is replaced, so it never terminates or parks agents through a registry nothing reads; no user-visible change.
  • Deleted tool-renderer, output-notice, image and LSP helpers that nothing called (renderCollapsedOutputLines, formatMeta, formatEmptyMessage, formatTitle, the rendered-string memo, appendParseErrorsBulletList, the styled truncation notices, SUPPORTED_INPUT_IMAGE_MIME_TYPES, getServerForFile, hasCapability); no user-visible change.
  • The benchmark CLIs share one time-to-first-token predicate, the guided-goal turn and the memory passes share one per-attempt credential refresh, the model registry and the sign-in list share one reader of disabledProviders, and the legacy plugin loader resolves package imports and exports targets through one function; no user-visible change.
  • Removed the parameters autoresearch branch handling and the release installer accepted and never read; veyyon update --force still reinstalls the running version, with no user-visible change.
  • The auth broker command imports the credential store from @veyyon/ai/auth-storage-sqlite, with no user-visible change.
  • Modules import the timeout, whitespace, advisor transcript name and slash-command category helpers from their owning modules; the utils/fetch-timeout re-export module is removed, with no user-visible change.
  • The LSP client and diagnostics, the web search tool and the web-search command import the language-id, grouped-diagnostic and search-provider metadata helpers from their owning modules instead of the lsp/utils and search/provider re-exports, which are removed except getSearchProviderLabel; no user-visible change.
  • Built the OpenRouter and Gemini image-generation URLs from the @veyyon/catalog/provider-endpoints constants instead of repeated host literals; no user-visible change.
  • 96 modules that read only the active theme import it from theme/theme-binding instead of loading the theme engine, so 60 of them no longer reach theme JSON loading, highlighting or mermaid; no user-visible change.
  • Removed two section comments in the github tool module that described fetchers now in gh-fetch.ts; no user-visible change.
  • The status line's context gauge finds its usage anchor by walking back from the newest entry instead of scanning the whole branch, so drawing it on a 97,000-entry resumed session takes 0.19 ms instead of 2.1 ms per frame.
  • Writing a message after a custom entry adds only the new entries to the session's message-timestamp index instead of re-reading the whole branch, so each such write on a 97,000-entry session takes 0.49 ms instead of 5.4 ms.
Fixed
  • A Public Web web_search that returns no result lists the engines that found no results for the query beside the engines that failed, instead of reporting All public engines failed for a query an engine answered with nothing.
  • A search of type files whose glob ends in /, such as vendor/plugin*/, lists the directories the glob matches instead of reporting No files found matching pattern.
  • With several ChatGPT accounts signed in, the model list holds the Codex models of every account's tier, such as the Daybreak-only models listed for a Daybreak account, and a turn on such a model is sent from an account whose listing includes it.
  • The Codex web_search provider and Codex hosted image generation send access_programs.cyber set to the Daybreak program the signed-in account is offered for the model, so a Daybreak account's security search or image request is no longer refused with cyber_policy for lack of the field.
  • A Codex web_search on a model the catalog marks for Responses-Lite, which includes every default search model, is sent in the plain Responses shape and searches, instead of failing with 400 Tool choice 'web_search_preview' not found in 'tools' parameter.
  • veyyon is built on Bun 1.4.3 and refuses an older runtime, so a synchronous spawn, such as reading a reftable repository's HEAD or running a models.yml !command value, no longer spins at 100% CPU forever with its exited child left a zombie when Bun 1.4.0–1.4.2 lost the child's exit (oven-sh/bun#34069).
  • A turn stopped by an abort, such as a subagent's soft request budget stopping its free-running turn to force a final yield, settles as aborted instead of being re-sent by auto-retry as a dropped request, so the forced yield runs instead of the agent reaching its hard request budget.
  • An overlay card on a terminal shorter than 16 rows fits the screen with its title, close glyph and footer chips, instead of drawing a 14- or 16-row card that the screen cut at the top or bottom; this covers the model picker, the model hub, the ask dialog, the plan review, the login dialog, the extensions dashboard, the session picker, the advisor configuration and every list card such as /theme and /effort.
  • A bash command that names /dev/stdin, /dev/stdout, /dev/stderr, /dev/fd/N or /proc/self/fd/N, as a builtin's operand or in a redirection, uses the command's own descriptor, so cat <(cmd), comm <(a) <(b) and grep x /dev/stdin read their input and tee /dev/stdout and > /dev/stderr stay in the captured output, instead of failing with "No such file or directory", reading the terminal until the call timed out, or writing into veyyon's terminal; a number the command does not hold fails instead of opening a file veyyon holds.
  • A program that find -exec, find -execdir, xargs, sed's e command, rg --pre or sort --compress-program starts in the bash tool runs in the shell's directory with the shell's exported environment and PATH, and its output is captured, instead of running with veyyon's environment and writing into veyyon's terminal.
  • A program the bash tool starts no longer inherits the files veyyon holds open, such as its session file.
  • diff in the bash tool reads a pipe or FIFO operand, such as diff <(a) <(b), once, instead of reading it again after comparing sizes and reporting different inputs as identical.
  • A tool call whose next argument the model wrote as </parameter><parameter name="…"> markup inside a string value runs with that argument in its own field, so an eval call with its title inside language runs instead of failing validation, and a write whose content ends in a leaked i no longer writes the markup into the file.
  • An ssh command that starts a background job, such as cd dir && nohup job > log 2>&1 & echo started, returns its own output and exit status when the command exits (469–529 ms on a LAN host) instead of waiting until the job ends or the call times out as cancelled, with a notice that the session closed without the job; on bash, zsh and sh hosts other than Windows.
  • An ssh call with a cwd runs every part of its command in that directory and none of it when the directory is missing, instead of running whatever followed a ;, & or newline in the remote home directory and reporting exit 0 after a failed cd; on hosts other than native Windows cmd and PowerShell.
  • launch stop, describe, logs, wait, send and restart answer for a process whose record the broker purged after the cleanup wait, from its retained completion record, instead of failing with Unknown daemon <name> while list still shows the name under "Recently completed".
  • An edit anchored on a line an earlier read or search displayed applies after reads or searches of 30 other files and a later read of the same unchanged file, instead of failing with "never displayed" while the re-read of the first range is refused as still in context.
  • An edit anchored on a line shown in an earlier edit's response, or displayed by a read before that edit, applies under the tag that edit returned after a later partial read of the file, instead of failing with "never displayed".
  • An edit of a copied file anchored on a line a read or search displayed in the file it was copied from applies after a ranged read of the copy, instead of failing with "never displayed".
  • An edit anchored on a line shown before or by an earlier edit that applied to a file changed outside the session, or to a file whose snapshot was evicted, applies under the tag that edit returned after a later partial read, instead of failing with "never displayed"; after an edit recovered onto a changed file, a line the change rewrote, added or moved is refused until displayed.
  • An edit anchored on a line a read or search displayed before the file changed outside the session applies under the tag a later ranged read of the changed file returned, when the change left that line in place, instead of failing with "never displayed".
  • edit, read, LSP workspace edits, ast_edit, write conflict resolution, archive, document, vault, skill and local:// reads, and context discovery open a workspace file through node:fs, so a file another process holds a lease on (an NFS-exported file a client has open) is read or written once the lease breaks instead of failing with EAGAIN: resource temporarily unavailable, and an AGENTS.md that hit that error is no longer cached as absent.
  • A ranged read of a file up to the snapshot cap decodes it in one readFile pass, so a 4 MiB file is materialized in 327 µs instead of 571 µs.
  • A tool Cursor runs through its exec channel receives the arguments the agent loop would give it, with the i intent field stripped, repairs applied, the schema checked and codec handles and secret placeholders expanded, so a Cursor search call no longer fails with Search type "text" does not accept: i and an invalid argument is answered with the validation error instead of reaching the tool.
  • A read whose delimited path names several paths that do not exist waits for the 5 s suffix-search limit once per call instead of once per missing path, and searches a repeated path once, so a four-path read with two missing paths over a busy 6-million-entry tree returns in 5.0 s instead of 7.5–7.7 s, and in 5 s where it took 10 s when each search reached the limit.
  • A search of type text that reaches its 30 s limit returns the matches found by then with a notice that the result is incomplete instead of failing with "Text search timed out" and no matches, and the targets of a delimited path share the limit instead of each taking 30 s; over a 6.1-million-entry tree, integrity= under a 2 s limit returns 104 matches in 82 files instead of an error.
  • A search of type structure and ast_edit skip parsing a file that lacks the literal text every pattern needs and walk the tree without first listing every file, so a structure search over 833,000 PHP files takes 2.4 s and peaks at 54 MB instead of 248 s and 598 MB, and over 99,960 files the tool returns in 0.31 s instead of 30 s; a malformed file that cannot hold a match is no longer reported as a parse issue.
  • Changing the working directory keeps the probed shell and OS of every SSH host whose destination is unchanged instead of deleting every host's record and closing its master connection, so the ssh tool description and the prompt-cache prefix stay byte-identical across a same-project re-root (8 configured hosts: 8 records kept instead of 0, tool definitions unchanged instead of rewritten to "detecting...").
  • Exiting on SIGTERM after a tmp cleaner removed a shell snapshot no longer logs "Cleanup callback failed" with ENOENT, and removes every other snapshot instead of leaving them in the tmp directory.
  • The embedded shell sizes each command's environment from the variables in scope instead of a count that grew with every bash call and never shrank, so 12,000 calls retain 13.5 MB of memory instead of 81.4 MB.
  • Keys typed while a session named by --resume, --continue or --fork is loading show in the composer instead of being discarded: the launch card now paints for those launches and holds the keys, so "hello" typed 30 ms after launch appears 40–53 ms after launch; a bare --resume still opens the session picker without the card.
  • A resumed session echoes keystrokes while its transcript is rebuilt: the transcript is built off screen in 8 ms slices, the first in a turn after the startup work and each tool's argument schema in a turn of its own, and replaces the startup frame in one step, so on a 150-prompt session the slowest keystroke echo after the composer appears falls from 112–141 ms to 40–45 ms.
  • A foreground bash call that returns its result inline drops its background-job record when it finishes instead of keeping it, its output, its abort controller and an eviction timer for five minutes, so a session that ran 3,200 commands settles at 225 MB of anonymous memory instead of 242 MB and holds no dead job per command.
  • A search of type structure and ast_edit parse a PHP file that closes its ?> tag and continues as HTML under the full PHP grammar instead of reporting it as a parse error and skipping it, so in a 556-file WordPress plugin 0 PHP files fail to parse instead of 139, echo $X; finds 3,238 matches instead of 2,636, and each structure search takes 454 ms instead of 979 ms.
  • A search of type structure prints a $$$ binding as the source it spans instead of listing each separator as an element, so foo($$$ARGS) over foo(a, b) shows ARGS=[a, b] instead of ARGS=[a, ,, b].
  • A read of a semicolon-delimited path list reads its entries without first searching the whole working directory for a file named by the joined string, so in a 300,000-file directory each such read takes 4.5 ms instead of 168 ms (larger trees waited out the 5 s search deadline on every call), and a suffix search that reaches its deadline stops walking the tree instead of finishing the walk in the background.
  • A memory pass on a model that does not accept its effort logs "Memory pass effort is not accepted by the model" once per model and effort instead of once per request.
  • A partial read of a large source file and an edit preview of one no longer freeze the terminal while tree-sitter finds the enclosing block: the parse runs off the event loop, so on a 3.5 MB TypeScript file the longest event-loop stall falls from 153 ms to 1 ms (0.5 MB: 51 ms to under 4 ms).
  • An eval cell whose output arrives as one large frame no longer freezes the terminal while the kernel's output is read: each pipe chunk is scanned once instead of rescanning everything received so far, so a 32 MB frame takes 33 ms instead of 541 ms; a frame over the 64 MiB stream frame ceiling (VEYYON_STREAM_FRAME_MAX_BYTES) ends the cell with the reason and restarts the kernel instead of hanging it.
  • An automatic compaction on a resumed session no longer freezes the terminal while it prepares its summary: compacted history is read back as copies in 8 ms slices instead of in one pass that kept every entry in memory, so on a resumed 34,572-entry session the longest event-loop stall before the summary request falls from 405 ms to 9.5 ms and 16,977 compacted entries stay on disk instead of in memory.
  • The first session spend tally after a resume (/session, a goal charge) no longer reads every compacted assistant reply back from the session file, so on a resumed 34,575-entry session it takes 3 ms instead of 95 ms.
  • A saved session's eval kernels, in every language, follow it across a directory change instead of starting a new kernel in each directory and keeping every earlier one alive until the session ended, so a session that visited five directories holds one Python kernel (102 MB) instead of five (211 MB) and keeps its variables; a directory with its own Python venv still gets its own kernel.
  • /new, /resume of another session and a handoff shut down the eval kernels of the conversation being left instead of keeping them alive until the session ended, so five conversations in one session hold one Python kernel (86 MB) instead of five (427 MB).
  • An eval cell that prints many lines no longer freezes the terminal while it runs: it sends one live update per 50 ms instead of one per printed line, and its output buffer re-encodes its window once per window of output instead of once per line, so a cell printing 100,000 lines finishes in 0.33 s instead of 10 s and the longest event-loop stall falls from 10 s to 14 ms.
  • An ssh command's live output is sent at most once per 50 ms, as bash output already was, instead of once per received chunk.
  • A tools.approvalMode in a config file that is not one of its values reads as ask instead of the default auto, and every configured value that does not match its declared type is shown at startup with the file to edit.
  • A failing !command for a provider API key or header in models.yml names the setting it was resolving in its log report, as the other config values already did.
  • ctrl+g in a hook or ask-input editor whose $VISUAL/$EDITOR cannot start shows the failure under the text instead of ending the session, and with no editor configured shows that instead of doing nothing.
  • A session resumed onto a model other than the one its branch recorded no longer reads its whole compacted history back from disk on every turn: pruning, oversized-tail rescue and session spend start at the boundary the context is built from, so 120 turns on a resumed 34,746-entry session peak at 800 MB instead of 1.2 GB and settle at 296 MB instead of 537 MB.
  • A provider error that ends a turn is logged at warn with the provider's message, model and error classification, and a failure's retry classification is logged once instead of once per recovery check (#935).
  • A headless browser launch reads the binary's product and version again after a --version probe that failed or timed out, instead of launching every later tab of that binary without a matching --user-agent, which named itself HeadlessChrome.
  • A credential-free web search that returns before its soft or hard deadline cancels the deadline's timer instead of holding the embedding process open until the deadline passes.
  • Disposing an advisor during the one-second delay before it retries a failed review ends the delay instead of holding a timer, and the embedding process, until it runs out.
  • A web search cancelled while its headless-browser fallback is opening a page closes that page once it opens instead of leaving it open in the shared browser, and a search cancelled during the fallback's retry delay ends at once instead of after the delay.
  • When several sessions start the launch process broker for one directory at once, one broker runs instead of a second one that read the first one's lease before its claim was written and took it as stale.
  • With browser.naturalInput on, a click whose delay an op deadline or abort cuts short releases the button at once instead of holding it for the rest of the delay, which failed the tab's next press with 'left' is already pressed.
  • A browser :has-text() selector matches the text Playwright matches, so a page whose <title>, inline <script>, <style> or <noscript> holds the words acts on the element showing them instead of timing out on an element with no box, and a submit input's value and a shadow root's text count as their element's text.
  • tab.fill on a time or datetime input whose min and max narrow the hour field, such as min="13:00" max="17:00", types the hour as a person does instead of setting the value by script with untrusted input and change events.
  • With browser.naturalInput on, a click through a tab.id() or tab.ref() handle whose element the page replaces while the button is held is made again on the replacement instead of reporting success with no click sent.
  • The browser tool removes the temporary Chrome profiles a crashed or killed process left in the system temp directory before it makes the next one.
  • A headless browser tab opens while another user of the host has a browser open or left a temporary profile in the shared temp directory, instead of every launch failing with EACCES on that user's profile.
  • A browser open with visible whose move fails or is interrupted after the tab left its browser, such as on a page that cannot load, puts the tab back on its browser with its page, context, cookies and localStorage instead of losing it, and a move whose tab has a page holding a dialog open fails within the call's timeout instead of after a minute.
  • A browser click or hover on an element in a cross-site frame, including a frame inside a frame, waits for the frames to draw first, so a press right after the page loads reaches the element instead of the document above its frame while reporting success.
  • With browser.naturalInput on, a tab.id() or tab.ref() handle whose element the page re-renders while the wheel scrolls to it scrolls to the replacement instead of failing as detached, and loading the browser tool no longer evaluates arktype before its first schema is built.
  • After a sign-in form in a headless browser tab, clicks and keys reach the page again: the browser runs with the password manager's save offer and breach check turned off, whose prompts Chrome drew over the tab a few seconds after sign-in and which blocked every later action without an error.
  • A session without the browser tool no longer reads about it: the read description names the browser only when the tool is on, and the reminder to verify an edit names only the check tools (bash, eval, debug, browser) the session has.
  • The browser tool's tab.fill replaces a value in one trusted text insertion, so a React or Vue field's state follows it, the empty value included, and a fill takes about 1.5 ms where the locator fill waited 33 ms for a stable bounding box; it fills contenteditable elements, sets date, time, colour and range inputs with input and change, accepting a value such an input stores in another form (#FF0000, 2026-09-26T10:30:00, 50.0), refuses checkboxes, radios, file inputs, <select> and read-only fields with the call that handles them, and refuses an element that cannot take focus instead of typing into the field that has it.
  • A browser click, hover or drag in a headless tab other than the most recently opened one completes instead of stalling for eight seconds and failing as hidden or covered: each run brings its tab to the front.
  • A browser tab.click by selector or aria ref, and a handle's click() and hover(), no longer press whatever covers the element: a cover that goes within 2.5 s is waited out, one that stays fails the call naming it with nothing pressed, and a disabled control is waited for until it is enabled. A handle's click(), hover() and fill() run under the deadline of the run that calls them and end with it.
  • A promise that browser run code does not await and that rejects, such as page.click("#missing") without await, fails its run as Unhandled rejection (missing await?), or is logged once that run has ended, instead of ending the tab's worker so the next run hung until the tab was killed.
  • A browser tab closed twice at once, or opened again while it closes, is torn down once, instead of releasing its context and browser twice and closing them under other open tabs; a tab closed while a timed-out run's worker is being replaced no longer keeps that new worker running.
  • A browser run stuck in synchronous work past its deadline, such as an execSync or a busy loop, gets its worker replaced and keeps its page, its fields and its session for the next run, instead of killing the tab.
  • A failed browser run's text, what it displayed and its error, is held to the same inline budget as a result's, keeping its head and its tail, instead of sending an execSync's stderr or a dumped page whole on that turn and every turn after it.
  • A browser tab.waitForNavigation() written after the click that navigates, with only reads or wait between them, returns once that page has loaded instead of timing out on a navigation that committed before it started listening.
  • Opening a second headless browser tab no longer resets navigator.platform in the first to the host's native value.
  • Workers the headless browser starts no longer run from blob: URLs, which exposed their location and broke relative importScripts.
  • Opening a visible browser on a Linux host with no display fails with a message naming DISPLAY and WAYLAND_DISPLAY instead of Chromium's launch error.
  • A browser run stuck in synchronous work no longer holds new tabs and page workers in every tab until the stuck command returns: the main thread holds each tab worker's browser connection and closes it when it replaces the worker, so during an execSync with 8 seconds left a new tab opens in 301 ms instead of 8,077 ms and another tab's page worker answers in 32 ms instead of 8,022 ms.
  • A browser tab whose stuck run had its worker replaced keeps its host-true identity, page scripts and viewport, and still loads state files, activates for each run and closes its page on close, instead of reporting empty client hints and a default-size window on its next page.
  • A headless browser tab opened with its own viewport reports a window around that viewport, instead of the shared window's width around it, which devtools detectors read as an open DevTools panel.
  • The headless browser screen leaves the host's taskbar or menu bar out of its work area and opens the window inside it, instead of a work area the size of the whole screen, and the functions its page scripts patch refuse a prototype cycle as native functions do, with chrome.runtime stubs that are not constructors: CreepJS rates the browser 31% like headless and 0% stealth instead of 38% and 40%.
  • The browser tool's bot-challenge check reads the page in puppeteer's isolated world, instead of making about 30 document.querySelector calls and a text walk in the page's own world after every open and run, where a page that replaces DOM methods saw them.
  • A visible browser tab emulates no viewport: its page lays out in the window's content area at the display's scale and follows the window when a person resizes it, viewport resizes the window to hold that content area, and a stuck run's replacement worker keeps the window's size, instead of a 1365x768 page at scale 1.25 whose bottom 87 px the window did not show; viewport.scale on a visible tab is refused.
  • The browser open result and tab.observe() report a visible or attached tab's content area and scale as its viewport, instead of 1365x768 at scale 1.25.
  • tab.observe() no longer fails with Cannot read properties of null (reading 'nodeType') while a date, time or colour picker is open; the picker's own controls are left out of the list.
  • A browser tab.drag() or multiple tab.select() cut short by its deadline or an abort releases the mouse button or modifier it pressed, instead of leaving it held so every later click on the tab failed with 'left' is already pressed or arrived as a Control-click.
  • A browser text/ click releases its page handles and its deadline timer when it returns, instead of leaking a handle per clickable ancestor on every poll.
  • A browser the browser tool spawned is killed on session end or a failed attach when the native addon cannot load, instead of being left running.
  • A foreground bash command that finishes before the auto-background threshold, a client-terminal command that exits before its timeout, an edit whose LSP diagnostics arrive inside the 500 ms inline wait, MCP startup, an LSP or DAP adapter shutdown, the GPU probe, the speech recorder's start wait, an async job delivery wait, the browser's selector hint, file-chooser and frame-draw waits, memory dispose and session shutdown clear their deadline timer when the work finishes, instead of leaving it armed for the rest of the window (up to 300 s for the bash threshold) and holding the process open.
  • A hook or custom command's ctx.ui.terminal.custom factory is typed (tui, theme, keybindings, done), the arguments the terminal passes, and the qna and handoff hook examples call done instead of the keybindings manager.
  • A custom command on a session built without an extension runner redacts through ctx.obfuscateProviderText instead of throwing a TypeError.
  • A discovered custom tool's factory-scoped ui and hasUI receive the host's UI, instead of staying a no-op context and false in every mode.
  • The image-generation, speech and Exa tools join a session's custom tools without a type cast; no user-visible change.
  • Fixed the task card crashing or drawing NaN% confidence when a reviewer yields a verdict whose explanation, confidence or correctness has the wrong type; the card now draws the last well-formed verdict.
  • Fixed a resumed session restoring a goal whose recorded status is not one this build writes, which ran as neither active nor finished while its badge showed it running; a usage record with such a status no longer overwrites the goal's counters.
  • Fixed a scalar where a settings group belongs in config.yml (such as tools: on) moving the whole file aside to config.yml.corrupt; the scalar is ignored and every other setting in the file still loads.
  • Setting the todo reminder limit no longer turns todo reminders back on, and turning reminders off no longer drops the limit; the limit is todo.reminderLimit, and a stored todo.reminders.max moves there on load.
  • Startup configuration warnings state what a setting of the wrong kind or outside its allowed values reads as, and report such values in --config overlay files as well as the profile config.
  • The task tool's context argument streams into the pending preview as it arrives in batch mode instead of advancing in throttle-sized steps.
  • The update check, release-list and checksum fetches, release binary download, Smithery requests and Hindsight requests bound the response body with their deadline and clear its timer when the request finishes, instead of leaving it armed afterwards.
  • /mcp smithery-login falls back to API-key entry after five minutes when a browser-login poll request stalls, instead of hanging.
  • The /mcp add wizard repaints a finished connection check and the review step that follows it without waiting for a key, and Esc or a newer check during the check or its pause keeps the step the wizard is on instead of jumping to the review step.
  • Fixed the /tree and /branch pickers cancelling themselves 100 ms after opening over an empty list, which also cancelled twice when dismissed inside that window; they now stay open on their empty state until dismissed.
  • The ! command block draws every streamed output window instead of skipping any that arrive within 50 ms of the previous one, which left the last line before a quiet period undrawn and joined the lines on either side of a skipped window; the ! and % blocks also no longer overflow the call stack on an output window of about a million lines.
  • A continuation scheduled while another run starts, such as the queued-message drain after a user interrupt or a /retry racing a steer, yields to that run instead of failing with "Agent is already processing".
  • The diff shown for an edit of a large file compares only the lines between the first and last change and finds enclosing blocks without splitting either file into lines, so a one-line edit of a 3.5 MB file holds the event loop 1.1-1.7 ms instead of 44-67 ms.
Removed
  • The headless browser no longer returns a made-up font list from queryLocalFonts.
  • Removed the tinyModelClient alias of tinyTitleClient and the OPENROUTER_BASE_URL alias in the Perplexity search provider; no user-visible change.
  • Removed the parseSha256Sidecar re-export from @veyyon/coding-agent/cli/update-cli; import it from @veyyon/natives/sha256-sidecar.

1.5.8

2026-10-16 View on GitHub ↗
Changed
  • A read refused because its lines are unchanged and still in context is now a tool error naming the earlier output's [path#TAG] header, rendered and sent to the model like any other failed read instead of as a read card holding the refusal text.
Fixed
  • A session started with --tools, and every spawned agent with a tool list, no longer logs a false "TTSR rule is scoped to a tool that does not exist" warning for each built-in rule scoped to a tool the session did not build.

1.5.7

2026-10-16 View on GitHub ↗
Breaking
  • Model roles are removed: modelRoles, modelTags, cycleOrder, custom roles, the @role, pi/role and * selectors, the --smol and --slow flags, the VEYYON_SMOL_MODEL, VEYYON_SLOW_MODEL and VEYYON_PLAN_MODEL variables and the /settings Roles tab no longer exist; defaultModel holds the model chain a session starts on, and agent.helpers.<id> (advisor, plan, vision, commit, title, memory, autoThinking, unexpectedStop, speech, completion) sets the model and effort of each feature's own model call.
  • The /settings Roster page lists a Helpers section above the Subagents section, and a helper with no model or effort set runs the session's model and effort.
  • Ctrl+P cycles the scoped models, or every available model when none are scoped, instead of cycling roles.
  • The eval completion() helper runs the completion helper when model is omitted, the session's active model for "default", and otherwise reads model as a model selector.
  • retryFallbackChains keys are default, a model selector or a provider/* wildcard, matched in that order of specificity: exact selector, then wildcard, then default.
  • The @veyyon/coding-agent exports formatRoleChip, resolveRoleAssignments and retryFallbackChainsForRoles are removed, and resolveRetryFallbackRole is renamed resolveRetryFallbackKey.
Added
  • A config written before this release migrates on load: modelRoles.default (or interactive) becomes defaultModel, the advisor, plan, vision, commit, tiny and smol roles become the matching helpers' models with @role references expanded, mnemopi.llmMode: smol becomes online, and each dropped key is reported once in the log.
  • An extension provider's oauth.refreshToken(credentials, signal) receives an AbortSignal that aborts when the refresh is abandoned.
Changed
  • An agent with no model or effort set on its roster page or in its definition runs the spawning session's live model and effort instead of the default model role at medium effort; bundled scout, sonic and librarian no longer pin an effort, model: inherit on a lane overrides a definition's model, and /account status counts the session's provider as an agent provider.
  • Resuming or switching to a transcript reads its starting service tier through the same function a new session uses; no user-visible change.
  • The /settings model hub's "Default & fallbacks" view and Default Model row edit defaultModel, and clearing the Default Model row keeps a --model launch as the session's model.
  • Advisor messages name agent.helpers.advisor.model and the Agents → Roster → Helpers → Advisor page.
Fixed
  • An agent whose effort is inherited or configured runs at the level its own model accepts, and its badge shows that level, rather than the parent's level for a model that lacks it; a parent with no effort leaves the agent at its own default instead of none.
  • An agent that resolves no effort of its own shows the effort its session settles on in its badge, and the /settings agent roster shows an agent that runs the session's model as session model, which leaves room for a read-only source marker.
  • The Runs line on a /settings agent page reads the session's model and effort for an agent with neither set, and session effort instead of inherit effort when only the model is set.
  • The plan-approval slider no longer offers the plan model as a second choice when it is the default model at the same effort.
  • Mnemopi online memory runs the session's model when no memory helper model is set, instead of the persisted defaultModel.
  • The /settings Roster page shows eight rows before it scrolls and a shorter description, so its Enter to configure · Esc to go back footer stays on screen in a 40-row terminal.
  • A turn whose model no account's plan includes, and no fallback model can take over, ends with the provider's refusal instead of retrying it.
  • The notice for a move accounts.loadBalancing withheld names a plan that does not include the model as well as a spent quota window, and the failover notice states why the previous account could not serve.

1.5.6

2026-10-14 View on GitHub ↗
Added
  • session.backgroundLimit (default 3, range 1-20) caps how many conversations run in the background at once, whether /new, RPC or ACP moved them there; a handoff past it stops the oldest background conversation and names it in the handoff message.
  • RPC new_session with background: true keeps a streaming session's turn running in the background and attaches the client to a new session, switch_session to a background conversation's transcript re-attaches the live session, get_background_sessions lists background conversations, cancel_background_session stops one, and the data.background handoff reports streaming: false for a session that moved with no turn running.
  • ACP _veyyon/sessions/background moves a streaming session to the background, where its pending session/prompt resolves when the turn ends and no session/update is sent; session/load or session/resume re-attaches it live, _veyyon/sessions/background/list lists background conversations, _veyyon/sessions/background/cancel stops one, and closing the connection stops every conversation it moved there.
  • /resume marks conversations running off-screen as running, and ctrl+x stops the selected one without resuming it.
  • A bash approval card offers Approve "<pattern>" for session, which allows later calls reporting the same pattern (git status * for git status -s) without prompting; a call with quoting, expansion, a pipe, a redirect, an environment variable, a working directory, or a guard flag offers no pattern row, and a program that runs another command (sudo, xargs, env) is granted only its exact command.
  • The lsp tool's incoming_calls and outgoing_calls actions list the functions that call the symbol at the cursor, or that it calls, with each call site, as the language server resolved them.
  • Composer predictions show the message you are likely to send next as dim text in the empty composer after each turn, inserted by Tab and sent only by Enter; composer.predictions.mode selects off (the default, which sends no request), chatgpt-pro, which requests a ChatGPT Codex prediction on GPT-6 Astra or GPT-6.1 Sol only with the token of a ChatGPT Pro plan Codex login, never a routed or API-key credential, may count against that account's usage limits, and otherwise sends nothing and shows as greyed out in /settings, or custom, which uses the first model with credentials in composer.predictions.model, chosen from any provider in the settings model picker; a stored composer.predictions.enabled: false loads as off.
  • A composer prediction ends with a dim · tab to accept hint showing the configured Tab key; the hint leaves with the suggestion when you type or press Tab, and a row too narrow for both drops the hint before it hides the suggestion.
  • read refuses a re-read whose every displayed row is still shown byte for byte under the same header by an earlier read result in context, returning a one-line pointer to that output instead of the content; no argument overrides the refusal, a pruned, shaken or compacted earlier result no longer counts, and no read is refused while an extension handles the context event.
  • The account card's signed-out login note offers f to forget it, which stops the card and /account from reporting a login you do not intend to sign back in.
Changed
  • A provider request carries a payload hook only while an extension handles before_provider_request, so a session with no such handler skips cloning and re-serializing every request body, which cut request building on a 300-turn transcript from 0.90 ms to 0.26 ms per request.
  • The lexical bracket scan behind read windows and edit previews, used for a source tree-sitter cannot parse, dispatches on character codes, skips a block comment with one search and scans each mode in its own function in utils/block-context.ts, so a lookup on a 9,815-line TypeScript file with a syntax error takes 0.85 ms instead of 7.74 ms, and on a 4,083-line .txt file 1.20 ms instead of 12.70 ms (median of 15 alternating rounds of 40 lookups); every boundary line is unchanged.
  • The status line fits its footline in one QuietRowFit pass in status-line/quiet-row.ts that keeps each half's joined text and width instead of re-joining the halves after every shed, so composing a default footline takes 999 ns instead of 1,454 ns at 160 columns and 9.46 µs instead of 12.15 µs at 60 columns, where it sheds zones (median of nine rounds of 20,000 calls); the drawn row is unchanged.
  • StatusLineComponent builds a frame's segment context through #locationContext, #gitFacts and contextGaugeReadings, and renderLocation and the model segment build their text in per-step functions; the drawn row and the git lookups it starts are unchanged.
  • The launch-facts recorder compares a recorded entry field by field instead of serializing both copies, so a status-row redraw that changes no recorded fact files in 338 ns instead of 1,119 ns, and a git status that finds the recorded tree in 528 ns instead of 1,313 ns (median of seven alternating processes of 450,000 calls).
  • The end-of-turn context check moved out of AgentSession into the TurnContextCheck session collaborator, and the starting service tier into session startup; no user-facing change.
  • The composer.predictions.mode row in /settings is named "Suggest Next Message" instead of repeating its "Composer Predictions" heading.
  • The retry ladder decides each attempt through #parkUsageLimit, #switchModel and #closeUnrecoverable in session/runtime/retry-runtime.ts; every retry, model or credential switch, wait and event is unchanged.
  • The settled edit card parses a hashline payload for its file only when neither the call nor the result names one, so re-rendering the card of a 2,000-line hashline edit takes 0.95 µs instead of 274 µs (median of seven rounds of 2,000 renders), and the call, result and multi-file cards are built in per-step functions in edit/edit-view.ts; every card is unchanged.
  • The /models hub maps a Roles-view key to its command through rolesCommandFor, routes each pointer report through its own wheel, motion and click step, and draws Roles-view and sidebar rows in per-row functions in modes/terminal/components/selectors/model-hub.ts; every frame, key and pointer action is unchanged.
  • The extension loader resolves each import of an extension's module graph through graphSpecifiers, resolveGraphEdge and resolveBareDependencyEntry in extensibility/plugins/legacy-pi-compat.ts; every module it hooks and every native-addon loader it rewrites is unchanged.
  • The lsp tool's rename_file action resolves its target, asks each server, merges their edits, applies them and notifies the servers in per-step functions in lsp/index.ts; every preview, applied edit, discarded overlap and notification is unchanged.
  • The patch parser reads each hunk in place instead of copying the rest of the diff for every hunk and every @@ line, so a 400-hunk patch parses in 0.71 ms instead of 1.78 ms (median of three runs of 15 alternating rounds), and it reads a hunk's header, nested @@ markers and body in per-step functions in edit/diff.ts; every parsed hunk and every parse error is unchanged.
  • The PDF converter reads a page's content stream through skipStringLiteral, tokenEnd and skipInlineImageData in export/markit/converters/pdf/extract.ts; the tokens of every stream that does not end in < are unchanged.
  • The PPTX converter reads its slide order, each slide and each slide's pictures and notes in per-step functions in export/markit/converters/pptx.ts, and the PPTX and XLSX converters read a part's relationships through readPartRelationships in export/markit/converters/opc-relationships.ts; a deck or workbook whose parts sit at their conventional names converts to the same markdown.
  • readPartRelationships resolves a root-level part's targets with the package root as their base without a separate root case; converted output is unchanged.
  • The launch result card reads each op's rows, the logs frame and the collapse cap in per-step functions in tools/shell/launch-view.ts, and a pty-backed logs card no longer scans the text it does not show, so a 1 MiB log renders in 0.0014 ms instead of 0.54 ms (median of 200 alternating rounds); every card is unchanged.
  • The emoji, GitHub reference, internal URL and prompt-action autocomplete providers declare their results as AutocompleteSuggestions; no user-visible change.
  • The assistant text reveal and the tool argument reveal run on one RevealFrameClock; both still tick at 30 frames per second only while text is held back.
  • The stdio, streamable-HTTP and SSE MCP transports answer a server-to-client request through one answerServerRequest in mcp/types; each answer is unchanged.
  • Tool result text joining and the web tool display projection use template literals and optional chains; their output is unchanged.
  • The custom tool file-extension list in discovery/helpers.ts carries a not-a-tool-name: marker, because its "bash" names an extension rather than the bash tool; no user-visible change.
  • createAgentSession reads the caller's telemetry config in two fewer statements; its behavior is unchanged.
  • The tools.intentTracing entry in system-prompt-builder/gate-registry.ts states the resolveIntentField resolver createAgentSession passes to the agent; no user-visible change.
  • /dump and /advisor dump raw write each message role through its own function in session/session-dump-format.ts; the transcript is unchanged.
  • The RPC server answers each command through its own entry of RPC_COMMAND_HANDLERS in modes/rpc/rpc-commands.ts, and builds its extension UI context in modes/rpc/rpc-ui-context.ts; every response is unchanged.
  • RPC set_host_tools checks that a host tool's parameters is an object through isRecord from @veyyon/utils; the accepted and rejected definitions are unchanged.
  • The task tool schedules its spawns through SpawnScheduler in task/spawn-scheduler.ts, runs each spawn through task/spawn-run.ts and builds its spawn advisories in task/spawn-advisory.ts; every result is unchanged.
  • The task tool validates a batch call and builds its approval lines in per-shape functions, SpawnScheduler admits a background spawn in its own step, and executeBash releases a stopped run and annotates an interrupted one in their own functions; every result is unchanged.
  • A launch builds no ICU time zone cache, number formatter or collator before the first frame: the terminal guard reads the local date from the C library, the tts tool description prints its character limit literally, and prompt templates sort variable names by code unit, so the source launch paints its first frame in 58.5 ms instead of 60.5 ms and its ready run peaks at 217.1 MiB RSS instead of 220.4 MiB (median of 30 and 11).
  • A launch builds no ICU time zone cache or grapheme segmenter: the logger, the session's tool signature and the date the session states to the model read local time from the C library, and the grapheme segmenter is built on first use, so the compiled binary reports ready in 180.3 ms instead of 188.0 ms and paints its first frame in 37.0 ms instead of 38.4 ms (median of 30), and 8 s after launch holds 249.5 MiB RSS instead of 254.3 MiB, 118.5 MiB anonymous memory instead of 119.7 MiB and a 260.4 MiB peak instead of 264.8 MiB (median of 10).
  • A launch evaluates yaml on the first settings file edit or secret declaration parse, @opentelemetry/api on the first traced span, and diff on the first diff it generates or renders, instead of with the module graph, so an RPC launch of the compiled binary evaluates 1,876 modules instead of 1,991 and holds 190.6 MiB RSS instead of 194.6 MiB, 93.4 MiB anonymous memory instead of 97.2 MiB and a 199.1 MiB peak instead of 203.7 MiB (median of 31).
  • A launch with secrets.enabled parses the bundled environment-keyword list with Bun's YAML parser and evaluates yaml only for a keyword file a user wrote, so an RPC launch of the compiled binary with secret obfuscation on holds 158.5 MiB RSS instead of 161.7 MiB, 74.9 MiB anonymous memory instead of 77.1 MiB and a 169.2 MiB peak instead of 172.8 MiB, on 210 ms of CPU instead of 220 ms (median of 31).
  • A session created without a telemetry config starts no OpenTelemetry span and evaluates no @opentelemetry/api module, instead of tracing every turn through the global tracer so that span text passed through the secret obfuscator, so an interactive session of the compiled binary spends 225 ms of CPU on turns two to six instead of 240 ms (median of 12) and holds 306,933 heap objects instead of 309,753 after four turns (median of seven); a session given a config still obfuscates secrets in its spans.
  • A launch evaluates arktype when the first schema is built instead of in the runtime warmup ahead of the session: shipped source imports arktype values from @veyyon/ai/utils/schema/arktype, the completion bridge and the custom command API's arktype member evaluate it on first use, and the warmup has no arktype stage, so the compiled binary names the model 183.6 ms after launch instead of 191.2 ms with createAllTools taking 7.4 ms instead of 13.7 ms (median of 15), and a session idle before its first turn holds 159.0 MiB RSS instead of 166.7 MiB (median of five); 40 s after a first turn it holds 178 MiB instead of 176 MiB with the same JS heap.
  • Loading a models config unchanged since its last accepted load evaluates no ArkType module, because the validator fingerprint reads the ArkType release from package metadata instead of the $ark registry that the eager arktype import installed.
  • A print, RPC or ACP session holds its at-rest context reading, which builds every active tool's schema, until its first prompt, as an interactive session already did, and the CLI's jitless ArkType setting is held until the first schema is built, so an RPC launch of the compiled binary with a provider key evaluates no ArkType module before its first turn: it evaluates 1,741 modules instead of 1,856, reports ready in 187.1 ms instead of 203.3 ms on 250 ms of CPU instead of 340 ms, and holds 170.9 MiB RSS instead of 190.2 MiB, 76.9 MiB anonymous memory instead of 93.6 MiB and a 184.2 MiB peak instead of 197.9 MiB (median of 31).
  • The presentation summary resolves the server-side compaction transport through @veyyon/agent-core/compaction/remote-compaction instead of @veyyon/ai/providers/openai-compaction, so loading it no longer evaluates the Codex client; no user-visible change.
  • A print, RPC or ACP launch evaluates no terminal renderer: main.ts loads the session picker only when --resume opens it, the launch command loads the launch card only when it paints, and the ask tool reads its card width from chrome/modal-geometry.ts instead of the modal shell, so main.ts reaches 1,467 modules instead of 1,582 and an RPC launch of the compiled binary reports ready in 221 ms instead of 228 ms with 190.6 MiB RSS instead of 196.7 MiB and a 205.3 MiB peak instead of 212.2 MiB (median of 20).
  • A streaming assistant message finds a Mermaid fence by jumping between runs of three backticks or tildes instead of splitting its whole text into lines on every delta, so a 108 KiB reply streamed in 24-character deltas spends 26 ms in message updates instead of 152 ms, and 735 ms instead of 892 ms with a 120-column render after each delta (median of three).
  • With smooth streaming on, an assistant message counts, slices and renders a provider delta on the next reveal frame instead of on every delta, and a delta reads only the blocks not yet visible to decide a layout repaint, so a 200,000-character reply streamed in 24-character deltas costs 780 ms of process CPU per turn instead of 940 ms (median of 15 turns).
  • With smooth streaming on, assistant text and streamed tool-call arguments reveal at the rate they arrive, held behind the arrivals by a lead sized to the gaps between them, instead of by an eighth of the waiting units every frame, so a reply arriving in 120-character batches every 400 ms reveals 8 to 11 characters a frame instead of 4 to 19, one arriving 4 characters every 200 ms reveals one character at a time instead of up to three, and one arriving 200 characters every 100 ms is shown 200 ms after its last delta instead of 1,000 ms (bench/reveal-pacing.bench.ts).
  • The transcript reports every leading row a re-rendered block left unchanged as stable instead of none of the block's rows, so the terminal engine re-reads a streamed reply from its first changed row instead of from the reply's top on every frame, and a 1,200,000-character reply streamed in 48-character deltas costs 2.69 s of process CPU per turn instead of 2.87 s (median of three), a 400,000-character reply 1.00 s instead of 1.05 s (median of five).
  • A streamed delta or tool event rebuilds the anchored todo board only when the agent's motion state, the terminal size or the theme changed since the board was last drawn, instead of on every event, so a 400,000-character reply streamed under a live three-phase board costs 1.18 s of process CPU per turn instead of 1.59 s (median of four), and the same reply with no board is unchanged.
  • A spinner step on a streaming write, edit or apply_patch card draws the card again only when a row it drew reads the frame, because a framed block reads the frame for its header and arrival row when it composes its rows and the card keeps its serialized arguments between builds, so a step of a 1,500-line streaming write costs 89 µs instead of 357 µs and of a streaming edit 15 µs instead of 230 µs (median of three), and a turn that streams a 1,500-line write in three deltas over 20 seconds costs 1.09 s of process CPU instead of 1.40 s (median of six).
  • A streaming tool call's argument reveal parses the call's JSON only when bytes arrive outside the string argument its decoder reads, and a tool card serializes a call's arguments when a block's input is read instead of on every revealed step, so revealing a 128 KB write parses 128 KB of JSON instead of 27 MB in 6 ms instead of 55 ms (median of seven), and a turn that streams a 1,500-line write costs 2.82 s of process CPU instead of 2.96 s (median of nine).
  • A rule with an ast-grep astCondition matches a streaming write or edit call again only after its source has grown by a quarter and by at least 1,024 characters, runs one match per call at a time with only the newest snapshot queued behind it, and always matches the completed call before its reminder is delivered, so a turn that streams a 1,500-line write under one such rule runs 14 matches over 756 KB of source instead of 3,814 over 233 MB, and costs 0.34 s of process CPU instead of 123.8 s with a 131 MiB RSS peak instead of 336 MiB.
  • The status line runs git status for its dirty marker when a turn ends, after a ! or % command and when HEAD changes, and otherwise once every 10 seconds, instead of on any render a second after its last lookup, so a 13-second streaming turn in a checkout of this repository spends 110 ms of CPU in child processes instead of 555 ms and 1.48 s of process CPU instead of 1.55 s (median of four).
  • A running agent's live preview appends each streamed delta to its output tail and derives its last eight lines when it reports progress, at most every 150 ms, instead of splitting the 8 KB tail on every delta once the agent has streamed 8 KB, so a turn that spawns one agent streaming a 400,000-character answer costs 760 ms of process CPU instead of 830 ms (median of nine turns).
  • On a terminal with the Kitty image protocol, a tool card finds the images of each streamed partial result in the result instead of building the card's views for it, so a bash card streaming a 50 KB build log costs 259 µs of CPU per drawn frame of four chunks instead of 779 µs, a test log 415 µs instead of 965 µs and a log of wrapped lines 208 µs instead of 373 µs (median of seven).
  • A tool card keeps the wrapped rows of each windowed section instead of only the last one drawn, and finds the lines a tail buffer moved up when it cut its front, so a streaming bash card wraps only the lines that arrived since the frame before: a frame of a 50 KB log of wrapped lines renders in 193 µs of CPU instead of 588 µs and of a test log in 388 µs instead of 441 µs (median of seven).
  • A command's 50 KB output tail drops the characters a chunk pushed out by walking them off its front instead of encoding the whole tail into a buffer and decoding it back, so keeping the tail of a streaming test log costs 19 µs of CPU per four chunks instead of 83 µs, of a build log 10 µs instead of 24 µs and of a log of wrapped lines 12 µs instead of 26 µs (median of seven).
  • A streaming bash card reads the progress-run shape of each output line by character code instead of with five regular expressions, reads the home directory once per os.homedir function instead of once per shortened span, no longer searches its already shortened output rows for the home directory, and computes the render context's output when a renderer reads it, so a frame of four chunks of a 50 KB build log costs 197 µs of CPU instead of 259 µs, of a test log 320 µs instead of 423 µs and of a log of wrapped lines 167 µs instead of 199 µs (median of nine).
  • A command's 50 KB output tail holds the chunks appended since its last cut concatenated after the kept front instead of joining both into a new string on every read, so a streaming bash card that receives 64 chunks per drawn frame costs 391 µs of CPU per frame of a build log instead of 766 µs, of a test log 407 µs instead of 942 µs and of a log of wrapped lines 387 µs instead of 582 µs (median of seven), and at four chunks per frame a build log costs 182 µs instead of 197 µs (median of nine).
  • An interactive session loads the /mcp, /ssh, /tan and /todo command controllers on the command's first run, the speech-to-text recorder and recogniser on the first push-to-talk, the DAP client on the first debug call, the emoji table on the first :name completion and the GitLab Duo Workflow client on its first turn, so an idle session evaluates 220 KiB less source and holds 303,171 heap objects instead of 314,768 and 55.10 MiB of heap and extra memory instead of 55.76 MiB, with banner time unchanged (median of seven).
  • An interactive session loads the /secret, /mcp and /ssh handlers, the /plugins manager, the /memory mm Hindsight helpers, the autoresearch run screen and launcher and the /review <pr> GitHub client on first use, so an idle session evaluates 34 fewer modules and 542 KiB less source and holds 295,277 heap objects instead of 299,223, 54.51 MiB of heap and extra memory instead of 54.98 MiB and 242 MiB RSS after collection instead of 245 MiB, with banner time unchanged (median of seven).
  • The compiled binary's legacy-extension table imports each retained host module's exports by name and builds a module's export record when an extension first imports it, instead of importing all 1,057 modules as namespaces, so the binary's chunks declare 27 module namespace objects instead of 1,031 and 1,395 export getters instead of 8,914, and an idle session holds 284,103 live objects instead of 325,240, 38.2 MiB of heap instead of 41.8 MiB and 246 MiB RSS after collection instead of 255 MiB (median of five).
  • An interactive session at rest arms no working-clock heartbeat, stops its loop watchdog after 10 quiet seconds and its idle trim after the trim, and samples its stack once a second, each until the next keystroke or frame, so the runtime's idle collector drops to its slow rate: the linux-x64 binary idle 90 seconds after launch records 131 thread wakeups in 60 seconds instead of 4,062 and spends 20 ms of CPU instead of 160 ms (median of three).
  • Capability discovery finds the repository root by checking each ancestor of the working directory for .git instead of listing and keeping every ancestor directory, and concurrent loads share one lookup; twenty concurrent lookups from a directory under a 1,700-entry directory take 0.31 ms instead of 2.50 ms and leave 32 KiB on the heap instead of 259 KiB, and from a home directory outside any repository take 0.30 ms instead of 1.85 ms and leave 33 KiB instead of 185 KiB (median of 15).
  • A session compares a SHA-256 digest of its tool names, descriptions and MCP server instructions to decide whether a tool change rebuilds the system prompt, instead of keeping the joined text, so each main session and live subagent holds 87,568 fewer bytes of heap once its tool set has been applied twice with the default tools.
  • On Linux the binary's embedded module pages are released on the first 5-second window under 5% CPU after work instead of after 30 quiet seconds, so an idle session 15 seconds after launch holds 190 MiB RSS instead of 270-286 MiB, and a session with turns 12 seconds apart holds 209-216 MiB after its second and third turns instead of 290-295 MiB, at unchanged turn latency.
  • The compiled binary holds one copy of Zod instead of two, because the schema converter no longer requires a CommonJS copy beside the one the package barrel hands to extensions; the binary is 2.3 MiB smaller and an idle session holds 3 MiB less RSS after collection (270 to 267 MiB, median of five).
  • The resolved model stage (resolved-models.json) stores each distinct compat record once and each model an index into that table, so on a profile with 5,646 models the file is 0.81 MB instead of 2.10 MB and a launch restores the model registry in 10.2 ms instead of 22.2 ms, with 4.5 MiB less RSS growth (median of 11); a stage written by an earlier release is rebuilt once.
  • 261 class members that read no instance state are module functions and constants instead of #private members; JSC copies every private name of a class into each function its body creates, so with the 73 moved in the other packages the binary shrinks by 815 KiB and an idle session holds 580 KiB less RSS after the idle trim (median of five).
  • The isolation runner loads the commit message generator, its model helper and the commit prompts on the first AI-written isolation commit instead of when the task tool loads, so an idle session holds 390 fewer live objects and 0.10 MiB less heap (median of five) and a source session evaluates 16 fewer modules.
  • The veyyon:// handler imports the embedded documentation index on its first resolve or completion instead of at launch, so a compiled binary no longer links the 1.4 MB documentation literal into the startup graph, and an idle session holds 0.8 MiB less RSS five seconds after launch (median of seven); the JS heap and the RSS after the idle trim are unchanged.
  • The Mermaid render cache imports lru-cache/raw like every other module, so a session evaluates one lru-cache build instead of two: the binary shrinks by 296 KiB and an idle session holds 537 fewer live objects (median of seven).
  • AgentSession runs its retry ladder through session/runtime/retry-runtime.ts and its secret redaction and display expansion through session/runtime/session-secrets.ts, and holds 404 private names instead of 487, so its compiled bytecode drops from 9,474 KiB to 7,646 KiB across the three modules and loading it from a --bytecode binary costs 18,660 KiB RSS instead of 21,424 KiB (median of nine).
  • The streaming reveal counts and slices each run of ASCII text one code unit per cluster and passes only the clusters that contain a non-ASCII character to Intl.Segmenter, with identical cluster boundaries, so revealing a 400,000-character reply costs 1.5 ms of grapheme work instead of 21.0 ms for ASCII prose and 11.1 ms instead of 21.3 ms for prose with CJK or emoji clusters (median of three).
  • The status line keeps the scratch-directory classification of the working directory until the working directory, the home directory or the temporary directory changes, instead of resolving each root with realpath on every render, so a status row renders in 9.2 µs instead of 21.9 µs warm (median of three).
  • AgentSession runs compaction through session/runtime/compaction-runtime.ts, compaction-summarizer.ts and compaction-recovery.ts, and the retry ladder's model switches through session/runtime/retry-fallback.ts, and holds 372 private names instead of 410, so the compiled bytecode of the session and its retry and compaction modules drops from 7,568 KiB to 6,926 KiB and loading them from a --bytecode binary costs 33,144 KiB RSS instead of 39,144 KiB (median of 15).
  • AgentSession runs the prewalk and plan-yolo model handoffs through session/runtime/model-handoff.ts and holds 362 private names instead of 372, so the session's compiled bytecode in a --bytecode binary drops from 6,712 KiB to 6,484 KiB and loading it costs 32,240 KiB RSS instead of 32,512 KiB (median of 15).
  • AgentSession runs plan mode, its approved-plan reference and its decision reminders through session/runtime/plan-mode-runtime.ts and holds 355 private names instead of 363, so the session's compiled bytecode drops from 6,153 KiB to 5,994 KiB and loading it from a --bytecode binary costs 32,068 KiB RSS instead of 32,180 KiB (median of 15).
  • AgentSession writes finished messages to the session log through session/runtime/message-persistence.ts and holds 340 private names instead of 354, so the compiled bytecode of the session and its message persistence drops from 6,012 KiB to 5,736 KiB and loading them from a --bytecode binary costs 31,652 KiB RSS instead of 31,852 KiB (median of 15).
  • AgentSession computes the context figure, the prompt snapshot of a run in flight and the history-rewrite usage anchor through session/runtime/context-accounting.ts and holds 335 private names instead of 340, so the compiled bytecode of the session and its context accounting drops from 5,676 KiB to 5,580 KiB and loading them from a --bytecode binary costs 31,388 KiB RSS instead of 31,512 KiB (median of 15).
  • AgentSession holds the memory backend's session state and delivers recalled memory through session/runtime/memory-context.ts and holds 325 private names instead of 335, so the compiled bytecode of the session and its memory context drops from 5,540 KiB to 5,381 KiB and loading them from a --bytecode binary costs 31,088 KiB RSS instead of 31,336 KiB (median of 15).
  • AgentSession routes requests under its provider session id and inherited prompt cache key, and closes provider transport sessions, through session/runtime/provider-sessions.ts and holds 313 private names instead of 325, so the compiled bytecode of the session and its provider sessions drops from 5,347 KiB to 5,175 KiB and loading them from a --bytecode binary costs 30,864 KiB RSS instead of 31,024 KiB (median of 15).
  • AgentSession runs the tool-call loop guard and the Gemini reasoning-header interrupt through session/runtime/loop-guards.ts and holds 306 private names instead of 313, so the compiled bytecode of the session and its loop guards drops from 5,044 KiB to 4,927 KiB and loading them from a --bytecode binary costs 30,592 KiB RSS instead of 30,744 KiB (median of 15).
  • AgentSession runs the empty-stop and unexpected-stop retry cycles through session/runtime/stop-retries.ts and holds 298 private names instead of 307, so the compiled bytecode of the session and its stop retries drops from 4,994 KiB to 4,838 KiB and loading them from a --bytecode binary costs 30,328 KiB RSS instead of 30,516 KiB (median of 15).
  • AgentSession records usage headers and turn cost, reads usage reports and saved resets, and runs Codex auto-redeem through session/runtime/provider-usage.ts and holds 295 private names instead of 298, so the compiled bytecode of the session and its provider usage drops from 4,795 KiB to 4,736 KiB and loading them from a --bytecode binary costs 30,160 KiB RSS instead of 30,256 KiB (median of 15).
  • AgentSession runs the stale-result and overflow prunes, image drops, shake and duplicate-result elision through session/runtime/history-rewrites.ts and holds 285 private names instead of 289, so the compiled bytecode of the session and its history rewrites drops from 4,686 KiB to 4,572 KiB and loading them from a --bytecode binary costs 29,976 KiB RSS instead of 30,188 KiB (median of 21).
  • AgentSession tracks the terminal yield through session/runtime/yield-tracker.ts and sends the rewind, verification and review reminders a settling turn owes through session/runtime/finalize-reminders.ts, and holds 276 private names instead of 285, so the compiled bytecode of the session and its yield and finalize modules drops from 4,460 KiB to 4,334 KiB and loading them from a --bytecode binary costs 29,720 KiB RSS instead of 29,888 KiB (median of 15).
  • AgentSession holds the --auto-approve flag, the /yolo bypass, the kept per-tool approval decisions and the ACP permission prompt with its standing answers in session/runtime/session-approvals.ts and holds 270 private names instead of 276, so the compiled bytecode of the session and its approvals drops from 4,303 KiB to 4,209 KiB and loading them from a --bytecode binary costs 29,604 KiB RSS instead of 29,676 KiB (median of 15).
  • AgentSession shapes every provider request, with its tool-call id map, the directory outbound paths render relative to and the bytes each request left out, through session/runtime/provider-wire.ts and holds 265 private names instead of 270, so the compiled bytecode of the session and its provider wire drops from 4,179 KiB to 4,139 KiB and loading them from a --bytecode binary costs 29,484 KiB RSS instead of 29,584 KiB (median of 15).
  • A compaction moves the payloads of the history it summarized out of memory once it is recorded, reading each entry back from the session file on first use.
  • An interactive session no longer loads the HTML export template, stylesheet, viewer script and tool renderers until /export runs: /share builds its snapshot from export/session-data.ts, cutting the idle heap and extra memory of the compiled binary from 104.8 MiB to 102.9 MiB.
  • The compiled binary keeps the embedded veyyon:// docs index off the heap until the first veyyon:// read, and with the bundled model catalog read from its embedded file on demand the idle heap and extra memory drop from 102.9 MiB to 95.9 MiB; dist/cli.js ships the catalog as dist/models.json.
  • The advisor renders its project-context prompt from the context files when it first starts instead of at session creation, and with the shared prompt copies and record-only entries read from the session file, a session holding 40 finished spawned agents after ten turns uses 150.6 MiB of heap and extra memory instead of 175.5 MiB and 479-484 MiB RSS instead of 488-497 MiB.
  • An interactive session loads the settings, model, account, session, tree and dashboard cards when the first one opens, so an idle session holds 546,422 heap objects instead of 551,514 and 304 MiB RSS after a full collection instead of 309 MiB, with peak RSS 332 MiB instead of 338 MiB (median of five).
  • The Mermaid ASCII render cache holds at most 512 Ki UTF-16 code units of source and render, least recently used first out, instead of every frame of every streamed diagram for the life of the session, so streaming 20 diagrams retains 4.3 MiB instead of 32.4 MiB.
  • A launch reads a models.yml the validator accepted before from accepted-models-config.json beside models.db while the file, its path and the validator are unchanged, instead of building the models-config schema, so an idle session holds 75.9 MiB of heap and extra memory instead of 81.9 MiB, 496,284 heap objects instead of 528,818 and 293 MiB RSS after a full collection instead of 303 MiB, and draws its banner in 0.243 s instead of 0.348 s (median of five warm launches).
  • The compiled binary precompiles every Handlebars prompt template at build time and revives it on first render instead of parsing and walking it, so a session builds its system prompt in 6.4 ms instead of 16.1 ms, createAgentSession takes 77.2 ms instead of 88.1 ms and the status line names the model 303 ms after launch instead of 315 ms (median of 11), and an idle session holds 71.5 MiB of heap and extra memory instead of 72.2 MiB (median of five).
  • The order a session's disposal runs in moved from createAgentSession to orderSessionDisposal in session/top-level-sessions.ts; no user-visible change.
  • The collab guest's ask dialog loop is split into one method per question kind and one per guest pick in extension-ui-controller.ts; no user-visible change.
  • A conversation /new left running is disposed once its turn ends and no background job it owns is running, releasing its browser tabs, eval kernels, advisor, spawned agents and roster entry and writing its session_exit record, instead of holding them until the process exits.
  • A session builds the advisor's tools on the advisor's first review or /advisor configure instead of at startup, so a session whose advisor never runs constructs no second copy of every built-in tool: the compiled binary's idle heap and extra memory drop from 58.8 MiB to 57.6 MiB across 578 loaded modules instead of 606, startup RSS from 334 MiB to 328.5 MiB, the first frame lands 13 ms sooner (median of six), and three turns spawning four agents each peak at 406-409 MiB RSS instead of 415-418 MiB.
  • The launch tool's output renderer loads @xterm/headless on its first screen replay, through the loader the interactive bash tool already used, so a session that replays no PTY screen no longer evaluates it at startup, saving 1.02 MiB of heap and 5.5 ms of module evaluation.
  • MCP servers stay connected until the last top-level session using them is disposed, so a conversation /new left running no longer orphans them at exit, and disposing one of several top-level sessions (a background conversation or an ACP session) no longer tears down the agent lifecycle or the title and embedding workers the others use.
  • ctrl+x in /resume and a /new past session.backgroundLimit cancel the stopped conversation's background jobs.
  • /new, /resume and a handoff abort a spawned agent of the previous conversation that is mid-turn before disposing it, deepest generation first, instead of disposing it with its bash, eval and advisor work still running.
  • A config with compaction.strategy: "off" beside compaction.enabled: true migrates to compaction.enabled: false, and compaction.enabled is the only setting that turns auto-compaction off.
  • The HTML export's session tree prints each tool call with the same label as the terminal tree, for every registered tool, instead of its own switch whose find and ls cases matched no registered tool and printed most calls as raw JSON; a newline in an op, action or name argument no longer breaks a tree row in either tree.
  • tools/fs/read.ts is split into per-concern read-*.ts modules with no change to the read tool's schema, output or exports.
  • The session retry loop, the async job manager, the launch broker and the Gemini web search provider take their exponential delay from exponentialBackoffDelay in @veyyon/utils; each loop's base, ceiling and jitter are unchanged.
  • The resolve pending row clamps its reason at 80 columns instead of 72, and the web_search and gh cards expand tabs in query and label text.
  • Production code strips ANSI through stripAnsi from @veyyon/utils; Bun.stripANSI is called only by that helper.
  • A session that renders its personality from a project .veyyon/personalities/<name>.md file raises a personality warning stating the file, and personality warnings reach the session's notice channel once per session instead of writing to stderr on every system prompt rebuild.
  • Restoring resolved-models.json at launch verifies a CRC-32 instead of a SHA-256 digest, cutting model registry construction from 22.86 ms to 20.69 ms (median of 21 interleaved launches), and the first launch after upgrading rebuilds the snapshot once.
  • The static model stage restored from resolved-models.json shares equal compat records the way a catalog build does, so a warm launch holds one record per distinct compat shape instead of one per model.
  • The model settings domain reads the thinking vocabulary from thinking/constants.ts instead of thinking/index.ts, so the launch card, editor and status row evaluate 355 modules instead of 358 before the composer accepts a keystroke, skipping 0.85 ms of module evaluation (median of nine).
  • A launch whose --model names its provider (provider/id, or an id with --provider) looks the model up among that provider's models instead of building all 4,499 catalog models first, skipping 48 ms of catalog construction, so a compiled --model provider/id launch draws its first frame in 310 ms instead of 333 ms (median of 13 interleaved launches).
  • The /debug CPU profile borrows the process's sampling profiler from the stall sampler and hands it back when the profile ends, instead of starting and stopping the profiler itself and leaving the stall sampler's profile stopped.
  • Assistant turns and tool cards create their image, conversion and rail-frame collections on first use and share one rail-frame table instead of each constructing its own, and a tool card's block producer holds its listeners in a shared empty array until one subscribes, so a rebuilt 26,806-entry transcript holds 2,547 Maps, 1 Set and 0 WeakMaps instead of 37,211, 29,120 and 7,858, retaining 64.1 MiB and 1.10M objects instead of 68.3 MiB and 1.17M.
  • A tool card builds its block on the frame that draws it instead of on each call, result, spinner start and stop handed to it, and reads its animation, freeze, displacement and repaint policies without building its views, so a rebuilt 81,240-row transcript builds each card once and its rebuild drops from 113.2 ms to 91.7 ms (median of five) with an unchanged first frame.
  • Assistant answer and thinking segments, custom and skill messages, summaries, collab prompts and hook dialogs paint their prose through one style object per theme colour instead of a new one per component, so a rebuilt component reuses the rows its predecessor rendered from the shared Markdown render cache, and a resumed 38 MB transcript draws its first frame in 218.3 MiB and 194 ms instead of 223.4 MiB and 219 ms (206.1 MiB and 183 ms with the Box row change).
  • A provider request's secret scan walks the payload with one frame per container that copies its keys or values only when the transform changes one, instead of queueing an event per key and value and re-measuring every unchanged string, and the literal-secret matcher steps its root state through a code-unit table and skips the second literal pass when no rule changed the text, cutting the scan of a 1,200-turn request with two configured secrets from 156.2 ms to 22.9 ms and an identity walk of it from 57.2 ms to 3.7 ms, with identical output across 400,000 generated payloads and 480,000 generated texts.
  • A rebuilt transcript's highlight prefetch holds each source until every card that draws it has read it, including sources the 256-entry highlight cache held when the prefetch ran, instead of dropping it for that cache on its first read, so a command run again or a rebuild after an earlier one no longer re-highlights evicted sources one at a time; a 13,470-entry transcript draws its first frame with 0 instead of 284 such highlights (512 on later rebuilds), from 214.5 ms to 200.2 ms.
  • A session reads its persisted MCP tool selection at construction and on each MCP tool refresh from the one entry that records it instead of rebuilding, deobfuscating and argot-expanding the branch's whole message list, cutting createAgentSession on a 26,806-entry resume from 40.2 ms to 35.4 ms.
  • A resumed read result numbers its card rows by scanning the result text in place instead of slicing and regex-matching each row, cutting SessionManager.open on a 76 MB session from 179.9 ms to 143.9 ms with identical cards across 400,000 generated result texts.
  • The CLI configures ArkType to validate by interpreted traversal instead of compiling a validator for every schema, cutting a compiled launch that opens a session from 372 ms to 316 ms and its heap by 11 MiB; a tool-argument rejection of a described closed set now reports the field's description followed by (accepted: …) instead of ArkType's list of the members.
  • The debug tool runs each action through its own handler in a table keyed by action instead of one 398-line switch, so an action added to the schema without a handler fails the type check; every action's text and details are unchanged across a gdb session.
  • The launch parser sets each value-less flag through the table the profile bootstrap reads as its list of value-less flags, instead of an if-chain that had to be kept in step with that list by hand, and splits a token's flag, extension, string, optional and positional handling into single-purpose functions instead of one 183-line loop; every result and refusal is identical across 300,000 generated argument lists.
  • The edit tool reads its mode descriptions from the tool prompt rows instead of the whole prompt registry, so a session that builds it no longer loads the commit-agentic, bench and prompt-registry modules it never renders, 9 fewer modules on a session start.
  • A session binds its own inline extensions (autoresearch and the custom tool bridge) without the api.pi package namespace, so a session with no author extension no longer loads the whole package barrel, cutting createAgentSession on a 13,470-message resume from 267 ms to 213 ms and its heap by about 5 MiB; an author's extension still receives api.pi.
  • A session checks whether its working directory is a project root once when it discovers the project, and again only when its cwd moves, instead of on every system prompt build, cutting a rebuild in the veyyon checkout from 1.16 ms to 0.23 ms and in a repository holding other projects from 75 ms to 0.25 ms with identical blocks.
  • A system prompt build looks up its inputs, names its tools, fills its template data, checks its eval and file overrides and assembles its blocks in single-purpose steps instead of one 520-line function, and reuses the paragraph split of a context file, rule or appended prompt it already compared instead of re-formatting the text for every comparison, cutting a rebuild with a 48 KB AGENTS.md from 1.56 ms to 1.23 ms with identical blocks.
  • init_experiment resolves its settings, writes the session, arms the runtime and builds its report in single-purpose steps instead of one 258-line execute, and reads the worktree status and path prefix concurrently when checking for harness changes, cutting a clean-branch init from 3.94 ms to 3.39 ms with an identical report, session row and tool set.
  • run_experiment and log_experiment read the worktree status and path prefix concurrently through one repository resolve instead of one after the other, cutting each read on a 400-file repository from 2.20 ms to 1.65 ms.
  • A spawned agent's session records no raw SSE frames, which only the displayed top-level session's debug viewer and report bundle read, so five turns spawning four agents that each stream 60,000 characters leave 84.9 MiB of heap and 36.6 MiB of extra memory instead of 95.5 MiB and 40.8 MiB, and peak at 576 MiB RSS instead of 597 MiB (mean of three).
  • The eval tool builds its parameter schema once per set of enabled languages and report_tool_issue once per tool list, instead of once per session, so building both for 3,000 sessions registers no ArkType node instead of 87,000 and retains 1.8 MiB instead of 9.5 MiB.
  • The lsp tool runs a file-bound action through one method that starts the server, opens the file and resolves the cursor, then one function per action (location lookups, references, hover, code actions, document symbols, rename, reload), instead of one 388-line method; no user-visible change.
  • The composer's submit runs its extension input handlers, collab guest routing, shell shortcuts, steering prompt and auto-title in single-purpose methods, and the streaming and between-turns paths share one steering prompt with draft restore instead of two copies; no user-visible change.
  • The bash tool runs a call's preparation, interception check, internal URL expansion, working directory resolution, spawn admission and its background, managed, client-terminal and local runs in single-purpose methods instead of one 480-line execute; a trivial command and a 20,000-line command run in unchanged time.
  • A rebuilt transcript highlights the code and diff context of every tool card in one parallel native batch before its first frame instead of one card at a time during it, cutting a resumed session's first frame from 497 ms to 357 ms, and from 14.2 s to 7.5 s with compacted history expanded, with byte-identical rows.
  • A tool card whose presentation changes with nothing subscribed builds its block when it is next read instead of at the change, so disposing a transcript no longer builds a sealed block for every card, cutting a transcript reset from 31.4 ms to 1.6 ms, and from 2,070 ms to 26.7 ms on a 64k-card transcript.
  • A collapsed tool card's progress-run folding keys each output line once instead of twice at every run boundary and skips the diagnostic lookup for a line whose first token has no progress shape, and home-path shortening returns a line that does not contain the home directory before running its pattern, cutting the two over 1.52M lines of 44,117 tool results from 207.8 ms to 141.9 ms and from 118.6 ms to 85.9 ms with identical rows.
  • veyyon session stats folds each entry through a reducer with one method per entry kind instead of one 340-line loop, cutting the report on a 104,969-entry session from 36.4 ms to 30.0 ms with an identical report.
  • The legacy agent settings migration runs as one step per retired area over a shared key reader, cutting a legacy-heavy config's migration from 15.0 µs to 10.9 µs per load; a current-format config is unchanged.
  • A compaction pass finds the entry it just wrote by the id the append returned instead of copying the session's entries and scanning them for its summary text, which cuts that step on a 238,086-entry session from 6.53 ms to 0.002 ms.
  • Automatic compaction runs its candidate loop, per-candidate retries, progress check and follow-up scheduling in single-purpose methods, and shares the hook offer and the write step with manual compaction; no user-visible change.
  • A tool card's display rebuild runs its call phase, result phase, custom and multi-file views, images and not-executed notice in single-purpose methods; resume render time on a 63,915-component transcript is unchanged.
  • The first-frame replay's description of its recorded environment states that a file-driven change such as a new defaultProfile is corrected by the row diff rather than by a file stat; no user-visible change.
  • A truncated read, search or run_experiment result records only its truncation counts in the session file, not a second copy of the kept text, so new results take less disk and memory and a resume parses less.
  • The lsp tool dispatches each workspace-scoped action (status, diagnostics, rename_file, capabilities, request, workspace symbols, workspace reload) to its own handler, and definition, type_definition and implementation share one lookup; no user-visible change.
  • A goal session records the token and time a tool call spends as a small goal_progress entry instead of a full copy of the goal, so the session file holds the objective once per goal change rather than once per tool call and a resume parses less.
  • A read whose displayed rows count up without a break records no per-row line-number list in the session file, since the card numbers those rows from the first line; a read whose rows jump or skip still records the list.
  • Goal records on a session branch parse through the shared isRecord guard instead of a local copy; no user-visible change.
  • A read result's session file line omits the card's copy of the file text when the result's own numbered rows or plain text rebuild it, and the session restores it on load, which cut the recorded read results in local sessions from 4.27 GB to 2.89 GB.
  • A tool start marker in the session file omits the start time and the argument summary the entry timestamp and the assistant message already hold, so the resume warning for an unanswered call reads the arguments from that message.
  • An edit result's session file line omits the post-edit file text when its pre-edit text and numbered diff rebuild it byte for byte, and the session restores it on load, which cuts the post-edit copies recorded across local sessions from 671.18 MB to 3.79 MB.
  • A search result's session file line omits the card's copy of the matched rows, the path list fileMatches already holds, and the wrapper's repeat of the sub-search's truncation counts when the rest of the line rebuilds them, and the session restores them on load, which cuts the recorded search details in local sessions from 331.33 MB to 248.91 MB.
  • An eval result's session file line omits each cell's output and the top-level status events when the result's text and the first cell hold them, and a job result's line omits each job's result and error text the result's text holds, and the session restores them on load, which cuts the recorded eval details in local sessions from 497.77 MB to 253.78 MB and the job details from 100.84 MB to 37.80 MB.
  • Session spend, which /session, get_session_stats and goal accounting read at every turn start, tool completion and agent end, tallies the history behind the compaction boundary once per boundary instead of on every read, which cuts a read on a 201,156-entry session from 29.25 ms to 0.92 ms.
  • A prune, shake, image drop, recovered retry marker, compaction tail elision or dead-end warning rewrites the session file only from the earliest entry it changed, instead of the whole file, which cut the persist step after a one-entry prune on a 376 MiB session from 1.2 s to 135 ms.
  • The session's advisors, their delivery routing and their interrupt latches run in a session collaborator, and advisor stats and overflow compaction in their own modules; no user-visible change.
  • Tool discovery state (the MCP and local selections, built-in names, default MCP selections and the search index), checkpoint state (the open checkpoint, its pending rewind report and the last completed rewind), user shell and Python runs, the work a turn schedules after prompt() returns and the IRC records a streaming turn has not yet taken run in session collaborators; no user-visible change.
  • With edit.streamingAbort on, the check on a streaming edit patch scans each diff line once instead of rescanning the whole diff on every delta, which cuts a turn streaming a 91 KiB, 2,000-line patch in 23,293 deltas from 7,852 ms to 212 ms, and from 124 ms to 64 ms with the setting off.
  • A streaming write or bash card highlights, numbers and wraps only the lines that arrived since its last frame instead of the whole source on every argument delta, which cuts drawing a 600-line write streamed in 754 frames from 27,125 ms to 376 ms and its last frame from 67.7 ms to 0.38 ms.
  • The per-agent run monitor (progress, abort and soft request-budget handling, usage totals and output capture) runs in task/run-monitor.ts, split out of task/executor.ts, with one handler per agent event; no user-visible change.
  • The status line's message fingerprint and usage-window reading run in per-role and per-window helpers; no user-visible change.
  • An agent's yield finalization, reminder ladder, session setup and teardown run in single-purpose helpers in task/executor.ts, and a child renders its own system prompt section once per run instead of on every system prompt rebuild, which saves 114.5 µs per rebuild for deep; no user-visible change.
  • The session's agent event handler routes each event type to its own method, records a finished assistant message as the settle's last message once before its first await instead of again after persistence, and splits post-run maintenance into yield settle, failure recovery and stop-time continuation passes; no user-visible change.
  • Text search resolves its scope, runs the native and virtual searches, pages the matches, and renders and fits its output in single-purpose functions; no user-visible change.
  • Raw settings migrations run as an ordered list of one function per retired setting family instead of one 600-line function; no user-visible change.
  • CLI startup resolves the launch model, prewalk and plan-yolo targets, settings overrides, the --fork/--resume session, the resume picker, extension flags, the initial prompt, the setup wizard, update notices and the mode handoff in single-purpose functions instead of functions of 272, 720, 229 and 102 lines; no user-visible change.
  • A session's secret runtime (the loader, the expansion lease, the reload queue, the unreadable-vault refusal and the tool-argument expansion) runs in SessionSecretRuntime in secrets/session-runtime.ts instead of in closures inside createAgentSession; no user-visible change.
  • Startup model and thinking-level selection (session restore, the settings default, deferred --model patterns, the fallback role chain, the first authenticated model and the metadata refresh) runs in StartupModelSelection in session/startup-model.ts instead of inline in createAgentSession; no user-visible change.
  • The edit tool's patch mode computes a hunk's replacements (the direct match, trimmed-context variants, fuzzy fallback and overlap checks) and re-indents a hunk's new lines (tab-to-space, space-to-tab and matched-line alignment) in single-purpose functions instead of functions of 341 and 215 lines; no user-visible change.
  • A session discovers its context files, workspace tree, repository context, skills, rules, watchdog files and advisor configs through one discoverProjectInputs path at startup and after a working-directory change, starts rules discovery with the other project scans instead of after the session context loads, and clears the 5-second workspace tree deadline timer when the scan finishes instead of leaving it armed.
  • A session's tool session (the file mutation counters, the active-tool set, the host notifier and the advisor's view) is built in session/tool-session.ts instead of inline in createAgentSession; no user-visible change.
  • A session's MCP startup (discovery, the deferred connect and the reactive tool, prompt and notification wiring) runs in session/factory-mcp.ts, and the project its system prompt renders, the re-discovery after a working-directory change and the appended-prompt assembly run in ProjectPromptInputs and helpers in session/prompt-inputs.ts, instead of inline in createAgentSession; no user-visible change.
  • The debug tool's load check stops probing PATH at the first debug adapter whose command resolves instead of resolving all 14 configured adapters, which it ran for the session's tools and again for the advisor's, cutting a bare session's construction from 7.30 ms to 5.02 ms on a host with gdb installed.
  • The advisor's toolset is built in session/tool-session.ts, and the context gauge a new session records at rest and the one the status row draws come from one measureContextGauge in config/compaction-strategy.ts, instead of a copy inline in createAgentSession; no user-visible change.
  • A tool card builds its display when a frame draws it instead of on every change, so a resume stops highlighting each rebuilt call only to replace it with its result, which cuts rebuilding and drawing a 4,712-block transcript from 999 ms to 603 ms.
  • The includeWorkspaceTree prompt gate states the project discovery scan that fixes it for the session instead of a read in sdk.ts that no longer exists; no user-visible change.
  • The read tool dispatches a path through single-purpose steps (internal URLs, archive, SQLite and PDF image members, directories, images, notebooks, converted documents, binary files, summaries, multi-range and single-range text), and a range read collects, truncates, formats and annotates its window in helpers of their own; no user-visible change.
  • A resumed read result builds its card text from its numbered rows when a card first draws it instead of when the session opens, a read group with previews off (the default) keeps no card text, and rewriting an unchanged resumed read writes back its stored tag without building the text, which cut the heap of a 38 MB, 1,280-read session after opening from 92.3 MiB to 67.6 MiB, its string cells from 915,658 to 106,754 and its open from 253 ms to 192 ms, its heap after the first frame from 171.1 MiB to 144.4 MiB, and its first whole-tail rewrite from 377 ms to 221 ms and 150.2 MiB to 120.5 MiB retained, with byte-identical file output.
  • A session's custom tools and tool registry are built in session/factory-tools.ts, its extensions and custom commands load in session/startup-extensions.ts, its Codex prewarm and language-server warmup start in session/startup-background.ts, its argot arm and start records run in session/startup-records.ts, its owned background-job manager is built in session/async-jobs.ts, and the secret lease each in-flight request was admitted under is tracked in SecretRequestLeases in secrets/request-leases.ts, instead of inline in createAgentSession; no user-visible change.
  • The transcript's frame walk places each block's rows, seals committed snapshots and carries the live-region boundary in single-purpose steps over one reused cursor, and a tool card's display resolves its policies in presentation/tool-execution.ts and its renderer views and generic fallback in presentation/tool-card-views.ts, which cuts a fully reused frame of a 20,000-block transcript from 0.407 ms to 0.306 ms and a committed-replay frame from 0.457 ms to 0.303 ms with identical rows.
  • A settings-screen change applies its live effect through a table keyed by setting path in modes/terminal/controllers/setting-effects.ts instead of a 261-line switch, and the effects for names no setting has (autoCompact, theme, thinkingLevel and fourteen statusLine* spellings) and for settings with no screen row are gone; no user-visible change beyond the two fixes below.
  • A URL read sends its alternate-markdown, .md suffix, content-negotiation, alternate-feed and llms.txt probes concurrently, keeps the highest-priority rendition that answers and aborts the rest, and downloads a document's bytes once for the converter and the binary notice, cutting an article read from 93.3 ms to 63.1 ms and a script-shell page read from 216.6 ms to 93.7 ms.
  • The same-file reload comparison lives in session/provider-replay-projection.ts and compares each message's replayed fields without deep-copying them first, and skips a message both lists share, cutting it on a 433-message branch from 0.47 ms to 0.13 ms.
  • A running veyyon process that has used under 5% CPU in each 5-second window for 30 seconds discards its compiled JavaScript code and returns free memory to the OS, cutting an interactive session's resident memory at idle from 361 MiB to 332 MiB after eight turns and from 325 MiB to 303 MiB after startup, at a cost of 37 ms on the next turn.
  • An idle veyyon binary on Linux also unmaps the clean resident pages of its embedded modules when it discards its compiled code, cutting an interactive session's resident memory at idle from 317 MiB to 226 MiB after startup and from 342 MiB to 251 MiB after eight turns, with no measurable change to the next turn.
  • The settings screen reads a record setting's override layers with isRecord from @veyyon/utils; no user-visible change.
  • A process keeps the CPU model its system prompt shows without the /proc/cpuinfo text it was read from, releasing 61 KB of heap for the process life on a 32-thread host.
  • A kept-alive spawned agent's session options and a parked agent's reviver hold only the run fields they read, and each progress snapshot copies its tail lines out of the streamed text, so a finished agent no longer keeps its run's assistant text, the spawning tool call's progress callback and abort signal, or the streamed message a tail line was cut from; after five turns spawning four agents each and the 20 agents parked, heap and extra memory is 61.2 MiB instead of 64.2 MiB and live objects 547,990 instead of 549,635 (median of three).
  • The CPU model the system prompt shows is copied through detachedString from @veyyon/utils; no user-visible change.
  • A session whose tools, commands and extensions are all first-party no longer evaluates Zod: the search tool declares its parameters with ArkType, which lists its type values as files, structure, text, and the command, custom-tool and extension loaders read api.zod from the package namespace only for author code, cutting the idle heap and extra memory of the compiled binary from 83.7 MiB to 81.9 MiB and live objects from 546,500 to 528,700 (median of five).
  • Built-in tools build their ArkType parameter schemas on the first read of parameters instead of when their modules load, and session creation reads no inactive tool's parameters for discovery keys or prompt metadata, so a default session registers 834 schema nodes instead of 1,841 and the compiled binary's idle heap and extra memory drop from 75.9 MiB to 72.2 MiB, live objects from 496,323 to 457,494 and RSS after a full collection from 292 MiB to 289 MiB (median of five).
  • The compiled binary renders the default system prompt from its precompiled statement templates with prompt.renderSequence instead of parsing and compiling their joined text at every session start, and evaluates no Handlebars compiler module, so buildSystemPrompt takes 3.0 ms instead of 6.0 ms and createAgentSession 44.4 ms instead of 47.6 ms (median of 13), and the idle heap and extra memory drop from 71.7 MiB to 70.1 MiB, live objects from 458,538 to 455,377 and RSS after a full collection from 288 MiB to 285 MiB (median of seven).
  • The bundled rules are parsed once per process and every session's TTSR manager shares one compiled set of their conditions, scopes and globs, so loading and registering them takes 0.02 ms instead of 0.5 ms per session and a live spawned session retains 245.6 KiB of heap instead of 277.0 KiB and 1,723 objects instead of 2,606 (median of three runs over 20 sessions).
  • ArkType schema nodes create their assert, pipe, rootApply and allows closures on first read instead of at construction, so a node traversed only as part of a larger schema retains half the function cells and the compiled binary's idle heap drops from 48.7 MiB to 47.8 MiB and live objects from 438,905 to 422,703 (median of seven).
  • An ArkType schema node without metadata serializes itself once and holds that JSON object and string as both its inner and its full serialization, so the compiled binary's idle heap and extra memory drop by 271 KiB, from 68,550 KiB to 68,279 KiB, and live objects from 422,696 to 421,155 (median of five).
  • A rebuilt transcript allocates no closure per assistant turn or tool card beyond the function a tool's view draws through: rail frames, framed blocks and cached views are class instances, cards, producers and tool-result images report through listener objects, inline images share one theme, and an assistant turn repaints through its host, so a resumed 600-turn session holds 120,613 KiB of heap and extra memory instead of 123,380 KiB, 639,759 live objects instead of 702,893 and 385 MiB RSS instead of 389 MiB (median of five).
  • A tool card computes no edit preview once its call has a final result, and a transcript rebuilt from history sets each card's result before any preview starts, so resuming a 600-turn session whose 521 edits target files that still exist no longer reads and diffs each of them: the session settles in 625 ms instead of 1,773 ms with 1.50 s of CPU instead of 3.83 s (median of nine), and holds 116.5 MiB of heap and extra memory instead of 129.1 MiB and 383 MiB RSS after a full collection instead of 531 MiB (median of five).
  • The at-rest reading a top-level session files for the next launch is measured by measureAtRestLaunch in session/startup-records.ts instead of inline in createAgentSession; no user-visible change.
  • createAgentSession runs as the ordered steps of SessionStartup in sdk.ts, with the agent identity and provider prompt-cache key in session/startup-identity.ts, the per-request hooks in session/startup-request-hooks.ts, the credential-disabled relay in session/startup-credential-relay.ts, the tool-discovery mode in session/tool-discovery.ts, and the providers.openaiWebsockets reading in config/openai-websockets-mode.ts; no user-visible change.
  • An MCP prompt command parses its key=value arguments and joins its reply's text through two helpers in session/factory-mcp.ts instead of inline; its output is unchanged.
  • Codex web search folds its response stream into the answer, sources, model and usage through CodexAnswerCollector in tools/web/search/providers/codex-answer.ts, and maps a failed response through the shared provider HTTP error classifier; its results and errors are unchanged.
  • The 98 bundled themes and the two root themes are embedded as files and the one a run asks for is read and parsed on demand, instead of every theme's JSON text held as a module string, so the binary shrinks by 240 KiB and an idle session holds 47.29 MiB of heap and extra memory instead of 47.76 MiB and 134.3 MiB of anonymous resident memory instead of 136.2 MiB (median of eight).
  • A context file in which no @ import resolves is kept as the string discovery read instead of a copy rebuilt from its segments, so a session in a project whose AGENTS.md is 48,191 characters holds 94 KiB of whole-text copies of it instead of 282 KiB.
  • An ArkType union in a jitless scope, as the CLI configures every scope, builds its discriminant, which only a compiled validator reads, on first read instead of at construction, and a union in any scope serializes it on first read, so a session start discriminates no union instead of 275, the compiled binary's warm:arktype startup phase takes 25.3 ms instead of 27.6 ms (median of 25), and an idle session holds 36.09 MiB of heap and extra memory instead of 36.38 MiB and 395,674 live objects instead of 398,201 (median of five).
  • An interactive launch takes the session's at-rest context reading, which builds every active tool's schema, once the frame that draws the first keystroke in the composer is committed or when a prompt is submitted, instead of inside session creation, and the status row draws the resting gauge the last launch recorded until then, so a cold createAgentSession takes 104.5 ms instead of 144.2 ms (median of 16) and an idle session holds 41.37 MiB of heap instead of 44.76 MiB, 335,831 live objects instead of 370,870 and 123.8 MiB of anonymous resident memory instead of 133.3 MiB (median of five).
  • ArkType builds each string.* keyword (string.email, string.url, string.date.iso and 50 more) when a schema first names it instead of when ArkType loads, so loading ArkType in the jitless CLI takes 11.5 ms instead of 21.3 ms and 2.0 MiB of heap instead of 3.9 MiB (median of 21), and an idle session holds 39.58 MiB of heap instead of 41.37 MiB, 314,847 live objects instead of 335,846 and 119.3 MiB of anonymous resident memory instead of 123.6 MiB (median of four).
  • A resumed session at rest states its context gauge, and the /context and /compact figures of the slash popup, with the non-message size its last response recorded in place of a measurement, instead of building every active tool's schema to measure it, so resuming a 600-turn session draws the model in 221.6 ms instead of 246.2 ms and spends 1.14 s of CPU instead of 1.20 s (median of 11), and the session at rest holds 70.8 MiB of heap instead of 73.8 MiB, 521,322 live objects instead of 553,019 and 348 MiB of resident memory after collection instead of 384 MiB (median of five).
  • The launch-facts record is defined in config/launch-facts.ts instead of modes/launch-facts.ts, so the session reads and writes it without importing the terminal modes; no user-visible change.
  • The launch-facts record clamps its context percentages with clamp from @veyyon/utils instead of a local helper; no user-visible change.
  • The in-flight prompt count and macOS power assertion, extension event forwarding, the title refresh on a re-plan, and working-directory re-scoping run in four session collaborators instead of as AgentSession members, which cuts the class from 265 private names to 186, so an idle session holds 10.67 MiB of private-name tables instead of 13.22 MiB and 96.3 MiB of anonymous resident memory instead of 102.0 MiB (mean of two).
  • The edit tool's write path, with the LSP writethrough and the ACP filesystem bridge, is defined in edit/modes/patch-execute.ts, which the streaming edit preview does not import, so the launch module graph holds 21 fewer modules (301 KiB of source) and a one-turn -p run takes 287.2 ms instead of 293.0 ms with 229.2 MiB peak RSS instead of 231.3 MiB (median of 61).
  • A tool execution block's input serialization is defined in presentation/tool-input.ts instead of presentation/tool-execution.ts; no user-visible change.
  • A session takes the Anthropic fast-mode reset, the Claude device id, the Codex transport details and compaction context, and the Gemini thought-signature accounting from leaf modules of @veyyon/ai, and loads the Codex client inside the background websocket prewarm, so the Anthropic, Codex and Google provider clients load on a session's first request to them instead of at launch: the launch module graph holds 21 fewer modules (691 KiB of source), and an idle session holds 251,352 live objects instead of 254,549, 50.12 MiB of heap and extra memory instead of 50.48 MiB and 234 MiB RSS after collection instead of 237 MiB (median of seven).
  • A turn reads the session's spend only while a goal is charged for it, and the spend tally reads each summarized assistant turn and task result back from the session file without keeping it in memory, so the first turn after resuming a 154 MiB, 53,819-entry synthetic session takes 250 ms of CPU instead of 490 ms and peaks at 354 MiB RSS instead of 458 MiB, and /session on it settles at 237 MiB RSS instead of 282 MiB (median of 3 alternating runs).
  • A streamed chunk's frame sizes the home anchor's fills from the rows it keeps for the status rows, the composer and its footline instead of rendering them again, so the first streamed answer of a session (4,000 characters at 400 characters a second in 8-character deltas) takes 285 ms of main-thread CPU instead of 353 ms and 555 ms of process CPU instead of 680 ms (median of 6 alternating runs); a turn whose transcript already fills the screen is unchanged.
  • A running session holds the text a read card, an eval cell output or a job result repeats from its tool result's content once, as a resumed session does, instead of a second copy in the result's details, so a 120-turn session that reads a distinct 8 KB file each turn holds 590 KiB of file text instead of 871 KiB and 27.45 MiB of JS heap after collection instead of 27.69 MiB (three runs each).
  • A session checks whether a message is already on its branch against a sorted typed array of the branch's message timestamps, comparing persistence keys only for entries with the same timestamp, instead of a Set of every message's persistence key, so after two turns on a resumed 600-turn synthetic session the persistence collaborator retains 688 bytes of heap and a 43 KiB typed array instead of 516 KiB of heap, and a 5,000-message branch's index adds 125 KiB to the heap instead of 1,182 KiB.
  • The profile, ~/.agent and extension-package providers load commands/, rules/, prompts/ and tools/ through one shared loader per layout, and an unreadable tools/ directory in the profile reports a discovery warning, as the other three layouts already did.
  • An extension tool call resolves its approval policy, raises its approval card, sends tool_call and rewrites its result in four steps instead of one 350-line method; approval, vetting and results are unchanged.
  • The secret obfuscator validates its registry, installs plain and regex entries, builds regex replacements and restores placeholders in single-purpose methods, and its message, content and provider-context walks share one identity-preserving map; no user-visible change.
  • Structure search resolves its scope, merges overlapping targets, groups matches, renders each file, lays out the result and fits it to the inline budget in single-purpose functions instead of one 280-line closure; no user-visible change.
  • executeBash plans the command, joins the CPU budget, leases the persistent shell, arms the abort and deadline, and settles the result in single-purpose steps instead of one 270-line function; a builtin command runs in 0.08 ms and a 20,000-line seq in 0.9 ms per call, unchanged.
  • The task card appends every agent, review, finding and nested-call row into one list instead of building and spreading a list per section; its rows are unchanged across a 6,000-card corpus, and drawing that corpus takes 1115 ms instead of 1305 ms.
  • A streamed delta sets the working message once, from the last tool call that states an intent, instead of once per call, and asks no earlier call's tool to derive an intent, so 4,000 deltas over six tool calls set it 340 times instead of 24,000 and a message update takes 4.5 µs instead of 5.3 µs (median of seven).
  • The terminal event controller starts a message, ends a message, settles a tool result and ends a retry in single-purpose steps, and a user message's local-echo signature is defined once in transcript-composer.ts; the transcript is unchanged.
  • /usage groups reports by provider, lists saved resets, collects limit rows and draws each row in single-purpose functions instead of one 180-line function; its output is unchanged across a 20,000-case corpus.
  • /session builds its provider, message, token, cost, language-server and MCP sections in single-purpose functions; its output is unchanged across a 20,000-case corpus.
  • /share runs the custom share script and the default share in separate steps, /memory runs each subcommand in its own method, /move checks and creates its target in one step, and /compact merges its instructions and mode in one function; no user-visible change.
  • /mcp runs its Smithery search, deploy and login steps from mcp-smithery-commands.ts, its OAuth login and reauthorization from mcp-oauth-login.ts, its list, resource, prompt and notification reports from mcp-server-reports.ts and its messages from mcp-command-output.ts, and MCPOAuthFlow.storedCredential builds the credential row a login stores; its output is unchanged across a 20,000-case corpus.
  • The composer's Esc handling, submission, /queue dispatch, follow-up and image-path paste run in single-purpose methods, its key listeners install once per editor, and the tiny-title download row is defined in tiny-title-download-row.ts; no user-visible change.
  • A session switch or reload captures its rollback, enters the target transcript, loads it and rolls back a failure in single-purpose steps instead of one 269-line method, and reads the branch once to restore the thinking selector and service tier; behavior is unchanged across 11,160 generated switch and injected-fault cases.
  • The end-of-turn context check recovers an overflow, retries an overflow stamped with the pre-promotion model, recovers a length stop and runs threshold maintenance in separate methods instead of one 231-line method; no user-visible change.
Fixed
  • A read of a missing artifact:// id, a missing agent:// output or a missing PDF image member lists at most 20 of what exists followed by a count of the rest, instead of every id in every session, which printed thousands of artifact ids into one tool result in a long session.
  • A transcript rebuild, such as after a compaction, releases the tool cards and assistant segments it removed from the screen and the arguments of calls that settled, instead of holding every card a long agent run ever drew, so a 900-second soak of tool turns and compactions ends at 987 MB RSS instead of 1,512 MB with 481,732 heap objects instead of 945,900.
  • A collapsed edit card whose change lines alone pass 40 draws 40 diff rows and counts the rest as hidden, instead of drawing every line of the run that crossed the budget (a 600-line replacement drew 603 rows) or overflowing the call stack on a run of a million lines, and cutting the diff and counting its lines no longer copy each run or re-split the kept text, so cutting a 5,600-line, 400-hunk diff takes 355 µs instead of 544 µs and counting it 56 µs instead of 190 µs (median of nine rounds of 300).
  • A session switch, /resume, reload, /new or /drop that fails part-way, such as on a disk error while the outgoing transcript is flushed, keeps the session listening, so later turns reach the screen and the session file instead of running unseen and unsaved.
  • Kimi web search with a kimi.ai credential posts to api.kimi.ai instead of api.kimi.com, and the Kimi API Format options describe the API each one uses instead of naming a host.
  • Reading a PowerPoint deck shows each slide's notes under that slide instead of under the slide whose number matches the notes part, so notes added to a later slide first no longer appear under an earlier slide, and it reads a slide named by an absolute or percent-encoded target, and the pictures and notes of a slide part not named ppt/slides/slideN.xml, instead of dropping them.
  • Writing into a ZIP or tar archive that holds a member named __proto__, or extracting or reading every member of such a ZIP, keeps that member under its own name instead of dropping it or listing its bytes as members 0, 1, ..., and converting an EPUB or XLSX whose reference names an absent member called toString or another Object.prototype property skips the reference instead of failing.
  • Reading a PDF, or attaching one with @, returns when a page's content stream ends in <, instead of never returning.
  • Escape or abort_retry that lands while an unreplayable tool batch's continuation is being announced cancels the continuation, instead of the session sleeping out the wait, re-requesting the turn and reporting a recovery that was cancelled.
  • In a linked worktree named after its branch, the status line's path segment and the launch card keep the worktree directory (monorepo/topic) on a row with a pr segment and no git segment, or with segmentOptions.git.showBranch: false, instead of showing monorepo with neither the worktree nor its branch on the row.
  • The launch card draws the dirty marker (*) and the effort the last launch's status line settled on when that row had no context gauge, instead of drawing a dirty branch clean or an older effort until the session mounted; a row that follows another repository no longer records that repository's tree status under the project.
  • A TTSR interrupt retries the turn it aborted when the aborted turn settles with a message whose timestamp differs from the partial it streamed, instead of dropping the injection and releasing the resume gate with no continuation.
  • An expanded task card draws an agent's Output heading once when the agent returned {}, [] or an empty JSON value, and when a running agent's live output is one, instead of twice.
  • An agent with several approval cards open at once stays marked as waiting until its last card closes, instead of showing as working once its first card is answered, so the agent dashboard draws it as blocked and the runtime budget excludes the operator's reading time across the whole span, counted once.
  • A non-recursive discovery scan reads only the files directly inside its directory, so a helper module under tools/<name>/ no longer registers as a custom tool named for its file, and a file below commands/, rules/, prompts/ or instructions/ (rules/archive/old.md) no longer loads as a command, rule, prompt or instruction.
  • VEYYON_TIMING=x on an interactive launch stops the launch card's terminal before it prints, so the startup timing tree reaches stderr instead of only the log file, and the startup bench's ready:load and ready:boot arms report samples again.
  • A tool card in a rebuilt transcript serializes its call's arguments through one accessor shared by every block instead of a getter allocated per block, so a drawn tool turn keeps one closure and two scopes instead of two and four (bash: 0.9 closures and 1.85 scopes per turn instead of 1.9 and 3.85).
  • The terminal components barrel exports HOOK_EDITOR_TEXT_PAD_COLS, computeModalDims, sizingForArea and the other modal sizing names again, which it dropped when they moved to chrome/modal-geometry.ts.
  • The compiled binary loads a legacy extension that imports @mariozechner/pi-coding-agent, @earendil-works/pi-tui, @veyyon/ai or another shimmed package root, or a pi- subpath such as @mariozechner/pi-ai/oauth, instead of failing it with no bundled module registered for @veyyon/pi-coding-agent or Cannot find package '@mariozechner/pi-ai'.
  • The slash popup a launch's first / opens states /context and /compact without a context figure while the session is at rest, instead of measuring it and building every active tool's schema inside the keystroke, so the first / echoes in 5.5 ms instead of 27.2 ms and its popup settles in 38.1 ms instead of 59.5 ms (median of 11).
  • A read card rebuilt on resume drops the file text it was built from once its card text exists, and a prune that replaces the read's result drops it too, so a resumed 600-turn session whose overflow prune superseded 398 reads holds 49.6 MiB of heap instead of 54.7 MiB and 244 MiB RSS after collection instead of 248-249 MiB (two runs each, 40-second settle).
  • Dismissing the welcome card on a resumed session reports the card's rows as dropped from native scrollback instead of unmounting them unreported, so the first turn no longer replays the transcript: on a resumed 600-turn session its peak resident memory is 492 MiB instead of 527 MiB, its CPU time 0.48 s instead of 0.68 s, and its largest erasing frame 57 rows instead of 31,635 (median of five).
  • Resuming a session or rebuilding the transcript puts its earlier prompts in the up/down history ring without writing them to the prompt history database again, so resuming a 600-turn session adds 0 rows to history.db instead of 600 (median of seven).
  • A spawned agent no longer records its context gauge, model name and thinking level into the launch facts, so the next launch's card and status row state the top-level session's reading instead of the last spawned agent's, and a spawned agent no longer builds every tool's wire schema at creation to measure that gauge: the first one created in a fresh process takes 119 ms instead of 181 ms (median of five).
  • A models.yml at a path other than the default one, rejected by a check after the schema (a missing apiKey, a retired key), names the file that was read in its error instead of the default models.yml path.
  • A language server error reaches the lsp tool's result once as LSP error: <message> instead of LSP error: LSP error: <message>, and rename_file drops a server that answers workspace/willRenameFiles with the JSON-RPC MethodNotFound code whatever its message says, instead of listing it as a server note.
  • A settings file with defaultThinkingLevel: off starts sessions with thinking off instead of at high.
  • A retry.fallbackChains entry that is not a string is skipped with a config warning and the next entry is tried, instead of leaving the failed turn's prompt waiting forever on a retry that threw.
  • A failure inside retry recovery, such as a locked auth database, a credential helper that exits with an error, or a full disk while the model switch is recorded, ends the retry with an auto_retry_end failure naming it, instead of leaving the prompt waiting forever.
  • A usage-limit or rate-limit error whose message states a zero or elapsed retry window parks the credential for the computed backoff instead of for no time, and the session retry loop, the auth gateway and the advisor read a retry window from an error message through one parser.
  • A same-file reload that changes a bash turn's kill signal or a user turn's synthetic, steering, attribution or demoted-reasoning marks now closes the live provider sessions, instead of continuing a provider chain whose history no longer matches the transcript.
  • A models.yml compat block type-checks every key of the compat contracts, so a wrong value such as thinkingKeep: last fails validation naming the key instead of going to the provider verbatim; thinkingKeep, reasoningDisableMode, toolSchemaFlavor, the Anthropic flags and trustExplicitThinkingOnly are documented overrides.
  • Disposing a session waits up to 1 second for its aborted agent loop to finish before it releases async jobs, eval kernels, browser tabs and the transcript, so a tool that ignores its abort signal no longer races the teardown of what it is using.
  • A record-valued settings row (model roles, default effort, provider limits, agents, fallback chains, per-provider retry, tool approval) opens when a runtime override or --config file sets one of its entries; the overridden entries show their source and are read-only, and edits to the other entries write only the profile's values.
  • The Default Model row states which layer supplies the active model at the start of its description, so the one-line footer no longer truncates it away.
  • A tool card's header and section labels are clipped at the card's width instead of running past its edge, so an ssh host or a write path with no break in it no longer folds onto the next terminal line, and no card row exceeds a terminal narrower than the rail and its indent.
  • An invalid enum value in config.yml falls back to the setting's default for every enum setting, not only edit.afterEdit.
  • The pending previews of ssh, browser, read, debug, bash, github, lsp and 30 other tools update a string argument as it streams instead of when the JSON object closes, and the live preview matches the rebuilt transcript.
  • The session /new starts while a response is still streaming, and every other top-level session in the process, runs background bash, the job tool and daemon exit watches on a job manager of its own, and a job reports to the conversation that started it or spawned the agent that started it instead of being refused.
  • The Claude Code capture helper moved from src/cli/claude-trace-cli.ts to scripts/claude-trace-capture.ts beside bun run claude:trace, its only caller; it was never a veyyon subcommand and no longer ships in the package source.
  • statusLine.segmentOptions.model.roomy: false joins the model and its thinking level with the dot separator in the composer footline instead of being overridden to the Model @level form.
  • The plan review overlay repaints when a plan is swapped in or an external-editor annotation is committed, instead of waiting for the next keystroke.
  • An agent spawned by another agent, and an agent revived from its transcript, reports its start, progress and finish on the top-level session's event bus, so the agent dashboard, the RPC agent stream and collab guests show agents at depth 2 and below instead of nothing.
  • --profile <name> --resume <id> for a session another profile wrote forks it into <name> at its recorded working directory and leaves the source unchanged, instead of appending to the other profile's transcript under <name>'s settings and credentials.
  • /resume <id> for a session another profile wrote relaunches Veyyon in that profile instead of opening the transcript under the running profile.
  • veyyon --resume <id> naming a subagent transcript nested inside a session's directory activates the profile that wrote it instead of forking it into the profile the launch started in.
  • veyyon --fork <id> for a session another profile wrote activates that profile and writes the fork under it, instead of copying the session into the profile the launch started in; --profile <name> --fork <id> still forks it into <name>.
  • A named profile with no hindsight.bankId set retains into and recalls from the veyyon-<profile> Hindsight bank instead of the veyyon bank every profile shared; set hindsight.bankId: veyyon in that profile to keep reading memories it retained before.
  • With sessions stored under $XDG_DATA_HOME/veyyon, veyyon --resume <id> activates the profile that wrote the session, and the session picker's all-projects view and an ACP client's session list show the active profile's sessions from every project, instead of none of them.
  • The session picker's all-projects view and an ACP client's session list no longer show each spawned agent's transcript as a session of its own.
  • /profile <name>, /resume of another profile's session, and veyyon --profile <name> run from a tool's shell start the other profile on its own .env files instead of the credentials the running profile loaded from its own.
  • An Exa API key read out of a profile's mcp.json no longer reaches a process started under another profile, which resolves EXA_API_KEY from its own configuration instead.
  • On Windows, launch in a project where another profile's daemon broker is running starts this profile's own broker instead of connecting to the other profile's pipe and failing with Daemon broker authentication failed, and a session under VEYYON_CODING_AGENT_DIR no longer shares the default profile's broker and its environment.
  • Switching a running session to a transcript another profile wrote, through an extension or RPC switch_session, fails with an error naming the owning profile instead of continuing that transcript under the running profile.
  • An unknown-flag error suggests a short flag in the spelling the parser accepts, such as -r for -rr, instead of --r, which the parser rejects, and offers -h and -v like every other flag.
  • A URL read whose image bytes do not decode returns the text page the server sent, or a note that the bytes were not a valid image, instead of failing the read.
  • A URL read of a page whose alternate <link> href is not a valid URL skips that link and reads the page instead of failing.
  • A compaction that writes the same summary as an earlier one, such as a second server-side compaction with its empty summary, stamps its dead-end warning on the new entry and passes the new entry to session_compact handlers instead of the earlier one.
  • With edit.streamingAbort on, a streaming edit patch whose last removed line has no trailing newline stops the turn when that line is absent from the file, instead of leaving it for the edit tool to reject after the stream ends.
  • Disposing a session while a Python or eval run is in flight no longer keeps the process alive for up to 3 seconds after the run finishes.
  • The CLI imports the terminal output guard when a worker thread starts rather than at startup, keeping it off the static boot graph; no user-visible change.
  • A tool card whose call carries an argument of the wrong type, such as input: 404 for search, draws the value as text or omits it instead of failing with Renderer failed: e.toWellFormed is not a function.
  • The read card for a structurally summarized file numbers each row with the line the model saw, a merged brace pair with its opening line, instead of counting up from line 1 past every elided body, and draws the … elision row and the summary budget notice without a line number.
  • The streaming-reveal throughput bench builds its target as a transcript view instead of a raw assistant message, so bun packages/coding-agent/bench/streaming-throughput.bench.ts runs again; no user-visible change.
  • An agent's live preview shows the shorthand the stream was still holding when a streamed message ends without a final content snapshot, instead of dropping it.
  • veyyon --resume <id> for a session from another project reopens that session in place and moves the launch into its recorded working directory, instead of prompting to fork it into the launch directory or failing without a terminal; an explicit --cwd moves the session's working directory there instead.
  • veyyon --resume <id> runs under the profile whose sessions directory holds the session, instead of the profile the launch started in; an explicit --profile takes precedence.
  • The advisor's tools read the primary tool session live, so an advisor ask delivers the host notification, an advisor task label rides the session's side transport, and an advisor spawn after a working-directory change inherits the new context files, workspace tree, skills and rules instead of the launch ones.
  • Clearing the transcript for a rebuild (resume switch, /shake, compaction, a display setting) releases the discarded blocks and their rendered rows before the new blocks are built instead of holding both trees until the next frame, cutting the retained heap at a rebuild of a 13,470-entry transcript from 264.7 MiB to 157.0 MiB.
  • Turning Settings → Providers → Import Other Tools' Config on or off applies to the next discovery load in the running session and leaves disabledProviders unchanged, instead of adding or removing a provider named importForeignConfig there and taking effect only in the next session.
  • Turning Settings → Appearance → Show Inline Images on or off redraws the transcript under the new value, instead of leaving the images on cards already drawn.
  • Closing /settings, flipping an appearance toggle there or hovering a status line preset keeps the configured statusLine.segmentOptions on the status line, instead of resetting them to the preset's until the next unrelated resync.
  • @veyyon/coding-agent/export/html exports buildSessionData and collectSubSessions again, which moving them to export/session-data had dropped from that entry point.
  • A resumed session at rest drops the committed transcript blocks above the retained screen from the terminal frame, including blocks that report a version and blocks a frame carries without drawing, keeps one block more instead of dropping none when the commit lands on a block boundary, and releases the rows each dropped block memoized, so a resumed 600-turn session at rest holds 87.9 MiB of heap and 746,900 objects instead of 105.5 MiB and 962,500 (median of three).
  • A session replace or display reset that lands between the paint that committed transcript rows and the next frame replays the whole transcript, instead of dropping the committed rows from the replayed frame and leaving 35 of 600 rows in the terminal's scrollback or 21 of 699 on the alternate-screen scroll tape.
  • The raw SSE capture that /debug reads releases each frame record as it evicts it instead of holding it until the window compacts, so the capture stays within its 512,000-character budget and a 60-turn session holds 883 content frames (130.0 KiB) instead of 1,407 (207.2 KiB).
  • An action on an element named by a tab.observe() id or a tab.ariaSnapshot() ref lands once on the element that replaced it after the page redrew, when that element is the only one with the node's role and accessible name, instead of failing with "Node is detached from document"; a click, hover or tap reads the element's point and dispatches in one round trip, so it also lands on a page that redraws every animation frame, and an element the role and name cannot single out fails naming the id or ref as stale.
  • tab.screenshot() sends a second capture on a CDP session of its own when the first has not answered within 1 second, up to three, so a capture sent while the page commits a navigation no longer holds until the protocol timeout or holds later screenshots and the tab's close behind it.
  • A tab.goto() aborted with net::ERR_ABORTED by a navigation the page started, such as a click handler's redirect, is sent once more and resolves on its own URL; a goto aborted twice fails naming the navigation that aborted it last.
  • A bash command whose caller cancels while the call joins the session CPU budget returns as cancelled without running, instead of running to completion and reporting success.
  • A /queue or => line submitted with Enter whose first message fails to send comes back to the editor as the => queue it was, with its pending images and their links, instead of leaving the editor empty.
  • veyyon commit edits a changelog's Unreleased section line by line, so adding or deleting an entry keeps the section's prose, categories outside Keep a Changelog, wrapped and nested entries and the file's final newline instead of dropping them, a ### toString heading no longer stops the changelog from being read, an entry differing from a proposed one only in case, spacing or a trailing period counts as the same entry for duplicates and deletions, and a changelog the proposal leaves unchanged is no longer rewritten, staged or reported as updated.
Removed
  • The unread sessionAccent field is gone from the status line's settings object; statusLine.sessionAccent still colors the editor border.
  • The unused built-in designer model role is gone from Settings → Model → Roles; a modelRoles.designer value you already set still resolves through @designer as a custom role.
  • The retired statusLine.separator and statusLine.transparent settings are gone; neither changed anything on screen, and a config file that still sets them loads unchanged.
  • 36 exported functions and constants that nothing called, and the unused Smithery Connect API client mcp/smithery-connect.ts, are gone; no user-visible change.
  • The model.toolCallLoopGuard.readSubsumptionThreshold setting and the tool-call loop guard's redundant-read steer are gone, replaced by read refusing reads still in context; a stored value is dropped from the config on load.

1.5.5

2026-09-25 View on GitHub ↗
Fixed
  • Running two veyyon versions at once on Windows no longer prints could not remove the stale addon cache ... EPERM over the interactive UI and pushes the composer down; a real removal failure shows as a natives warning notice.
  • A console print from a library, a native addon warning or a worker thread no longer writes into the interactive UI and shifts the composer on Linux or Windows; the text goes to the veyyon log file.

1.5.4

2026-09-24 View on GitHub ↗
Changed
  • Slash-command reports (/tools, /hotkeys, /context, /jobs, /todo, /lsp, /plugins, /effort) format with clean human summaries, consistent headers and indentation, and without raw XML tags or run-on bullet sequences.
  • The extension dashboard aligns list cursor bands to avoid text overlap, keeps the provider tab strip on a single scrollable line, and adopts the shared search input style.
  • The account manager displays quieter empty provider states without trailing dashes and phrases initial account addition cleanly.
  • The profile picker presents a dedicated Profiles title, drops the redundant other option, and cleans up the create-profile label glyph.
  • The resume session selector omits file size metadata when displaying empty sessions without messages.
  • The agent dashboard renders active tabs with standard theme highlight styling without hardcoded bracket characters.
  • Settings panel presents booleans as On/Off, humanizes enum and status labels, displays the selected setting description in the footer, simplifies default model display, and aligns the value column.
  • Bare-command pickers (/mcp, /usage, /account, /debug and the rest) widen to show every usage hint and description whole, cut a usage that cannot fit after a whole word, print one key legend in the footer with esc close instead of esc/ctrl+c close, name the search there while the list is searchable, and draw a dim scrollbar with a silver thumb.
  • The /debug card is titled /debug, matching the other bare-command cards.
  • Provider request shaping (secret redaction, Anthropic metadata, tool-order check) moved from session/agent-session to session/agent-session-provider-request; no user-visible change.
  • Home-path shortening in tool cards compiles its pattern once per home directory instead of on every call; no user-visible change.
  • A spinner or rail tick in the transcript re-renders only the blocks from the animating one down, so an idle resumed session with a long transcript no longer spends a core re-walking every block.
Fixed
  • Tool-result preview lines replace tabs with spaces, so a tab-indented line no longer opens a gap in the rendered preview.
  • Shutting down an LSP client releases callers still waiting for its project to load, and the LSP idle checker no longer keeps the process alive.
  • Timeout timers in MCP HTTP startup, the eval kernel exit wait, the lspmux liveness probe, stdin reading, ACP cancel cleanup, browser user-agent overrides and the interactive closing frame are cleared once the awaited operation settles; no other behavior change.
  • The ask dialog rejects a question with no options and no free-text answer instead of opening a dialog that cannot be answered.
  • A collab guest answering an ask question is offered Other only when the question allows a free-text answer, and a guest reply of Other to a closed question records no custom answer.
  • The extension dashboard's overflowing tab strip reserves room for the paging arrows and stays on one row at every width.
  • A bare-command picker on a narrow terminal narrows a long usage column so every subcommand keeps its description.
  • Switching to a model on another provider after a server-side compaction no longer resends the whole session history: before the next prompt, the session asks the model that minted the compaction to summarize it and continues from that summary, reported as an auto-compaction with reason provider_switch.
  • A prompt or idle compaction on a session that switched providers after a server-side compaction ports that compaction first, instead of summarizing the re-expanded history on the new provider in hundreds of staged requests.
  • A staged compaction summary that fails part way resumes on the next attempt from the segments that never completed instead of restarting from the first segment.
  • A background task card restored from a resumed session stops its rail animation once it scrolls above the live region, instead of repainting the transcript every 100 ms for the rest of the process.
  • A displaceable tool preview sealed during an animation frame releases the live region at that frame instead of holding it open until the next full render.

1.5.3

2026-09-23 View on GitHub ↗
Fixed
  • A cursor-agent turn whose connection stops answering fails as a dead connection within 40 seconds of the last server byte, instead of up to 70 seconds.

1.5.2

2026-09-22 pending release
Added
  • /usage reset and its selector list and redeem usage-limit reset credits for Anthropic Claude accounts beside OpenAI Codex accounts, and accept a provider prefix such as /usage reset anthropic active.
Fixed
  • A turn whose provider stream died after every in-stream tool call of a batch that cannot be replayed (a Cursor exec-channel batch) continues from the results in context instead of stopping.

1.5.1

2026-09-22 pending release
Changed
  • The bash tool prompt states that a backgrounded job is never polled: no sleep, pgrep, ps, tail -f, top, and no second call that watches it.

1.5.0

2026-09-19 View on GitHub ↗
Breaking
  • Agent settings use agent.*, tier.agent, advisor.agents, and argot.agents; legacy keys migrate on load, while historical runtime export names, custom-theme color tokens, session records, and RPC spellings remain unchanged.
  • Account formatting helpers are exported from @veyyon/coding-agent/session/account-format instead of @veyyon/coding-agent/slash-commands/helpers/format.
  • Screen takeover moved off ExtensionUIContext and HookUIContext onto an optional ui.terminal capability: custom() and setEditorComponent() are now ctx.ui.terminal?.custom(...) and ctx.ui.terminal?.setEditorComponent(...), and a component widget goes through ctx.ui.terminal?.setWidgetComponent(key, factory) while setWidget(key, lines) keeps the text form every host draws. A host that is not a terminal omits ui.terminal rather than declaring members with empty bodies.
  • Removed ui.setHeader() and ui.setFooter(), which every host implemented as an empty function, interactive mode included.
  • Session spine, plugin loader and contribution registry modules moved from src/session/ and src/extensibility/ to @veyyon/kernel: affected subpath imports now use @veyyon/kernel/session/*, @veyyon/kernel/loader/* and @veyyon/kernel/registry/*; edit-specific event normalization remains at @veyyon/coding-agent/extensibility/tool-event-input.
  • The 152 modules under src/tools/ moved into one directory per domain — core/ for the plumbing every domain reads, then fs/, search/, shell/, web/ and agent/ — so a subpath import previously resolved through @veyyon/coding-agent/tools/<name> is now @veyyon/coding-agent/tools/<domain>/<name>.
  • sanitizeStatusText is @veyyon/utils/sanitize-status-text, so a subpath import previously resolved through @veyyon/coding-agent/modes/sanitize-status-text names the utils module: the function is text-only and every host reduces a value to one line the same way.
  • The 81 site scrapers, the page loader and the Parallel extraction client moved to @veyyon/web: a subpath import previously resolved through @veyyon/coding-agent/web/scrapers/* or @veyyon/coding-agent/web/parallel is now @veyyon/web/scrapers/* and @veyyon/web/parallel, and the search providers' withHardTimeout is @veyyon/web/hard-timeout.
  • escapeMarkdownTableCell and the Turndown helpers are @veyyon/utils/markdown-table and @veyyon/utils/turndown, and htmlToBasicMarkdown is @veyyon/utils/html-markdown, so a subpath import previously resolved through @veyyon/coding-agent/utils/markdown-table, @veyyon/coding-agent/utils/turndown or the scrapers barrel names the utils module.
  • CliUsageError is @veyyon/utils/cli-usage-error; @veyyon/coding-agent/cli/usage-error is removed, so a flag the root parser rejects and one the command framework rejects are the same class.
  • @veyyon/coding-agent/session/auth-storage is removed; the credential types and AuthStorage it re-exported are imported from @veyyon/ai/auth-storage, the module that defines them.
  • The setting declaration vocabulary — SettingDef and its definition kinds, SettingType, SETTING_TYPES, isSettingType, SettingTab, AnyUiMetadata and SubmenuOption — moved from @veyyon/coding-agent/config/settings-schema to @veyyon/settings; the schema, its readers, the tab metadata and the tab groups stay where they were.
  • URL target parsing is exported from tools/web/read-url-target instead of tools/web/fetch.
  • Setting-change signals are exported from config/settings-signals instead of config/settings.
  • fgOrPlain is exported from theme/theme-binding instead of theme/theme.
  • Diagnostic cards use diagnosticsSection from tools/core/diagnostics instead of formatDiagnostics from tools/core/render-utils; diagnostic parsing and sanitisation helpers are imported directly from tools/core/diagnostics.
  • Read selector helpers parseSel and isRawSelector are exported from tools/core/path-utils instead of tools/fs/read.
  • readSourceFsPath is exported from tools/fs/read-view instead of tools/fs/read and remains available from the package root.
  • metadataLine is exported from tools/core/render-utils instead of tools/web/search/view.
  • Removed the unused inheritedAgentDir keybinding option and ohMyPiXAIUserAgent alias; xAI requests continue to use veyyonXAIUserAgent.
  • @veyyon/coding-agent/extensibility/hooks no longer exports HookRunner, HookToolWrapper, discoverAndLoadHooks, loadHooks and execCommand: the legacy hook runtime is removed, a plugin's hooks entry loads through the extension runner, and the subpath keeps the hook types.
  • UNICODE_SYMBOLS is @veyyon/view's; theme/symbols re-exports it and keeps the terminal-only Nerd Font and ASCII presets, the spinner frames and the bar ramps.
Added
  • Exported projectToolDisplay from presentation/web-tool-display.ts, projecting canonical tool execution displays for collab live sessions and HTML export.
  • tools/view-registry.ts exports toolViewDefinitions, the host-agnostic ToolViewDefinition for every tool card the terminal drew, and tools/renderers.ts derives the terminal adapters from it; the set of cards and their chrome are unchanged.
  • A tool card value-imports no tool: the search card limits are tools/search/search-card-limits.ts, the web search provider label is tools/web/search/types.ts, and the launch card owns callMeta and readyPendingSummary; each name is exported from that one module only. Print mode and the HTML export load a card without the tool behind it, and no output changes.
  • presentation/transcript-builder.ts is split into content-text.ts, custom-display.ts and session-projection-engine.ts, each under the presentation module size ceiling; no output changes.
  • src/presentation/ builds the @veyyon/wire/presentation view-models from session state, and PresentationEventBridge turns session events into transcript updates, so a renderer draws a session without importing one.
  • src/modes/terminal/driver.ts implements PresentationContext on @veyyon/tui: it renders every transcript block kind, the status line, the composer and the dialogs from view-models alone, and reports operator input back as UIEvents.
  • InteractiveMode.presentation applies transcript, status, composer and overlay updates to the existing terminal surface without constructing a second terminal or composer.
  • /process-manager opens the Agent Control Center across every conversation this process is running rather than only the one on screen, and a switches the roster, the comms stream and the transcript guard between the two scopes together.
  • read accepts a semicolon-delimited list of internal resources (skill://demo/one.md;skill://demo/two.md), the same list form grep and glob take, and returns one section per entry.
  • @veyyon/coding-agent/session/facade exposes AgentSessionFacade, a thirteen-member session API a front end drives — start, stop, submit, interrupt, retry, per-call tool approval, six event streams and the model, provider and context-usage readings — over a live AgentSession; the facade owns the permission prompt while it is started, and refuses a session another host already routes through.
  • setImageDisplayProbe lets a front end state whether it draws pictures, which is what the session reports to the model about an image a tool returned; a client that installs nothing draws nothing, so a host embedding the engine no longer inherits a terminal's answer.
  • ToolDefinition.view lets an extension describe its tool's call and result cards as a ToolView instead of building a terminal component, and re-exports the @veyyon/view vocabulary (ToolView, StatusRowView, TextBlockView, ViewSpan, ViewTone, ViewStatus) so a plugin can construct one; the terminal draws it, and a tool that also declares renderCall/renderResult keeps those.
  • src/modes/terminal/draw/draw-tool-view.ts draws a ToolView as terminal bytes through exhaustive tone-to-colour and status-to-icon records, so a tone added to the contract fails the type check until the terminal states how it looks.
  • A ToolView span carries file for a filesystem path a host opens however it can, separate from the link a URL rides on, and the tone vocabulary adds diffAdded and diffRemoved for the two sides of a change; the terminal wraps a file run in an OSC 8 link to its file:// URI.
  • Tool domains declare lazy factories in manifest.ts, while tools/view-registry.ts defines their views and policies and tools/renderers.ts derives terminal adapters with shared identities for provider aliases.
  • CustomTool.view lets a tool authored as a custom tool describe its call and result cards as a ToolView, the member ToolDefinition.view already offered an extension, and both adapters forward it to the host.
  • The ask tool emits a host-agnostic HostNotification through ToolSession.notify instead of calling the terminal, and the running host installs its delivery through setToolNotifier; a host that cannot reach an operator outside its own window installs nothing and the capability reads as absent.
  • Source-path comments in modes/terminal/controllers/input-controller.ts, tools/render-utils.ts, utils/block-context.ts and utils/shell-snapshot.ts name the Rust modules they cite at their new paths under natives/. No user-visible behavior changes.
  • A commit whose changes all sit under a grouping directory named natives proposes the directory below it as the scope, the way crates, packages and tests already do, instead of proposing natives.
  • The set_cwd renderer drops name, renderArguments and renderPending: no host reads any of the three, and the tool-renderer contract declares none of them. No user-visible behavior changes.
  • showHookInput's inputOptions.mask is a boolean rather than the character to draw, so the host that paints the field owns the glyph and /secret add no longer names the terminal engine to ask for a hidden field; the masked prompt draws the same • it drew before.
  • The todo tool states where a closed task's completion strike has reached with todoStrikeSplit and writes no SGR escape itself: the terminal draws the struck run with the theme's strikethrough attribute, so a session with terminal attributes off receives the task text without the \x1b[9m bytes it cannot render, and the transcript card sweeps the strike exactly as it did before.
  • runCommitAgentSession reports its run through a CommitAgentReporter instead of writing to stdout itself, and commit/agentic/agent-render.ts is the only module that draws it, so the commit domain names neither the terminal engine nor chalk; veyyon commit prints the same thinking line, markdown, tool tree and totals it printed before.
  • The /collab QR block draws its own leading blank row instead of being presented behind a spacer, so the slash-command registry no longer imports the terminal engine; the transcript shows the same blank row above the code and above the too-narrow hint.
  • The compaction policy vocabulary (check outcomes, the bar a pass is measured against, the truncation edge budget, the prune cache window and idle flush, and the recovery band) lives in @veyyon/kernel/session/agent-session-compaction-policy rather than interleaved with shutdown timeouts and credential backoffs in agent-session.ts, with no behavior change.
  • resolveSlashCommand in slash-commands/helpers/parse resolves a parsed invocation against a command set, joining the first argument token back onto a namespaced plugin command name.
  • SingleResult.isolationFallback records the requested and actual isolation backends and the reason when an explicit mode was not honoured; isolationModeName in task/worktree states a backend's setting spelling.
  • TruncationMeta.totalLinesUnknown states that a read's scan stopped after the shown window, so the notice omits a total it does not have.
  • PLUGIN_MANIFEST_ENTRY_KEYS and PluginManifestEntryKey in extensibility/plugins/loader state the four manifest entry keys a plugin contributes through.
  • cli/stdout-drain exports awaitStdoutDrain and exitAfterStdoutDrain, the one way a non-interactive mode exits after its last frame is written.
Changed
  • Typing a line that does not name a builtin slash command no longer loads the builtin implementations: slash-commands/dispatch.ts answers that from the declarations and loads the handlers only once a name matches, taking the launch graph from 1,642 modules to 1,545 and the interactive input controller from 1,296 to 1,059. No command, argument or completion behavior changes.
  • The 1,806-line builtin handler object moved out of slash-commands/builtin-registry.ts into one module per command category (builtin-setup.ts, builtin-modes.ts, builtin-session.ts, builtin-context.ts, builtin-share.ts, builtin-workspace.ts, builtin-model.ts, builtin-info.ts), with the autocomplete builders in builtin-completions.ts and the category map in builtin-categories.ts; the registry assembles the eight maps and still exports every name it carried.
  • The 860 lines of raw settings migrations moved out of config/settings.ts into config/settings-migrations.ts, which also drops the theme-classifier, builtin-tool-name and compaction-strategy imports from the module most of the product reaches for a setting. No setting, default, order or migration behavior changes.
  • Model target selection moved out of session/agent-session.ts into session/agent-session-model-targets.ts: role resolution, a configured target's model, the compaction candidate list and its configured thinking efforts read only the settings, a model and the available list, so they are callable without a session. No selection, ordering or fallback behavior changes.
  • A running tool card animates one mark: the "… (streaming)" spinner row is drawn only under a header that carries no running spinner of its own, and an agent an eval cell spawned shows the task card's static accent mark instead of a second spinner.
  • The read and write cards parse their arguments and details through @veyyon/utils/fs-tool-args, so a terminal launch no longer evaluates @veyyon/tool-render; the cards draw the same rows.
  • The legacy memories.enabled key is no longer a declared or host-defaulted setting: a config that still holds it migrates to memory.backend on load, the key is dropped on the next rewrite, and the local memory pipeline is enabled by memory.backend: local only. The presentation module's error messages, read-target parsing and cursor clamping use the @veyyon/utils helpers; no behavior change.
  • Reworded the Include Model in Prompt, Max Retry Delay, Hindsight Bank ID, Subagents and Subagent Delegation setting descriptions shown in /settings.
  • The HTML export attaches sub-sessions, redacts and writes the file through one finishExport for the session-manager and file entry points, a stage-1 memory job is completed under its ownership token through one completeOwnedStage1Job for the with-output and no-output paths and the global phase-2 claim reads its row through one readGlobalJobRow, the JavaScript eval cell builds its success, cancelled and failed results through one finish, the GitHub commit watch reports each poll and its grace and confirm notes through one reportWatching, and a capability scope splits (, [ and { groups through one keyed depth table so a closer of another kind never ends the open group; no behavior change.
  • The token-rate helpers are presentation/token-rate.ts, moved from modes/components/status-line/token-rate.ts without a forwarding module, and the status view-model is presentation/status-producer.ts with no presentation/status-builder.ts beside it; the search card limits are exported from tools/search/search-card-limits.ts only, and callMeta and readyPendingSummary from tools/shell/launch-view.ts only.
  • The propose-commit and split-commit tools state the summary and detail limits in their verdict through one verdictWithLimits, Enter and Ctrl+Enter run a builtin slash command and recall the line as typed through one #consumeBuiltinSlashCommand, and a read records its hashline snapshot through one recordFullHashlineContext and renders an over-long first line through one oversizedFirstLineText on the ranged and whole-file paths; no behavior change.
  • Tool-argument repair parses a stringified payload and a parse-sentinel payload through one repairJsonObjectArguments, the launch path resolves the prewalk strong, prewalk cheap and plan-yolo models through one resolveLaunchModel, --resume relocates a session whose recorded directory is gone through one block for local and cross-project matches, and the vault key scans staging entries through one bounded stagedKeyEntries for orphan recovery and crash-stage cleanup; no behavior change.
  • The models-config schema rejects an empty id, name, baseUrl, apiKey, contextPromotionTarget or compactionModel through one narrow helper, the URL fetcher assembles every render result through one buildRenderResult, the patch mode resolves a space-separated outer inner context through one resolveInnerAfterOuter, and the clipboard reads images and text from Windows through one runPowerShell bridge; no behavior change.
  • The plugin manager runs every bun install, bun update, bun uninstall and dry-run through one #runBun, the marketplace manager resolves where a plugin is installed and which scope a verb applies to through one lookup and one #scopeFor, the microphone recorder and its streaming twin walk the detected recorders through one fallback loop, the ZIP64 locator and end-of-central-directory record are parsed by one reader for the in-memory and ranged paths, and head and tail truncation build their single-line results through one helper each; no behavior change.
  • The profile bootstrap reads --profile and --alias through one flag reader, the vault's Linux and macOS atomic exchange share one rollback builder, the eval tool builds its cancelled, failed and completed results through one finishCell, and the lexical bracket scanner opens quote modes from one table; no behavior change.
  • ToolExecutionComponent rebuilds its block through one #syncBlock whenever the spinner frame, the expansion or the freeze changes, including when the spinner starts and stops, so a card that reads context.frame in its view (the vibe composer caret) blinks from its first paint and holds still once stopped.
  • The terminal tool card keeps four behaviors the producer split had dropped: a settled streaming diff preview is drawn without waiting for the next spinner tick, a live-widget call that never ran (ask) falls back to its label, a background task result finalizes its block while the job runs, and the write card coerces non-string content to text; EventController.attachTo seeds the projection engine from the engine's own message source.
  • DapSessionManager.launch and attach share one start sequence, and each breakpoint kind (source, function, instruction, data) replaces its list through one helper for both set and remove; no behavior change.
  • CustomEditor dispatches its twenty app-level shortcuts through one ordered table with the same precedence, deferral during early startup, bash-background fall-through and retry-yields-to-extension rules; no behavior change.
  • Every ModalShell host (tree, session, settings, model hub and model picker selectors, the agent dashboard and transcript viewer, the plan review, login, ask and MCP wizard dialogs, the extension dashboard) routes its close glyph, outside click, breadcrumb and footer chips through one routeModalChrome prelude instead of a hand-typed hitTestModalChrome sequence; no behavior change.
  • Goal and vibe mode context reach the model through one delivery step that keeps the hidden display, the agent attribution and the requested channel; plan-mode context is unchanged.
  • The /btw and /omfg panels settle every outcome (complete, saved, rejected, aborted, error) through one step per panel that clears a previous error and ignores a dismissed panel; the painted rows are unchanged.
  • The reftable ref readers answer null for a missing ref and rethrow an abort through one read-only git query, and the github ops raise the same "unavailable" ToolError for a missing repository root, primary root, branch or head through one check; no behavior change.
  • The legacy extension resolver's six promise caches (package root, manifest, bare dependency, native addon, addon-require scan, realpath) share one memoizer and one importer-scoped key; each result is cached once per key, as before.
  • veyyon setup speech picks the speech-to-text and text-to-speech models through one step that persists only a value the setting declares and flushes it before the next pick; no behavior change.
  • The SearXNG endpoint, token and Basic-auth readers share one settings-then-environment lookup, with an empty endpoint or token still read as unset, and the tool result builder records match, result and head limits through one setter; no behavior change.
  • ACP session/resume opens a stored session through the same step as session/load (same cwd check, same MCP configuration, same not-found error) without replaying history, and the symbolPreset and colorBlindMode settings apply to the theme through one signal hook that logs a fallback or a failed setter under the setting's name; no behavior change.
  • Single-range and multi-range read clip long lines to tools.outputMaxColumns through one display-only clipper that records each clipped line, including a block-context line outside the window, out of the seen-lines record and reports the column cap once; no behavior change.
  • /btw, /tan and /omfg read their argument and clear the composer through one handler; the composer's locked and awaitingApproval flags enter and leave their modes through one step; an agent's extension sendMessage and sendUserMessage are tracked and error-logged through one step; the b, c and down-arrow empty-composer keys install through one listener; and the token_in, token_out, cache_read and cache_write status segments render through one counter; no behavior change.
  • Async job deliveries and in-flight deliveries filter by owner and suppression through one step; the projection engine's running and background-task marks toggle set membership through one step; and skill loading resolves authored and managed skill real paths through one helper, so one SKILL.md reached through two paths loads once without a collision warning; no behavior change.
  • RPC agent and session events pass one typed-set check; every streaming edit mode recovers its matcher paths and entries through one non-empty and one single-path step; and skill, rule, context-file, prompt-template, slash-command and custom-command discovery resolve their project and agent roots through one step; no behavior change.
  • Streamed text and thinking segments reveal through one generic step; both Gemini search request paths build their per-attempt body through one transform step; and the cmux tab's waitForSelector is waitFor; no behavior change.
  • The theme.dark and theme.light setting hooks republish their slot through one factory; the RPC host_tool_result and host_tool_update frames pass one guard parameterised on the frame type and payload key; and the Hindsight retainMode, recallBudget and scoping env and settings values are accepted through one listed-value picker; no behavior change.
  • Built-in model discovery selects its standard and special providers through one predicate (disabled set, configured discovery rows, provider filter) and resolves each provider's discovery endpoint through one lookup (runtime override, models.yml, catalog); the ! and % shortcuts present, stream into, settle and release their transcript block through one step with their own failure labels; no behavior change.
  • The agent executor reads a message's or event's content and usage through one field reader, and a symbol-preset or colour-blind change re-renders the committed theme through one ephemeral re-apply step; no behavior change.
  • The legacy pi-coding-agent read, bash, grep, find and ls tool definitions draw their call card through one step (title, then the call's own summary), with the same bytes as before; no behavior change.
  • Grouped read displays and path expansion share delimiter scanning while preserving escaped separators, glob braces and selector ranges.
  • Learn and Memory Edit result views share text projection while preserving titles, empty results and error formatting.
  • Collab and HTML tool previews build display data without serializing discarded transcript input.
  • Tab expansion imports @veyyon/utils/tab-width; no user-facing effect.
  • The speech-to-text, tiny-model and TTS worker clients share one request lifecycle (subprocess/worker-request-client) and one progress-event shape; a worker error or client shutdown settles every pending request the same way in all three, with no user-facing effect.
  • Collab link formatting and parsing (formatCollabLink, parseCollabLink, generateRoomId) are @veyyon/wire's, re-exported from collab/protocol; a link the host mints and the browser guest parses read one grammar, with no user-facing effect.
  • Claude plugin hooks, tools, skills, slash commands and MCP servers resolve their plugin roots through one pluginRootsFor step, and no loader can mutate the cached root warnings; no user-facing effect.
  • Terminal and presentation event handling share tool-argument correlation and retry traces, with stable block identities across streaming snapshots and session resets.
  • Standalone and adopted terminal drivers share transcript updates and composer bindings with unchanged read-card presentation.
  • Grouped read projections preserve per-call status, paths, previews and line numbers across serialization.
  • Live and rebuilt tool cards share single-card rendering while preserving renderer precedence, streamed arguments and failure notices.
  • Status-line usage fields use the shared presentation contract without changing rendered output.
  • Bash and job cards load shared presentation helpers without importing their execution modules.
  • Plugin discovery shares installed-registry validation and root collection without changing scope precedence or warnings.
  • Runtime initialization no longer waits for first-frame replay cache publication.
  • Eval bridge options share field declarations while preserving exported interfaces and runtime behavior.
  • Settings selectors share list initialization, model-picker attachment and inline updates without changing input routing or persistence.
  • Extension API instances no longer allocate unused flag maps and provider-registration arrays; flags and registrations remain in the shared session runtime.
  • MCP commands share argument parsing without changing terminal and CLI option policies or interpreting argument text as a second command.
  • DAP and LSP configuration discovery share source ordering, and Gemini and OpenCode share user-context loading, without changing precedence or warnings.
  • Editor keybinding matching shares default key sets while preserving remap isolation and fallback chords.
  • Autoresearch experiment tools share active-branch session resolution without changing errors or session selection.
  • Autoresearch session updates share optional-column assembly without changing stored values, omitted-field handling, or database errors.
  • Extension dashboard loading shares disable and shadow precedence across capability kinds without changing state or metadata.
  • settings-selector.ts writes its escape comparison as \x1b instead of a raw control byte. No user-visible behavior changes.
  • Output minimizer tool filters collapse repetitive line filtering, table formatting and subcommand routing into declarative specs with unchanged output behavior.
  • GitHub search operations in the web domain and vibe mode tools use shared parameterized dispatch tables; behavior is unchanged.
  • Terminal selector cards and command controllers share modal select delegation, mouse routing, subcommand dispatch, and markdown panel presentation without changing TUI behavior.
  • Settings selectors share model-chain summaries, heading rows, picker targeting and candidate deletion without changing display or persistence behavior.
  • Parity ledger schema validation, module specifier resolution, and workspace traversal logic are consolidated into shared script helpers without changing validation verdicts.
  • Custom and legacy hook messages use the agent-core type definitions without changing message conversion or public type signatures.
  • Filesystem reads and writes share range calculations, candidate probing and result assembly while preserving SQLite row-operation exports.
  • Terminal code cells and tool views share row splitting, truncation summaries and text sanitization without changing rendered output.
  • Image inspection, Mnemopi initialization and search-provider loading use AI subpath imports while preserving usage-provider and credential-ranking registration.
  • Launch and live status rows share configuration reads, and launch redraws avoid enumerating the settings schema.
  • Settings group reads reuse declaration-path membership without caching setting values.
  • Filesystem and goal previews load without their tool execution modules.
  • Task cards share row construction, nested traversal, finding normalization and yield labels without changing rendered output.
  • Web-search providers share credential resolution and HTTP error handling, and discovery providers share equivalent scanners without changing provider behavior.
  • Tool cards share hidden-count formatting and symbol presets share identical glyph definitions without changing rendered output.
  • Tool cards share error rows, metadata and empty-result construction without changing rendered output.
  • Python, Ruby and Julia kernels share runtime probing and subprocess initialization while preserving language-specific environment and execution behavior.
  • First-frame replay recordings are written asynchronously so filesystem operations do not block editor input.
  • Launch status rendering reuses repository discovery when reading branch and worktree metadata.
  • Launch layout measures the fixed-height status footline without rendering it.
  • Every setting in every domain states what it does and what each value selects in one to three sentences, with no design history or internal vocabulary; the idle timeout row is labelled "Park Idle Agents After", the Park and Prune groups are one "Idle Agents" group, the artifact rows are "Artifact Threshold", "Artifact Head Size" and "Artifact Tail Size" with the unit on their options, and the MCP debounce row is "MCP Notification Delay".
  • AgentRegistry.setStatus consults AGENT_TRANSITIONS and throws AgentTransitionError for a status move the lifecycle does not perform, so a turn event that arrives after a kill or a park no longer revives the agent; a collab guest mirrors the host's roster through mirrorStatus.
  • An agent adopted at hand-over, revived from disk or listed from a previous run receives its idle and prune budgets through one builder, so a zero quiet budget disables pruning and a waiting budget is never shorter than the quiet one on every path; no behaviour changes on the paths that already agreed.
  • A retired agent.* setting is retired in one place: rejectedAgentModelSettings sweeps the keys the schema itself marks retiredBy instead of a second hardcoded list, and a retired key with no page hint is reported against the replacement the schema declares rather than being named as undefined; agentsEnabled is the one predicate for whether agents exist, replacing the delegationEnabled alias that returned it unchanged. No setting changes what it does.
  • Interactive chat and the transcript viewer use one replay implementation without changing displayed content or live-tool lifecycle.
  • Transcript rebuilds and live updates share tool-text projection without changing displayed content.
  • Settings group types derive from the settings schema while preserving their existing optional fields and value types.
  • JSON tree projections share bounded traversal, and code and Markdown cells share output assembly, with unchanged rendering.
  • Plugin discovery, import rewriting, MCP configuration toggles, Exa responses, secret-preserving text transforms, todo state cloning and projection, and session-file discovery use shared implementations without behavioral changes.
  • Tool views share progress rows, diff statistics, disclosure metadata, and task separators without changing rendered output.
  • Extension kind labels use a shared function without changing list or sidebar text.
  • Handbook HTML and search assets are generated during documentation and website builds instead of being tracked in Git.
  • Startup reads setting-change signals and terminal formatting without constructing the settings store or unrelated tool modules.
  • The terminal host constructs autoresearch screens and styled slash-command reports; headless command execution no longer imports those terminal components.
  • Subagent statistics and output sanitization are shared across the task tool's view and dashboard through host-independent presentation helpers in task/agent-stats.ts without terminal imports. No user-visible behavior changes.
  • Account inventory formatting no longer imports terminal progress-bar or theme helpers; displayed values are unchanged.
  • Terminal mode initialization overlaps session discovery instead of loading during sequential runtime warmup.
  • Interactive startup begins background model discovery after terminal initialization.
  • Model registry initialization defers unused provider records until lookup or enumeration while preserving runtime provider updates and model overrides.
  • Startup reads provider caches without constructing unrelated discovery options or their bundled reference maps.
  • Model discovery snapshots from earlier host-classification rules rebuild before model selection.
  • Resolved model snapshots no longer duplicate the bundled catalog; model selection and provider overrides are unchanged.
  • Resolved model snapshots use shared byte-integrity checks and atomic replacement without durability flushes; obsolete snapshots rebuild before model selection.
  • Startup imports AI streaming helpers and usage registration without evaluating the AI package barrel; usage providers and credential ranking remain available.
  • Evaluator implementations load on the first enabled request instead of session or tool construction, and loaded runtimes register their own process-exit cleanup.
  • URL reader initialization is deferred until an enabled URL read or search; local tools and transcript previews no longer initialize it.
  • Vibe tools load on /vibe activation rather than during startup, and failed loading preserves the session toolset.
  • The settings schema registry is @veyyon/kernel/settings/schema and config/optional-number is @veyyon/kernel/settings/optional-number; config/settings-schema composes the domain tables through declareSettings and still exports the queries (getDefault, getType, getUi, hasUi, getPathsForTab, retiredBy, isSettingPath, getEnumValues, isUnsetNumberPath, describeSettingTypeMismatch), the SettingPath and SettingValue types, SETTINGS_SCHEMA, the tab metadata and the typed groups, so importing a query loads the tables it reads. No setting, default or config file changes.
  • Settings (config/settings) extends SettingsStore from @veyyon/kernel/settings/store and passes the product's hook set (the global setting bindings, the SETTING_HOOKS table, the config migrations, the settings.json and agent.db legacy read, the changelog-marker seed and the per-directory resolution of enabledModels); config/settings re-exports the store's vocabulary and SettingSignal under the same names, so every import resolves. No setting, default, config file or write order changes.
  • Settings.getGroup delegates prefix path lookup to groupSettingPaths from the kernel store; model role dictionary normalization is consolidated across layer accessors.
  • The tool session, the terminal mode and the SDK read HostNotifier from @veyyon/host instead of @veyyon/utils/host-notification; behavior is unchanged.
  • session/messages.ts registers its message kinds on @veyyon/session's CustomAgentMessages rather than @veyyon/agent-core's; behavior is unchanged.
  • SessionManager, buildSessionContext, the session file loader and AgentStorage are @veyyon/kernel/session/*; session/messages.ts re-exports the custom-message payload helpers and the rehydration sanitiser from @veyyon/kernel/session/custom-message-payload under the same names. appendMessage accepts every AgentMessage but a branch or compaction summary, the set it accepted before. Behavior is unchanged.
  • BashExecutionMessage, PythonExecutionMessage, bashExecutionToText and pythonExecutionToText are @veyyon/coding-agent/tools/shell/execution-messages, declared on the shell domain's manifest as message kinds; session/messages.ts no longer exports them, and convertToLlm converts the two roles through the kind table the tool registry fills. formatGroupedDiagnosticMessages is tools/core/grouped-file-output, which lsp/utils re-exports. Behavior is unchanged.
  • The plugin loader, the plugin manager, the plugin settings dialog and the extensibility/plugins barrel read the manifest vocabulary from @veyyon/plugin; the barrel exports the same names. No user-visible behavior changes.
  • The website source is apps/site and the Python clients are clients/python, the directories that were website and python; the source-checkout veyyon launcher, the binary build scripts and the brand-parity checks read them there, and nothing they produce changes.
  • veyyon update on a source checkout regenerates the HTML export tool views from clients/web, the directory that was packages/collab-web, and the compiled binary reads the embedded stats dashboard from apps/stats, the directory that was packages/stats; the commands and their output are unchanged.
  • Typed tuple and Set copies use spreads rather than .concat() or .slice(), which those types do not define. No user-visible behavior changes.
  • web_search is constructed from tools/web/search rather than the retired web/search module. No user-visible behavior changes.
  • normalizeRoots takes one working-directory string. No user-visible behavior changes.
  • createCachedComponent lives in modes/terminal/draw/utils with the rest of the terminal drawing helpers, and the source map no longer lists src/web/ or src/swarm/ as top-level directories. No user-visible behavior changes.
  • Tests that lived under retired folder names (test/tui, test/capability, test/web, test/vibe, test/repair, and the other pre-cutover aliases) now sit next to the source they cover. No user-visible behavior changes.
  • ToolView cards that walk a JSON value read their bounds and scalar formatting from json-tree-view.ts rather than loading the terminal walker that draws tree-rail glyphs. No user-visible behavior changes.
  • The terminal's ToolView drawer names every kind the contract declares, so a kind added to the union fails the type check instead of drawing as a one-line text row. No user-visible behavior changes.
  • Session persistence, plugin loading and generic contribution registration use @veyyon/kernel; the turn loop, prompt rendering and tool-specific extensibility remain in the coding-agent package.
  • Terminal drawing of a ToolView lives in src/modes/terminal/draw/, and web search lives in src/tools/web/search/. Subpath imports previously resolved through @veyyon/coding-agent/tui and @veyyon/coding-agent/web/search now name those directories. No user-visible behavior changes.
  • Every tool module is grouped by domain under src/tools/<domain>/, each domain importing only core/ and itself, so the dispatch table no longer sits above 139 flat modules. No user-visible behavior changes.
  • Source-path comments and the gallery search fixture name the terminal renderer at its new path, hosts/terminal/engine, and a new architecture gate records every module outside src/modes/terminal/ that still imports it. No user-visible behavior changes.
  • A source-checkout update runs the native-addon ensure step in natives/bridge/bindings, the bindings package's path after it moved out of packages/.
  • Sixteen tool modules keep their terminal drawing in a <tool>-render.ts sibling — ask, ast-edit, bash, debug, fetch, file-search, job, launch, read, resolve, search-tool-bm25, ssh, structure-search, text-search, todo and write — completing the convention eight tools already followed, and tools/json-tree.ts is tools/json-tree-render.ts. Twenty-four of the twenty-six modules under tools/ that name @veyyon/tui are render siblings, print mode no longer loads the renderer through the todo tool, and subpath imports of the moved renderers follow the new layout. No user-visible behavior changes.
  • All five autoresearch experiment tools — init_experiment, update_notes, certify_arms, log_experiment and run_experiment — describe their call and result cards as a ToolView instead of building terminal Text, so none of them imports @veyyon/tui; the terminal draws the same bytes it drew before, including run_experiment's collapsed five-line output preview and its expanded full output.
  • ToolDefinition.view renderers receive a ToolViewContext stating whether the card is expanded, so a tool can shorten its collapsed output without asking a host what it is.
  • The goal tool describes its call row and result panel as a ToolView instead of constructing terminal components; panel and error formatting are unchanged.
  • The report_finding tool describes its call row and its result row as a ToolView instead of building terminal Text, so it no longer imports @veyyon/tui; the terminal draws the same priority mark, tone and truncation bounds it drew before.
  • The set_cwd tool describes its call row and its result frame as a ToolView instead of building terminal components in a set-cwd-render.ts sibling, which is deleted; the terminal frames the same header, rule counts and no-op wording, and the call row loses the blank row above and below it that Text's default padding added, drawing in the column every other tool's call row draws in.
  • The retain, recall and reflect tools describe their cards as a ToolView instead of building terminal components in a memory-render.ts sibling, which is deleted; the terminal draws the same rows, memory bullets, preview caps and expand hints, and a memory cut to a terminal narrower than the eight-column floor the sibling clamped to now ends in an ellipsis inside its own colour instead of a hard cut mid-escape.
  • The read_url tool describes its call row and its result card as a ToolView instead of building terminal components in a fetch-render.ts sibling, which is deleted; the terminal draws the same panel, metadata rows, preview caps, truncation notice and OSC 8 links, and the line stating how many preview lines were held back now draws in the dim its expand hint already used instead of a lighter muted.
  • The resolve tool describes its call row and its result plate as a ToolView instead of building terminal components in a resolve-render.ts sibling, which is deleted; the terminal fills the same plate in the same colour for an accepted, failed and discarded resolution, and the renderer's inline flag goes with it, since the only reader was the gallery CLI.
  • The debug tool describes its call row and its result panel as a ToolView instead of building terminal components in a debug-render.ts sibling, which is deleted; the panel draws the same session lines, output preview and truncation note, the header states the action after the tool name instead of concatenating both untoned, and the line stating how many preview lines were held back draws in the dim its expand hint already used instead of a lighter muted.
  • The ssh tool renders through a host-agnostic ToolView instead of an ssh-render.ts sibling, and a command or output longer than the viewport is windowed by the rows it occupies after wrapping instead of by its line count.
  • The todo tool describes its call row, its board and its finished line as a ToolView instead of building terminal components in a todo-render.ts sibling, which is deleted; the card draws the same rows, phase names, task marks, completion sweep and one-line summary it drew before, a task's mark and its words carry the tone as two runs instead of one, and a task whose status this build has no case for is drawn as open work rather than reaching the terminal with no colour to resolve.
  • The inspect_image tool describes its call row, its answer panel and its failure card as a ToolView instead of building terminal components in an inspect-image-renderer.ts sibling, which is deleted; the card draws the same question line, four-line collapsed and sixteen-line expanded answer windows, held-back note and sanitised failure text, the settled panel states the outcome on its rail instead of taking the muted legacy edge, and the model and media type ride on the header row rather than a second row beneath it.
  • The search_tool_bm25 tool describes its call row and its match list as a ToolView instead of building terminal components in a search-tool-bm25-render.ts sibling, which is deleted; the card states the same status line, five collapsed matches, label and description truncation bounds and fallback warning, the matches are a list the terminal marks and indents rather than rows carrying their own bullet and dot separators, and the held-back count closes the list with the expand gesture left to the host.
  • ast_edit uses ToolView cards with host-managed expand hints; change content and error formatting are unchanged.
  • The irc tool renders through a host-agnostic ToolView instead of an irc-render.ts sibling, a message states its direction in words (IRC to AuthLoader) rather than an arrow, and createIrcMessageCard and ircToolRenderer are no longer exported from the package root.
  • The write tool renders through a host-agnostic ToolView instead of a write-render.ts sibling, the line-number gutter is three columns wide through a 999-line file instead of widening at each power of ten, and a partial result no longer leaves two blank rows between its progress line and the file.
  • The file_search tool renders through a host-agnostic ToolView instead of a file-search-render.ts sibling, and a path too long for the frame is cut to the frame's width instead of wrapping onto a second row.
  • The text_search tool renders through a host-agnostic ToolView instead of a text-search-render.ts sibling, and the rows of a card with no matches indent two columns under their header instead of starting in column zero.
  • The structure_search tool renders through a host-agnostic ToolView instead of a structure-search-render.ts sibling, and a match group is held whole or dropped rather than cut at the row the budget ran out on.
  • The launch tool renders through a host-agnostic ToolView instead of a launch-render.ts sibling, and each captured terminal row is cut to one row with an ellipsis instead of wrapping onto a second.
  • The search tool describes its dispatching card as a ToolView instead of building terminal components in a search-renderer.ts sibling, which is deleted; a call reaches the same file, text or structure card it reached before, whether its type comes from the call or from the result's details, and the row for a call whose type is still arriving, the row naming a type that is not one of the three and the row for a failure that named no type draw in the column every other tool's row draws in instead of one column past it.
  • The github tool renders through a host-agnostic ToolView instead of a gh-renderer.ts sibling, each failed job's held-back log count closes that job's own log rows instead of sitting under the last job in the group, and one held-back log line reads as 1 more log line.
  • The browser tool renders through a host-agnostic ToolView instead of a render.ts sibling, a spawned browser's binary path is shortened against the home directory, and a rebuilt transcript holding a result without its call states no section for the script it does not have.
  • The read tool renders through a host-agnostic ToolView instead of a read-render.ts sibling, the file is the row's description so the row reads Read: src/example.ts, and the line-number gutter is a constant three columns instead of widening at the 10, 100 and 1000-line crossings.
  • The ask tool renders through a host-agnostic ToolView instead of an ask-render.ts sibling, and an option label keeps the emphasis its author wrote through an inline-Markdown run instead of the tool colouring it.
  • The web_search tool renders through a host-agnostic ToolView instead of a render.ts sibling, and veyyon q's answer cap counts the answer's own lines rather than the rows a terminal wrapped them into.
  • The five vibe tools render through a host-agnostic ToolView instead of a vibe-render.ts sibling, and the composer's caret blinks only on a surface that repaints and never on a message already delivered.
  • The job tool renders through a host-agnostic ToolView instead of a job-render.ts sibling, and a collapsed card closes with one held-back note instead of a count on the closing branch of each tree it cut.
  • The eval tool renders through a host-agnostic ToolView instead of an eval-render.ts sibling, a call is one card whose cells are labelled groups instead of one railed box per cell, and output that rewrote its row with a carriage return shows the row's last text instead of every draft of it.
  • The lsp tool renders through a host-agnostic ToolView instead of a render.ts sibling, a diagnostic is one row of location, severity and message, and references are one row per location instead of a per-file tree two levels deep.
  • The bash tool renders through a host-agnostic ToolView instead of a bash-render.ts sibling, and a sentence shaped like one of the tool's truncation, exit, wall-time, background or artifact notices that the program itself printed now survives instead of being deleted.
  • The edit tool renders through a host-agnostic ToolView instead of an edit/renderer.ts sibling, an edit spanning several files is one card whose sections are the files instead of one card per file, and the change counts are stated at the end of the row instead of a ⟦+3/-1⟧ suffix in the tool's name.
  • The task tool renders through a host-agnostic ToolView instead of a task/render.ts sibling, a call whose result has arrived stops repeating the brief and the agent list, and the live output under an agent is bounded to six rows instead of measured against the terminal's height.
  • formatContextUsage is stated once in @veyyon/utils, which the status-line gauge, the subagent progress row and an eval cell's subagent tree all read, so a tool no longer imports a terminal module to format a token count. No user-visible behavior changes.
  • Tool cards and late diagnostic messages share diagnostic parsing, severity ranking and structured rendering, with home-directory paths shortened in late diagnostic output.
  • formatSessionSnapshot is stated once in debug/session-snapshot.ts for both halves of the debug tool. No user-visible behavior changes.
  • A subprocess tool handler declares renderFinal alone: renderInline had one producer and two readers that both skipped it by name, so nothing it returned ever reached a screen. No user-visible behavior changes.
  • A custom tool's renderCall and renderResult return HostView instead of a @veyyon/tui Component, so the published tool-plugin contract no longer makes every tool plugin a terminal plugin; a renderer that returns a Component still satisfies it unchanged. No user-visible behavior changes.
  • An extension's MessageRenderer and AssistantThinkingRenderer and a hook's HookMessageRenderer return HostView instead of a @veyyon/tui Component. No user-visible behavior changes.
  • The autoresearch setup console and init_experiment clamp breadth and attempts through clamp/clampLow from @veyyon/utils/math instead of local copies of the same arithmetic. No user-visible behavior changes.
  • Time-Traveling Stream Rules, the todo board and thinking-effort resolution are session collaborators under src/session/runtime/, each owning its own state behind a host interface it declares (8, 13 and 12 names), instead of 22 fields spread across AgentSession, which drops from 19761 to 18356 lines. No user-visible behavior changes.
  • #processAgentEvent records the turn's last assistant message once, in its synchronous prologue, instead of twice in the same synchronous stretch. No user-visible behavior changes.
  • The hidden nudge vocabulary is session/nudges.ts alone: the customType names the session injects, the continuation cap, the plan-mode reminder budget, the plan-decision and prewalk trigger tables and the mid-run todo nudge gates, with HIDDEN_MESSAGE_TYPES naming the set. agent-session-message-shapes.ts reads message shapes and declares no type name, and runtime/todo-runtime.ts keeps no copy of the nudge thresholds. No user-visible behavior changes.
  • Source-path comments in prompts/all-registries.ts, prompts/eval-overrides.ts and tools/reroot-hint.ts name the benchmark modules they cite at their new paths under tests/evals/; behavior is unchanged.
  • Imports of the string, escape, keyboard, mouse and motion primitives name @veyyon/utils instead of @veyyon/tui, which no longer re-exports them. No user-visible behavior changes.
  • No file under session/ names the terminal renderer: the session id comes from @veyyon/utils/ttyid and image visibility from the front end's probe, so @veyyon/tui is no longer loaded on the conversation engine's account. No user-visible behavior changes.
  • Source directories are consolidated: memory (memories, memory-backend, mnemopi, hindsight), discovery (tool-discovery, capability), speech (tts, stt) and debugging (dap) each live under one directory, and seventeen single-module directories fold into the concern they belong to. Subpath imports of @veyyon/coding-agent follow the new layout. No user-visible behavior changes.
  • The terminal component tree is grouped by concern: the 94 modules that sat flat in src/modes/terminal/components/ now live under transcript/, composer/, selectors/, dialogs/, chrome/, dashboard/ and account/. Subpath imports of @veyyon/coding-agent/modes/terminal/components/* follow the new layout. No user-visible behavior changes.
  • The interactive terminal lives under src/modes/terminal/, and the modes that draw no terminal — print-mode.ts, rpc/, acp/ and the magic-keyword parsing in keywords/ — sit beside it rather than inside it. The palette moves to src/theme/ and extension state aggregation to src/extensibility/extension-state/, both of which a headless run reads. Subpath imports of @veyyon/coding-agent/modes/* and @veyyon/coding-agent/theme/* follow the new layout. No user-visible behavior changes.
  • Goal mode, the working line and push-to-talk are their own modules under src/modes/terminal/controllers/ instead of living inline in the interactive mode, which drops from 5605 to 4495 lines. No user-visible behavior changes.
  • The session runtime's module-level declarations move out of src/session/agent-session.ts into six siblings — agent-session-types.ts, agent-session-permissions.ts, agent-session-queue.ts, agent-session-retry-fallback.ts, agent-session-compaction-policy.ts and agent-session-message-shapes.ts — so importing the session event union or config record no longer pulls in the 20909-line runtime, which drops to 19704 lines. Subpath imports of @veyyon/coding-agent/session/agent-session follow the new layout; the package root barrel still exports every moved name. No user-visible behavior changes.
  • The session factory's free declarations move out of src/sdk.ts into six siblings under src/session/ — factory-options.ts, factory-extensions.ts, factory-prompt.ts, factory-tools.ts, factory-mcp.ts and factory-notices.ts — so naming CreateAgentSessionOptions or calling a discovery helper no longer imports the composition root, which drops from 4861 to 3832 lines. Subpath imports of @veyyon/coding-agent/sdk follow the new layout; the package root barrel still exports every moved name. No user-visible behavior changes.
  • Multi-target ast_grep searches now execute concurrently while preserving globally ordered paging, totals, parse errors, cancellation, and target-order failures.
  • The vibe screens, the image-inspection call and an LSP hover code block draw no border of their own inside a tool block, so a block keeps one left edge; a tree connector remains only where a row belongs to the row above it, in the eval value tree, the grep line gutter, the job tree and the LSP reference tree.
  • The legacy Pi bundled-module generator states which package roots a compatibility shim serves, so the compiled-mode override sweep derives that set instead of carrying its own copy; behavior is unchanged.
  • The /agents dashboard uses a centered, bordered card with bracketed tabs and explicit agent status words.
  • The status row reads its truncation limits from tools/core/render-limits, a leaf that imports nothing, rather than tools/core/render-utils, which drops the tool renderers, path helpers and image resizing from the launch card's import graph; first-frame time is unchanged, because those modules only declare functions.
  • An MCP tool describes its call and result cards as a ToolView instead of building terminal components in mcp/render.ts, which is deleted; the terminal states the same arguments, structure walk, raw rows, held-back count and spill warning, indented two columns under the row that heads them and without the branch glyph the call row opened with.
  • SETTING_KIND_HANDLERS is typed per setting kind, so each handler receives the definition variant its key selects instead of the whole union widened to any. No user-visible behavior changes.
  • Subagent drive paths share abort-aware promise handling with unchanged cancellation behavior.
  • Hook and user-message selectors share search editing without per-keystroke callback or query-array allocations.
Fixed
  • Fixed the daemon broker client and broker startup exiting 0 silently mid-read: Bun.file().text()/.json() does not ref the event loop, so a process that reached the token, lease, presence, or metadata read with nothing else pending could drain and exit before the read settled; the reads now use fs.readFile.
  • A pasted OAuth callback typed after a slash command that takes no arguments is consumed instead of being sent to the model as a prompt.
  • Automatic maintenance cuts an oversized body until a summarization request fits a summarizer, instead of parking the session with "Compaction freed too little context to make progress" when every candidate was skipped for holding fewer tokens than the summary needed.
  • Print, JSON and RPC mode flush Bun's stdout sink before exiting, so a piped consumer receives the whole last frame instead of losing up to 1 MiB of queued output.
  • A spawned agent's card shows its resolved-model badge again on the live block, the registry path an extension wraps and the rebuilt transcript, per agent.showResolvedModelBadge.
  • With VEYYON_FORCE_IMAGE_PROTOCOL=sixel and VEYYON_ALLOW_SIXEL_PASSTHROUGH=1, a bash card draws an inline Sixel image row as the program wrote it instead of blanking it.
  • The extension graph walk reads each module file from disk once; the CommonJS check on a candidate reuses the walk's read instead of opening the file again.
  • veyyon --help summarises worktree with the profile-scoped path ~/.veyyon/profiles/<name>/wt, matching the command's own description.
  • Legacy hindsight.dynamicBankId and hindsight.agentName written as flat keys migrate to hindsight.scoping and hindsight.bankId and are dropped on rewrite instead of surviving as dead entries.
  • Antigravity turns from a consumer Google account (aicode-consumers) no longer fail with 429 RESOURCE_EXHAUSTED on every request: the backend rejects any system instruction carrying the upstream oh-my-pi conventions header, so the preamble now opens Keywords follow RFC 2119: instead of RFC 2119:.
  • A Gemini or Antigravity 429 whose body is Google's generic Resource has been exhausted (e.g. check quota) / RESOURCE_EXHAUSTED is a per-minute throttle and retries on the same account after 45–75 seconds instead of being read as a 30-minute daily quota that exceeded retry.maxDelayMs and ended the turn; the "exhausted your capacity … quota will reset" body still reads as the daily wall.
  • Removing the retired providers.parallelFetch key no longer leaves an empty providers: section in the rewritten config.
  • A nested legacy task.isolation.enabled no longer overrides an explicit task.isolation.mode during migration.
  • Corrected comments that named a distribution channel or runtime API the project does not use; no behavior change.
  • A subagent that inherits the session's model shows that model and effort in its Subagents row, the task widget and the /agents roster, and keeps the badge when a follow-up turn wakes it.
  • An inherited subagent model's badge prints the effort the session settled on, so a parent running auto shows the resolved level rather than auto.
  • A subagent's row label is generated with the session's live model when no tiny, commit or smol role is configured, as a session title is, instead of the persisted default role.
  • A compaction candidate whose single-request summary timed out and was completed in stages starts the next compaction on that model staged, instead of waiting out the same timeout first.
  • Command-mode detection recognizes shell and Python prefixes after Unicode leading whitespace in loaded drafts.
  • An MCP server that repeats a pagination cursor or never ends its pages no longer hangs resources/list, resources/templates/list or prompts/list; every list method ends with a warning and the pages collected so far, as tools/list already did.
  • Tool result cards preserve raw-string and multipart text, including MCP output and grouped read previews, while runtime result cards select eval or launch from their call arguments.
  • Collab reconnect snapshots preserve completed tool result text and display metadata across current and historical tool-call record formats.
  • HTML export preserves provider fallback transitions and redacts their model text in primary and nested transcripts.
  • Empty job results render their success or error message for every registered job alias.
  • The website model catalog refreshes from its relocated repository path before using the deployed copy.
  • Release validation checks native sentinels under every discovered workspace root, and shortened release notes link to the complete tagged changelog.
  • Terminal input delivery continues to later subscribers when an earlier subscriber throws.
  • Tool cards retain wire-provided results during expansion and sealing, and restore expanded output when subsequent updates contain raw results.
  • Clearing or replacing presentation rows stops detached animations, preserves completed-call history, and keeps subsequent reads visible.
  • Stopping a terminal presentation driver releases card animation clocks even when its engine is not running.
  • Extension discovery resolves installed plugins from the session's selected profile.
  • Python composer borders retain their mode color when an agent view is focused.
  • Completed and rebuilt tool cards retain their call arguments and rendered call details.
  • Disposing a tool card stops its animation clocks and detaches its presentation subscription.
  • Legacy tool result renderers receive the completed call arguments for partial and final results.
  • Background provider usage refreshes repaint the status line without requiring further input.
  • Tool cards retain both call and result renderer failure notices with their fallback output.
  • The library entry point retains read-selector functions, write-preview helpers, filesystem-source extraction and the goal view after renderer separation.
  • An auto-compaction pass that finds nothing to summarize warns about a compaction dead end only while the context is still over the recovery band, so a pass that runs after maintenance already freed the context no longer advises starting a fresh session.
  • The MCP add wizard retains manually entered credentials for stdio, HTTP and SSE servers and opens OAuth settings after authentication errors.
  • Retry and Edit OAuth settings accept pointer input immediately after OAuth failure or cancellation in the MCP add wizard.
  • Kernel codec and shutdown defaults remain active when optional configuration fields are undefined.
  • Startup frame capture stops retaining terminal output after typing, recording settlement, or frame release.
  • Disabled launch status rows remain blank when the terminal is narrower than the composer inset.
  • veyyon licenses reads the Open Sans and Source Code Pro notices from the tracked docs/handbook/fonts/ copies instead of the ignored mdbook build output, so the bundle regenerates and its test passes on a checkout without a handbook build.
  • A compaction that had just freed context no longer reports "Compaction freed too little context to make progress" when its entry is written in the same millisecond as the kept assistant turn; whether a turn predates the latest compaction is read from its position on the branch, not its timestamp.
  • The home anchor sizes its fills, the welcome hero mounts, and the per-frame sizing pass runs on the screen the interactive mode renders on rather than the one its constructor built, and startup.quiet is read from the session's settings like the other startup reads.
  • An agent whose session is on screen is no longer parked under it: opening an agent pins it for as long as the main view points at it, a park deadline that elapses meanwhile is deferred, and the idle TTL counts again from the return to the main session.
  • The task card lifts the missing-yield warning out of an agent's output under both its current spelling, SYSTEM WARNING: Agent exited without calling yield tool, and the Subagent spelling a session file recorded before it; the task:subagent:progress and task:subagent:lifecycle bus channels a collab guest matches on keep their spelling.
  • Custom tools retain their declared call and result views when converted into extension tool definitions.
  • Terminal tool cards shorten home-directory paths and replace tabs in metadata, notices, code, diffs, and generic argument previews before width fitting.
  • Failed task results without agent details retain error text styling.
  • Launch model context estimates exclude project context and clamp the remaining percentage to zero.
  • Launched processes report completion even when they exit before the completion watch registers.
  • Autoresearch best-result and confidence calculations exclude unmeasured placeholder zeros while retaining measured zero values.
  • Configured shortcuts apply from the first editable frame, and model-selector shortcuts entered during startup preserve the draft through initialization.
  • The launch composer repaints typed input before runtime initialization continues and preserves the mounted editor's change handler.
  • Ordinary CLI launches no longer evaluate ACP authentication, and startup applies the configured theme once.
  • Submissions entered during startup execute after initialization without waiting for a model turn, preserving later drafts and attachments through command handling and editor replacement.
  • The launch composer shows the same linked-worktree location and draft-token estimate as the mounted session, avoiding a late footline repaint.
  • bun run gen:tool-views in the coding-agent package uses the relocated clients/web generator.
  • A web_search refusal, missing-credential, or provider-failure result is marked isError, so the model sees the failure as a failure.
  • A tool result whose image-visibility notice is unchanged is memoized across turns instead of allocating a new wrapper each time.
  • edit and apply_patch share one renderer object again, so a host that groups by identity (streamed-arg keys, the first-result replay) treats them as the same card. No user-visible change.
  • A debug adapter command resolves against the debug working directory only when it is spelled as a relative path (./tool, ../tool), restoring the prefixes a mechanical path rewrite had widened to any leading dot.
  • An overflow whose summary cannot fit any model no longer waits on a restore that never runs: the dead-end rescue truncates the oversized message to an artifact and the turn is retried, which the overflow-refusal suite now pins.
  • A live tool card drawn from a ToolView spins again: a view is handed the frame it draws, so the spinner tick now rebuilds the card instead of only repainting it, and the streaming glyph on the browser, debug, eval, launch, ssh and vibe cards no longer sits frozen on the frame it was born with.
  • The debug, resolve, retain, recall and reflect renderer entries declare the inline policy they declared before their cards became views. The flag reaches no reader in the terminal today, so nothing on screen changes.
  • A tool card's header keeps the subject it states: the middle-cut the edit card needs was applied to every framed card, so ast_edit, file_search, text_search, structure_search, search_tool_bm25, inspect_image, launch and ssh cut a query, a glob or a path to … in a narrow terminal to keep counts that already fitted. A card now asks for the cut, and the edit card is the one that asks.
  • A live card whose tool describes a ToolView obeys the merge policy its renderer entry states: debug, resolve, retain, recall, reflect and ssh drew the call row above the result card while the call was on screen, and drew one card when the transcript was rebuilt.
  • veyyon config set and veyyon config reset create the profile's config directory before taking the file lock, so a first write into a profile that has no directory yet persists the setting instead of exiting 1 with ENOENT.
  • goal-tool.ts no longer imports a ViewSpan type it stopped using when the goal card became a view. No user-visible change.
  • A structure in a tool card stops at the nesting level its bound names: the view walk numbered a root key 0 where the terminal walk numbered it 1, so every task, eval and argument card showed one level deeper than the collapsed and expanded bounds allow.
  • A JSON structure in a tool card states 1 more line where one line of a long string is held back, instead of 1 more lines; the view walk wrote the phrase by hand where the terminal walk it replaced counted through the shared formatter.
  • The launch shell no longer evaluates the prompt registries: modes/keywords/{orchestrate,ultrathink,workflow}-keyword.ts kept imports of prompts/subagent/rows, prompts/turn-control/rows and the @veyyon/utils barrel after the notices they fed moved to magic-keyword-notices.ts, which pulled 62 extra modules into the first frame's import graph.
  • The subagent model resolver's own precedence list no longer points at a fifth case it lost when subagent.model became the shared-switch layer. No user-visible change.
  • HTML export works again: the five assets export/html/index.ts loads as strings — the markdown renderer, the template CSS, HTML and JS, and the generated tool views — lost their with { type: "text" } import attributes while unreleased, so each one loaded as a module and every export threw Missing 'default' export in module.
  • Seven published entry points the reorganization dropped are served again at their new paths: ./modes/terminal/components/*, ./modes/terminal/components/extensions/*, ./modes/terminal/components/status-line/*, ./modes/terminal/controllers/*, ./modes/terminal/setup-wizard/*, ./modes/terminal/utils/* and ./export/markit/*. Every subpath 1.3.0 published now has a successor key.
  • A source build of the compiled binary reaches the native addon package at natives/bridge/bindings, its path since the bindings moved out of packages/, instead of failing on a chdir to packages/natives.
  • Tools are offered in BUILTIN_TOOL_NAMES declaration order again: composing the registry from the five domain manifests reshuffled seven names, and tool order is prompt order, so every cached prompt prefix was invalidated for a session whose tool set had not changed.
  • The source launcher (scripts/veyyon, scripts/veyyon.cmd) finds the native addon at natives/bridge/bindings/native and provisions it through that package's ensure-native.ts, instead of dying at boot on packages/natives/scripts/ensure-native.ts after the bindings moved out of packages/.
  • The compiled binary builds again: its legacy-extension module surface resolved each bundled package by its directory name under packages/, so the build died on packages/natives/package.json once the bindings moved to natives/bridge/bindings and the terminal engine to hosts/terminal/engine. Each bundled package is now found by the name its manifest declares, wherever the member sits.
  • The compiled binary builds through its legacy-extension shims again: the @veyyon/ai and TypeBox compat shims were named by hand-written paths under packages/coding-agent/src/extensibility/, so the build reported two unresolvable entrypoints once both shims moved into @veyyon/kernel. Each shim is now resolved through its owning package's published subpath, at build time and at extension load.
  • The launch card states the context percentage recorded at the end of the last launch instead of ?, and falls back to ? when the release, the model or the project changed.
  • A debug adapter that exits during startup now reports its own stderr — pip install debugpy for a missing debugpy — instead of EPIPE: broken pipe, send.
  • A submission arriving in the tick after the terminal asks for input is no longer dropped, and loop mode's auto-submit timer no longer arms a tick late: the goal-mode exit check ran as an await on every turn, and an async guard that returns early still yields before the input callback is installed.
  • A run that draws nothing no longer tells the model its picture is on screen. -p, rpc and acp emit text, and the sentence attached to an image a tool returned was written from the launching terminal's graphics protocol, so the same read in a Kitty window reported the image as displayed to a pipe; the front end now states whether it draws, and a client that says nothing is taken at its word.
  • A debug launch whose interpreter refuses now reports the interpreter's own exit code and stderr instead of EPIPE: broken pipe or DAP adapter disposed: writing the first request onto an adapter that has just died fails at the pipe, and the pipe's error names nothing the user can fix.
  • An extension published against the old @veyyon/tui barrel loads again. Moving the width, key, mouse, motion, LaTeX, fuzzy and paint primitives to @veyyon/utils removed them from that barrel, so a plugin importing visibleWidth or Key from @earendil-works/pi-tui failed at import time and its whole extension went inactive; the bare tui package root now resolves to a compatibility surface carrying the renderer plus every module the barrel dropped.
  • A turn that stops right after a tool round gets its stop-time passes again: the assistant message the settle reads was recorded behind the persistence await, so a text-only stop dispatched in the same tick as a tool result settled as if it still carried tool calls, and the todo reconciliation never fired past its first reminder.
  • A model selector that names a provider and no model (openai/, openai/:high) is rejected where it is written instead of parsing to a model id of the empty string, which every caller then carried until a lookup failed somewhere else.
  • A read, write, grep or image target that reaches outside the working directory through a symlink asks for approval even when it carries a selector suffix, so link.env:1-10, db.sqlite:users:42 and archive.zip:dir/file.ts:5-9 are no longer auto-approved where the bare path would have prompted.
  • A tool status line shortens the paths it was given, so grep, glob, ast_grep, ast_edit, debug and set_cwd show ~/project/src instead of printing the home directory into the transcript, and a long path list is truncated rather than pushing the row past the terminal width.
  • Multi-target ast_grep searches across overlapping paths deduplicate matches so totals, file counts, and paged results are not duplicated or truncated.
  • grep reports why an archive could not be opened or read when the failure is not an Error, instead of the word undefined.
  • The advisor configuration overlay, the autoresearch dashboard overlay and the autoswarm setup console share one set of box chrome, one stat strip and one key legend, and each frame ends where its content ends instead of being padded to the height of the terminal.
  • The advisor overlay footer states the chord and the verb instead of repeating the advisor or model name already in the frame title.
  • The autoresearch dashboard overlay opens on alt+x; ctrl+shift+x never reached veyyon under kitty, whose kitty_mod default consumes that chord.
  • The autoresearch result table and summary no longer repeat the primary metric as a secondary column.
  • A crashed autoresearch run reports - for the metric instead of 0ms, which sorted it as the fastest run in the table.
  • A turn that calls a tool and then stops with text is treated as ending in text: the todo reminder fires again as the board changes instead of falling silent after the first one, and the rewind, plan-mode, verification and code-review checks run at that stop.
  • The goal report from /goal show and the goal detail menu states the goal's status once: a paused goal read Status: paused (paused), and a finished one Status: complete (paused). Goal mode being off is now named only where the status does not already carry it, as active (mode off).
  • A goal objective reaches every surface that shows it as one plain line: the /goal show report, the /goal menu title, the warning a disabled Goal Mode prints over a stored goal, the /goal autocomplete row and the goal tool's own card each formatted the objective raw, so an escape sequence in one styled or moved the rest of the surface, a tab opened a hole in it, and a newline split it across two fields.
  • veyyon profile new runs in the compiled binary; 1.4.1 failed with awaitPromise is not defined from a mis-minified dynamic import, and --smoke-test and the installer CI now drive the profile seed path through the artifact.
  • --export <path> of a missing or non-file session exits non-zero with Session file not found or Not a session file instead of writing an empty transcript and reporting success.
  • --mode json exits EXIT_FAILURE on an errored turn and EXIT_INTERRUPTED on an aborted one, as text mode does; print and RPC mode wait for stdout to drain before exiting so a piped consumer receives the last frame.
  • RPC mode answers a malformed stdin line with the documented parse error frame and keeps reading; the previous chunk parser threw on the first bad line and ended the session.
  • veyyon install with no target exits 2 as a usage error, the same as a missing positional in every other subcommand.
  • --help lists every --mode value from the parser's own table, acp included; the export example and the worktree description state the profile paths (~/.veyyon/profiles/<name>/…).
  • --no-extensions disables discovery only: a path named with -e on the command line still loads, in a session and in veyyon models, as the flag's help text states.
  • A --model @role whose role is unset, unknown or cyclic is reported as that role failure; a model id no model matches is reported with the count of models with usable credentials and the nearest candidates, instead of Model "x" not found. Run "veyyon models".
  • A plugin's slash command runs from /<plugin>:<name> and from /<plugin> <name>; the parser split the namespaced spelling at the colon, so an exact lookup never matched.
  • The goal tool is a read-tier tool: it prompted for approval in ask mode and was denied outright in plan mode, having no declared tier.
  • An explicit agent.isolation.mode the host cannot provide runs on the next backend, records isolationFallback on the result, opens the merge summary with a notification naming the requested and actual backends, and is logged; auto reports no fallback.
  • A spawned agent whose merge back into the parent tree does not land (a patch that does not apply, a branch that does not merge, a nested repository patch that fails) is reported as merge-failed instead of a clean completion whose work is not in the tree.
  • The task card's line and size counts describe the block the reader sees: when the child's output was empty and stderr or a placeholder stands in for it, the artifact's 0B no longer labels that text.
  • Claude Code's ~/.claude/plugins/installed_plugins.json is read only when discovery.importForeignConfig is on, and the plugin-roots cache is keyed on that setting; marketplace installs, --plugin-dir roots and a trusted project registry are the operator's own and load at the default, and their skills are part of the profile's skill set.
  • The read card states depth and limit by name after the path; read { path: ".", limit: 3 } drew .:1-3, a line range the tool never read, and the HTML export's call line did the same.
  • A ranged read of an immutable source (archive.zip:src/a.ts:2-3, artifact://x:2-3) numbers its lines whatever readLineNumbers is set to, so the requested lines are attributable.
  • A read of a file over the snapshot size cap states Showing lines A-B (file not scanned to end) and no of N: the scan stops once the window is collected, so N was a lower bound presented as the file's length.
  • The streaming bash preview reads the env object by walking the partial JSON, so "env" inside a command string is not an assignment list and a cwd or timeout after the object is not an entry.
  • No tool card text reaches the terminal with a control sequence in it: drawToolView strips escapes from every text field of every view kind, so a model-supplied reason, a file's contents or a generic argument carrying \x1b[2J or an OSC 8 link is drawn as text; a captured run keeps the styles the terminal replays and loses the rest.
  • A tool card whose renderer throws falls back to the generic arguments-and-output card, never to the exception's text; the vibe card reads a recorded session's details field by field, so a malformed record draws the generic card rather than failing the transcript.
  • The job card lists a queued job as queued, with its position, rather than as running.
  • A daemon the broker ran on a PTY that died to a signal reports that signal (SIGTERM, SIGKILL) instead of the shell's exit code 1; the addon recovers the signal from the wait status.
  • The launch broker's idle reaper stops last-client-exit daemons when the last client disconnects and a persistent sibling keeps the broker alive, and re-arms when that persistent daemon ends so the broker exits too.
  • A plugin whose package.json or .claude-plugin/plugin.json cannot be read or parsed costs that plugin and is reported through the operator channel and veyyon plugin doctor; it no longer aborts the session's plugin load.
  • A plugin manifest's hooks and commands entries load: hooks through the extension runner and commands as plugin-sourced custom commands; only tools and extensions were read before.
  • Two extensions registering the same tool or command name, and a custom tool or command that fails to load, are reported on the operator channel; the later registration wins and the earlier one was silently dropped.
  • An MCP tool that withholds arguments withholds values only; a key-only error was delivered as undefined.
  • An MCP server whose reconnects trip the breaker is reported on the operator channel with the server name and the suspension; the suspension was logged only.
  • A CommonJS extension (module.exports = …, or a transpiled module with exports.__esModule) runs instead of being reported as missing its default export; the wrapper mirrors Bun's __esModule interop.
  • A marketplace catalog entry the parser drops is reported with the plugin name, the failing field and the reason: veyyon plugin marketplace add/update print it to stderr and a session states it on the notice channel; the entry was skipped in silence and the cached catalog persisted without it.
  • The account manager names the account a failed OAuth refresh signed out ("the login for user@example.com was signed out"), so a surviving account rendered beside it is no longer read as the dead one; a credential that states no account keeps the unattributed wording.
  • A provider whose other login still serves every request states that instead of printing press a to sign in again, which claimed the provider was unusable on the same card that listed the account using it; a provider with nothing left serving still asks for the login.
Removed
  • WRITE_GUTTER_MIN_WIDTH is no longer exported: the line-number gutter of a code card is the host's, stated once in src/modes/terminal/draw/draw-tool-view.ts, and no tool sets it.
  • resolveModelFromSettings is removed from config/model-resolver; the role chain a session starts from resolves through resolveModelRoleValue, which reports why a role failed.
  • ReadRenderArgs no longer carries offset: the read schema states a line window on the path itself (src/app.ts:50-200), and limit is the directory entry cap.

1.4.1

2026-09-08 View on GitHub ↗
Added
  • The /autoswarm dashboard lists a New session action (n) over an existing session, which closes it keeping every file and every logged run and starts a fresh one with the setup as it stands.
  • Swarm presets: swarm and wide are built in, and the console saves the current shape under a name to presets.json beside the autoresearch databases, offered in every repository.
  • The run screen's running row shows the last twelve lines the harness printed under the command, refreshed once a second, with escapes stripped and a carriage-return progress row shown in its final state.
  • The setup form's models note lists up to three authenticated models close to a spec that resolves to nothing (No model matches "opus4". Close: anthropic/claude-opus-4, …).
Changed
  • The updater, startup version check and rollback picker order releases by publication date and treat any different latest version as an update.
  • /autoswarm opens the swarm console and takes no arguments. On a branch with no session it is a centered launcher card: a form with the goal, a swarm/wide preset switch, breadth from 2 to 8 with ◂/▸ steppers, per-arm models, attempts, a certification toggle, an iteration cap, a Start button and a Save as row for presets. Over a session it is the run dashboard: the ledger beside the detail of the highlighted row, the actions the swarm's state allows on single keys (s start or resume, p pause, n new session, x stop, c clear session, r reset worktree), e for the setup form and Enter for the full-width detail view.
  • A field edited in the setup form is written as it is typed, to the session on the branch or parked for the start; the form opens with the caret on the Goal row, Enter on the Goal row starts or resumes the swarm, ↑↓/tab move between rows, ←→ or a digit set a count and space flips a toggle, ctrl+u clears a text row, a click lands the caret or steps, picks and flips the control under the pointer, and the footer names the keys of the highlighted row.
  • /autoresearch is the serial loop only, with the subcommands status, resume, goal <text>, off and clear [--keep-tree|--reset-tree]; /autoswarm no longer takes them.
  • The run screen opened by ctrl+x and /autoresearch status is the run ledger alone, with its type-to-filter and its esc close footer.
  • The dashboard hydrates the session on the branch from the store when the runtime has not loaded it, so its detail pane states the session's goal and runs instead of (not stated).
  • A click on a single-line field places its caret under the pointer in the hook prompt, the login dialog, the MCP add wizard, the history search, the text and config rows of the settings screens, and the setup form; the rollback panel's list takes the pointer through the settings host.
  • ctx.ui.custom(..., { overlay }) accepts OverlayOptions beside true, so an extension can place and size its own card over the transcript.
  • The /agents card ships as it did in 1.4.0; the flat frame and the roster detail pane added after that release were withdrawn before this one.
Fixed
  • The permission card's title bar reads Permission required instead of the markdown source ## Permission required; a select dialog's title bar draws the heading's text and leaves the markdown to the body.
  • A hook status set through ctx.ui.setStatus keeps the theme colours it was painted with, as its contract states, so the autoresearch status row shows its kept count in green, its flagged count in yellow and its best metric in the tool colour instead of one grey line; cursor moves, hyperlinks and graphics in a status are still stripped.
  • Interrupting Claude mid-thinking no longer fails every later turn with Refusal (reasoning_extraction) on an endpoint that enforces the classifier: the hidden continuity message that carries the unfinished reasoning states which turn it came from, and the request drops it on same-model replay to a signing Anthropic endpoint, and after one refusal on any other, instead of re-sending it on the retry and for the rest of the session.
  • A logged metric of zero or below is a measurement: a session minimising a count tags the kept run that reached zero as best, and a signed metric's negative runs are ranked by direction in the Best row, the keep gate of log_experiment, the confidence figure, the Trend row and the prompt's recent-run rows; only a crash's logged placeholder reads as unmeasured, and it prints no metric in the prompt as it does on screen.
  • The setup form's models note states a spec past the last arm ("glm" has no arm at breadth 2.), which the persisted setup dropped without a word when breadth came down.

1.4.0

2026-09-04 View on GitHub ↗
Added
  • The models page on veyyon.dev lists every provider and model veyyon supports, read live from the bundled catalog and auto-refreshed from the repository; bun run site:build regenerates website/models-data.json from packages/catalog/src/models.json.
  • A bare interactive launch replays the previous launch's card from a cache before the CLI's import graph is evaluated, then adopts those rows and corrects only what changed. bun scripts/bench-startup.ts --runs 5 --bin packages/coding-agent/dist/vey reports the card's first byte at a 34-35ms median composed and a 15ms median replayed. The recording is discarded unless the terminal size, the environment this process received and the binary's path, size and modification time all still match, and it ages out after 24 hours; a launch whose composed card disagrees with the replayed rows drops the recording so the next launch records a fresh one.
  • bun scripts/bench-startup.ts gains a replay arm and keeps the first-frame recording inside its scratch directory. The recording resolves its path from os.homedir(), which Bun fixes at process start, so the bench's seeded HOME did not reach it and a run read and overwrote the operator's own cache.
  • VEYYON_REPLAY_DEBUG names a file the launch appends its replay decision to. A rejected recording is otherwise indistinguishable from a slow launch, and the logger does not exist yet at that point.
  • /rephrase asks for the reply on screen again in plainer prose, and refuses unless the conversation is resting on a finished reply.
  • /autoswarm opens a setup console for the goal, breadth, attempts and certification, then runs autoresearch with breadth: each iteration builds several candidate arms, rejects the ones that are empty, out of scope, unreadable or duplicates, has the survivors cross-review each other, and keeps at most one; /autoresearch is unchanged and still serial.
  • The autoswarm setup console assigns a model per arm, comma separated in arm order, so one iteration compares models as well as ideas; start_arm switches the session to that arm's model before its first edit, the status row names the arm and the model building it, and the session returns to its own model when the arm is logged or the mode is left.
  • An autoswarm run records the model in force when run_experiment measured it and the run screen shows it under the arm, so a round that stayed on one model is distinguishable from a model comparison; measuring an arm that start_arm never announced, or one that is not the arm in flight, states which model actually built it.
  • The autoswarm setup console accepts a pasted model list that carries a newline, which was rejected whole and inserted nothing.
  • Autoresearch and autoswarm have handbook pages.
  • Machine-wide resource limits cap CPU, memory, disk writes and process count across every veyyon process at once, beside the existing per-session limits, in /settings under Resources; both scopes default to no limit.
  • The two resource-limit scopes share one definition of each cgroup control-file format, with no user-visible change: the duplicate the machine scope carried while unreleased could write a freeze quota for a very small CPU budget.
  • bun run test:cgroup-proof drives both resource-limit scopes against a real kernel outside the test sandbox and reports each cap as held or not, refusing with a named reason on a host that cannot delegate cgroups rather than passing having proved nothing.
  • The run screen's session pane shows the number of runs since the segment's best one as Since 8 runs later, none better, and a Trend row of one block per run, oldest on the left, scaled between the segment's lowest and highest measurements; an unmeasured run draws as ·, and a segment wider than the pane draws its most recent runs behind a leading ….
  • The autoresearch status row shows the same gap as 2 since best, and drops that segment before the best metric when the terminal is too narrow for both.
  • The autoswarm setup console states under its title what Enter does on this branch: resumes the named session with its run count, or starts one, with whether autoresearch.sh exists or the first turn writes it; over a session the legend reads enter resume.
  • /autoresearch resume and /autoswarm resume continue an interrupted or paused session without a console or a transcript line, are offered in argument completion, and print what would start one when the branch has no session.
  • An interrupted autoresearch loop puts paused · send a message to resume on the status row and (paused) in the run screen title until a turn resumes it, and the interrupt notice names /autoresearch resume and /autoresearch off in full rather than a bare off.
  • The run screen title is fitted to its border before the border truncates it, so a long session name gives way and (paused) or (mode off) stays readable instead of ending in (paus….
  • /autoresearch <text> on a live session where <text> is the stored goal is a resume with nothing to add: it neither prints a context notice nor sends the goal to the model a second time.
  • A file search accepts path as the directory its input globs are searched under, the way path scopes a text search: { type: "files", input: "*.ts", path: "src" } is src/**/*.ts, each input entry keeps its own depth, and a scope that is a glob or an input that is absolute is rejected naming the spelling that works.
  • Browser tool calls batched in one turn run in the order written; run and close on the same tab used to start together and the run found its tab closed.
  • ExtensionAPI.setModel(model, { ephemeral: true }) switches the session's model for the rest of the turn without recording it as the session's own model, so a resumed session opens on the model the operator chose.
Changed
  • The hidden messages a session injects and the gates that fire them live in session/nudges.ts rather than as file-private literals in agent-session.ts, and the mid-run todo and prewalk gates key their tool tables through the TOOL registry so renaming a tool now fails to compile instead of silently disabling the nudge.
  • The subagent model resolver reads the shared-model switch once and builds the layers of whichever scope that selects, instead of gating each layer against a second reading of it, and the unread SUBAGENT_MODEL_SCOPE_VERSION constant is gone from the rejected-setting log record. No change to what any subagent runs.
  • The compaction policy vocabulary (check outcomes, the bar a pass is measured against, the truncation edge budget, the prune cache window and idle flush, and the recovery band) lives in session/compaction-policy.ts rather than interleaved with shutdown timeouts and credential backoffs in agent-session.ts, with no behavior change.
  • The thinking display's hidden-code fence marker is named hiddenCodeMarker, no longer colliding with the unrelated elisionMarker in @veyyon/utils/byte-truncate; the marker text is unchanged.
  • The read tool's URL routing, internal-URL routing, notebook reading, document conversion and structural summarizing each live in their own named method instead of inline branches of one 758-line execute, with no change to what any read returns.
  • The doc comments on the agent registry's conversation scope and address check, and on the subagent model and thinking-level resolvers, state the precedence and the boundary rule without the surrounding narrative; no behavior changes.
  • The queued-message predicates and the retry.fallbackChains selector vocabulary live in session/queued-message.ts and session/retry-fallback.ts instead of as file-private helpers in agent-session.ts; RestoredQueuedMessage is imported from the first of those.
  • The ACP permission gate's argument reading — which tools need consent, the prompt each call earns and the file locations it points at — lives in session/permission-intent.ts instead of as file-private helpers in agent-session.ts, which also drops that file's private copy of getStringProperty in favour of the @veyyon/utils owner. No change to what is gated or prompted.
  • The launch card paints about 8ms sooner: the bundled themes are embedded as text and parsed on the ask instead of building all 98 before the first frame, and the card path no longer evaluates node:assert/strict, node:crypto, node:inspector, node:child_process or node:zlib for calls it does not make.
  • The status row reads its truncation limits from tools/render-limits, a leaf that imports nothing, rather than tools/render-utils, which drops the tool renderers, path helpers and image resizing from the launch card's import graph; first-frame time is unchanged, because those modules only declare functions.
  • The home screen hero drops the recent-session row; /welcome still lists recent sessions.
  • The launch card paints the whole status row from config instead of a hand-written path and branch, so the profile, model, approval rung, branch and context gauge are on screen with the first frame; measured on a pty against the built binary, the row lands at 47-48ms rather than 1067-1083ms and the frame is editable at 49-50ms.
  • The status row's segment gathering and row fitting live in one module, modes/components/status-line/quiet-row.ts, which the live footline and the launch card both render through, so the two rows cannot carry different segments or order them differently.
  • A status-line segment reads a flat SessionFacts value block rather than the AgentSession itself, which is what lets the same segment table render before a session exists. No change to the mounted row.
  • bun scripts/bench-startup.ts renames its statusline arm to statusrow and times the status row being on screen; the old arm timed a segment only a session supplied and now reports nothing, because the card supplies the row.
  • The autoswarm setup console, the autoresearch experiment tool and the run screen's stacked split clamp their breadth, attempt and row counts through the shared clamp rather than local copies. No behavior change.
  • bun scripts/bench-startup.ts times its statusrow and replay:statusrow arms against the approval rung on the row rather than the context gauge, which is the row's last segment and is shed on the bench's eighty-column pty: both arms reported no samples at all. They now read a 39ms median composed and 15ms replayed against the built binary.
  • The autoswarm setup console and the autoresearch experiment tool clamp their breadth and attempt counts through the shared clamp rather than local copies. No behavior change.
  • VEYYON_TIMING reports the window between process start and the launch card instead of hiding it: the tree now starts at the CLI entry and carries spans for the command load, the launch-card import, the prologue, settings, the theme and the paint, leaving only Bun's own start and the entry's static imports under (before instrumentation).
  • The launch card arrives in about half the time. The binary is now code-split, so the standalone loader links the CLI entry and the launch card instead of the bytecode of every subcommand, tool and agent-runtime module before the first statement runs, and whitespace and syntax minification are on. Measured warm on a pty, the card's first byte goes from 138-151ms to 57-72ms, the first keystroke echoes at 111ms instead of 188-207ms, and the binary is 231.7MB instead of 296.9MB. Function names are still kept, so a stack trace is unchanged.
  • The six modules on the launch path that reached for the @veyyon/utils barrel now import the subpath that owns what they use, so painting the card no longer evaluates the YAML parser, Handlebars and the prompt-variable layer that the barrel re-exports. The launch card's import graph drops from 311 modules to 268, its import span from 32.5ms to 20.2ms, and the card's first byte to 50-58ms.
  • The launch shell no longer evaluates a workspace barrel. The launch card, the editor and the status row reached @veyyon/tui, @veyyon/utils and @veyyon/agent-core for a handful of symbols, and each barrel is export * from over its whole package; every such edge now names the leaf that owns the symbol. Three modules were split along the same line: internal-urls/resolve-sync.ts takes the URL resolver out of the OSC 8 writer, modes/image-reference-markers.ts takes marker rendering out of the blob store, and modes/magic-keyword-notices.ts takes the three hidden notices out of keyword detection. Module evaluation for the three shell entries drops from 147ms to 63ms, the editor from 36ms to 3.6ms and the status row from 78ms to 6.5ms.
  • The status row no longer evaluates the agent runtime, the compaction engine, the provider error registry or the bundled model catalog before the composer takes a keystroke. session/context-usage.ts reached the @veyyon/agent-core barrel for countTokens, its compaction barrel for estimateTokens and @veyyon/ai/utils/schema for two wire helpers, and config/inline-tool-descriptors-mode.ts reached @veyyon/catalog/identity for one family token; each now names the leaf that declares the symbol. The three shell entries evaluate 333 modules rather than 583.
  • The status row reads its premium-request formatter from @veyyon/utils/format instead of @veyyon/stats/format, so painting the card no longer evaluates the stats package. No visible change to the row.
  • The status row's non-message token accounting lives in session/non-message-tokens.ts, so painting the launch card no longer evaluates the compaction layer or the tokenizer through session/context-usage.ts, and config/inline-tool-descriptors-mode.ts reads modelFamilyToken from @veyyon/catalog/identity/family instead of the identity barrel. No change to the counts the row reports.
  • The host capability probe and the environment it measures against moved out of the session budget module into session/cgroup-host.ts, and the capabilities a probe reports no longer carry the field it used to pick a cgroup parent. No behavior change.
  • The first-frame recording is written by startup/first-frame-recorder.ts through the shared atomicWriteFileSync instead of a hand-rolled temp-and-rename, so the cache file is created owner-readable only; the replay reader on the boot path still reaches node builtins only.
  • A cold launch states the context gauge as soon as the session knows its usage instead of when the live status row mounts: the at-rest context record fires on session construction and the launch card repaints on it. A warm launch repaints nothing.
  • The launch card paints the working directory on the status row instead of leaving it blank until the session mounts. Measured on a pty, the row named the directory at 59-62ms with the card rather than at 1067-1083ms; the model, mode and context gauge still arrive with the session, to the right of it.
  • The status row's location is rendered by one owner, modes/components/status-line/location.ts, which the live row and the launch card both call, so the two cannot drift. shortenPath and sanitizeStatusText moved to their own modules, re-exported from tools/render-utils.ts and modes/shared.ts; defaultDisplayRoots and resolveDisplayRoots are now imported from the location module rather than from segments.ts.
  • The launch card paints the git branch on the status row beside the working directory. Measured on a pty, the branch appeared at 59-66ms with the card rather than at 1067-1083ms.
  • The status row's branch is rendered by one owner, modes/components/status-line/branch.ts, which the live row and the launch card both call, so the two cannot drift.
  • Which segments a status-line preset shows is resolved by one function, resolvePresetSegments, so the launch card honors the same preset and git.enabled rules the mounted row does. No behavior change to the mounted row.
  • The branch a repository is on can be read from .git alone through utils/git-head.ts, without running git; utils/git.ts composes that reader with the git symbolic-ref fallback a reftable repository needs, rather than keeping a second copy of the file parsing.
  • StatusLineComponent.watchBranch is watchGitState: one repaint request for every git read the row is painted from, rather than a name that described only the HEAD watcher. No user-visible change.
  • The model and effort a subagent runs are chosen on one of two exclusive scopes. Subagents → Same Model for All Subagents is off by default, and each agent's page under Roster decides; on, Shared Model and Shared Effort decide for every agent while the per-agent rows are hidden and keep what they hold for when the switch goes off. An agent naming neither runs the profile's default model role at medium effort, and subagent.modelByDepth decides nothing in either scope.
  • A subagent definition that names a tool nobody recognizes is reported with the file and the unknown names instead of loading an agent with no tools and a prompt pruned of everything.
  • User-authored subagents are discovered from ~/.veyyon/subagents/, shared across profiles, and enabled per profile.
  • The compaction loader names the engine on every pass, not only a remote one: "Compacting context... (local compaction)", "(openai remote compaction)", "(azure remote compaction)" or "(codex remote compaction)". A codex or azure server-side pass used to be announced as openai, and a local pass was not announced at all.
  • The model the advisor runs is asked in one place: Model → Advisor → Advisor Model, directly under Enable Advisor, hidden while the advisor is off. advisor is gone from the Roles table, which was a second surface for the same slot under a different name; the slot itself is unchanged, so @advisor and any existing modelRoles.advisor keep working.
  • The Advisor rows are contiguous in the Model tab: the Prewalk rows were declared between them.
  • The resolved-model snapshot a warm launch restores is verified against the bytes it was written from instead of being parsed and serialized back to check itself. The file is now a header line then the stage payload, and reading it costs 14.6ms instead of 27.6ms measured on a 9.2MB snapshot; a snapshot written by an earlier version misses and is rebuilt.
  • The launch card paints the real composer instead of a drawing of one. Typing at the card edits the editor the session goes on to use, so nothing has to be replayed into it at handover, and a submit typed before the session exists no longer discards the draft. Measured warm on a pty, a keystroke at the card echoes 3.2ms after the card's first byte.
  • The settings store holds no database handle. AgentStorage.forAgentDir is the one owner of the run's agent.db and opens it on first use, config/legacy-agent-db-settings.ts owns the first-run read of the pre-config.yml settings table, and the launch card no longer evaluates bun:sqlite or the SQLite credential store to read a setting. Measured warm on a pty, the card's first byte goes from 50.5ms to 42.4ms and a keystroke is echoed at 45.6ms instead of 53.6ms; a database that will not open now costs usage statistics with a logged reason rather than failing the launch.
  • The three hidden magic-keyword notices are in session/magic-keyword-notices.ts rather than under modes/, which was the one edge from the session into the UI directory with no drawing behind it. No behavior change.
  • A running autoresearch or autoswarm loop occupies one status row instead of a widget above the composer, and ctrl+x opens a run screen listing the session, the playbook, the run in flight and every logged run, with the highlighted entry in full beside it.
  • A bare /autoresearch opens the run screen instead of leaving the mode; off still leaves it.
  • /autoresearch clear and /autoswarm clear ask before resetting the worktree, naming the baseline commit and how many files hold uncommitted changes, and reject an unrecognized flag instead of resetting.
  • /autoresearch and /autoswarm list their off and clear subcommands before a letter is typed, and clear offers --keep-tree and --reset-tree.
  • A run records the arm that produced it and the arm that certified it, both shown on the run screen.
  • Each row of the run screen's list states the run number, the arm that produced it, its metric, its change against the baseline of its own segment, and whether it is the baseline, the leader, kept, dropped, crashed, failed or flagged.
  • The run screen's session pane opens with the best measurement of the segment, its change against the measurement the segment started from, and the run and arm that produced it.
  • The autoresearch status row prints the best metric with its change against the segment baseline, and sheds the pair together.
  • The autoswarm setup console legend lists only the keys that act on the focused field and the range its arrow keys move within.
  • The autoswarm setup console states the harness runs one iteration costs, as 3 arms × 3 attempts: up to 9 harness runs per iteration.
  • The autoswarm setup console legend reads enter needs a goal while the goal is empty, and Enter starts nothing.
  • The run screen's session pane states the count of runs logged since the best one.
  • The autoresearch status row states the count of runs logged since the best one, and sheds it before the best it qualifies.
  • The run screen's session pane draws the segment's measurements as a row of blocks, one per run, with a gap for a run the harness never measured.
  • The run screen's list states the run in flight and the run awaiting a log by number, with the harness result on the unlogged row.
  • The subagent model resolver states the layer numbering its per-agent chain actually resolves. No behavior change.
  • The status row no longer carries the secrets segment. The secrets id is gone from every preset and from statusLine.segments, and a configuration naming it is rejected; /secret list states what a session has masked.
  • The roster states that an operator may write an agent, and names docs/features/subagents-authoring as the instructions.
  • The subagent authoring page states which frontmatter key spellings are read: thinkingLevel and thinking-level reach the same field, an underscore does not, and the bundled definitions use the dashed form.
  • The rewind and checkpoint entry readers and the side-channel reply bound live in session/rewind-checkpoint.ts and session/ephemeral-reply.ts instead of as file-private helpers in agent-session.ts; the doc comment describing the Anthropic request metadata payload is attached to the function it describes rather than to the tool-order check below it. No behavior change.
  • session/content-text.ts is gone; the session modules that flattened content blocks call the @veyyon/utils owner, which now carries the options that copy held. Two implementations of the same flattening each documented themselves as the only one.
  • The MCP command controller races its OAuth login and its connection wait through withTimeout and raceWithTimeout in @veyyon/utils rather than a file-private copy, and the protocol probe's truecolor bar converts hue through hsvToRgb in @veyyon/utils/color rather than a second implementation of the same conversion. Both emit what they emitted before, byte for byte.
Fixed
  • /login for a provider that takes a pasted API key (OpenAI Platform, Groq, xAI and every other key provider) shows the dashboard where a key is obtained and prompts for the paste, instead of opening a platform login page in the browser as if it were an OAuth sign-in; the setup wizard likewise neither opens nor copies that URL.
  • The /login picker prints api key or browser login beside every provider, and the two OpenAI rows read OpenAI Platform and ChatGPT (Codex subscription), so a key paste and a subscription sign-in are told apart before one is chosen.
  • vey auth-broker login <provider> prints Get an API key at: for a key provider instead of Open this URL in your browser:.
  • The RPC open_url login request carries credential ("api-key" or "oauth") so a host opens only the URL a flow waits on; RpcClient.login's onOpenUrl receives it as a fourth argument.
  • Cancelling or failing a sign-in in the setup wizard clears the provider search that started it, so the next keystroke begins a new search rather than appending to the old one and matching nothing.
  • Tool renderers sanitize raw tabs and shorten embedded home directory paths across error, output, and fallback views.
  • A job poll whose job failed lists each job with its own error again, instead of collapsing to the result text.
  • Print mode exits with code 130 rather than 1 when a turn is cancelled or aborted.
  • The web search command exits with code 2 on missing or invalid query arguments.
  • The TTSR command exits with code 2 on missing required subcommand parameters or unrecognized actions.
  • The shell command exits with code 2 when invoked without an interactive terminal.
  • CLI file argument processing reads attachments via portable node:fs promises rather than runtime-specific file methods.
  • The subagent HUD retains the model badge for running tasks without a description when space is available, rather than dropping it against an unused description floor.
  • Deleting a session in the session selector removes it from the folder and all-projects lists so toggling scope does not restore the deleted entry.
  • ModelSelectorPanel displays 'No matching models' when an active query yields zero results instead of the unprompted 'No models available' login hint.
  • The model browser replaces a Bun ANSI-stripping call with the portable node:util helper on disabled model rows.
  • The model picker avoids re-fetching and re-sorting the catalog on every query keystroke.
  • The thinking effort selector preselects the default row when initialized without a level override.
  • veyyon auth-gateway serve honours accounts.loadBalancing: with it off, one account per provider serves every request the gateway forwards, where before the gateway rotated on each of the several credential reads a single request makes.
  • An autoswarm arm's model switch is ephemeral: quitting mid-arm and resuming the session no longer opens on the arm's model with nothing to restore the session's own.
  • An overlay box narrower than six columns no longer draws a title wider than its own border.
  • A warning repeated verbatim with nothing between the two, as the compaction dead-end notice was at the top of a resumed turn, renders once.
  • Settings selector displays a dimmed '(unset)' placeholder for optional text settings with empty values.
  • The subagent roster list bounds item rows and wraps custom agent hints so the list and navigation controls fit within the modal viewport.
  • The settings selector passes the target pane width to the status line preview.
  • The autoswarm setup console handles Unicode emojis, CJK characters and combining marks on backspace and windowing without splitting surrogate pairs, and supports Shift-Tab field navigation.
  • Autoswarm triage rejects candidate arms whose edits fall inside off-limits directories, where an exact string comparison only matched exact path literals.
  • Autoswarm review assigns the director as the sole reviewer when certification is disabled on the session, instead of creating peer review rings for three or more surviving arms.
  • Autoresearch storage rejects completing or logging an abandoned run, and rejects duplicate log calls on an already logged run.
  • /autoresearch status and /autoswarm status open the run screen, where the word was swallowed as the goal and overwrote what a live session was optimizing.
  • A live session's goal changes only through goal <text> or the setup console, so any other text after the command reaches the model as context for the resume and leaves the stored goal as it was.
  • /autoresearch and /autoswarm offer status and goal in their argument completions, where only off and clear were listed and every other word reached the goal write.
  • Checking out a branch other than the one an autoresearch or autoswarm session records now shows paused · session on <branch> on the status row and keeps the session's runs readable through ctrl+x, where the session was looked up by its branch alone and so read as baseline pending with no runs whenever it was resumed off that branch.
  • An autoresearch or autoswarm loop re-reads the branch at the start of every turn, so checking the session's branch back out lifts the pause and restores the experiment tools, where a checkout mid-conversation went unnoticed and the loop kept its tools and system prompt on a branch it was not on.
  • Turning an autoresearch or autoswarm loop off while it is paused clears the pause, so the status row stops naming a branch to return to and reports the mode as off.
  • Leaving the autoswarm setup console with Escape reports that nothing was started, where it returned to the prompt without a word.
  • Pressing Escape during an autoresearch or autoswarm turn pauses the loop until the next message, where a measurement waiting to be logged made the loop resume itself on the very next turn and the interrupt did nothing.
  • A hidden continuation that was waiting for the agent to go idle no longer starts a turn after Escape ends the one it was waiting on, where an autoresearch stall nudge queued a turn earlier restarted the stopped loop three milliseconds after the interrupt.
  • An autoresearch or autoswarm loop no longer diagnoses a stall when the turn that ended was a session continuation and the loop's own resume has just been accepted behind it, where the false stall queued a second hidden turn and counted against the budget that turns the loop off.
  • /autoswarm <text> over a live session opens the console on the session's stored goal, where it prefilled the typed text and Enter overwrote the goal with a message meant as context for the resume.
  • A slash command that opens a console or a prompt while the agent is idle no longer sits under the Working… loader and its elapsed clock; a prompt raised mid-turn keeps the turn's loader.
  • The autoswarm setup console's breadth, attempts and certification answers outrank the breadth, attempts and certify arguments the model passes to init_experiment, where a guessed breadth: 1 turned a configured swarm into a serial loop; the tool's reply states the configuration in force and that the console set it.
  • A metric unit that is a word is spaced off the number (1,596,000 comparisons) while a symbol or abbreviation stays attached (192.78ms), and a metric_unit that repeats the metric's own name is dropped, where every surface printed 1,596,000comparisons.
  • The autoresearch status row pluralizes its run and arm counts (1 run, 2 arms), where it read 1 runs.
  • log_experiment rejects status: "keep" for a run that did not improve on the segment's best unless a justification is given, where a loop kept eight flat runs in a row as eight commits that changed nothing the harness could see.
  • skill://<name> and skill://<name>/SKILL.md read a skill whose SKILL.md is a symlink into a directory outside the skill's own, where the read was refused as an escape of the skill root; every other file under the skill still has to resolve inside it.
  • /account status, /account refresh, /lsp and /trust print their report as a titled transcript block at the rail, where the lines landed as a bare paragraph that read like an assistant message.
  • Logging an arm whose model restore is refused, because the session model lost its key mid-run, reports that the session is still on the arm's model instead of recording the restore as done, and the next arm's restore target stays the session's own model rather than the arm it was stranded on.
  • An autoresearch or autoswarm turn that ends with no experiment tool run, no measurement waiting and no resume armed is steered back to the loop on the next turn; after three such turns in a row the loop turns itself off and states how to reach the session's runs, where the mode stayed on and the status row read as a live experiment until the user typed something.
  • /autoswarm goal <text> opens the setup console with <text> in the goal field, where the field read goal <text> and that literal was written as the goal on start.
  • /autoresearch clear --keep-tree, and a clear off an autoresearch/* branch, leave every worktree file in place, where both deleted autoresearch.sh and the other loop files from the worktree; a confirmed reset restores the committed harness and removes only the legacy files the prompt forbids, and a clear on a project that never ran a loop no longer creates the run store.
  • The interactive console (bash with a PTY), the autoresearch dashboard and every other ui.custom(..., { overlay: true }) surface sit above the composer zone instead of covering the whole screen: the prompt, status line and footline stay painted while the overlay is up, and the console box is sized to the rows above them.
  • A session on a model whose thinking blocks are bound to their conversation prefix, such as Claude 5.1 and later, leaves an already-sent tool result in place instead of superseding it mid-history, which invalidated every thinking block recorded after it and drew a 400 on the next turn.
  • The installer refuses to replace a binary whose only ownership record is a pre-identity v1 receipt, instead of moving it aside. That receipt vouches for the path alone, so a user who deleted the installed binary and put their own file at the name left exactly one behind, and it was being read as permission to displace their file.
  • veyyon agents unpack writes to ~/.veyyon/subagents, the directory subagent discovery reads, instead of the profile's agent/agents dir, where an unpacked definition was reported as written and then never loaded.
  • veyyon config set and veyyon config reset no longer exit 1 with an ENOENT on a profile that has never been launched: the save now creates the profile's agent directory before it takes the config file's lock, which refused a parent directory that did not exist yet.
  • A /btw or /omfg reply long enough to be truncated no longer ends in a replacement character when the cut lands inside an emoji: the trim counts UTF-8 bytes but removes UTF-16 code units, so it could stop on half a surrogate pair.
  • A malformed content block no longer opens a blank line in a session listing or in rendered history. A text block whose text is absent or is not a string contributed an empty part, so the join placed a separator beside it, while a thinking or tool block carrying just as little text was skipped outright.
  • The composer hairline and the transcript rules no longer change shade about half a second after the launch card appears: the card mixes them out of the background this terminal reported on the previous launch instead of a static token, and tui.paintGround on auto decides the paint from that same recorded background rather than repainting the whole window when the terminal answers. The background is recorded per terminal in cache/launch-facts.json, whose shape version is now 4.
  • The launch card's context gauge no longer jumps when the session mounts in a project it has never measured: the reading filed under the model is now that reading with the measuring project's context files subtracted, so a card seeded in a heavy repository no longer states 77% left where the session settles at 88%. A project's own reading is unchanged and still wins where it exists.
  • The session mount no longer forces a full-viewport repaint over the launch card, so the screen no longer flashes and darkens at handover; the mount now writes only the rows whose content changed.
  • veyyon agents unpack writes bundled definitions to ~/.veyyon/subagents, the directory agent discovery reads, instead of the active profile's agent/agents, where nothing loaded them; the --user and --project flags are gone, and --dir still writes to a path you name.
  • The launch card states the model name, git state and context percentage recorded at the end of the last launch instead of placeholders, so the status row and hero do not change when the session mounts; each fact falls back to its placeholder when the release, the model or the project changed.
  • The launch card's status row resolves a linked git worktree the same way the live row does, so the path the card paints, its ◫ marker and the truncation it forces survive the session mount without being rewritten.
  • The launch composer's footline reads the draft's token estimate from the same editor the session mounts, so the right zone is on screen with the first keystroke instead of appearing when the session does.
  • certify_arms is attached only to a session whose breadth is above 1, so a serial autoresearch loop is no longer offered a tool that triages arms it does not have.
  • An autoswarm winner has to beat the segment's baseline, not merely the worst of its sibling arms: an iteration where every arm regressed reported a winner, which was then logged as an improvement and re-applied.
  • /autoresearch clear --keeptree and any other misspelling of --keep-tree no longer fall through to resetting the worktree, which is the opposite of what the flag selects.
  • The autoswarm setup console keeps its hint column still while a value is adjusted, and wraps its explanatory line instead of cutting it on a narrow terminal.
  • The autoresearch status row reads the breadth once, so the first turn of a swarm no longer prints autoswarm with no arm count: the name came from the configured breadth and the arm count from the stored session, which do not agree until init_experiment runs.
  • The run screen keeps esc close on its footer at every terminal width, shedding the navigation hints first, instead of truncating the exit hint off the right edge of a narrow terminal.
  • The autoresearch status row drops whole segments, least informative first, when the terminal is narrower than the row, and rebuilds on a resize, so the ctrl+x runs chord that opens the run screen is on screen at every width.
  • A crashed run reports what its harness measured before it died, and states that it has no metric when the harness measured nothing, instead of formatting the zero the log call was required to supply as a measurement, which listed a segfault as the fastest result of a session where lower is better.
  • The run screen lists each metric once: the primary metric a log call repeats among its secondary metrics is no longer stored or rendered as a secondary of itself, which printed a second unitless copy of every measurement and a -100.0% row for a crashed run.
  • Every surface reporting the best run of a segment names the same run. The run list, the session pane, the status row and the prompt built from the session each ran their own scan, and two of them counted a run logged with the placeholder zero the log call requires of a run that measured nothing; where lower is better that zero is the best value there is, so the list tagged a run best that the pane beside it did not.
  • The run screen prints the artifacts directory with the home directory collapsed to ~, so a screenshot of a loop no longer states the account name and profile layout it ran under.
  • The run screen fits a terminal shorter than fourteen rows: it wrote a fixed fourteen rows whatever the height, so a ten-row terminal lost the four rows holding the footer and the border.
  • The run screen fits a terminal narrower than 29 columns: the sidebar is sized from the available width rather than its own floor, and every row is cut to the width it was handed, so the border no longer wraps into rows the card did not count.
  • The run screen stacks its list above its detail on a terminal too narrow to carry both beside each other, instead of leaving the detail two columns wide and printing every field of the selected run as a single letter and an ellipsis.
  • The run screen names an autoswarm the setup console configured before the first init_experiment call, instead of titling it "Autoresearch" and reporting "serial, no arms and no review" for a swarm whose breadth was already set.
  • /autoresearch clear resets to the baseline of the session on the branch it is standing on rather than the newest open session, so a second worktree on another branch no longer selects the commit this one is reset to, nor has its session closed instead.
  • The run screen pages its detail pane with pgup and pgdn, and closes on escape only: q closed the surface, so filtering the run list for a label containing a q lost the screen mid-keystroke.
  • The status row of a run in flight advances its elapsed time once a second instead of freezing at the value it had when the run started, and its clock stops as soon as no run is in flight and the run screen is closed.
  • A search filter typed into the run screen survives the loop logging a run and the clock advancing, instead of being cleared once a second while a run was in flight, and the highlighted run stays highlighted when rows are added above it.
  • /autoresearch clear rejects the reset when it cannot read git status, instead of prompting about zero uncommitted files and then discarding whatever was there.
  • The GitHub link in the veyyon.dev navigation carries an accessible name, so a screen reader announces the destination instead of an unnamed link holding a hidden icon.
  • veyyon config set and veyyon config reset create the profile directory they write into, so the first command run on a machine that has never launched a session persists the setting instead of exiting 1 with an ENOENT on that directory.
  • Raising breadth, attempts, parallelism or certification on a live session is written to the session instead of being dropped, so the loop runs the shape the setup console last showed.
  • The launch card keeps one set of facts per project instead of one for the whole machine, so working in two projects no longer erases both and leaves the context gauge reading ? on every start. The file is versioned, bounded to the 24 most recently written projects, and a copy written by the previous shape is discarded rather than read.
  • The launch card records what a project knows and what a model knows separately, so working in two projects no longer erases both and leaves the context gauge reading ? on every start, and a project opened for the first time states the model's display name and effort instead of a raw id. The file is versioned, each map is bounded to its 24 most recently written entries, and a copy written by a previous shape is discarded rather than read.
  • The launch card states the context gauge in a project it has never measured, using the at-rest reading the configured model last took anywhere, so a project opened for the first time draws a real bar instead of ? left and an empty one; the project's own reading still wins where it has one, and the gauge falls back to ? only until that model has idled once.
  • The launch card states the effort the last launch ran at, so the status row no longer grows a @high tail when the session mounts and shifts every segment beside it; the rung is dropped when the model changes and erased when the row stops printing one.
  • The launch card prints the configured model id's last path segment rather than the whole qualified id, so a namespaced id no longer costs the status row its context gauge on the first launch of a project.
  • The launch hero states the configured model instead of no model yet · /login when no display name has been recorded yet.
  • The context percentage the next launch states is recorded only while the session is running the configured default model, so a session started with --model, switched with /model before anything was sent, or fallen back to another model no longer leaves the card a gauge measured against a window its model does not have.
  • The context gauge renders every percentage at one width, so a reading that arrives or changes no longer shifts the status row beside it.
  • The launch card lays its status row out against the same width the live row uses, so a narrow terminal no longer shows the card keeping a segment the running session immediately drops.
  • The screen no longer shakes while an answer streams into a viewport it has not filled: each streamed chunk repaints its own block alone, and the anchor fill above it is now resized in that same frame rather than reused at the previous frame's height, which composed one row past the viewport and moved the window per row of the answer.
  • The composer no longer lifts off the bottom row for a frame when content collapses (a tool card closing, the working indicator retiring): the anchor is sized from the children about to render rather than from the frame that already composed, so the placement no longer needs a second paint to correct it.
  • Context budgeting is unchanged from 1.3.0: the unreleased reserve for the model's output allocation is withdrawn, because subtracting it from the usable window moved every model's compaction threshold, roughly doubling how often compaction fired and invalidating the prompt cache on each pass.
  • A turn too large for compaction to summarize is truncated in the middle, keeping the head and the tail, instead of pausing automatic maintenance; the removed text is written to a recovery artifact the notice names. A session whose newest turn was a single oversized message could previously make no progress, and rewinding the tree did not clear it.
  • A payload the outbound secret scan refuses for its size is treated as a context overflow, so the session compacts and retries instead of stopping at "the provider request exceeds the confidentiality scan byte limit" on every attempt. The scan runs before the request is sent, so nothing else had reported the turn as too large.
  • An image a kitty-protocol terminal cannot be handed reports the format as the reason instead of claiming images are switched off, and a picture whose conversion is still running no longer prints a placeholder that a moment later becomes the picture.
  • A key pressed before the launch card appears is drawn into the card's composer about a millisecond later instead of 156ms later, so the composer no longer sits on screen ignoring what is typed into it while the main module loads.
  • The status row's dirty marker appears when git status answers instead of waiting for whatever redraws next, which in a resting session is the next keystroke; the row had been showing a clean branch over a tree nothing had looked at.
  • The status row keeps the dirty marker the launch card painted instead of dropping it for the width of its own git status, so a handover on a dirty tree no longer shows the branch change colour twice; a scan that finds the tree really did move still repaints it once.
  • A turn that ends on text after a tool call is recognized as finished even while a session subscriber is still running, so the todo reminder, the rewind pass and the session-stop hooks no longer skip a turn whose final message arrived behind a slow subscriber.
  • A memory limit pins the capped subtree's swap to zero, so the cap bounds the whole anonymous footprint; while unreleased a 256 MB machine cap let a single process reach 5,520 MB by swapping.
  • The machine limit requires a parent that delegates two cgroup levels, so a host that delegates one — a container whose cgroup root holds processes — reports per-session limits held and the machine tier unheld, instead of reporting a machine cap the kernel never applies.
  • The CPU-limit probe and the limiter resolve one environment, so the probe can no longer report support for a cgroup path the limiter does not write to.
  • A probe directory left behind by a killed veyyon no longer makes the only usable cgroup parent look unusable, which dropped the machine to no budget at all until it was deleted by hand.
  • /cpu-limit status reports whether the kernel is holding the machine-wide limit, naming the resource it refused, instead of printing the configured cores on a host that holds none of them.
  • /cpu-limit states that a session CPU cap above the machine cap is bounded by it, rather than printing the two numbers with nothing relating them.
  • A background bash job joins its session's CPU and memory budget instead of running outside every cap.
  • A model whose compaction route answers 404 reports the downgrade to local compaction once, instead of once for the 404 and again in different wording on the next compaction.
  • A session that never enabled goal mode no longer reports "Goal mode stopped driving" after three consecutive provider-killed turns; the failed-turn counter and its stand-down warning now require a running goal.
  • A goal now starts with its full failed-turn tolerance instead of inheriting the failures an earlier goal in the same session left behind, which stood it down on its first error rather than its third.
  • A turn-ending provider error too long to render inline now reports how many lines were dropped instead of ending without a trace.
  • The installer asks what is already installed before downloading, so a machine already on the released version finishes in seconds instead of fetching the whole binary to discard it.
  • The installer repairs an install whose binary was replaced since it was written — a local build copied over it, or a write interrupted mid-swap — by moving that file aside and installing, instead of refusing and leaving the machine on the old version; a file at a path the installer has never installed to is still refused untouched.
  • A completed goal now reports the tokens the turn that completed it spent after the goal tool ran, including a subagent that returned in the same batch, instead of stopping its count at the tool call.
  • /cpu-limit no longer sets a budget: it reports both scopes and lifts this session's CPU cap, and points at /settings under Resources for configuration.
  • An ACP client following a tool-call location now opens the file, not a name ending in the read tool's line range.
  • The settings screen states that left returns to the category list, and no longer expands a row that has no description, which consumed the next left with nothing on screen to show for it.
Removed
  • subagent.sharedModel, subagent.model, subagent.thinkingLevel and subagent.modelByDepth decided the model and effort for every subagent at once and are rejected; a config still holding one is reported once, naming the agent page that replaces it.
  • The --subagent-model launch flag, which set the model for every subagent in the session.
  • The --project flag on veyyon agents unpack, which wrote definitions to ./.veyyon/agents; there is no project scope for subagent discovery, so those files were never loaded.
  • The tagline under the wordmark on the session welcome hero, which the launch card and the mounted hero each printed.

1.3.0

2026-08-28 View on GitHub ↗
Breaking
  • The model-facing workspace search surface is now one mandatory search tool taking ordered required type ("files" | "text" | "structure") and input, replacing the separate glob, grep, and ast_grep tool IDs. Retired per-engine and search.enabled values are discarded while text-context values and persisted tool inventories migrate.
Added
  • search takes paths for a text search, returning the matching files with per-file counts instead of match lines; the shell route it replaces (rg -l) is intercepted, and searching buildSystemPrompt under packages/coding-agent/src costs 3,492 tokens as match lines against 215 as a file list.
  • Esc pressed twice within half a second over a composer holding text discards the draft; undo brings it back, and a single Esc still leaves the draft alone.
  • /advisor reports advisor status, opens the WATCHDOG.yml roster editor and applies a save to the running session, starts or stops the advisor for the session, and copies the advisor's own transcript; the subsystem shipped complete but no command, key or menu row reached it.
  • session.newKeepsBackground decides what /new does to a turn still streaming: off (the default) stops it and closes its provider stream before the new session starts, on keeps the old conversation running and says which one.
  • The status line carries a background chip counting conversations this process is still running that no screen is showing, present in every preset and silent at zero.
  • The terminal renderer composer zone gains a formal defect oracle and automated invariant sweep suite covering prompt counts, output bleed, row mixing, footer alignment, mouse click routing, caret positioning, overflow, pad transparency, hairline integrity, and virtual scroll stability.
  • prewalk.cheapModel and prewalk.strongModel configure the cheap model prewalk switches into at the first edit and the strong model it starts on.
  • /prewalk accepts an optional model argument to arm a per-session target model override.
  • edit.afterEdit selects what one turn that changed files owes before it finishes: verify (the default) runs one check when none followed the last edit, review reads back every code file changed since the last user message and judges correctness, maintainability and cross-file contracts, off neither; the legacy edit.critiqueCodeMutations boolean migrates to review or verify on load.
  • Configurable launch.cleanupWaitMs setting (default 15 minutes) purges exited launch daemon records from memory and disk after a retention TTL.
  • Exporting a session to HTML streams the snapshot into the output file instead of assembling the whole document in memory, taking an 80MiB transcript from 1007MiB of peak resident memory to 532MiB with byte-identical output.
  • A session snapshot that contains a reference cycle fails the HTML export with an error instead of writing until the disk fills.
  • bench/session-memory.bench.ts reports heap after a forced GC, current RSS and high-water RSS at each of three phases (module baseline, SessionManager.open, buildSessionContext) over a synthetic transcript sized by SESSION_MB.
  • Added model.toolCallLoopGuard.readSubsumptionThreshold (default 3) to steer models that re-read unchanged code lines back-to-back before consuming full context.
  • VEYYON_DEBUG_STARTUP=1 writes one line per phase of a prompt submission (compaction check, plan arm, context build, memory context), so a slow submit names the phase that spent the time.
  • read takes depth and limit arguments for directory listings, and a read of the session working directory root with neither now returns a concise top-level listing with per-subdirectory entry counts instead of the recursive tree.
  • A tool result that carries an image now states whether the picture reached the screen, so a model reading a file describes what it shows instead of reporting that it displayed it.
  • A picture the block gives up on after the fact, because the session's image budget demoted it or a Kitty session could not convert it, is stated to the model as undrawn instead of being reported as displayed.
  • statusLine.segmentOptions.path.displayRoots names the workspace roots the working directory is shown relative to, with ~ accepted for the home directory, replacing the two hard-coded conventions (~/Projects and /work); the first matching entry wins and a non-absolute entry is dropped and named in the log once.
  • read accepts a semicolon-delimited list of internal resources (skill://demo/one.md;skill://demo/two.md), the same list form search takes, and returns one section per entry.
  • Eval kernels gain kv, a bounded JSON store under the session's artifacts directory that survives kernel resets and is shared between JavaScript and Python without cross-session filename collisions or lost concurrent updates, and defs(), which lists the names user code has defined in the kernel.
  • Every supervised process termination records which component ended it and why, with distinct attribution for each path (operator stop, signal, restart, broker shutdown, idle reaper, OS signal, broker recovery, launch failure, external signal, and natural exit); launch list output shows the lifetime owning condition and retained completion records with exit codes, reasons, and output tails, queryable after the name is reused and across broker restarts.
  • A click on the working directory, git branch or pull-request text in the composer status line widens the location to the row and retracts the model chip to pay for it, animated over the shared expand curve, and a second click reverses it; display.transitions: off lands on the click frame.
  • /omfg forges rules that carry the extended TTSR frontmatter (astCondition, interruptMode, pathScope, repeatMode, repeatGap, repeatCompactions, warmupMatches), confirms ast-grep conditions against the conversation's tool history through the same gate chain a live stream applies, and fails loudly on a malformed optional field instead of dropping it.
  • /omfg saves forged rules to the active profile's rules directory only; the project target is gone, because project .veyyon/rules was never discovered across sessions.
  • Settings → Stream Interrupts (TTSR) groups the profile's own rules under a leading User created section instead of From native, ahead of foreign-tool and built-in sections.
  • An opt-in eval.pyWorkspace experiment teaches the agent to keep large tool results and repeated repository operations inside the persistent Python kernel, reducing intermediate transcript output without changing kernel execution.
Changed
  • A search result carries its limit and truncation notice again. The unified tool nested each type's result one level deeper than the output layer reads, so a capped search files returned five paths and said nothing about the cap, no search of any type ever named a raised limit or a page selector, and an already-spilled result was spilled and truncated a second time.
  • A capped structure search pages with skip and names the match count instead of advising limit, which the tool accepts only for a file search: following the old advice cost a rejected call, an error result and a retry.
  • A structure-search metavariable binding is elided past 60 bytes, because a binding is a source range inside the match the result has already printed line by line. A multi-node capture arrives joined onto one line, so $$$BODY was a second copy of the whole body, and a capture spanning lines entered the result with no line number for a caller to anchor on. Over five patterns of this repository the bindings cost 8,414 tokens on top of 9,052 tokens of match text, and the same five searches now cost 12,769 tokens against 19,826. A value inside the bound is kept, since it names which fragment bound to which variable for about ten tokens.
  • A text search states its per-file match cap and its internal ceiling. A search of one file returned the first 200 matches and said nothing, so a file with 4,000 matches read as a file with 200; a multi-file search capped each file at 20 with the same silence; and a search that stopped at the 2,000-match native ceiling reported a file count that was a floor as though it were a total. skip pages files and reaches nothing past either cap, so each notice names narrowing the pattern.
  • A search call rejected for a cross-type field names the fields that type accepts. In a recorded trial a model sent limit to a text search, read Search type "text" does not accept: limit, and spent a second request rediscovering the field by removing it; the rejection already costs a full round trip, so it now states the set that would have worked.
  • A read whose line bound came from the default rather than from the caller is held to the tools.artifactSpillThreshold budget every other tool result is held to, instead of a compiled 512-bytes-a-line allowance: reading packages/coding-agent/CHANGELOG.md cost 19,768 tokens and now costs 10,586, and :50 cost 23,643 and now costs 10,357. A read that names a line count still returns those lines.
  • Reading a notebook, a converted document, an archive entry, a URL body or an internal resource is bounded by tools.artifactSpillThreshold instead of a compiled 50KB constant the setting could not reach, so lowering the setting now lowers those results as it already lowered bash, eval and ssh output.
  • A @path mention in a prompt is bounded by tools.artifactSpillThreshold instead of a compiled 50KB constant, and a capped mention names the budget in effect rather than that constant; the file body, an over-long first line and a mentioned directory's listing all take the same budget.
  • A multi-range read whose first line alone exceeds the output budget names that line and its size, instead of a backwards [Lines 1-0 …] window whose continuation selector pointed back at the line that just failed.
  • A directory listing from read takes the tools.artifactSpillThreshold budget: the unsliced listing followed a compiled 50KB constant the setting could not reach, and a listing sliced by :N-M carried no byte bound at all. A capped slice names how many listing lines remain and the selector that continues them.
  • An archive directory listing from read takes the tools.artifactSpillThreshold budget instead of a compiled 50KB constant the setting could not reach.
  • A structural summary from read stops at read.defaultLimit lines or the tools.artifactSpillThreshold budget, whichever binds first, clips lines to tools.outputMaxColumns, and names the bound that stopped it and the line that continues it. A summary is a projection over the whole file and carried no bound at all, so a selector-free read of a declaration-dense file returned the whole projection: packages/catalog/src/discovery/cursor-gen/agent_pb.ts cost 326.5KB, about 82,000 tokens in one result, and now costs 3,138 tokens. Across 4,039 summaries in this repository the median is 57 lines; the 54 files over 300 lines cost 311,211 tokens between them and now cost 174,450.
  • A PDF image-member list and an agent://<id>/<field> extraction from read take the tools.artifactSpillThreshold budget. Both returned the whole collection whichever size the document or the artifact happened to be: a scanned PDF listed every extracted image, and an extraction takes no line selector, so nothing could page it. A capped list names how many members it dropped, and a capped extraction is cut by bytes and names its full size and the URL that pages it.
  • A read of a directory that names no depth lists the top level instead of recursing two levels: every entry up to 100, each subdirectory annotated with its direct-child count, and a footer naming depth: 2 for the recursive listing. Only the session working directory root answered this way before, and the second level is a default nobody asked for: over seven directories of this repository the selector-free read cost 27,568 tokens and now costs 7,131, with packages/coding-agent/src at 8,163 against 1,273. A directory wider than 100 entries states how many it held back and names depth: 1 for the flat listing of all of them; a caller that names depth or limit is unaffected.
  • A search_tool_bm25 call activates the tools it matched well instead of every ranked match up to its limit of 8, which under tools.discoveryMode: all is the whole hidden set. An activated tool's schema is re-sent on every later request of the session, so one loose query cost more than the mode saved: "keep track of what is left to do" activated todo plus set_cwd, task and web_search for 2,239 tokens a request where todo alone costs 1,048, and across eight such queries the tail was 3,319 of 7,349 tokens. A tool now activates when it scores at least half the best match, so a near-tie still activates and the same queries cost 4,030; a weaker match is returned in also_matched and a query naming it activates it.
  • tools.artifactSpillThreshold bounds what a spilled tool result costs a request, not only when an artifact is written. The window kept inline was tools.artifactHeadBytes + tools.artifactTailBytes, so a 404KB result delivered 39.8KB at a threshold of 8KB and the same 39.8KB at 200KB; it now delivers 7.8KB and 39.8KB. The head and tail settings shape the window inside the budget and keep their ratio, and the elided bytes stay recoverable through the artifact:// id. This covers every tool result except read, which is bounded by the lines its caller asked for.
  • The debug tool loads only where at least one configured DAP adapter command resolves, so a host with no debugger installed no longer pays about 1,000 tokens of debug schema on every request for a tool whose every call would fail on the missing adapter.
  • search.contextAfter defaults to 1 line instead of 3. A tool result is sent again on every later request of the session, so each line of a search result is billed once per remaining request; over eight searches of this repository the wider window cost 16,836 tokens against 11,483.
  • The eval prompt-override registry, the system-prompt eval hooks, the argot cache and the reroot hint name @veyyon/evals paths instead of the retired @veyyon/metaharness, @veyyon/typescript-edit-benchmark and @veyyon/deepswe-bench packages. No behavior change.
  • The /providers account card filters its provider sidebar: ctrl+s enters search, typing narrows the list by fuzzy match on provider name and id, the arrows move within the matches, and esc leaves search before it closes the card (#922 by @Crqptx).
  • A parked subagent is pruned rather than closed: subagent.autoClose.enabled, .parkedMs and .waitingMs are now subagent.prune.enabled, .afterMs and .waitingAfterMs, existing config files migrate on load, and the settings tab states park and prune as two stages in their own groups.
  • A parked subagent keeps its roster row for an hour, and two hours when it stopped waiting on a peer, instead of five and thirty minutes.
  • A subagent restored from a previous run is aged from its own transcript rather than from the moment this session found it, so restored agents no longer sit at "just now" forever and are pruned on the same budget as the rest.
  • session.newKeepsBackground states that a change needs a restart, because switching it does not affect the running session (#928).
  • A turn that changed files takes at most one continuation before it finishes; the verification pass that always ran unconditionally is now the verify value of edit.afterEdit and no longer stacks a second forced continuation under the review pass.
  • The Julia, Python and Ruby eval kernels share one execution loop instead of three copies of it; no change to how a kernel behaves.
  • Reading a file or fetching a URL no longer loads the document converters, and a web search no longer loads the browser fingerprint generator, because the constants those paths wanted are separated from the libraries that sat behind them, taking about 40ms off session startup.
  • The launch card is painted and flushed before the agent runtime graph is loaded, taking an interactive launch from a blank terminal for 760ms to a typable composer at 111ms.
  • The agent runtime is loaded in stages that hand the event loop back between them, so a character typed while the launch card is up is drawn in 6ms instead of 198ms; the load itself takes the same time.
  • /agents is the subagent dashboard: the surface is named that in its title, its /agents description, its keybinding descriptions, /hotkeys and the handbook, in place of "Agent Control Center".
  • The subagent dashboard no longer opens across every conversation the process is running: /process-manager and the a scope toggle are removed, and the card is scoped to the conversation on screen.
  • A locally built binary minifies identifiers the way the released one does, cutting it from 310.7MB to 303.4MB and its launch card from 143ms to 131ms; function names are still kept, so stack traces are unchanged.
  • veyyon --help renders its command list from registry summaries verified against command statics and loads only the hidden default command for its flag table, reducing a measured warm Windows invocation from 1.2 seconds to 0.13 seconds.
  • The CPU model is read once per process instead of on every system prompt build, removing about 30ms from the window before the composer accepts input.
  • No user-visible change: the once-per-process CPU model cache gained a reset the test suite calls, so a suite that fakes the platform reads its own answer instead of the one an earlier suite in the same process cached.
  • Row band painting compiles its escape pattern once for the process rather than once per painted row.
  • The default launch command imports the session runtime and ACP terminal authentication only when it runs, so loading its flag table no longer imports the runtime graph.
  • The vibe screens, the image-inspection call and an LSP hover code block draw no border of their own inside a tool block, so a block keeps one left edge; a tree connector remains only where a row belongs to the row above it, in the eval value tree, the search line gutter, the job tree and the LSP reference tree.
  • Classified runner output (cargo, bun, Go, ctest, dotnet, clippy, golangci-lint, Gradle lint, pytest, and tsc/eslint-family) opens with a result-contract header, [clean] <command> or [errors] / [errors N] <command>, carrying the verdict above a body of retained diagnostics.
  • Files → LSP is one enterable row whose nested page independently controls language servers, the agent tool, diagnostics after write or edit, format after write, lazy startup, and diagnostics deduplication; --no-lsp still disables the full stack.
  • Startup paints the resting composer, with its real hairline, ghost prompt and exact row count, in the first frame from one static component shared with the mounted zone, instead of reserving eight blank rows until mode initialization finished and letting the prompt arrive seconds into a cold launch.
  • Multi-target structure searches now execute concurrently while preserving globally ordered paging, totals, parse errors, cancellation, and target-order failures.
  • A picture a terminal will not draw now leaves a row naming the file, the media type, the pixel size and the cause, in place of [Image: image/png], including when a Kitty session cannot convert it to PNG.
  • Session creation overlaps two serial file reads with neighboring startup work: rules discovery starts as soon as the session context loads rather than after the skills await, and the vault key read starts before the secrets, env and vault entries load.
  • ModelRegistry persists its static bundled, cached-standard and cached-discovery layers to a content-verified resolved-models.json that a warm launch restores instead of rebuilding, invalidated by catalog, cache-row and custom-model content changes or a cached row crossing its 24 h freshness window, but not by SQLite sidecar churn or a provider re-verifying models it already had.
  • A failed MCP tool call decides on a reconnect from the shared socket vocabulary plus this layer's own stale-session rules, so an unreachable or unresolvable host reconnects the server the way a refused connection already did, while a live server answering 500 or holding a request past its deadline stays a failed call.
  • The debug log records which classification rules decided a failed turn's retry, next to the classified kind, so a retry nobody expected is diagnosed from the log instead of by re-reading the provider's sentence.
  • The browser tab worker and supervisor state why each teardown step and each optional probe discards its failure; behavior is unchanged.
  • The browser tab worker and supervisor reach bestEffort and optionalResult through @veyyon/utils/discarded-fault rather than the package barrel; behavior is unchanged.
  • Daemon completion parsing and eval-store serialization errors use shared type guards; behavior is unchanged.
  • Broad multi-file text searches now keep only deterministic representative matches inline and save the complete formatted result behind an artifact:// reference. The preview budget follows the turn-aware output curve from an 8 KiB search ceiling (~2 KiB early at turn 0), emitting up to two representative matches per file while preserving counts and warnings; explicit single-file and line-range searches retain their full output, and only visible representative lines are recorded as seen for anchored edits.
Fixed
  • Tool discovery ranks a tool on its full description instead of its one-line summary alone, which left 96 to 99 percent of each tool's own text out of the retrieval corpus. Over the 17 built-ins, launch scored zero for "tail the output of a server I launched" and eval scored zero for "evaluate javascript and keep the variables", while short-description tools such as goal and set_cwd ranked in six of ten realistic queries; launch now ranks first in eight of those ten.
  • Tool discovery indexes a compound word both whole and in parts, so a lowercase query reaches the word it names: SQLite was indexed only as sq and lite, TypeScript only as type and script, and IPython only as i and python, so queries spelling any of them scored zero against the tool that documented it.
  • A search limit notice is true of the result it prints beside. A text search over 84 files reported "at least one file had more than 20 matches" for a page whose largest file held 12, reported "stopped at its internal ceiling of 2000 matches" for a result of 63, and marked its complete file total "84+": the per-file flag was computed over every matching file rather than the 20-file page, and one flag meant both an exhausted 2000-match fetch budget, which leaves files unopened, and a single file's clipped match list, which does not.
  • A structure search excludes matches in prose grammars (markdown, reStructuredText, AsciiDoc, LaTeX, plain text, logs, CSV, TSV) and states how many it withheld, instead of reporting documentation paragraphs as code matches: over this repository logger.warn($$$ARGS) returned three changelog paragraphs averaging 2,000 characters, none of which contains the string logger.warn.
  • The search tool states that case is on by default and that passing false matches case-insensitively, so a case-insensitive text search no longer depends on guessing the default.
  • A directory listing reports a native addon that could not load instead of answering "(empty directory)". A container whose glibc was older than the shipped addon required got an empty listing for a full checkout on the first read ., both in the tool result and in the workspace tree the system prompt carries.
  • A directory listing reports the errno for a directory the process cannot open instead of answering "(empty directory)", which a model reads as a directory worth no further look; only a directory that is not there still answers empty.
  • An explicit --model pointing at a dynamically-discovered model (a providers /v1/models` entry or models.dev overlay absent from the bundled catalog) no longer fails with "not found among N models" when the background discovery refresh has not completed before model resolution. The deferred pattern path does a synchronous cache-aware discovery pass when none of the patterns resolve against the static catalog, mirroring the fallback already present for default-role models.
  • Unified search now preserves purpose-specific field semantics through the Antigravity tool-schema adapter, replaces primitive search tools in explicit tool lists, keeps plan/subagent/bash guidance aligned with the active tool, and redirects intercepted shell searches to search.
  • A bash-interceptor rule that still names a retired search primitive (grep, glob, find, ast_grep) now redirects to search naming the type field the tool accepts, instead of the purpose field it rejects.
  • File and structure search results are head-truncated at their own byte budget with the full output saved to an artifact, instead of relying on the shared spill layer's middle-elision. File search uses a 4 KB head window (paths are dense and mtime-sorted, so the most recently modified files are on top), and structure search uses the same 8 KB budget as text search. Both recover the full output through an artifact:// footer.
  • veyyon --help describes the grep dev command as the standalone native text-search probe, which is what the command itself says, instead of naming the retired standalone grep tool.
  • Bundled edit and write guidance now uses TTSR's deferred reminder path instead of inheriting the global interrupt policy and aborting the active model response. Every bundled tool-scoped rule must now declare its interrupt policy explicitly.
  • A streaming answer lands in the empty space below the conversation instead of pushing every row already on screen up one row per token, so the screen no longer shakes while a model talks into a viewport that is not yet full.
  • A settings search box reduced to nothing but spaces leaves search and shows the settings list again, instead of holding an apparently empty box over zero matches until esc.
  • A permission prompt for a long command keeps its answer rows on screen: the card sheds lines from the command, saying how many it dropped, instead of clipping the option list off the bottom.
  • A session file that another window wrote its session_exit record into no longer reports that window as a live second writer, so a session whose duplicate window was closed by SIGHUP stops telling the operator to close a session that has already closed.
  • veyyon --resume <id> finds the session under any profile, so the id printed on exit resolves after relaunching under a different one instead of reporting the session as not found.
  • The collab host, guest client and relay socket load when /collab or /join runs instead of during every interactive startup, and a settings domain reads the relay default from @veyyon/wire rather than through the collab protocol module.
  • Argot's dictionary generator, corpus walker and project vocabulary load when a project dictionary is first read instead of during every startup, so a session with argot.enabled off no longer evaluates them.
  • The stats dashboard's aggregator, SQLite layer and embedded client load when /stats first runs instead of during every interactive startup, so a session that never opens the dashboard stops parsing them.
  • The Python, Ruby and Julia eval backends call their kernel and executor modules on every cell instead of holding a copy of each taken when the backend module loaded, so an availability check or executor replaced after startup is the one that runs.
  • A cursor-agent model receives the operator's global, profile and project instruction files again: the assembled prompt was blanked for that api in favour of a channel the server ignores, so every layer reached the model on no channel at all; one prompt is now built for every api and carried to Cursor on the active user turn.
  • A personality named after a property JavaScript objects inherit, such as toString or constructor, is reported as unknown and falls back to the default like any other unrecognized name; the built-in catalog was indexed without an own-property check, so those names resolved to a function, the system prompt build failed silently, and the default was substituted with no warning and any personality/default.md override ignored.
  • A personality spec can no longer spell a prompt tag such as <critical> and have it render as prompt structure; only <personality> was neutralized before, and a project's .veyyon/personalities file, which arrives with a cloned repository and outranks the user's own, is injected into every request.
  • plugin install <name>@<marketplace> --dry-run no longer performs the install: the marketplace branch never read the flag, so it fetched the plugin, wrote the cache and both registries, and reported a completed install; it now resolves the version from the catalog and writes nothing.
  • plugin link <path> no longer fails with EISDIR when the plugin is already installed as a real directory from npm or a marketplace, which is the state a local checkout replaces.
  • The Agent Control Center's read-only transcript viewer expands argot shorthand instead of showing the model's raw §handle text; it parses a subagent's or advisor's persisted transcript directly, and the persisted form keeps the handles.
  • Characters typed in the same terminal read as a paste are no longer discarded; the editor read the pasted payload and the bytes following it but dropped the ones preceding it, so the last thing typed before Cmd+V disappeared.
  • Backspace works at the launch card: the startup gate refused any chunk carrying a control byte, so a character typed by mistake before the composer mounted could not be taken back and the typo was what the session started with.
  • An unattended goal keeps driving after a turn whose post-turn maintenance outlasts the continuation delay, instead of sitting active and idle until someone types.
  • Text typed at the launch card appears there as it is typed, instead of staying invisible until session startup finishes and the composer mounts.
  • Text typed before the launch card paints reaches the composer instead of being destroyed, because the startup tty flush now runs only for the relaunch backlog it was written for.
  • The advisor roster editor reports a failed save instead of clearing the buffer and claiming the write reached disk.
  • The advisor roster editor states why the model list is unavailable when the model registry fails, instead of opening a picker holding nothing.
  • /advisor status names the next move on a text client too — the setting to change or the model role to assign — instead of reporting the state and stopping.
  • Interrupting a turn stops every configured advisor's review as well, instead of leaving one model call per advisor streaming and billing against a turn that was just stopped.
  • A prompt typed at the launch card while the session is still starting is carried into the composer instead of being discarded, and the terminal's own probe replies are still excluded so no escape sequence reaches the draft.
  • A bash working directory on a different Windows drive from the project renders as the absolute path it is, instead of being reported as a path inside the project.
  • Web search keeps trying the next provider when one returns only follow-up suggestions or intermediate search queries, instead of counting that metadata as a result and handing the model a list of questions; a SearXNG "did you mean" on a misspelled query no longer ends the search.
  • Public Web search reports which engines did not answer within the deadline instead of reporting an empty web, so a slow or bot-walled engine no longer surfaces as "returned no renderable search content".
  • The VEYYON_TINY_DEVICE and VEYYON_TINY_DTYPE reference states the providers.tinyModelDevice and providers.tinyModelDtype defaults as the default sentinel each setting actually holds, and names what that sentinel selects, instead of listing CPU and q4 as the stored values.
  • A collapsed ssh result measures its preview in rendered rows at the frame's inner width and shows the newest three lines with a count of what was hidden, instead of slicing the first five newlines and overflowing the frame whenever a remote line wrapped.
  • A terminal resize, theme switch or session switch no longer seals a backgrounded subagent's tool card mid-flight, so the progress it reports afterwards still reaches the card instead of being dropped for the rest of the turn.
  • The composer defect oracle counts only the prompt glyph the frame states, so a transcript row opening with $, > or ! is no longer reported as a second composer prompt.
  • An exported or shared session escapes quotes in every value it places in an HTML attribute, so a link target, link title or image mime type carrying a " renders as text instead of closing the attribute and adding an event handler that runs on the share origin.
  • An exported or shared session escapes the model names in its header, so a model name carrying markup renders as text.
  • The write tool accepts a file holding an indented numeric mapping key, so a docker-compose 80: http, a Kubernetes container port and a dict literal keyed by port number are written instead of being refused as pasted search output.
  • A read, write, search or image target that reaches outside the working directory through a symlink asks for approval even when it carries a selector suffix, so link.env:1-10, db.sqlite:users:42 and archive.zip:dir/file.ts:5-9 are no longer auto-approved where the bare path would have prompted.
  • A server-side compaction failure states the reason once instead of wrapping it in its own prefix, so a host without the compact route reports "Server-side compaction is not available for openai-codex/… (404 Not Found); falling back to local compaction." rather than nesting the message inside itself.
  • A tool status line shortens the paths it was given, so search, ast_edit, debug and set_cwd show ~/project/src instead of printing the home directory into the transcript, and a long path list is truncated rather than pushing the row past the terminal width.
  • The /omfg panel names the rule it saved under ~, truncates it to one row, and shortens the paths embedded in a failure message, instead of printing the home directory in its subheader, footer and error text.
  • The launch status header truncates the command it is starting instead of drawing a row wider than the terminal, and a failed launch collapses to a few lines with a count of the rest until it is expanded, instead of printing every line the process wrote.
  • A conversation /new leaves running in the background keeps its own row in the agent registry instead of being overwritten by the session that replaced it, so it stays listed and its finished turn no longer marks the foreground conversation idle.
  • The /resume picker floats its card in the middle of the screen instead of drawing it against the top edge over a half-blank terminal, most visible right after /new or a profile switch, when the folder holds few enough sessions to make the card short.
  • Clearing memory waits the full deletion retry window before reporting the database files removed, instead of half of it, so a Windows SQLite lock that outlives close() no longer leaves files behind under a success message.
  • Ollama discovery keeps a configured base URL's path, so an endpoint mounted at a subpath behind a reverse proxy is found instead of reporting no models.
  • The write tool and the hashline parser agree on what a numeric-keyed mapping looks like, so a body of true, false or null values is accepted by both instead of one each way.
  • Cancelling an LSP request while a project is still loading returns on every language server, instead of returning on most and throwing AbortError on rust-analyzer alone.
  • Reading a directory the process cannot open reports the permission error instead of rendering it as (empty directory).
  • A commit-analysis or changelog reply that a model writes as text is matched against the shape the caller needs, so a refusal, an error object or a reasoning object no longer crashes the parse or fills a changelog with one bullet per character.
  • Launch daemon teardown and browser process cleanup no longer throw on a host where the native addon cannot load; a daemon falls back to ending its PTY and a browser scan reports no candidates, instead of the failure ending the session (#917).
  • ctrl+g passes a GUI editor the flag that makes it block, so an edit made in VS Code, Cursor, Zed or Sublime is read back into the composer instead of the editor forking and the composer keeping the text it already held.
  • A /guided goal turn survives a model that wraps its JSON in prose, a code fence or a brace run that is not JSON, instead of ending the interview with a parse error.
  • A /guided goal turn shows a spinner while it runs, so the screen between an answer and the next question no longer looks inert.
  • A streaming answer no longer composes a frame one row taller than the viewport on every chunk, which moved the window down to fit and back up on the next frame and shook the screen for as long as the answer kept arriving.
  • Mounting a chat block no longer routes home-anchor slack for rows the content has already taken, which composed a frame taller than the viewport and moved the window on that frame and back on the next.
  • An irc send with await ends as soon as its recipient is terminated or leaves the roster, instead of blocking for the full timeout, or forever at timeoutMs: 0, on a reply that can no longer arrive; a recipient that is merely idle or parked is still woken by the delivery and given the full timeout to answer.
  • A truncated advisor preview, retry reason, and background-task label measure their budget in display columns rather than UTF-16 code units, so a wide or multi-code-unit character is no longer cut in half or counted as one column.
  • The tool approval card, the ast_edit diff preview, and an eval display() value cut long text at a code point rather than a UTF-16 code unit, so an emoji or rare CJK character sitting at the limit is no longer split into an invalid lone surrogate.
  • The Stream First Event Timeout and Stream Idle Timeout settings name the VEYYON_* environment variables that override them, instead of a PI_* prefix that no longer exists.
  • A Kagi search refused for exhausted credits reports that, instead of a generic request failure, on any status code other than 401, 402 and 403.
  • A rendered tool error shortens embedded home-directory paths, so an error card no longer prints the home directory and no longer spends its width budget on the prefix instead of the reason.
  • A job label truncated for display keeps a regional-indicator flag whole instead of emitting half of one, and an empty width budget yields an empty label rather than an ellipsis a column too wide.
  • Brave and Jina web search honor an API key held in the credential store, instead of reporting themselves unconfigured unless the key was also exported as an environment variable.
  • A JSON-RPC header field whose name merely ends in Content-Length, or a server log line that mentions it, no longer sets the frame length and parks the language-server connection on a byte count the stream never reaches.
  • A grep over an archive member removes its extracted scratch directory when extraction fails partway, instead of leaving it behind for the life of the host.
  • Waiting for a language server's project load removes its abort listener, instead of leaving one on the turn's signal for every feature request made during that turn.
  • A path list naming an entry the process is not permitted to stat resolves that entry as present, instead of failing the whole tool call with a permission error.
  • The working-directory boundary selects its targets by value, so a path argument carrying no usable value can no longer suppress the paths it also inspects.
  • An auto-compaction failure names its actual cause when the rejection is not an Error, instead of reporting the literal text compaction failed.
  • A liveness probe of the lspmux server cancels its timeout once the process answers, instead of leaving a timer pending for the rest of the window on every probe.
  • SQLite path detection restarts its scan at the beginning of the string, so a scan that ended abnormally cannot make the next one miss candidates.
  • The write tool rejects content carrying hashline patch markers, unified diff hunks, or read-output display prefixes with an error naming the detection and stating corrective action instead of silently stripping prefixes before writing.
  • Converted LLM message wrappers preserve reference identity across turns so the provider context canonicalizer re-renders only newly appended messages.
  • Memory pipeline SQLite storage (storage.sqlite) manages schema migrations via PRAGMA user_version and dynamically backfills missing columns on legacy databases.
  • The session tree selector formats custom tool arguments using width-aware truncation without double-stringifying string arguments or splitting surrogate pairs.
  • Renderer failure notices sanitize thrown errors, subjects, and fallback descriptions by shortening embedded home directory paths, replacing tabs, and truncating long payloads.
  • The extension inspector origin path truncates Windows backslash paths on directory boundaries and uses standard preview limits.
  • veyyon session declares the sessions alias so the plural command routes to session analysis.
  • Error-formatting call sites use errorMessage so thrown non-Error values and empty-message errors surface readable text, and a reported cause no longer repeats a redundant Error: prefix ahead of its message.
  • AgentSession logs compaction tail elision artifact persistence failures explicitly instead of swallowing them.
  • Quitting no longer hangs when a background session never settles.
  • /new typed while the agent is answering starts the new session without interrupting the answer: the running turn finishes in the background and is flushed to its own transcript, while the composer attaches to a fresh session immediately.
  • /resume onto a session that is still answering re-attaches the running session instead of replaying its transcript as finished text, so its answer keeps streaming into the view and the session being left takes its place in the background.
  • veyyon bench --model @role and veyyon dry-balance --model @role resolve a configured model role instead of failing to find a model named after the alias.
  • The model name segment on the composer status line is preserved against wide working directories and git branch names by ranking it above location shortening in footline degradation.
  • A clipped working directory on the composer status line now carries one ellipsis at the front instead of one at each end, so the directory the session is in stays visible and the visible text reads as a suffix of the real path.
  • The composer status line clips the working directory and the git branch from their own fronts together instead of dropping the branch, never clips a branch short enough to read whole, keeps the path's icon in front of the clip mark, and gives up the context gauge before letting either part fall under its floor.
  • A clip mark on the composer status line is painted in the colour of the text it kept instead of the colour in force before the segment, and a clipped directory or branch opens on a name boundary within four cells of the cut rather than on an orphaned separator.
  • The composer status line no longer paints an empty location zone beside a wide gap: the cells a shed right-group part frees are given back to the working directory and branch, including the cells freed by the shed that ended the fitting, and a token estimate or context gauge is given up before the zone falls under the width at which a name reads.
  • The composer status line keeps the running-subagent count after every other part has gone, instead of giving it up to widen the working directory; at the widths where the count is the whole row the location zone is empty rather than the count being absent.
  • The composer status line's state chips stay on the right edge of the row when no working directory or branch shares it, instead of rendering against the left margin.
  • The composer status line leaves the location zone empty rather than painting a directory fragment with its icon cut off, at the widths where the zone cannot hold an icon, a clip mark and a letter.
  • A click on the composer status line's working directory or branch now shows that name in full, spending the model chip and then the rest of the row's readouts for the room, and only leaves it clipped when the name is longer than the whole row; the click previously paid with the model chip alone, and lost even that room to a context gauge the collapsed row had shed.
  • The composer status line's expansion travels on a 320ms symmetric curve instead of a 180ms front-loaded one, and the room it frees now tracks the widening text frame by frame, so the row no longer steps backward at the start of a click before opening.
  • A click on the composer status line shows the half that was clicked in full rather than widening both, and a readout the click narrows past the width a name reads at is given up whole instead of resting as a fragment.
  • A clipped working directory on the composer status line opens on a directory boundary on Windows, where a path outside the home directory keeps its \ separator; the clip previously had no boundary to find in such a path and always opened mid-name.
  • The composer status line's path budget is counted in terminal cells rather than UTF-16 code units, so a working directory holding wide or astral characters is clamped to the width it paints and is never cut between the halves of one character.
  • The composer footline's click targets — the context gauge, the secrets chip, the goal readout and the path expansion — answer a click in a session whose transcript has not yet overflowed the viewport, instead of staying inert until it does.
  • A stripped working directory keeps the case it has on disk on Windows, instead of being lowercased by the case-insensitive comparison that decided it was under the root.
  • The status line's default-branch lookup no longer raises an unhandled rejection in a directory holding a .git on a host with no git on PATH; the lookup fails to the main fallback instead.
  • The composer status line no longer prints a control character or an escape sequence a name carries: a working directory, git branch, worktree label, multi-repo suffix or provider model name holding a tab, carriage return, bell, newline or escape is sanitized before it reaches the row, where it previously opened a hole in the width arithmetic, overwrote the row's own start, rang the terminal on every repaint, or handed the terminal a sequence of its own.
  • Outbound wire path canonicalization only relativizes paths matching the active session working directory instead of accumulating prior working directory roots, preventing distinct absolute paths in command output from collapsing to the same relative representation.
  • A working-directory change in a live session no longer re-renders earlier messages already sent to the provider, so only messages appended after a set_cwd render against the new directory.
  • Session CPU limits fail closed on unsupported or failed budget groups, lift rate control on removal, refuse a process-creating command before the process exists while leaving launch stop and launch list reachable, escalate over-budget termination from SIGTERM to SIGKILL, and track descendant processes on macOS.
  • Saturated session CPU limits now refuse spawns for MCP servers, extensions, hooks, and custom tools before the process is created.
  • Windows session CPU limits disable Job Object rate control on non-positive or non-finite core counts rather than throttling the process to the minimum rate.
  • A bash command carrying a leading cd, or a relative cwd, is now judged for approval against the directory it will actually run in.
  • Patch failure error rendering shortens absolute paths to avoid displaying home-directory paths and bounds large unmatched hunks with an omitted line count.
  • Filesystem cwd boundary checks expand comma- and whitespace-delimited path arguments matching execution, preventing multi-target reads or searches from bypassing working-directory approval prompts in non-yolo modes.
  • The read tool renderer sanitizes resolved directory paths with shortenPath to avoid displaying unshortened home-directory paths.
  • Stopping a daemon during restart backoff cancels the timer and attributes operator stop without recording a duplicate completion entry, and broker recovery terminates daemons left in restarting state without dead recovery branches.
  • Multi-target structure searches across overlapping paths deduplicate matches so totals, file counts, and paged results are not duplicated or truncated.
  • Acknowledging a completed background job before lifting its watch no longer delivers a duplicate completion notification when retention is zero.
  • A generic tool card with an undrawable image result no longer accumulates duplicate image placeholder rows on rebuild.
  • With Language Servers off, which is the default, the write and edit tools no longer start a language server to inject diagnostics, format the file, or notify the workspace that a file changed, including on the ACP client-bridge write path.
  • A malformed irc send reports its own validation error instead of being reported as an interrupted wait when a peer message arrives in the same batch.
  • A job list snapshot or cancel-only call keeps its own result when an interrupt lands beside it.
  • The composer sits on the viewport bottom on the frame it mounts instead of appearing mid-screen for a moment after the launch card is adopted.
  • The Agent Control Center reports the model an agent is running now instead of the one recorded when it registered.
  • /new and /resume restart the driving session's roster clock, so the Agent Control Center no longer ages the main agent from the conversation that ended.
  • The main agent's roster age advances with its turns instead of freezing at process start.
  • Web search no longer reports "Public Web returned no renderable search content" when one engine serves a bot wall: Startpage's proof-of-work interstitial served at HTTP 200 is now refused as a challenge, and an engine answering with zero results no longer ends the aggregate's wait for a slower engine that has results.
  • Adding an account with a key the provider rejects now leaves the error on screen, instead of remounting the account manager over it so the attempt looked like it silently did nothing; cancelling still returns to the account card.
  • veyyon plugin install --dry-run now resolves the target and fails when it cannot be installed, instead of exiting 0 with "Would install" for an unpublished npm name or a missing git repository, and reports the name and version the target resolves to rather than a 0.0.0-dryrun placeholder (#911 reported by @Crqptx).
  • veyyon plugin uninstall now removes a plugin installed from a local path, which was permanently unremovable because uninstall read only plugins/package.json dependencies while linking registers the plugin in the runtime config and node_modules; the linked directory itself is left untouched.
  • veyyon plugin doctor no longer reports "no plugins installed" in a profile whose plugins were all linked, and names how many linked plugins it found.
  • veyyon plugin config <plugin> now names the missing subcommand instead of reporting "Plugin name required" for a plugin name that was supplied.
  • A completed background job now fills its still-pending originating tool call instead of starting an unrelated recap turn after an interruption, including when zero retention is configured or foreground completion races background delivery.
  • Automatic compaction parks the run, or drains already-queued input once, when every summarizer candidate refuses, instead of reporting that nothing happened and looping.
  • A successful local compaction rescue retries without restoring the failed overflow or truncated assistant turn, and idle compaction stays silent.
  • Agent transcript headers and roster rows share terminal, approval-blocked, and peer-waiting status precedence, so interrupted agents settle red and untyped agents render without a dangling separator.
  • /agents keeps a parked subagent focused, preserves its reconstructed assistant messages, tool calls, and results, reattaches a revived session, and rejects stale revival, removal, scope, and rapid-focus races instead of switching to the wrong transcript.
  • IRC broadcasts no longer wake completed idle peers; direct messages still wake the addressed peer.
  • ImageMagick pixel caches used by proof capture and HD demo scripts stay inside an owned scoped directory that the parent removes after child failure without deleting concurrent or inherited unrelated directories.
  • An indented row inside a tool block keeps its indent when it wraps at a narrow width, instead of continuing at the block's left edge.
  • The finalization reminder counts the files a multi-file edit actually wrote: a call that reports overall failure after writing some of its files is now unverified evidence, and a file a per-file entry skipped is no longer named as affected.
  • A mutated path is XML-escaped before it reaches the hidden finalization reminder, so a file name spelling </system-reminder> cannot end the reminder envelope early, and a relative ast_edit path is resolved against the call's working directory before duplicate paths are collapsed.
  • A colour or title escape sequence a command writes in two pieces no longer leaves part of itself in tool output: the sink holds a sequence its chunk ended inside until the piece that finishes it arrives, and drops one the stream never completes.
  • A launch tool block no longer renders as a bare title with no rows: the header drops the placeholder ellipsis while op is still streaming, and every operation falls back to the result text when the structured detail it renders from is absent.
  • The compaction.remote setting description documents that server-side compaction applies to supported OpenAI, Azure OpenAI, and ChatGPT Codex Responses models.
  • branchSummary.reserveTokens reaches the branch summarizer, which previously used the built-in 16384 reserve whatever the setting said.
  • The ssh tool works again on a profile whose directory nests more than a few levels deep, because its connection multiplexing socket is named from a 16-character digest instead of a 64-character hash that exceeded the 108-byte Unix socket limit, and a path that still cannot fit drops multiplexing with one warning rather than failing the connection.
  • debug reaches the Python debugger on a host that installs python3 and no unsuffixed python, because an adapter may now declare alternate command spellings, while a command written in dap.json is still used exactly as written.
  • A subagent that calls yield with unusable data now fails the run instead of returning success with the system warning as its result, matching how a subagent that never yields at all is already reported.
  • A subagent result that cannot be serialized now fails the run and reports the serialization error, instead of returning success with an unparseable error envelope as its payload.
  • launch recovers from a broker connection that fails while the broker is still binding its socket, instead of caching the rejection for the life of the process and reporting that first error on every later call.
  • bash runs cd - && … again, instead of reading the leading cd as a directory literally named - and rejecting the call with a path the operator never typed.
  • A bash working-directory error shortens the path it reports instead of printing the absolute one, which put the home directory into the tool result and the transcript.
  • search reports why an archive could not be opened or read when the failure is not an Error, instead of the word undefined.
  • A detached daemon that exited while no broker was supervising it is recorded as its own exit, not as a non-detached daemon terminated by the replacement broker.
  • Background conversations abandoned at shutdown before their transcript finished flushing are named in the log, instead of leaving a short file as the only trace.
  • A streaming answer no longer slides the whole conversation up one row per streamed row: the anchor slack now sits below the content and above the composer, so a streamed row lands in the empty space and the composer keeps the viewport bottom.
  • The registry's static-stage snapshot (resolved-models.json) now actually hits on a warm launch. Two defects kept it missing every time: the fingerprint stamped models.db and its SQLite sidecars by mtime, and SQLite moves those files on every connection — including the writer's own — so the launch after every write rebuilt and rewrote the 12 MB file; and authoritativeFreshProviders was serialized as a Set, which JSON turns into {}, so the reader's array guard rejected every restore regardless. The fingerprint now reads a row-content stamp from the cache table, the field serializes as an array, and a relocated registry writes its snapshots beside its own database instead of beside the default profile's. Warm registry init drops from about 183 ms to about 49 ms; test/the-static-model-stage-snapshot-hits-unless-cache-content-changes.test.ts defends each case.
  • Unified search approval preflight now covers every multi-target syntax execution accepts; search also excludes byte-truncated context from editable seen lines, unions ranged and unrestricted text scopes, orders equal-mtime file results by path, suppresses pattern errors from unrelated structure languages, and distinguishes exhausted structure pages from a search with no matches.
  • Unified search now keeps warning-heavy text results within the inline byte budget, preserves semicolon path lists longer than one filename component, excludes matches hidden by generic truncation from editable seen lines, classifies every SSH path-list encoding at the execution approval tier, matches native Unicode tie ordering, and reports exhausted text pages with their totals.
  • Unified search no longer broadens or misroutes malformed calls: files-mode rejects a path owned by other modes while retaining the historical /-means-workspace alias, structure search rejects unsupported ssh:// scopes without an approval prompt for work it cannot execute, immutable internal or fetched sources never receive editable hashline anchors, and the Bash interceptor no longer redirects mutating or otherwise non-equivalent find commands to a read-only file search.
  • The plan-mode extension example now keeps canonical search available both while planning and after restoring normal tools. It previously advertised retired grep/find identities, requested a nonexistent find tool, and dropped search when plan mode ended.
  • Memory summarization now retains canonical search results from session rollouts. It previously allowlisted the retired grep tool name but discarded every result emitted by unified search before Stage 1 summarization.
Removed
  • The /providers account card no longer writes accounts.loadBalancing: its b key and footer chip are gone, Settings → Providers → Accounts is the one writer, and the card reports the stored value.
  • Dropped the Ecosia web search engine; it answered a search with a Cloudflare challenge rather than results, and the Public Web aggregate now fans out to Startpage, Google, DuckDuckGo and Mojeek.
  • A launch from your home directory no longer prints the three-line notice about relocating to a scratch directory; the relocation is unchanged, and /cwd and the status line state the session's directory.
  • The tools.unifiedRuntime experiment and the runtime tool it gated. The unified tool never shipped enabled, duplicated the eval and launch prompts at 2,368 tokens, and the experiment was abandoned in favour of keeping eval and launch as separate tools.

Veyyon is a fork of oh-my-pi 16.5.2 (MIT, by Can Boluk). Everything before the fork is upstream history, not a veyyon release. See oh-my-pi's releases for it.

History

Built on oh-my-pi.

Veyyon is a fork of oh-my-pi (MIT) by Can Boluk, shipped as its own product. Full commit history and per-release detail live on GitHub.