ruby_llm-ag_ui 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8529d394d1ef5d52bc73952e047ee5303634af7aa7738cc894acc8dde378f8b
-  data.tar.gz: ed676da00af762d17fbf6d1a743b995f03d1e7744aba9afb985b95c20bedf93f
+  metadata.gz: fd1d89205c88b89562445e5f654f2f2f931753ac4ff4e2ed4434031ad65251d6
+  data.tar.gz: ec70b5e27313a50c8596beaa33c2de9f3b8fc46fab5968b309cc8f626b4a70a0
 SHA512:
-  metadata.gz: 34df865e3f9dd71cbf573ad7a89d19259d16931685cb153df6aab6e989d92be68407f6207e654fc44f615b625a840a90a44e6c4e725e5781e976e253d6744457
-  data.tar.gz: 40c5c7fd607e2ce6ccd54e53e6e6e8c2482bf7645d3155e4cdf0eedb95c58f3337bb481650a44c902863629a52bc70cd03dd4224ecaad2ab0546a947f633a0e1
+  metadata.gz: 7526b6e10f776726e8647efa1a47819d4958b0f0e54cb57f65c81968c4929bbf7330a326197adcbc869f1cc3333921d37f8eb74eb088da9f71690cea7a2c6715
+  data.tar.gz: ec8fd2a7271e5aa28f8084716a75ebd8d5067a2d7d4e164aa521e8ceeea4b24897397242f1110ef0cd6cd4b5588dd0fb7c25e732c137ea196c5249ef5ece7f28

data/CHANGELOG.md

@@ -6,6 +6,31 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-20
+
+### Added
+
+- Explicit stopped-worker recovery with a `worker_lost` outcome, retaining run
+  identity and exposing unknown tool effects for host reconciliation.
+- Atomic storage revisions and independent-process SQLite reservation,
+  approval redemption, conflicting-write, and worker-death tests.
+- Exact-run, actor-scoped cancellation and HTTP abort workflows in the offline
+  browser example, plus real RubyLLM HTTP timeout and cancellation checkpoints
+  verified without a provider connection.
+
+### Fixed
+
+- Continue a live run after its response transport disconnects, preserving the
+  real outcome and side-effect identity instead of failing the run on a write.
+- Reject stale record writes and preserve uncertain database-write outcomes.
+  Disable callbacks even when a producer cannot persist its final record.
+- Keep uncertain reservation and approval acknowledgements separate from run
+  failures, without executing a provider turn or guessing whether a decision committed.
+- Recognize Puma connection failures as disconnected transports and classify
+  Faraday timeouts as `transport_timeout` instead of generic transport errors.
+- Require JSON 2.x so Rails 8.0 can load a real RubyLLM chat without passing
+  a removed `quirks_mode` option to JSON 3.
+
 ## [0.2.0] - 2026-10-19
 
 ### Added

data/README.md

@@ -19,7 +19,7 @@ RubyLLM and AG-UI maintainers.
 ## Install
 
 ```ruby
-gem 'ruby_llm-ag_ui', '~> 0.2.0'
+gem 'ruby_llm-ag_ui', '~> 0.3.0'
 ```
 
 Requires Ruby >= 3.2, RubyLLM >= 2.1 and < 3.0, and `ag-ui-protocol` 0.2.x.

data/docs/_advanced/client-example.md

@@ -45,6 +45,17 @@ redacted by default. Approved tools also publish synthetic progress counts;
 the host policy withholds progress messages. The text, sanitized failure, and cancelled scenarios show
 the other run outcomes.
 
+During approved progress, **Cancel server run** requests cancellation for the
+exact fixture actor, thread, and run. The host rejects another actor, an old
+run id, or a completed run. The synthetic tool checks cancellation before its
+effect. This does not establish cancellation latency for a real provider or
+arbitrary tool.
+
+**Disconnect stream** calls the client's HTTP abort. The producer keeps running
+and records its actual outcome. Reconnect after it finishes to read that result
+without repeating the tool. An early reconnect is refused while the host still
+owns the active chat. The timeout scenario produces a sanitized recorded failure.
+
 Use **Reconnect completed run** after a successful turn. The client sends the
 original input and receives the recorded outcome and snapshot; no new model
 turn or text delta is produced.

data/docs/_advanced/rails-integration.md

@@ -106,8 +106,11 @@ what makes run identity survive a worker:
 
 - `reserve` inserts; a `RecordNotUnique` means another worker won, and the
   existing row is attached or refused by digest.
-- `redeem_interrupt` runs under `row.with_lock`, so exactly one resume records a
-  decision and the tool runs once.
+- `redeem_interrupt` uses a conditional update and revalidates competing
+  decisions, so only one caller redeems an approval.
+- `save` checks record revisions and refuses stale writers. Keep its returned
+  record for the next update. See [Worker Recovery]({% link _advanced/worker-recovery.md %})
+  before closing a run whose producer stopped.
 - `find_interrupt` is scoped by `(scope, thread_id, interrupt_id)`, so an
   interrupt id is not a global key.
 

data/docs/_advanced/worker-recovery.md

@@ -0,0 +1,104 @@
+---
+layout: default
+title: Worker Recovery
+nav_order: 4
+description: Close a run after confirmed worker loss without repeating unknown tool effects.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How to close a run whose worker has stopped.
+* How record revisions prevent stale writes.
+* Why recovery cannot prove or undo tool effects.
+
+## Recover a Stopped Worker
+
+First confirm through your process manager that the producer has stopped.
+Then load its record using an authorized scope and exact identity:
+
+```ruby
+record = store.find(scope: authenticated_scope, thread_id: thread_id, run_id: run_id)
+raise 'Run not found' unless record
+
+# The host has confirmed that the producer and its tool threads have stopped.
+recovered = store.recover(record)
+recovered.status # => :failed
+recovered.failure.fetch('code') # => 'worker_lost'
+```
+
+Use `ActiveRecordStore` when the record must survive a process exit. Recovery
+changes a reserved or started record to failed. It retains the identity,
+snapshot, and input digest. The original request can reconnect to a sanitized
+`RUN_ERROR` with code `worker_lost`; it cannot execute the run again.
+
+Recovery does not stop a worker. A timeout, disconnected browser, or old
+`updated_at` value does not prove the worker is dead. Confirm that all producer
+and tool activity has stopped before calling this method. The gem does not
+provide leases, worker discovery, or automatic recovery.
+
+## Keep the Latest Record
+
+Each successful store write increments `RunRecord#revision`. Keep the record
+returned by `save` if you write it again:
+
+```ruby
+record = store.save(record.start(now: Time.now))
+record = store.save(record.finish(:succeeded, now: Time.now))
+```
+
+`save` and `recover` raise `StaleRecordError` when the stored revision changed
+since you read it. This error is a `RunConflictError`. Reload and inspect the
+current outcome before making another decision. A terminal outcome cannot be
+replaced by recovery. The revision is separate from event sequence numbers.
+
+The memory store checks revisions under its mutex. The ActiveRecord store uses
+a conditional database update against the observed payload. Competing approval
+redemptions reload and revalidate after a conflict; a repeated decision is a
+replay, and a disagreeing decision is refused.
+
+## Handle an Uncertain Database Write
+
+`Run#stream` raises `PersistenceError` if storage fails without a reliable
+acknowledgement. It does not attempt another terminal write or send a guessed
+`RUN_ERROR`. The first write may already have committed. When storage becomes
+available, reload the exact identity. Reconnect if it ended; confirm the worker
+has stopped before recovering a non-terminal record.
+
+This applies to identity reservation and approval redemption as well as status
+writes. If approval acknowledgement is lost, the decision may already be stored
+even though the chat never received it. Inspect both records and reconcile the
+chat; do not issue a new resume or execute the tool on the assumption that the
+decision failed.
+
+A stale or failed producer disables its mapper callbacks before returning, so
+reusing its chat cannot append events to that old stream.
+
+## Reconcile External Effects
+
+A tool may complete its external change before the worker dies. A recovered
+record says that execution ended without a recorded outcome; it does not say
+that the tool failed or that no effect occurred. Inspect the external system
+and use host-owned idempotency keys before starting another run. Never delete
+the reservation to retry an uncertain effect. The gem does not promise
+exactly-once external effects across crashes.
+
+The host also serializes different run ids that share one mutable chat. Run
+identity and approval redemption do not lock an entire conversation.
+
+## Upgrade the Store Contract
+
+The revision lives in the JSON payload, so the shipped table needs no new
+migration. Records written before 0.3 load with revision zero. Drain old workers
+before upgrading: a 0.2 writer does not honor the new conditional-write contract.
+Custom stores must implement atomic revision checks, return the incremented
+record from `save`, and provide the same recovery semantics as `Store::Base`.
+
+## Next Steps
+
+* [Reconnects and Run Identity]({% link _core_features/reconnects.md %}) - report a recorded outcome.
+* [Security and Deployment]({% link _advanced/security-and-deployment.md %}) - keep authorization in the host.

data/docs/_core_features/cancellation.md

@@ -0,0 +1,84 @@
+---
+layout: default
+title: Cancellation and Timeouts
+nav_order: 5
+description: Request cancellation on the authorized producer and distinguish it from a disconnected stream or provider timeout.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How to request cancellation on the producer's chat.
+* Why aborting a browser request does not cancel server work.
+* How provider timeouts become recorded failures.
+
+## Request Cancellation in the Host
+
+Resolve the active chat through your host's authenticated registry, using the
+exact actor, thread, and run identity. The lookup below is application code:
+
+```ruby
+chat = authorized_active_chat_for(current_actor, thread_id: thread_id, run_id: run_id)
+chat.cancel
+```
+
+RubyLLM checks cancellation cooperatively. When it raises `CancelledError`,
+`Run` closes open content and persists a cancelled outcome. The client receives
+`RUN_FINISHED` with `outcome.type` equal to `cancelled`. A cancellation request
+is not proof that the run has stopped; wait for its recorded outcome.
+
+Reject a cancellation for another actor, a previous run, or an inactive chat.
+Otherwise a delayed cancellation can stop a later turn. The host serializes
+operations on a mutable chat and delivers cancellation to the worker that owns
+it. Calling `cancel` on a newly loaded chat in another process does not cancel
+the original in-memory object. The gem supplies no cross-worker message broker.
+
+## Keep HTTP Abort Separate
+
+`HttpAgent#abortRun()` stops the browser's HTTP subscription. It does not call
+`Chat#cancel`. While the producer remains alive, the gem detaches its failed
+writer and continues to record the actual outcome. Reconnect with the same
+input and run id after completion to read that result.
+
+Wire an explicit, authorized cancellation endpoint when your application needs
+server cancellation. The maintained client example shows both actions. See
+[Client Example]({% link _advanced/client-example.md %}).
+
+## Bound Provider Requests
+
+Set provider transport limits through RubyLLM's context:
+
+```ruby
+context = RubyLLM.context do |config|
+  config.request_timeout = 30
+  config.max_retries = 0
+end
+chat = context.chat(model: 'gpt-4o-mini')
+```
+
+A provider request timeout ends the AG-UI run as failed, with a sanitized
+`RUN_ERROR` code `transport_timeout`. Reconnecting reports the same failure
+without a new provider request. A timeout is not a cancelled outcome.
+
+The request timeout does not bound an entire multi-request turn or a local
+tool. Provider retries can extend elapsed time. Put deadlines and cancellation
+checkpoints in your tools and reconcile external effects before retrying an
+uncertain action. Cancellation cannot undo a tool that already changed an
+external system.
+
+## Check the Offline Evidence
+
+`spec/integration/provider_lifecycle_spec.rb` runs the real RubyLLM chat with an
+intercepted HTTP request. It verifies timeout classification and cancellation
+before a provider request. It uses synthetic configuration and makes no live
+provider call. Browser fixtures separately exercise host cancellation and
+HTTP abort; they do not establish a provider's cancellation latency.
+
+## Next Steps
+
+* [Streaming Runs]({% link _core_features/streaming-runs.md %}) - understand terminal outcomes.
+* [Worker Recovery]({% link _advanced/worker-recovery.md %}) - close a run after confirmed worker death.

data/docs/_core_features/reconnects.md

@@ -37,10 +37,16 @@ run id is a conflict.
 
 ## Choose a Store
 
-`MemoryStore` is suitable for tests and a single process. Its records disappear on restart and are not shared between workers. The Rails adapter's `ActiveRecordStore` persists records and redeems interrupts under a database lock.
+`MemoryStore` is suitable for tests and a single process. Its records disappear on restart and are not shared between workers. The Rails adapter's `ActiveRecordStore` persists records and redeems interrupts with atomic conditional updates.
 
 The store boundary is `RubyLLM::AgUI::Store::Base`. Configure a compatible store globally or pass it to `Run.new`. For multi-process deployments, the database must enforce unique run identity and serialize interrupt redemption.
 
+Store writes check `RunRecord#revision` and refuse stale snapshots. A run whose
+worker died remains non-terminal until the host confirms the worker stopped
+and explicitly recovers it. See
+[Worker Recovery]({% link _advanced/worker-recovery.md %}) before changing a
+stuck record; deleting its reservation can repeat unknown tool effects.
+
 ## Next Steps
 
 * [Configuration]({% link _getting_started/configuration.md %}) - set the default store.

data/docs/_core_features/streaming-runs.md

@@ -42,9 +42,23 @@ An assistant message opens on its first non-empty chunk and closes before a tool
 
 The run record reaches a terminal state before the terminal event is written. If the connection closes in the middle, the record remains available for a later reconnect.
 
+## When the Client Disconnects
+
+The producer detaches a failed transport and continues the same chat turn while
+its worker stays alive. A broken connection does not cancel the provider or
+undo a tool. The store retains the real success, failure, approval pause, or
+cancelled outcome. A retry while the turn is running is refused; after it ends,
+the same input and run id receive the recorded outcome without execution.
+
+This also applies when the first write or a flush fails. A terminal write
+failure cannot replace an outcome that is already persisted. `SSEWriter` used
+directly raises `TransportError`, a subclass of `StreamError`; `Run` handles
+that transport error. Mapping and persistence errors are separate failures.
+
 ## Next Steps
 
 * [Validating Input]({% link _core_features/input-validation.md %}) - parse untrusted request data.
 * [Tool Progress]({% link _core_features/tool-progress.md %}) - publish local tool updates.
+* [Cancellation and Timeouts]({% link _core_features/cancellation.md %}) - connect host cancellation to the active chat.
 * [Approval and Resume]({% link _core_features/approval-and-resume.md %}) - answer an interrupt on a new run.
 * [Reconnects and Run Identity]({% link _core_features/reconnects.md %}) - serve a completed run again.

data/docs/_getting_started/whats-new-in-0-3.md

@@ -0,0 +1,61 @@
+---
+layout: default
+title: "What's New in 0.3"
+nav_order: -1
+description: Verify transport failure, scoped cancellation, and explicit worker recovery.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How a run continues after its client disconnects.
+* How to reconnect without executing a turn twice.
+* How to recover after confirmed worker loss.
+* How host cancellation differs from HTTP abort and provider timeout.
+
+## Keep the Recorded Outcome
+
+```ruby
+record = RubyLLM::AgUI::Run.new(chat: chat, input: input, scope: scope,
+                              store: store).stream(to: response_stream)
+```
+
+If the response transport disconnects, the worker continues the same turn and
+persists its real outcome. A failed terminal write cannot change an already
+recorded result. This is not a background job: worker termination still stops
+execution. See [Streaming Runs]({% link _core_features/streaming-runs.md %}).
+
+## Reconnect with the Same Input
+
+Resend the original input and run id after completion. The store returns its
+recorded outcome without running the chat or tool again. A second stream while
+the original is still running is refused. See
+[Reconnects and Run Identity]({% link _core_features/reconnects.md %}).
+
+## Recover Lost Workers Explicitly
+
+After confirming a worker has stopped, load its authorized record and call
+`store.recover(record)`. The recorded failure uses code `worker_lost` and keeps
+the identity reserved. Stale record writes are refused by revision checks.
+Storage acknowledgement failures propagate as `PersistenceError` rather than
+inventing a terminal outcome. See
+[Worker Recovery]({% link _advanced/worker-recovery.md %}).
+
+## Cancel the Authorized Run
+
+The client example now shows separate controls for host cancellation and HTTP
+abort. Its cancel endpoint checks the fixture actor and exact run identity;
+disconnecting the browser leaves the producer running. RubyLLM's HTTP timeout
+is recorded as `transport_timeout`, without raw provider details. See
+[Cancellation and Timeouts]({% link _core_features/cancellation.md %}).
+
+Version 0.3 adds independent-process SQLite tests, including a producer killed
+after a synthetic tool effect.
+These tests do not establish live provider or other-database behavior.
+
+Before updating, read [Upgrading]({% link _reference/upgrading.md %}) for worker
+draining, the custom-store contract, and the JSON 2.x dependency requirement.

data/docs/_reference/compatibility.md

@@ -23,10 +23,11 @@ dependency does.
 
 | Component | Range | Evidence |
 |---|---|---|
-| Ruby | `>= 3.2` | CI passes on 3.2.11, 3.3.12, and 3.4.11; 3.3.5 checked locally |
+| Ruby | `>= 3.2` | Recorded 0.3 CI passes on 3.2.11, 3.3.12, and 3.4.11 |
 | RubyLLM | `>= 2.1`, `< 3.0` | 2.1.1 (callback, approval and cancellation behavior read from its source) |
 | `ag-ui-protocol` | `~> 0.2.0` | 0.2.0 |
-| Rails (adapter only) | `railties`, `actionpack`, `activerecord` `>= 8.0` | CI passes on 8.0.5.1 and 8.1.4 with Ruby 3.3/3.4; 8.1.4 checked locally |
+| JSON | `>= 2.0`, `< 3` | 2.21.2 passes both Rails lines; JSON 3 removes the `quirks_mode` option used by Rails 8.0 |
+| Rails (adapter only) | `railties`, `actionpack`, `activerecord` `>= 8.0` | Recorded 0.3 CI passes on 8.0.5.1 and 8.1.4 with Ruby 3.3/3.4 |
 | AG-UI schema | pinned commit `89cedd3fd549feeee41e50e1d7c6d373e549241a` | vendored, SHA-256 recorded in [AG-UI Protocol Coverage]({% link _reference/protocol-coverage.md %}) |
 
 The pure-Ruby core uses `ruby_llm` and `ag-ui-protocol`, plus the patched
@@ -53,7 +54,42 @@ adapter is only loaded when `Rails::Railtie` is already defined.
 
 The RSpec suite runs offline with fakes and no provider credentials. Package verification uses the network only to install dependencies, then runs its core and Rails checks without a provider. Its advisory check includes the actual default-library gem versions activated by the isolated core install.
 
-## Recorded Client Verification
+## Local 0.3 Development Verification
+
+On 2026-10-19, Ruby 3.3.5, RubyLLM 2.1.1, and Rails 8.1.4 pass 284 examples
+with zero failures and one opt-in provider example skipped. The 18 browser
+workflows pass with `@ag-ui/client` 1.0.3, Playwright 1.64.1, and Puma 8.0.2;
+all 242 consumed events validate against the pinned schema. Desktop disconnect
+and 390px cancellation screenshots were inspected.
+
+Independent Ruby processes share one SQLite file to check reservations,
+approval decisions, and competing outcome writes. Write barriers force both
+processes to observe the old payload before either updates it. A producer
+killed after a synthetic tool effect is explicitly recovered; reconnect never
+executes the tool again. Mutation checks reject removal of either SQL compare
+conditions or revision validation.
+
+The real RubyLLM chat is also checked with intercepted HTTP: cancellation at
+a checkpoint makes no provider request, and a request timeout produces a
+sanitized, reconnectable failure. These tests make no live provider call.
+Installed-host checks pass for both endpoints and generated Rails models.
+## Recorded 0.3 CI Verification
+
+The [2026-10-20 CI run](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39375830117)
+passes all ten jobs at `aa9e035`: Ruby 3.2.11, 3.3.12, and 3.4.11; Rails
+8.0.5.1 and 8.1.4 on Ruby 3.3/3.4; lint; installed-host checks; and the browser
+suite on Ubuntu 24.04. Each test job passes 284 examples with zero failures
+and one opt-in provider skip. The browser suite passes 18 workflows and
+validates all 242 consumed events with `@ag-ui/client` 1.0.3.
+It uses Playwright 1.64.1 and Chromium 156.0.8078.4. Desktop disconnection and
+390px cancellation screenshots from this run were inspected.
+
+The first candidate failed when Rails 8.0 and JSON 3 loaded a real RubyLLM
+chat. Version 0.3 bounds JSON to 2.x; the passing matrix uses 2.21.2. Intercepted
+HTTP tests reproduce the failure before the bound and pass after it. These
+checks make no live provider call.
+
+## Recorded 0.2 Client Verification
 
 On 2026-10-19, the local 0.2.0 candidate passes the maintained browser workflows
 with `@ag-ui/client` 1.0.3, Playwright 1.64.1, and Chrome 155.0.8059.82 on macOS.
@@ -79,6 +115,12 @@ scenarios, with 154 consumed events validated against the schema. Its desktop
 progress and mobile denial screenshots were also inspected. These remain
 synthetic checks; no live provider session is recorded.
 
+The [0.2.0 release workflow](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39180349362)
+also passes browser, advisory, installed-host, and clean-install verification.
+The published GitHub and RubyGems downloads have matching checksums. The actual
+published artifact separately passes the installed-host and clean core/Rails
+checks after download.
+
 ## What is not asserted
 
 - **Other clients or versions.** CopilotKit and client versions other than the
@@ -94,8 +136,8 @@ synthetic checks; no live provider session is recorded.
   initializer, and its specs run on 8.0/8.1. It may work on 7.2 and it is not
   tested there.
 - **Databases other than SQLite** for the ActiveRecord store. The store uses a
-  unique index and `with_lock`; PostgreSQL and MySQL should behave the same, and
-  that is untested.
+  unique index and conditional payload updates. PostgreSQL and MySQL are
+  untested; the SQLite checks do not establish their concurrency behavior.
 
 ## Deliberate behavior worth knowing
 

data/docs/_reference/release-history.md

@@ -17,7 +17,8 @@ description: Review RubyLLM AG-UI releases, newest first, with highlights and up
 
 | Release | Date | Highlights |
 | --- | --- | --- |
-| [0.2.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.2.0) | 2026-10-19 | [Client workflows and tool progress]({% link _getting_started/whats-new-in-0-2.md %}): opt-in redacted progress, a real-client demo, and completed resume reconnect |
+| [0.3.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.3.0) | 2026-10-20 | [Lifecycle and worker recovery]({% link _getting_started/whats-new-in-0-3.md %}): disconnect handling, scoped cancellation, and conditional durable writes |
+| [0.2.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.2.0) | 2026-10-19 | [Client workflows and tool progress]({% link _reference/whats-new-in-0-2.md %}): opt-in redacted progress, a real-client demo, and completed resume reconnect |
 | [0.1.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.1.0) | 2026-10-18 | [First release]({% link _reference/whats-new-in-0-1.md %}): AG-UI event mapping, approval and resume, cancellation, reconnect, and the optional Rails adapter |
 
 To move an application from one release to the next, follow [Upgrading]({% link _reference/upgrading.md %}).

data/docs/_reference/releasing.md

@@ -67,3 +67,13 @@ Replace the example tag with the version you are releasing. The `Release Gem` wo
 On success, the workflow creates a GitHub Release with the gem, checksum, and CHANGELOG notes. The Docs workflow runs after the release workflow succeeds. It publishes the tagged version at `/` and current `main` at `/next/`.
 
 Check the version on RubyGems, the GitHub Release assets, and the documentation installation command. If a publish attempt fails, inspect its logs before retrying. A published RubyGems version cannot be overwritten.
+
+Download the published gem from both RubyGems and the GitHub Release. Compare
+their SHA-256 hashes with the release's `SHA256SUMS` and RubyGems metadata.
+Verify that its packaged files match the tag. The publish job builds its own
+artifact, so a verification job's earlier hash is not proof of the public bytes.
+
+Place the downloaded gem under `pkg/` and repeat the installed-host check with
+`--built`, followed by `bin/verify-package --rails --audit`. Do not rebuild the
+gem between downloading and checking it. Confirm the rendered stable and
+`/next/` guides, API links, and version menu after the Docs deployment succeeds.

data/docs/_reference/upgrading.md

@@ -15,33 +15,42 @@ After reading this guide, you will know:
 * How to move between versioned releases.
 * Where to find changes that need code updates.
 
-## Move from 0.1 to 0.2
+## Move from 0.2 to 0.3
 
-Change your Gemfile and update the dependency:
+Drain your old workers, change your Gemfile, and update the dependency:
 
 ```ruby
-gem 'ruby_llm-ag_ui', '~> 0.2.0'
+gem 'ruby_llm-ag_ui', '~> 0.3.0'
 ```
 
 ```sh
 bundle update ruby_llm-ag_ui
 ```
 
-The 0.2 release keeps the 0.1 run, store, and Rails APIs. It does not require
-another migration or installer run.
-
-Tool progress is off by default. Set `config.emit_tool_progress = true` only
-when your client handles activity snapshots, and review its redaction policy.
-See [Tool Progress]({% link _core_features/tool-progress.md %}).
-
-## Completed Resume Retries in 0.2
-
-An exact retry of a completed resume run now returns its recorded outcome.
-Keep the original run id and full input, including `resume`. A new run id that
-tries to answer an already answered interrupt is still refused, and changed
-input under the original id is a conflict. No approval or tool is executed again.
-
-## Older Development Checkouts
-
-For the initial release's generator namespace correction, read the
-[0.1 upgrading guide](https://github.com/yorzi/ruby_llm-ag-ui/blob/v0.1.0/docs/_reference/upgrading.md).
+Version 0.3 requires JSON 2.x. Rails 8.0 passes an option removed in JSON 3
+when RubyLLM loads its chat class. If your Gemfile pins JSON 3, remove that pin
+or select JSON 2.x before updating. This bound also applies to plain Ruby hosts.
+
+`Run` now continues after a response write or flush fails. It saves the real
+outcome instead of reporting the disconnected client as a failed run. Hosts
+that previously relied on disconnects to stop work must explicitly request
+cancellation on the authorized chat. `SSEWriter` still raises a `StreamError`
+subclass when used directly. See
+[Streaming Runs]({% link _core_features/streaming-runs.md %}).
+
+Store writes now use an atomic revision check. Always retain the record returned
+by `save`. Custom stores must implement this contract before upgrading. Existing
+JSON payloads load with revision zero and the shipped table needs no migration.
+Drain old workers first, since 0.2 writers do not enforce revision checks.
+`PersistenceError` now propagates storage failures without guessing a terminal
+outcome. Read [Worker Recovery]({% link _advanced/worker-recovery.md %}) for
+explicit recovery and external-effect reconciliation.
+
+Faraday request timeouts now use `transport_timeout` instead of the generic
+`transport_error` code. Both remain failed outcomes. See
+[Cancellation and Timeouts]({% link _core_features/cancellation.md %}).
+
+## Older Releases
+
+For earlier upgrade steps, read the
+[0.2 upgrading guide](https://github.com/yorzi/ruby_llm-ag-ui/blob/v0.2.0/docs/_reference/upgrading.md).

data/docs/{_getting_started → _reference}/whats-new-in-0-2.md

@@ -1,7 +1,8 @@
 ---
 layout: default
 title: "What's New in 0.2"
-nav_order: 0
+nav_order: 2
+parent: Release History
 description: Verify real AG-UI client workflows and opt in to redacted tool progress.
 ---
 

data/lib/ruby_llm/ag_ui/emitter.rb

@@ -94,7 +94,11 @@ module RubyLLM
       private
 
       def emit(event)
+        return if @detached
+
         @writer.write(event)
+      rescue TransportError
+        @detached = true
       end
 
       # Closes whatever content is still open, then writes the terminal event.
@@ -108,7 +112,7 @@ module RubyLLM
       end
 
       def persist(record)
-        @store.save(record)
+        Persistence.write { @store.save(record) }
       end
 
       def now

data/lib/ruby_llm/ag_ui/error.rb

@@ -37,6 +37,10 @@ module RubyLLM
       end
     end
 
+    # An observed run was changed by another writer. Reload before deciding
+    # whether an update is still valid; never overwrite the newer outcome.
+    class StaleRecordError < RunConflictError; end
+
     # Raised when run identity is required but missing.
     class InvalidRunIdentityError < InvalidInputError; end
 
@@ -56,10 +60,17 @@ module RubyLLM
     # Raised when the pinned protocol version is not the one this gem speaks.
     class UnsupportedProtocolVersionError < InputError; end
 
-    # Raised when the stream cannot be closed in order (for example the
-    # transport died mid-run). The run is reported as RUN_ERROR.
+    # Raised when run or stream ordering cannot be honored.
     class StreamError < Error; end
 
+    # The response transport is closed. A running producer detaches its writer
+    # and continues to persist the real outcome while its worker remains alive.
+    class TransportError < StreamError; end
+
+    # A store write failed without a reliable acknowledgement. The persisted
+    # outcome may be unknown; inspect storage before attempting recovery.
+    class PersistenceError < Error; end
+
     # Raised when RubyLLM paused the run for something the pinned AG-UI shape
     # cannot express as an interrupt this producer may answer, such as an MCP
     # input request or a long-running MCP task. Reported as a sanitized

data/lib/ruby_llm/ag_ui/error_sanitizer.rb

@@ -40,6 +40,7 @@ module RubyLLM
         ],
         'RubyLLM::AgUI::StreamError' => ['The run could not be streamed to completion.', 'stream_failed'],
         'RubyLLM::Error' => ['The model provider returned an error.', 'provider_error'],
+        'Faraday::TimeoutError' => ['The model provider request timed out.', 'transport_timeout'],
         'Faraday::Error' => ['The model provider request failed.', 'transport_error'],
         'Timeout::Error' => ['The model provider request timed out.', 'transport_timeout'],
         'Errno::ETIMEDOUT' => ['The model provider request timed out.', 'transport_timeout']

data/lib/ruby_llm/ag_ui/persistence.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module AgUI
+    # Keep uncertain write acknowledgements separate from run outcomes.
+    module Persistence # :nodoc:
+      module_function
+
+      def write
+        yield
+      rescue Error
+        raise
+      rescue StandardError => e
+        raise PersistenceError, "The store write could not be acknowledged: #{e.class}"
+      end
+    end
+  end
+end

data/lib/ruby_llm/ag_ui/rails/active_record_store.rb

@@ -50,10 +50,8 @@ module RubyLLM
         def save(record)
           scope_key(record.scope)
           row = row_for(record.scope, record.thread_id, record.run_id)
-          raise InvalidRunIdentityError, "run #{record.run_id} was never reserved" if row.nil?
-          raise RunConflictError, conflict_message(record) if row.digest != record.digest
-
-          row.write_run_record(record)
+          updated = next_record(row&.as_run_record, record)
+          row.write_run_record(updated)
         end
 
         def find_interrupt(scope:, thread_id:, interrupt_id:)
@@ -62,21 +60,34 @@ module RubyLLM
           row_for_interrupt(scope, thread_id, interrupt_id)&.as_run_record&.interrupt(interrupt_id)
         end
 
-        # Records +decision+ on the interrupt under a row lock, so two resumes
-        # that arrive together cannot both record a decision and run the tool.
+        # Records +decision+ with a conditional update. Competing writers reload
+        # and revalidate, so only one can redeem the approval.
         def redeem_interrupt(scope:, thread_id:, interrupt_id:, decision:, now:)
           unless Interrupt::DECISIONS.include?(decision)
             raise ConfigurationError, "decision must be one of #{Interrupt::DECISIONS.join(', ')}"
           end
 
-          row = row_for_interrupt(scope, thread_id, interrupt_id)
-          raise ResumeRejectedError, "no interrupt #{interrupt_id}" if row.nil?
+          retry_stale do
+            row = row_for_interrupt(scope, thread_id, interrupt_id)
+            raise ResumeRejectedError, "no interrupt #{interrupt_id}" if row.nil?
 
-          row.with_lock { redeem(row.reload.as_run_record, interrupt_id, decision, now) }
+            redeem(row.as_run_record, interrupt_id, decision, now)
+          end
         end
 
         private
 
+        def retry_stale
+          attempts = 0
+          begin
+            yield
+          rescue StaleRecordError
+            attempts += 1
+            retry if attempts < 3
+            raise
+          end
+        end
+
         # A retry of the same identity attaches; a different input under the
         # same key is a conflict, because one run id may not mean two requests.
         def attach(row, digest)
@@ -91,8 +102,7 @@ module RubyLLM
           raise ResumeRejectedError, "interrupt #{interrupt_id} expired" if interrupt.expired?(now)
 
           answered = interrupt.decide(decision, now: now)
-          row = row_for(record.scope, record.thread_id, record.run_id)
-          row.write_run_record(record.replace_interrupt(answered, now: now))
+          save(record.replace_interrupt(answered, now: now))
           Redemption.new(interrupt: answered, replayed: false)
         end
 

data/lib/ruby_llm/ag_ui/rails/record.rb

@@ -28,13 +28,18 @@ module RubyLLM
           ::RubyLLM::AgUI::RunRecord.from_storage(::JSON.parse(payload))
         end
 
-        # Writes +record+ onto this row and returns the record.
+        # Writes +record+ only if this row's observed payload is still current.
+        # Returns the record or raises StaleRecordError on a competing update.
         #
         # The identity columns are not writable: a row keeps the identity it was
         # reserved with, so a record cannot be stored under another run's key.
         def write_run_record(record)
-          update!(digest: record.digest, status: record.status.to_s, sequence: record.sequence,
-                  payload: ::JSON.generate(record.to_storage))
+          changed = self.class.where(id: id, payload: payload).update_all(
+            digest: record.digest, status: record.status.to_s, sequence: record.sequence,
+            payload: ::JSON.generate(record.to_storage)
+          )
+          raise StaleRecordError, "run #{record.run_id} changed before it could be saved" unless changed == 1
+
           record
         end
 

data/lib/ruby_llm/ag_ui/rails/streaming.rb

@@ -45,9 +45,9 @@ module RubyLLM
           include ::ActionController::Live
         end
 
-        # Streams one run and returns the run's record, or nil when the client
-        # disconnected. The block receives the parsed input and returns the chat
-        # for it.
+        # Streams one run and returns its record. A disconnected transport does
+        # not stop its worker from completing and storing the real outcome.
+        # The block receives the parsed input and returns the authorized chat.
         def stream_ag_ui_run(&resolve_chat)
           if resolve_chat.nil?
             raise ConfigurationError, 'stream_ag_ui_run needs a block that returns the chat for the input'

data/lib/ruby_llm/ag_ui/resume.rb

@@ -88,15 +88,19 @@ module RubyLLM
       # The store's redemption is atomic: the first answer record wins, and a
       # repeat comes back as a replay that must not execute anything.
       def redeem(planned, now:)
-        redemption = @store.redeem_interrupt(
-          scope: @scope, thread_id: @input.thread_id,
-          interrupt_id: planned.interrupt.id, decision: planned.decision, now: now
-        )
+        redemption = persist_decision(planned, now: now)
         raise ResumeRejectedError, "interrupt #{planned.interrupt.id} was already answered" if redemption.replayed?
 
         redemption.approved? ? @chat.approve(redemption.tool_call_id) : @chat.deny(redemption.tool_call_id)
       end
 
+      def persist_decision(planned, now:)
+        Persistence.write do
+          @store.redeem_interrupt(scope: @scope, thread_id: @input.thread_id,
+                                  interrupt_id: planned.interrupt.id, decision: planned.decision, now: now)
+        end
+      end
+
       # The protocol's resume vocabulary is resolved or cancelled; the interrupt
       # records the truthful decision, and a cancelled answer denies the call
       # rather than approving it.

data/lib/ruby_llm/ag_ui/run.rb

@@ -64,9 +64,9 @@ module RubyLLM
       end
 
       def reserve
-        @store.reserve(
-          scope: @scope, thread_id: @input.thread_id, run_id: @input.run_id, digest: @input.digest
-        )
+        Persistence.write do
+          @store.reserve(scope: @scope, thread_id: @input.thread_id, run_id: @input.run_id, digest: @input.digest)
+        end
       end
 
       # An identity that is already reserved is never executed a second time.
@@ -92,8 +92,12 @@ module RubyLLM
         @record = finalize { finish }
       rescue RubyLLM::CancelledError
         @record = finalize { @emitter.cancel }
+      rescue PersistenceError, RunConflictError
+        raise
       rescue StandardError => e
         @record = finalize { @emitter.fail(e) }
+      ensure
+        finalize { @mapper&.close }
       end
 
       def start_execution(record, to)
@@ -104,8 +108,8 @@ module RubyLLM
 
       def build_emitter(record, to, mapper: build_mapper(record))
         Emitter.new(
-          writer: SSEWriter.new(to, logger: @logger), mapper: mapper,
-          store: @store, record: record, clock: @clock, logger: @logger
+          writer: SSEWriter.new(to, logger: @logger), mapper: mapper, store: @store,
+          record: record, clock: @clock, logger: @logger
         )
       end
 
@@ -164,8 +168,7 @@ module RubyLLM
 
       def run_started_event(record)
         Protocol.run_started(
-          thread_id: record.thread_id, run_id: record.run_id,
-          parent_run_id: @input.parent_run_id, input: @input.to_h
+          thread_id: record.thread_id, run_id: record.run_id, parent_run_id: @input.parent_run_id, input: @input.to_h
         )
       end
 
@@ -175,13 +178,9 @@ module RubyLLM
         end
         raise ConfigurationError, 'input must be a RubyLLM::AgUI::Input' unless @input.is_a?(Input)
 
-        validate_scope!
-      end
-
-      def validate_scope!
         return if @scope.is_a?(String) && !@scope.empty?
 
-        raise ConfigurationError, 'scope must be a non-empty String built from authenticated identity'
+        raise ConfigurationError, Store::Base::SCOPE_MESSAGE
       end
     end
   end

data/lib/ruby_llm/ag_ui/run_record.rb

@@ -52,6 +52,10 @@ module RubyLLM
       # reconnect are ordered by it rather than by wall-clock time.
       attr_reader :sequence
 
+      # Storage revision, distinct from the event sequence. Stores increment it
+      # atomically and reject writes from older snapshots.
+      attr_reader :revision
+
       # The host-owned run state kept for a reconnect snapshot, or nil.
       attr_reader :snapshot
 
@@ -67,13 +71,14 @@ module RubyLLM
 
       # rubocop:disable-next Metrics/ParameterLists -- one keyword per field the record owns
       def initialize(scope:, thread_id:, run_id:, digest:, created_at:, status: RESERVED, sequence: 0,
-                     snapshot: nil, interrupts: [], failure: nil, updated_at: nil)
+                     snapshot: nil, interrupts: [], failure: nil, updated_at: nil, revision: 0)
         @scope = scope
         @thread_id = thread_id
         @run_id = run_id
         @digest = digest
         @status = assert_status!(status)
         @sequence = sequence
+        @revision = revision
         @snapshot = snapshot
         @interrupts = interrupts.freeze
         @failure = failure
@@ -122,6 +127,11 @@ module RubyLLM
         with(now: now, sequence: sequence + 1)
       end
 
+      # Storage bookkeeping; hosts retain the record returned by save.
+      def next_revision # :nodoc:
+        with(now: updated_at, revision: revision + 1)
+      end
+
       # Closes the run with +status+: :succeeded, :interrupted, :cancelled or
       # :failed, and, for a failure, the sanitized error a reconnect reports.
       # Re-applying the same terminal status is an idempotent no-op — so the
@@ -158,6 +168,7 @@ module RubyLLM
         with(now: now, interrupts: replaced)
       end
 
+      # rubocop:disable-next Metrics/AbcSize -- one entry per serialized record field
       def to_h
         {
           'scope' => scope.to_s,
@@ -166,6 +177,7 @@ module RubyLLM
           'digest' => digest,
           'status' => status.to_s,
           'sequence' => sequence,
+          'revision' => revision,
           'snapshot' => snapshot,
           'failure' => failure,
           'interrupts' => interrupts.map(&:to_h),
@@ -186,7 +198,8 @@ module RubyLLM
         new(
           scope: hash.fetch('scope'), thread_id: hash.fetch('threadId'), run_id: hash.fetch('runId'),
           digest: hash.fetch('digest'), status: hash.fetch('status').to_sym,
-          sequence: hash.fetch('sequence'), snapshot: hash['snapshot'], failure: hash['failure'],
+          sequence: hash.fetch('sequence'), revision: hash.fetch('revision', 0),
+          snapshot: hash['snapshot'], failure: hash['failure'],
           interrupts: interrupts_from_storage(hash['interrupts']),
           created_at: Interrupt.parse_time(hash.fetch('createdAt')),
           updated_at: Interrupt.parse_time(hash.fetch('updatedAt'))
@@ -201,10 +214,10 @@ module RubyLLM
 
       # rubocop:disable-next Metrics/ParameterLists -- one keyword per field, each defaulted to the record's own
       def with(now:, status: self.status, sequence: self.sequence, snapshot: self.snapshot,
-               interrupts: self.interrupts, failure: self.failure)
+               interrupts: self.interrupts, failure: self.failure, revision: self.revision)
         self.class.new(
           scope: scope, thread_id: thread_id, run_id: run_id, digest: digest, status: status,
-          sequence: sequence, snapshot: snapshot, interrupts: interrupts, failure: failure,
+          sequence: sequence, revision: revision, snapshot: snapshot, interrupts: interrupts, failure: failure,
           created_at: created_at, updated_at: now
         )
       end

data/lib/ruby_llm/ag_ui/sse_writer.rb

@@ -10,7 +10,7 @@ module RubyLLM
     # buffer frames or choose how a host relays a background job to a client.
     # What it does own is the ordering and the framing of the events it writes.
     #
-    # A dead stream is reported as a StreamError and the writer stays closed.
+    # A dead stream is reported as a TransportError and the writer stays closed.
     # The reason is a transport truncation, not a run outcome: it is never
     # evidence that the work finished, succeeded or was cancelled.
     class SSEWriter
@@ -82,7 +82,7 @@ module RubyLLM
       # Encodes +event+ and writes it, then flushes so the client sees it now.
       # Returns the encoded frame.
       def write(event)
-        raise StreamError, 'The event stream is closed.' if @closed
+        raise TransportError, 'The event stream is closed.' if @closed
 
         frame = @encoder.encode(event)
         @stream.write(frame)
@@ -90,12 +90,14 @@ module RubyLLM
         @events_written += 1
         @bytes_written += frame.bytesize
         frame
-      rescue IOError, SystemCallError => e
+      rescue StandardError => e
+        raise unless transport_error?(e)
+
         # The client is gone. The class name is enough for the host log; the
         # message may embed a path or a socket address and is not echoed.
         @logger&.warn("[ruby_llm_ag_ui] the event stream failed: #{e.class}")
         @closed = true
-        raise StreamError, "The event stream failed: #{e.class}"
+        raise TransportError, "The event stream failed: #{e.class}"
       end
 
       # Pushes buffered bytes to the client. A no-op for a stream that cannot
@@ -114,6 +116,16 @@ module RubyLLM
       def closed?
         @closed
       end
+
+      private
+
+      def transport_error?(error)
+        return true if error.is_a?(IOError) || error.is_a?(SystemCallError)
+        return true if defined?(::Puma::ConnectionError) && error.is_a?(::Puma::ConnectionError)
+
+        defined?(::ActionController::Live::ClientDisconnected) &&
+          error.is_a?(::ActionController::Live::ClientDisconnected)
+      end
     end
   end
 end

data/lib/ruby_llm/ag_ui/store/base.rb

@@ -63,11 +63,24 @@ module RubyLLM
           raise NotImplementedError
         end
 
-        # Persists an updated record and returns it.
+        # Atomically persists a record only if its revision is still current.
+        # Returns a new record with its revision incremented. Retain this return
+        # value for later writes. A stale write raises StaleRecordError.
         def save(record)
           raise NotImplementedError
         end
 
+        # Closes an observed non-terminal run after the host confirms its worker
+        # has stopped. Does not cancel a worker, undo effects, release identity,
+        # or execute anything. A newer revision or terminal run is refused.
+        def recover(record)
+          raise RunConflictError, 'only a non-terminal run can be recovered' if record.terminal?
+
+          failure = { 'code' => 'worker_lost',
+                      'message' => 'The worker stopped before recording an outcome. Tool effects may be incomplete.' }
+          save(record.finish(RunRecord::FAILED, now: now, failure: failure))
+        end
+
         # The interrupt with +id+ anywhere on the thread, or nil.
         def find_interrupt(scope:, thread_id:, interrupt_id:)
           raise NotImplementedError
@@ -88,6 +101,16 @@ module RubyLLM
 
         private
 
+        def next_record(stored, candidate)
+          raise InvalidRunIdentityError, "run #{candidate.run_id} was never reserved" if stored.nil?
+          raise RunConflictError, conflict_message(candidate) if stored.digest != candidate.digest
+          if stored.revision != candidate.revision || (stored.terminal? && stored.status != candidate.status)
+            raise StaleRecordError, "run #{candidate.run_id} changed; reload its record before writing"
+          end
+
+          candidate.next_revision
+        end
+
         # The host's scope must be a canonical string. An arbitrary object would
         # make two requests from the same tenant hash differently, so a retry
         # would not attach and the run would execute twice.

data/lib/ruby_llm/ag_ui/store/memory_store.rb

@@ -55,13 +55,8 @@ module RubyLLM
         def save(record)
           key = key_for(record.scope, record.thread_id, record.run_id)
           @lock.synchronize do
-            stored = @records[key]
-            raise InvalidRunIdentityError, "run #{record.run_id} was never reserved" if stored.nil?
-            raise RunConflictError, conflict_message(record) if stored.digest != record.digest
-
-            @records[key] = record
+            @records[key] = next_record(@records[key], record)
           end
-          record
         end
 
         def find_interrupt(scope:, thread_id:, interrupt_id:)
@@ -89,7 +84,8 @@ module RubyLLM
           raise ResumeRejectedError, "interrupt #{interrupt_id} expired" if interrupt.expired?(now)
 
           answered = interrupt.decide(decision, now: now)
-          @records[key_for(scope, thread_id, record.run_id)] = record.replace_interrupt(answered, now: now)
+          @records[key_for(scope, thread_id, record.run_id)] =
+            record.replace_interrupt(answered, now: now).next_revision
           Redemption.new(interrupt: answered, replayed: false)
         end
 

data/lib/ruby_llm/ag_ui/version.rb

@@ -3,6 +3,6 @@
 module RubyLLM
   module AgUI
     # The version of the ruby_llm-ag_ui gem, as a string.
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-ag_ui
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andy Wang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ag-ui-protocol
@@ -44,6 +44,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: cgi
   requirement: !ruby/object:Gem::Requirement
@@ -145,7 +165,9 @@ files:
 - docs/_advanced/client-example.md
 - docs/_advanced/rails-integration.md
 - docs/_advanced/security-and-deployment.md
+- docs/_advanced/worker-recovery.md
 - docs/_core_features/approval-and-resume.md
+- docs/_core_features/cancellation.md
 - docs/_core_features/input-validation.md
 - docs/_core_features/reconnects.md
 - docs/_core_features/streaming-runs.md
@@ -153,7 +175,7 @@ files:
 - docs/_getting_started/configuration.md
 - docs/_getting_started/getting-started.md
 - docs/_getting_started/overview.md
-- docs/_getting_started/whats-new-in-0-2.md
+- docs/_getting_started/whats-new-in-0-3.md
 - docs/_reference/api-reference.md
 - docs/_reference/compatibility.md
 - docs/_reference/protocol-coverage.md
@@ -162,6 +184,7 @@ files:
 - docs/_reference/third-party-notices.md
 - docs/_reference/upgrading.md
 - docs/_reference/whats-new-in-0-1.md
+- docs/_reference/whats-new-in-0-2.md
 - docs/index.md
 - lib/generators/ruby_llm/ag_ui/install_generator.rb
 - lib/generators/ruby_llm/ag_ui/templates/create_ruby_llm_ag_ui_runs.rb.tt
@@ -177,6 +200,7 @@ files:
 - lib/ruby_llm/ag_ui/interrupt.rb
 - lib/ruby_llm/ag_ui/mapper.rb
 - lib/ruby_llm/ag_ui/message_parser.rb
+- lib/ruby_llm/ag_ui/persistence.rb
 - lib/ruby_llm/ag_ui/protocol.rb
 - lib/ruby_llm/ag_ui/rails/active_record_store.rb
 - lib/ruby_llm/ag_ui/rails/railtie.rb