# Changelog Release notes for Prime Agent. Historical TypeScript release notes are recorded in the [TypeScript changelog](https://github.com/PrimeIntellect-ai/prime-agent/blob/v0.9.8/packages/coding-agent/CHANGELOG.md). ## [0.10.5] - 2026-11-18 - Daemon, print/JSON (`prime-agent -p`), and RPC stdio-mode refinements now write the harness stores the session's digest reads: the global store under the agent dir's `harness/` path and the local store in the session's own artifact directory, instead of the orphan `~/.prime/agent/harness_state.json` and `~/.prime/agent/refinement_history.jsonl` (written by daemon and RPC `/refine --global`), one shared `~/.prime/agent/sessions/harness/harness_state.json` (written by every session whose session dir is the sessions root), and `/harness/harness_state.json` under any custom session dir (`--session-dir`, `PRIME_AGENT_SESSION_DIR`, or the `sessionDir` setting). The old files stay on disk but nothing reads them anymore. No automatic migration ships: entries in the orphaned global file can be merged by hand into `~/.prime/agent/harness/harness_state.json`; the shared local files mix sessions and cannot be attributed back. - Bundled skills now win name clashes: a project or user skill with the same name (for example `goal`) no longer replaces the bundled one. To use your own skill instead, add `"skills": ["-"]` to `~/.prime/agent/settings.json`. - The bundled `factory` skill loads again, and a skill with invalid frontmatter now reports the YAML error instead of vanishing. - New `prime-agent skills` command lists every discovered skill and why it is active, hidden, shadowed, disabled, or invalid. A new session also shows a warning when a skill could not load. - `/skill:` now works anywhere in a message, including for hidden skills. Unknown skill names show a notice. - Switching a Python skill between the bundled copy and your own now installs the selected copy into the Python kernel. - Fixed uv discovery rejecting the global `~/.local/bin/uv` install when Prime Agent is launched from the home directory (notably on Windows), and made the missing-uv install hint match the platform. ## [0.10.4] - 2026-11-17 - Fixed `rlm.collect` reporting a child as completed (`done`, settled) when it read idle for a moment right after its task was admitted and then started running. - Fixed submits staying blocked with "Daemon reconnection failed" after the TUI reconnected to the daemon. - Fixed a paste while the /factory page is open landing in the hidden prompt editor. - Retrying a session whose worker crashed now relaunches the worker instead of reporting success while the worker is dead. - `/update` and `prime-agent update` now describe the update as installing the latest version, without mentioning the TypeScript version or the Rust build. - Session HTML exports now escape the `read` tool's line range, so a crafted `offset` in a tool call can no longer inject HTML or script into the exported page. - `/mcp login` and MCP OAuth token refresh now give up after 8 seconds on an unresponsive authorization server instead of hanging, which also blocked other processes waiting on the same refresh. - The agents view's Model column now widens to fit the longest model name when the terminal has room, instead of cutting names at 32 characters. In narrow terminals the model name is shortened first, and the Session column keeps at least half of the shared space. - Sessions created with `rlm.create_session` now keep the parent's telemetry opt-out (`DO_NOT_TRACK`, `PI_OFFLINE`, `PRIME_AGENT_TELEMETRY`). - The TUI no longer turns raw OSC 8 terminal-link sequences in model output, tool arguments, file contents, agent messages, or background shell output into clickable links; only links the TUI renders itself (such as markdown links) stay clickable. - On shared Unix hosts, the daemon now refuses a default socket directory owned by another user or replaced by a symlink, and clients refuse a daemon socket served by another user. - Files that can hold private data are now created readable only by you (mode 0600 on Linux and macOS): large bash output spill files in the temp directory, rewritten session transcripts, window-cache sidecars, refinement history, diagnostic logs, and persistent-shell output and records. Existing files keep their current permissions. - When `PRIME_API_KEY` or `--api-key` supplies the Prime Inference key, requests no longer send the team saved by `/login` with it. The team now comes from the same place as the key: `PRIME_TEAM_ID` (or no team) for an environment or command-line key, the saved team for the saved login. - Private Prime Inference models now come from the same account-scoped model catalog as the public ones. A newly granted private model appears after the next catalog refresh (startup, login, or the hourly refresh) instead of within 5 minutes, and a key without a team selection now sees the private models the server lists for it. - Closing a menu with Ctrl+C (settings, tree, fork, confirm, share upload) no longer makes the next quick Ctrl+C at the editor force-quit Prime Agent about 1.5 seconds later. - The kernel's Python runtime now requires patched releases of mcp (>= 2.2), PyJWT (>= 2.15), and opentelemetry-api (>= 1.45.1), which clears the open security advisories against its locked versions. - When a provider rejects a signed-in OAuth credential that has not expired yet, the session now refreshes the token and retries once. When the refresh fails, the turn ends with a message that names the provider and the reason and asks you to run `/login`, instead of a bare provider error or "No API key". - ACP: `session/list` and `session/load` are served (`loadSession` and `sessionCapabilities.list` are advertised), so editors such as Zed can list saved prime-agent sessions and reopen one. The ACP session id is now the prime-agent session id; `session/load` opens the saved session (reusing its live worker if one is running), replays its conversation as `session/update` notifications, and then answers. Subagent sessions and sessions without messages are not listed. - Release archives on every platform now include `THIRD-PARTY-NOTICES.txt`, with the license texts of all Rust crates built into the `prime-agent` binary and the crates each license covers. Installs keep it beside `LICENSE` in the payload directory. - Turning auto-compaction on or off in a running daemon session now takes effect at the next turn instead of after the session restarts. - A session that replaced another in the same daemon worker (fork, import, new or switched session) no longer stays marked closed: its goal and autonomous continuations run again, and background bash completion notices reach it. - Accepting an `@` file, path, or slash-command suggestion right after typing more characters now replaces the whole typed token. Before, part of the old token stayed in front of the completion (`@pr@prime-agent/`). - Every model request a session makes now carries an `X-PI-Session-Id` header with the session's stable id, so the Prime Inference gateway aggregates one session's calls into a single trace instead of one trace per request; requests without a session context send no header. - The prompt editor suggests emoji for shortcodes: typing `:` plus two letters at the start of a word (for example `:he`) lists matching emoji in the completion menu, and accepting one (Enter or Tab) inserts it, so `:heart` becomes ❤️. Typed text is never converted on its own: `:heart:` followed by a space stays as typed. No menu opens in code spans, fenced code blocks, URL paths, or text like `std::fmt`. Turn it off with the `emojiShortcodes` setting or the Emoji shortcodes row in `/settings`. - Fixed sessions whose sessions folder sat behind a symlink (such as macOS `/tmp`) silently dropping every message after the first session was created, and stopping an attached session on macOS showing "connection lost" instead of the stop notice. - Fixed a duplicated `cwd` field in pa-daemon's watch tests that broke the workspace build. - The TUI stays busy for the whole agent run instead of going idle after each model turn: Esc and Ctrl+C between two tool turns now abort the run, the loader no longer blinks out between turns, and `!` bash output started mid-run is held until the run ends. A run that ends without its own `agent_end` (an abort before the run starts, or a run interrupted by a tree move or compaction) is now still closed on the wire, so attached clients no longer stay busy after it. Refinement planning runs in the background, with harness edits and model notices committed between complete agent runs. Existing context rows stay unchanged, and resumed sessions append an updated harness digest only when durable harness state changed. - Fixed an injected custom message without a timestamp failing the turn with "parse failed: missing field timestamp": a missing clock now fills from the serde default on the message type at parse, and a row that still fails to parse logs a redacted summary (its customType, top-level keys, and byte length) plus the requesting session's identity to the daemon log. - Fixed sessions wedging on the provider's request-size limit: a provider 413 now triggers one compact-and-retry. - The ACP terminal-quiescence observation now reports `outstandingBackgroundJobs` (live background `bash()` handles plus `[bash-done]` notifications still queued for delivery), so hosts that close episodes on quiescence no longer tear a sandbox down while a detached background job is still running. - Project settings can no longer redirect session storage or select executable configuration when opening a repository. - The Rust TUI reports its status to terminals that support OSC 7501 (the Program Status Protocol), such as Rex: it asks the terminal once at startup and writes reports only when the terminal answers. A chat reports working for the whole agent run (including a pending provider retry), done when the run ends normally, error when it fails for good, and idle at rest or after an interrupt; the agents view reports idle. On exit it leaves the terminal's record alone, as the protocol asks. - The daemon sends a failed run's `agent_end` after the retry loop's next event, so clients see a pending `auto_retry_start` before the end of the attempt it retries. - Run completion keeps its original cancellation outcome even when an abort request races delivery of the final event. ## [0.10.3] - 2026-11-11 - Concurrent OAuth credential lookups now keep the refresh flight reserved until the refreshed credential is committed and reloaded, preventing a second lookup from reusing the expired refresh token between fetch and persistence. - `!` command output and autonomous gate output no longer turn a multi-byte character split across two pipe reads into replacement characters, and gate output past the 1 MiB cap no longer panics when the cap lands inside a character. - `prime-agent send` now accepts `--steer` and `--follow-up`, as its help already listed: `--follow-up` queues the message until the agent's current turn ends, and `--steer` (still the default) delivers it as steering while the agent is busy. - `/refine` and the automatic refine review now say why they failed: a reply cut off at the model's output limit reports the limit and the model, and a provider error reports the provider's message, instead of "Refiner did not return a JSON object". - A graceful daemon shutdown can continue interrupted turns on restart while explicitly cancelled queued input remains parked. - A daemon shutdown interrupted mid-stop (a lost shutdown verdict, or a supervisor death inside the stop pass) keeps the session resumable on the next boot instead of archiving it. - `/context` groups each factory run's agents under one `factory ` row with the run's summed tokens and cost, and deleted subagents now stay in the totals as `deleted` rows, so the `/context` total cost matches the agents view's session total. - Factory machines can now run a Python function as a state: a state with `"python": {"import": "", "callable": ""}` instead of a `subagent` runs the function in a short-lived isolated subprocess, receives its bound inputs as a dict, and returns its declared outputs, so deterministic routing and data shaping no longer need a child agent. The `/factory` diagram labels such states `(py .)`. - Factory page: the arrows now walk each run's header and the states that spawned a session, and Enter or → opens that state's latest session. The opened session shows its `depth N` label, and leaving it returns to the factory page on the same run and state. Navigation never stops a run any more: stopping takes two presses of Ctrl+X (the agents view's stop key) — on a run header it stops the run, on a running state it stops that state's agent — and `r` resumes a paused run. `/resume ` now opens that session instead of exiting the app. - `await bash(cmd)`, `await handle` and `await r.handle` now always return after at most 1 second in sessions with `[bash-done]` notifications: a command still running by then returns the usual snapshot (`r.running` True, `r.handle` the live handle) and its `[bash-done]` notification arrives on completion. The `yield_after` parameter is gone; passing it raises a `TypeError`. - Factory runs no longer wake the parent session once per state: factory children are told their final message is the state's output instead of replying with `agent_message.send`, and their exit and failure notices are no longer posted into the parent conversation (the factory still reads every settle and failure through `rlm.collect`). - User `mcpServers` entries accept `clientSecret` and `scopes`, and OAuth discovery accepts an issuer that differs only by a trailing slash, so Google's Drive and Sheets MCP servers can be logged in with your own Google OAuth client; logins against Google request offline access so the grant refreshes. See `docs/google-workspace-mcp.md`. - → now opens the selected shell in the bash panel, like Enter (← already closes it), and the footer says so. - Edits made with the python tool's `edit` skill now show in the ipython cell card: one `path +N -M` summary line per edited file, and the numbered diff rows at the Details and All levels. The python highlighter no longer crashes the TUI on some non-ASCII text. - `rlm.spawn(..., cwd=...)` starts a subagent in another directory and loads that directory's `AGENTS.md` project context. - Session cost and token totals now include the model calls of `/refine`, the automatic refine review, and side questions (`/btw`), even when the caller is cancelled, and a subagent's compaction spend now reaches its parent's total. - The agents view and the expanded activity dock now count a session's stored factory specs beside its live runs (`⚙ N factories · M running`), and the expanded shells row leads with its running and persistent counts. - A `python_repl` cell that runs past its time limit is now interrupted instead of only getting a note afterwards. The model sees an error that names the limit and explains how to move long work into asyncio tasks; variables survive. If the cell ignores the interrupt, the kernel is restarted. The model can set a per-call `timeout` (seconds, max 180); the default stays 60 s (`pythonCellTimeoutMs`, `0` disables). - `rlm.session.messages(start, limit, role=..., agent=...)` and `rlm.session.count()` read the session's own transcript, or a family member's, from the Python REPL, including the messages compaction summarized away. - Billed rows now count in goal budgets, session stats, and telemetry: get_session_stats reports whole-branch spend, including children, across compactions. - The factory's settle-capture cap rose from 8,192 to 65,536 characters, at parity with the 64 KiB bound the host already puts on `rlm.collect`'s answer text. A settled child's fenced JSON output longer than the old cap was truncated mid-object before the parse and failed capture although the envelope carried the whole answer; one that fits the collect bound now binds whole. - Factory json output ports now also bind from a bare JSON object that ends the settle answer (a plain-text tail after prose, a fence that lost its markers, a punctuation-dirty tail), instead of failing the settle with "no JSON object containing output" and burning a re-admission. - A turn no longer ends silently when the model's final reply has no visible answer or was cut off at its output limit: the reply is retried once, and a second failure ends the turn with a visible error (ACP clients receive an error instead of `end_turn`). Harness notices and agent messages may still be acknowledged silently. - `rlm.end_turn()`: a sanctioned terminal programmatic call in the Python REPL ends the turn — the host marks the executing cell, the tool result confirms "turn ended", and no further assistant response is streamed. A tool batch now terminates on ANY end-turn result instead of requiring every result to terminate, so work cells and the end-turn call in one message both execute and the turn still ends. Bedrock joins consecutive user turns, so an ended turn's history does not break the next request there. - Fixed GPT Responses conversations losing encrypted reasoning when replaying earlier turns. - Preserve signed, redacted, and reasoning-only responses when continuing conversations with Anthropic, Bedrock, Google, and chat-completions providers. - The /model picker labels live-catalog Prime Inference routes with their declared serving class (`prime-hosted` on Prime's clusters, `prime-gateway` through the Prime gateway) instead of the plain provider id. - Prevented repository settings and Python skills from running code automatically when a project opens. - Fixed Bedrock concatenating two signed thinking blocks streamed under one content index into a single block, which failed replay with an "Invalid signature" error. - Fixed GPT Responses streams wiping accumulated function-call arguments when an output item done event arrives with empty arguments. - A Codex request cancelled right before it was sent no longer leaves the session's WebSocket stuck as busy; later turns in that session reuse the cached connection and continue the response chain again instead of opening a new socket and resending the full context every turn. - Reopening the current session over RPC (`switch_session` to the session's own file) no longer revives an older Python namespace: the reopened kernel restores only after the replaced kernel has saved its final snapshot. - `prime-agent status`, `doctor`, and `shutdown` now see the default daemon on Linux for uid 1000 and root (socket dir `/tmp/prime-agent-1000` or `/tmp/prime-agent-0`) instead of skipping it, so `shutdown` stops it and `doctor --fix` can reap it. - After a repaired Python kernel had to be discarded, a failed re-setup no longer leaves `python_repl` failing for the rest of the session, and a later discard re-installs the runtime (`rlm`, `bash`, skills) instead of starting a bare kernel. - Added a **Web search provider** setting in `/settings` → **Agents**: the `websearch` skill can use You.com Eco Search instead of Serper (still the default). Paste the Eco key in `/mcp` under **You.com Eco (web search)**; the choice applies to new sessions. - Directory locks no longer delete a newer lock when two processes reclaim the same stale lock, or when a holder whose lock was reclaimed releases it; oversized lock owner records are no longer read in full. - Project settings (`.prime/agent/settings.json`) can no longer link outside the project: such a link is now refused with an error instead of being read and overwritten. Links inside the project keep working, and saves now write to the linked file instead of replacing the link. Project settings files are limited to 4 MiB. - Bumped rustix 1.1.4 -> 1.1.6 so the cargo-deny advisories gate is clean again after RUSTSEC-2026-0486 (informational xattr unsoundness, affected >= 1.0.0, < 1.1.6) landed in the RustSec DB; no other dependency moves. - Autonomous-gate workspace snapshots no longer start programs a repository's own git configuration names (fsmonitor hooks, index-write hooks, diff text conversion and external diff programs, including in submodules, and promisor lazy fetches over any transport); submodule edits and commit bumps still count as workspace changes, and `.gitattributes` clean/process filters, including inside submodules, remain a documented limit. - The running daemon now serves re-authenticated provider credentials on the live session's next request: a rotated credential (a fresh `/login`) or an expired OAuth token (refreshed in place) is picked up per request, instead of serving the credential captured when the session started until a `/reload` or a daemon restart. - The first-run provider picker now says that Prime Inference is your default model, and its continue row reads `Continue with Prime Inference (default)`. When you started with your own model, it says you are signed in to Prime Inference and offers `Continue with your current model` instead. - Fixed the transcript view following output again after suspending the TUI with Ctrl+Z. - `agent_observe.recent_messages` reads its message members now instead of guessing from previews. - MCP server configuration is read from user settings only; a cloned project's declared servers never execute at session start. - A click on a Python card opens that card's session, not the one selected when the click began. - A multi-line paste on Windows arrives as one paste again instead of one event per line. - Tool calls show a live timer while they run. ## [0.10.2] - 2026-10-28 - The static usage layer no longer tells agents to await commands before ending the turn: since #3580 daemonless sessions also wake on a queued `[bash-done]` turn, every session kind has completion notifications, and the no-polling rule (end the turn and collect the result on the done notification) is the one turn-end contract. - Agents view: leaving a session now returns the focus to that session's row, even after `/switch`, `/new`, `/fork`, or `/resume` in the chat, and when the row loads late. - `tool_execution_end` events on the RPC stream and in `--mode json` print output carry `isError` again, as the TypeScript version emitted them. - Azure OpenAI Responses requests no longer fail with 404 on the v1 API: they now post to `/openai/v1/responses?api-version=v1` with the deployment as the request's `model`, instead of a `/deployments//responses` route Azure does not serve. A different `AZURE_OPENAI_API_VERSION` (for example `preview`, or a dated version against a custom `/openai` base URL) is sent as the `api-version` query instead, and an empty one falls back to `v1`. - A `!` command or a model `bash` tool call whose shell dies from a signal (for example a crash, an OOM kill or `kill`) now reports 128 + the signal number as its exit code, so the model is told it failed, like the TypeScript version. - ACP: a failed `session/prompt` now carries `kind`, `category` and `retryable` in its error data next to `details`, so a host can tell an exhausted model connection (`kind: "model_transport"`, the only retryable kind) from a context overflow (`context_limit`), an authentication or rate-limit error, or a harness failure. - The bundled websearch skill is now offered only when a Serper API key is set up (saved through `/mcp`, or `SERPER_API_KEY`), instead of being advertised on installs where every call fails; `bundledSkills.websearch` in settings still turns it on or off explicitly. A key saved in `/mcp` activates the skill in new sessions (`/new`). - A `python_repl` cell that runs longer than the new `pythonCellTimeoutMs` setting (default 60 seconds, `0` disables) now gets a note on stderr that points long shell work to `bash()` and long Python work to smaller cells. The cell is not stopped and keeps its result. Sessions without the daemon add no note. - When a running subagent is cancelled, deleted with `rlm.delete_subagent`, or stopped because its parent session is killed, the parent's semantic-edge ledger now records a `child_cancelled` line with the reason (`user_cancel`, `parent_delete` or `close:killed`) and no `child_returned` line beside it. A daemon restart or update records no such line. - A PageUp or wheel scroll that reaches the top of the loaded transcript while older messages are still loading is no longer lost: the view scrolls once the older page arrives. - `@` file completion is now instant: the project's files are indexed in the background when the TUI starts, suggestions come straight from that index, and the menu opens in the same frame as the keystroke. Large file changes (such as moving a big directory) no longer block typing. Which files match, and their order, is unchanged. - Requests to Gemini models through the Google and Vertex AI providers no longer fail with `400 INVALID_ARGUMENT`: the system prompt is now sent in the content format Google's API requires instead of as a plain string. - MCP OAuth login no longer fails when a server's advertised authorization server and its metadata `issuer` differ only by a trailing slash (for example TickTick). - Rows written around a compaction (a queued prompt, a rename or refinement notice) no longer show twice in the transcript. A steer or follow-up queued while you navigate the session tree or fork now waits until that finishes and runs on the branch you end up on, as the TypeScript version did. - Restoring a kernel snapshot no longer reopens saved file handles: a leftover handle opened for writing (even a closed one) used to empty its file on every restart. Restored file objects now come back closed, keeping their name and mode; open the file again to use it. - On openai-completions and Mistral providers, a turn whose tool calls were streamed without a function name no longer ends silently: the call gets a `Tool unknown_tool not found` error so the model can retry, and a nameless call next to named calls is dropped. Sessions that already stored such a call no longer fail every later request with `400 ... missing a function name`. - A subagent whose final model call fails with a provider error (after retries) now settles as `error` with the provider's message in `rlm.collect`, `rlm.list_subagents` and the factory, instead of `done` with no answer. If it had not replied yet, the parent gets a failure notice. - Requests through openai-completions, openai-responses and Mistral no longer send two `Authorization` headers when the model or the caller sets one (for example a custom provider with `authHeader: true`), so strict servers stop rejecting them. - A cost a provider reports in `usage.cost` is now used for any OpenAI-compatible provider, not only OpenRouter, so gateways in front of OpenRouter such as LiteLLM no longer record $0. - `prime-agent mcp add --bearer-token-env-var` now writes the `bearerTokenEnvVar` settings key the MCP engine reads, so HTTP MCP servers added this way send their bearer token instead of connecting without auth. Settings already written with `bearer_token_env_var` keep working. - Claude Haiku 5.x models on Anthropic and Bedrock now use adaptive thinking with an effort level instead of budget-based thinking, which the API rejects with a 400; on Bedrock, turning thinking off now disables it explicitly. Haiku 4.5 keeps budget-based thinking. - Prompt caching on openai-codex works again: every request in a session carries the same session id, which now stays stable across resumes and daemon restarts, so Codex WebSocket reuse and cached input work like the TypeScript version. Other providers also send the session id where the TypeScript version did (for example `prompt_cache_key` on OpenAI and Azure, and Mistral's affinity header), and side questions reuse the conversation's cache. - Bedrock works again: profiles that use `credential_process` now get credentials, requests are signed the way AWS expects instead of being rejected, and streamed replies are no longer empty. `AWS_CONFIG_FILE` and `AWS_SHARED_CREDENTIALS_FILE` are honored for credentials and region, and Claude 5 and newer models on Bedrock get prompt caching. - Fresh installs now ship the live model and MCP catalog, instead of a test snapshot that stayed listed until the first catalog refresh. - Gemini 3 and newer models on the Google and Vertex AI providers (for example `gemini-4-argon` and `gemini-flash-latest`) now send `thinkingLevel` instead of `thinkingBudget`, so the thinking levels actually differ, and thinking off sends the model's lowest level instead of a zero budget some models reject. Gemini 2.x keeps `thinkingBudget`. - On Anthropic-compatible endpoints that return thinking without a signature (such as MiMo, Kimi and DeepSeek), earlier thinking is now passed back as thinking instead of as visible text, so the model no longer echoes its reasoning more each turn. Claude models drop unsigned thinking, which they reject; the new `requiresThinkingSignature` compat flag overrides the per-model default. - A session with a large Python namespace no longer overflows its context after repeated compactions: each `[python-state]` notice lists at most 200 names or 4 KB (ending with `+N more`), and only the newest notice is kept in the model's context. - OpenCode and OpenCode Go requests carry the `x-opencode-session` header with the conversation id again, including compaction, refinement and branch-summary calls. Those three calls now send the session id to every provider for prompt caching, as the TypeScript version did, but always over SSE instead of the Codex WebSocket. - Prime Inference models dropped from the model catalog because the server sent no specs for them are now named in a log warning. - Kernel: `rlm.factory.run(...)`, `rlm.factory.help()`, and every other `rlm` namespace call keep working after a cell runs `import rlm`, and `dir(rlm.harness)` now lists the harness methods. - Factory machines can loop back into an entry state: an entry state may now declare inputs as long as all of them are optional. Its first entry binds the null sentinel, and a later entry through a transition binds the real output, so an investigate/verify loop no longer needs a duplicate re-investigate state. A required input on an entry state is still rejected, with a message saying it must be optional. - A parent session's usage totals now include a grandchild's spend that lands after the parent already read the child's spawning turn. Before, that spend was dropped from the parent's totals, so long-running grandchildren were undercounted. - Reopening a saved session now publishes its passive subagents before the first Agents view snapshot, even when worker registration is delayed or the opening client disconnects. - A subagent spawned while its parent has no turn running (for example a factory run resumed between turns) now gets its task prompt at once instead of up to 60 s later. A parent turn aborted by a manual compaction or tree move no longer leaves later spawns waiting for that bound either. - `/refine` and automatic refinement work again with Prime Inference team billing: they sent no team header and failed with "Refiner did not return a JSON object". ## [0.10.1] - 2026-10-21 - A corrupted line in the RLM spawn ledger is now skipped and logged instead of failing every ledger read, so session listings and new subagent spawns keep working. - Idle passivation now defers while a command to the session is still in flight (for example adding a heartbeat or cron job), so such a job no longer stays dormant until the session is resumed. - On macOS the daemon no longer spawns a `ps` process for every client connection and every process-liveness check; start times and zombie states are read in-process from the kernel's process record, cutting idle battery drain. - The chat title and the agents view now include the spend of deleted subagents, and both show the same number. - Large sessions reopen faster: the usage scan is saved when a session closes and reused on the next open. - Removed the `-t/--tools`, `-nt/--no-tools` and `-nbt/--no-builtin-tools` flags. They were silently ignored; they now fail as unknown options. - `/update` in the TUI no longer hangs on an installer prompt or swallows keystrokes: the installer now runs detached from the terminal. - The daemon no longer wakes up every second for each session it keeps running across a restart or update: it now waits on the operating system's process-exit notification (kqueue on macOS, pidfd on Linux), which cuts idle battery drain. On macOS this also stops a `ps` process being spawned every second for each such session. - ACP sessions and TUI `--no-session` sessions are now owned by the client that created them: they are never idle-passivated, and their agents-view row is removed when they stop instead of lingering as a passive row that cannot be resumed. - Messaging a subagent whose worker was idle-passivated now wakes it and delivers the message, instead of failing with "Unknown active session". - Nightly updates download the nightly installer directly instead of going through the stable installer first. - A malformed escape sequence containing a non-ASCII character (for example, Option-key input mixed with Cyrillic or accented text) is now passed through as typed text instead of crashing the terminal UI. - A session file whose header id is not a plain file name (for example `../x` or an absolute path) is now treated as an invalid session, so its artifacts can no longer be written outside the session-artifacts folder. - `prime-agent list` and other daemon commands no longer hang until they time out when a busy daemon sends a large response slowly. - A subagent that fails because its task cannot be delivered, or whose worker becomes unreachable, now sends a failure notice with the error to its parent, and a goal waiting on it resumes. - Cancelling a running prompt by its admission id now reports it as `owned` instead of `cancelled`, and with `cancelOwned` the cancel now stops the turn. - On Linux the daemon no longer spawns a `ps` process each time it checks the identity of a process that has already exited (stale session leases, session reuse, update checks). - Agent runs no longer stall the session while recording git state: the git checks at the start and end of each run now run in parallel in the background instead of blocking other work on the session. - Long lines inside fenced code blocks now wrap onto the next row instead of being cut off at the edge of the terminal. - An ipython cell that mostly runs shell commands now shows as `bash` in its collapsed card, with its first `bash()` command and how many more it ran, including commands run through helper functions. - A prompt stashed with ctrl+s now returns to the empty prompt box after you send another prompt, as it did in the TypeScript version. - ACP sessions run one prompt turn at a time: a prompt sent while a turn runs, or while a cancel is stopping it, is refused instead of overlapping it; a cancel now stops only its own turn, and a failed turn no longer reports itself as finished. - The installer's `--force` no longer stops the daemon the install runs under, waits for the normal drain before signalling a stuck daemon, and no longer leaves a temp directory behind when it exits early. - After a daemon restart or update, a parent session lists its subagents again, and messaging one wakes it as the parent's subagent, instead of rlm.list_subagents() coming back empty. - New `prime-agent factory list | import | export` commands manage the machine library of shareable `MACHINE.md` factory templates; the bundled seeds (`builder`, `pr-manager`, `review-sweep`) ship inside the runtime so every install sees them, personal machines live under the agent dir, and an invalid machine never persists. - `await rlm.factory.run('')` runs a library machine directly without creating a harness entry; a machine that exists but is broken names its exact errors, and an existing export target is refused instead of silently overwritten. - Each model request now carries a request id header, and each session writes a semantic-edge ledger (request, subagent and compaction events) matching the TS agent. - ACP mode over the daemon now rejects an `initialize` request with invalid params (for example a string `protocolVersion`), as the TypeScript version does. - `--mode acp` no longer falls back to a separate in-process engine when the background service cannot start: it now requires the daemon, and a startup failure prints `Error:` and exits 1, like the TypeScript version. A `session/cancel` sent as a request instead of a notification now answers "method not found", like the TypeScript version. - ACP mode now reports heartbeat schedule changes and shell commands that another client runs in the session (as tool calls), and leaves out empty tool output, like the TypeScript version. - ACP `session/new` now clears the connection's MCP servers when admitting them fails or times out, so servers the worker applied before a lost acknowledgement no longer stay admitted, matching the TypeScript behavior. - ACP prompts now finish only once the subagents they started have finished: the completion update reports how many were still running, the final update reports zero, and cancelling or closing the session cancels them. Closing stdin no longer waits for running work to finish. - ACP mode over the daemon now honors the session flags: without `--no-session` the conversation is saved like any other session and `--resume`, `--continue`, `--fork` and `--session-dir` open or place it; only `--no-session` sessions belong to the editor's connection and end when it disconnects, and `session/close` stops the running work without ending the session. Startup failures (an unknown or busy session) now exit with an error instead of starting, and `DO_NOT_TRACK` / the telemetry setting now also disable the daemon session's telemetry. - ACP prompts and other long daemon requests (waiting for a turn, idle or headless completion, compaction, tree navigation, session start) now wait up to 24 hours like the TypeScript daemon instead of failing with "Session worker timed out" after 10 minutes, and a session worker that dies mid-request now fails it right away instead of after its restart. - The daemon now always delivers a turn's events before the reply that ends the turn, and ACP mode no longer waits up to 30 seconds after some turns before answering. - Added the `rlm.rename(new_name, session_id=...)` kernel function: renames the calling session (no `session_id`) or a direct child selected by spawn handle, `list_subagents()` row, or session id — never by child name — reusing spawn-name validation and daemon-owned sibling uniqueness; the renamed session gets a `Session renamed `old` -> `new`` transcript notice (suffixed ` by parent` when a parent renamed it), and the kernel readiness check now requires a runtime with `rlm.rename`. - Agents view: the rename affordance (ctrl+r / `/name`) now also applies to subagent rows, which carry the same renameable session identity as top-level agent rows. - A request that a crashed session worker never answered now fails with "Daemon worker socket closed", the same error the TypeScript daemon reports. - Client-owned sessions (`--no-session` ACP and TUI sessions) now stop 30 seconds after their client disconnects without closing them, or 30 seconds after a daemon restart if the client does not reconnect, instead of running on hidden until the daemon stops. - Clicking a compaction summary, a harness refinement notice, a skill invocation, or an injected prompt (heartbeat, goal, subagent status) in the transcript expands or collapses it again. - openai-completions streams no longer hang forever when a server keeps the response body open past the `data: [DONE]` marker (a persistent SSE channel with no content length, chunked terminator, or half-close): the stream now ends at the marker like the TypeScript SDK, so the turn runs its tool call instead of waiting silently for an EOF that never comes. - A `maxTokens` configured in models.json (or a per-model override) now reaches the provider unchanged instead of being silently clamped to the 32000 default output ceiling; catalog models keep the default ceiling ([#755](https://github.com/PrimeIntellect-ai/prime-agent/issues/755)). - The Windows one-liner is real again: the release pipeline publishes `install.ps1` (the stable-channel render, the channel's own base + fallback to beta when stable carries no Windows build) on every beta cut instead of waiting for a first Rust stable that has not been cut, and the README's PowerShell command points at the copy that actually serves (the merged repo file, the same route the Windows battery installs from) instead of the domain prefix that 404s. - Session resume no longer wedges when the saved state held a `bash()` handle: snapshots skip live process handles, whose restore reopened a stale fd number and killed the restored kernel's event loop. Restoring also refuses to reopen any pickled raw fd number (legacy snapshots, user pipe objects), failing just that saved name instead of the whole kernel. A kernel that drops a protocol frame now logs it to kernel-stderr.log instead of failing silently. A timed-out request whose code was still being sent to a stalled kernel no longer leaves the kernel permanently busy; the kernel restarts instead. - Internal: daemon log, panic, and test assertion messages no longer print session ids or fixture API keys (CodeQL `rust/cleartext-logging` cleanup). - ACP mode now resolves a prompt turn whose final model response stopped at the provider's output-token limit with `stopReason: "max_tokens"` instead of `end_turn`, so a truncated answer is no longer indistinguishable from a finished one; autonomous-run limits keep their existing stop reasons (the TypeScript version does not map the truncation case). - A spawned subagent's kickoff task now renders as an agent message from the parent (labeled `[task from parent]`) instead of an unlabeled user message, and spawn prompts are no longer expanded as slash commands or prompt templates, matching the TypeScript version. - `prime-agent update` on a Homebrew-managed install (Cellar formula or Caskroom cask) no longer attempts an installer self-update: it now refuses and points at `brew upgrade prime-agent` (or `brew upgrade --cask prime-agent`). - Model output streamed over HTTP no longer shows replacement characters in place of CJK characters or emoji when a provider's chunk boundary lands inside one: the stream holds the split bytes and decodes the character once it is complete. - The `/` and `@` autocomplete dropdowns now open, and drag auto-scroll keeps scrolling, while a reply streams, instead of waiting for the stream to pause. - With many agents running, session workers send at most one roster update at a time and no longer look up model details while holding the session lock, which cuts background CPU during subagent fan-outs and keeps state queries responsive. - Listing agents (CLI list, resume preflight, the agent roster) and spawning a named session no longer stall behind one unresponsive session worker: resident summaries are read concurrently under a short per-worker bound that degrades an unreachable worker to its recovering row, and the saved-session and scheduled-jobs roster scans moved off the supervisor's runtime threads. - Session workers whose registration reaches an interrupted stop now retire and release their session lease instead of repeatedly registering and re-running the stop after a daemon restart. - Print and JSON runs now release their session lease after the runtime stops, including error exits and panic unwinding, so detached session writers finish or are cancelled before another run can reopen the session. - Daemon housekeeping now reclaims dead-owner session leases and obsolete cache files, retains recent socket logs, and removes retired worker recovery journals only after their writer is proven gone. Journals with unverifiable ownership and flat TypeScript update status records are preserved. Premature explicit lease releases on RPC disposal and orphan teardown have been removed. - Print-mode goals consume eligible empty-turn backoff wakeups and report the no-progress continuation cap rather than silently losing further progress. - Opening a session no longer scans the whole RLM spawn ledger and the whole session-artifacts tree: only the opened parent's own subagents are re-listed, and a create that makes a brand-new session skips the scan, so session opens stay fast as the ledger grows. - Keep a submitted prompt draft consumed when the daemon connection closes before its reply, preventing an accidental duplicate submission after reconnect. Inspired by [Pi Durable](https://github.com/earendil-works/pi/tree/main/packages/durable) and [Pi Pocket's §05 “Exactly once” explanation](https://tannermidd.github.io/pi-pocket/durable.html#once). - Replacement session workers stay supervised after re-registration, and failed worker relaunches after an abandoned update resume crash recovery instead of leaving the session unsupervised. - Agents view: the selected agent's row now expands to show its latest `rlm.progress_note` (live child progress) while it runs. - Progress notes fit narrow panes and clear before an aborted run is published as idle. - HTTPS clients and Codex WebSockets now trust operating system certificate authorities alongside bundled roots, and honor custom CA bundles supplied through `NODE_EXTRA_CA_CERTS`, including the default proxy streaming path. - Daemon recovery journals now preserve intact records and safely remove an incomplete trailing record after a crash, including a cut in Unicode text, so subsequent records survive reopening. Healing syncs worker recovery data before replacement and stops on journal read failures instead of rewriting unreadable data. - A parent session's usage and cost totals include its subagents' usage again: child usage attribution rows are written to the parent's transcript file, so live totals count child cost and a resumed parent keeps it, matching the TypeScript version. - Attribution retries are idempotent: each row keeps the stable identity of its frozen report, and a re-delivered report appends nothing once that identity is already in the transcript, so a partial save or a lost cursor cannot double-count child usage. - Wrap complete sign-in URLs and login actions in narrow terminals, giving the onboarding login panel more space when needed. - Upgrading from the npm package no longer deletes the native `prime-agent` command when npm and the installer share a bin directory, even if the npm uninstall fails or is interrupted. The installer now fails when the installed command cannot answer `--version`, instead of reporting success with a broken command. - On macOS, socket paths are now checked against the native 103-byte limit, and a long `TMPDIR` (for example under Nix) no longer breaks the daemon: its sockets move to `/tmp/prime-agent-` when the default location would be too long. - Settings changes preserve unrelated and concurrently updated fields, and no longer overwrite a settings file that failed to parse. Adding the first MCP server also recovers from the null server map written by older settings saves. - `mcp.config` host requests now resolve integrations live: an MCP server connected or configured mid-session (e.g. through `/mcp`) is dispatchable from the kernel without restarting the session. Added a configurable auto-compaction percentage with five-point settings steps, retention-aware triggering, and preserved model output headroom. - Add an enabled-by-default, global-only **Harness refinements** toggle in `/settings` → **Agents**. Project settings cannot override it. Turning it off prevents refinement generation and loading saved harness rows into future model requests; existing saved state is preserved. - Disabled `refine.run()` requests report a refusal without scheduling work. Plans completed while disabled are discarded. Undelivered digests are deferred until a turn admitted with refinements enabled; toggling does not re-arm a consumed digest. - Earlier replies and summary prose may already reflect refinements, and sent requests cannot be recalled. Start a new disabled session for a conversation that has never used saved refinements. - Factory execution also requires harness access for stored specs and subagent references: `factory.run()` refuses while refinements are off, including library-machine lookup. It does not start children or change saved state. - On macOS, a long `TMPDIR` no longer breaks the daemon socket for installer and npm installs: when the default socket path would exceed the 103-byte limit, it moves to `/tmp/prime-agent-rust-`. - Factory resident states now reject `retries`, and the factory help plus the pr-manager seed's fixing prompt spell out the recovery posture a re-run needs when an earlier attempt already changed the working tree. - The kernel's `model.info` and `compact.status` context window now follow daemon model switches (set_model, cycle_model, and provider failover) instead of reporting the session-creation model. Slack is available in the MCP connector list with browser login, token refresh, and support for its registered desktop callback port. - Terminal worker stops on macOS (and Linux kernels without pidfd) now send SIGTERM and SIGKILL via kill(2), gated by the start-id identity check before each signal, instead of silently reporting the worker as survived. - Saved-session catalog rows no longer include `allMessagesText`; full session transcripts remain unchanged. Current Rust and Desktop clients do not use this field, but older TypeScript clients and older typed consumers that require it are incompatible with the new daemon. - Kernel startup no longer fails on a raw EACCES when the kernel venv's directory is not writable by the current user: a venv that still runs the runtime yields its python with the missing Python skills disabled behind the unavailable-skill notice, and a venv that cannot run the runtime errors naming the venv and the `PRIME_AGENT_KERNEL_VENV` / `PRIME_AGENT_KERNEL_PYTHON` overrides. - Agents view and `/resume`: the newest 200 sessions load first, scrolling loads more, and a search loads the rest. A footer shows how many older sessions are not loaded yet. - Remove automatic session archiving and the `sessionArchiveMaxAgeDays` and `sessionArchiveMaxSessions` settings. The agents view and `/resume` page through the live session store instead. - Keep lazy recovery of files archived by older Rust versions: a saved-session wake by ID, ID prefix or exact name restores a matching archived file when no live session matches. Existing live files are never overwritten; other archived files stay in place until addressed. - The agent prompt now sanctions ending a turn with a text-only reply and forbids placeholder no-op tool calls (such as a `pass`-only cell) used to acknowledge a message or signal idleness.