* 🔑 fix: Replay a Request Rejected for a Superseded Bearer Instead of Refreshing Again
A burst of requests leaves with one bearer. The first 401 starts a refresh and the
rest share it only while it is in flight: a 401 delivered after the refresh settled
found no recovery running and started a second one, although the session had already
recovered and the response described a bearer that was no longer in use.
Compare the bearer the rejected request carried with the current one. When it has
been replaced and no recovery is running, replay the request with the current
bearer. A replay that is rejected again carries the current bearer, so it takes the
ordinary refresh path. The fetch transport follows the same rule.
This is what failed "recovers from an expired bearer during app bootstrap without
redirect looping": 9 of the 21 bootstrap 401s were delivered after the first
recovery finished, so the test counted a third refresh and a second recovery cycle.
* 🔊 test: Play Decodable Audio and Hold the Reply's Button in the Read-Aloud Replay Scenario
The fixture answered the speech request with four bytes the MP3 parser rejects, so
every playback failed. A failed playback cancels its request, and the audio is
cached only once the response has been read to the end, so the replay was served
from memory only when the response finished before the decoder gave up. When the
decoder won, the replay issued the second request the scenario forbids.
The test also located the button by its name. While a message is read aloud its
button is named "Stop", so the locator resolved to the user message's read-aloud
button: the wait for playback to end passed at once, and the second click could
land on a different message.
Serve a third of a second of silent MPEG frames so playback succeeds and ends on
its own, and locate the reply's button by its test id so the wait and the replay
address the same control.
* 📅 test: Wait for the Schedule Save to Land Before Reloading
The edit scenario clicked Save and reloaded the page in the next step. A reload
discards requests still in flight, so when it won the race the PATCH was cancelled
before the server answered and the edited schedule never appeared. Await the PATCH
response, and require it to succeed, before reloading.
* 🔗 fix: Grant a Legacy Shared Link's Permissions Once When Its First Views Race
The share page requests a link's config and its messages together, and each request
migrates a legacy link on the way in. Both find no grant and both write one. The
grant is an upsert matched on the principal and resource, which no unique index
covers, so the two writes inserted two rows: a second public entry, a second owner
entry, or both.
`grantPermission` now accepts the `_id` to give the entry if the grant creates it.
The migration derives that id from the link and the principal, so the second insert
collides on `_id` and is replayed as an update of the first entry. It holds across
processes because the database enforces it. Grants that pass no id are unchanged.
"manages a shared-link snapshot and preserves legacy public links through runtime
migration" asserts one public entry and saw two.
* 🔑 fix: Refresh When a Replayed Fetch Is Rejected With the Current Bearer
The fetch transport replayed a request whose bearer had been superseded and
returned whatever came back. A second 401 there means the current bearer is not
accepted either, which is the case the refresh exists for, and the axios path
already handles it that way. Replay first, then fall through to the ordinary
recovery when the replay is rejected too.
* 🔗 refactor: Derive a Unique Grant's Entry Id in the Data Layer
`AccessControlService.grantPermission` took the entry's `_id` as a Mongoose
`ObjectId`, which put a storage type in an exported `packages/api` signature. The
service now takes `uniqueEntry: true`, and `grantPermission` in data-schemas
derives the id from the principal and resource it already matches on. A caller can
no longer pass an id that names a different grant.
* fix: Advance Slack Account Linking in Place
* fix: Narrow Slack Reply Transport Contract
* fix: Make Slack Link Reply Updates Monotonic
* fix: Clear Invalidated Slack Link Cards After Delayed Writes
* fix: allow members to connect agents to installed Slack workspaces
* fix: clarify Slack destination assignment actions
* fix: align Slack assignment status with destination heading
* fix: explain Slack agent assignments in terms of the connected bot
* fix: separate Slack connection setup, management and confirmation
* fix: name replaced agents only when the member can view them
* perf: avoid redundant Slack assignment identity lookups
* fix: Allow Admins to Remove Disconnected Slack Workspaces
* fix: Use Workspace Status Chips and One Confirmation Action
* fix: Confirm Workspace Removal in a Stacked Dialog
* fix: Align Confirmation Cancel Action to the Left
* 🔑 feat: Bind Agent API Keys to Source Authority
* fix: isolate bound key digests and fence owner issuance
* fix: redact grant authorization failures and type owner lookup
* refactor: separate bound grant validation from personal-key authentication
* test: Drain Concurrent Key Creation and Erasure Before Teardown
* test: Observe and Drain Concurrent Fixture Work
* 🧷 fix: Promote Unapplied Steers to Durable Queued Turns at Run End
A steer the server accepted (202) but the run never applied was handed back
in FINAL as `pendingSteers` and re-owned by the browser as a tab-local queued
message. A reload, closed tab, or a predecessor race before the drain lost it.
At terminal publication, a normally completed run now promotes such steers
into server-owned agent queued turns (parent: the ended response, epoch: the
ended generation's createdAt, chained behind any turn already queued against
that epoch). The job store hands the parked copy over atomically
(`promoteSteerLeftover`: parked item removed, receipt settled `recovered`), so
status recovery, lost-ACK retries and legacy recovery starts cannot queue the
same words again. FINAL reports the receipts in `promotedSteers`; the client
adopts them as server rows instead of converting the steer locally.
Promotion is opt-in per steer (`promoteLeftover`, sent only by clients that
adopt receipts and only for steers with no tab-only context), so older
clients keep the legacy path unchanged, and older servers simply never
report `promotedSteers`.
* 🔒 fix: Settle a Promoted Steer's Hand-Off at Admission, Not Only at FINAL
The job-store hand-off of a promoted steer now returns an outcome and stamps
the receipt with the owning queued turn, so it is idempotent for that turn.
The queued-turn resolver repeats it before admitting a promoted turn: it
completes a hand-off a crash interrupted, and cancels the turn when the
parked copy was discarded or recovered elsewhere, so the words never run
twice. At FINAL, a row whose hand-off was refused and whose retirement cannot
be confirmed is withheld from `pendingSteers` and left for that admission
check. The conservative reconcile frame keeps `promotedSteers`, and the
client adopts it there before sweeping local chips.
* 🔏 fix: Give Promoted Steers Durable Ownership, Their Run's Queue Lineage and Approval Mode
A turn promoted from an unapplied steer now records its source on its own
row: the steer's ids, the generation that accepted it, and a mark set only
once the job store handed the parked copy to that row. Admission runs a
promoted turn on that mark or on a hand-off the job store confirms now;
without proof (the store's evidence expired, or the host cannot ask) the
turn is held for review instead of running.
- Hand-off replies that are lost no longer cancel the row. The row stays as
the client's handle and its admission settles ownership, so a committed
hand-off can no longer leave the steer with no runnable copy.
- A replayed promotion never hands the parked copy to a row that was
cancelled or failed.
- Promoted turns join the queue lineage of the generation that accepted
the steer, so a sibling still queued behind that run no longer strands
them with a predecessor mismatch.
- The steer request carries the sender's code approval mode onto the
promoted turn; an unreadable mode keeps the steer on the client path.
- A steer whose quotes its owner stripped stays on the client path.
- The queued-turn receipt names the promoted steer by both ids, and the
receipt list retires a pane's local copies even when it missed FINAL.
* 🚧 fix: Fence Promoted Turns to Workers That Prove Steer Ownership
A promoted row without an approval mode was published under the v1 queued
turn capability, so during a rolling deploy a worker that predates the
ownership check could claim it and run an unsettled row while the parked
steer was still recoverable elsewhere.
Promoted rows now publish under a new agent_queued_turn_v3 capability and a
v3 delivery identity, always reserved before insertion. A replica that
projects an older version can neither publish the reserved delivery nor
claim it, and enqueue refuses a promoted row without a reservation.
* 🪦 fix: Keep a Dead Promoted Turn Answering for Words It Held
A pane that learns of a promoted steer from the receipt list dropped the
mapping for every dead row. A row quarantined as ADMISSION_INDETERMINATE can
still settle as admitted, and a row that died after it was proven the sole
owner of the words is their only surface, so in both cases the pane kept a
chip whose recovery could never run.
The receipt now says whether the turn owned its steer's words, and a dead
receipt keeps answering for them when it did or when its admission is
indeterminate. A replayed promotion applies the same rule to a settled row.
* 🧾 fix: Find Promoted Turns by the Steer a Pane Holds, Join Root Lineages, Redact Hand-off Errors
- A promoted turn's request id is now derived from the client steer id, and a
pane asks for the receipts of the steers it still holds a local copy of
(recovery rows and failed chips). A promoted turn that already ran is only
listed when asked for by name, so a pane that missed FINAL now finds it
and retires its copy. A client steer id too long to key a queued turn is
not promoted.
- The lineage lookup includes a generation admitted from a root queued turn,
which has a parent and no epoch. The promoted turn joins that lineage
without an epoch instead of opening a second one.
- A failed hand-off at admission reports a fixed message. The job store's
own error text stays out of the dead-letter record a client can read, and
promotion logs carry safe error metadata instead of error text.
* 🔢 fix: Ask for Held Steers First Under the Receipt Lookup Limit
The receipt list answers for at most 100 request ids, and a pane's server
rows were listed ahead of the steers it still holds, so a full server queue
could push every held steer out of the request. A promoted turn that had
already run was then never found.
Held steers now come first. An active server row is listed whether or not
it is asked for, while a settled promoted turn is found only by name.
* fix: Let Queued User Turns Go Before Completion Wake-ups at Run End
When a run ends with both a server-owned queued user turn and a background
or subagent completion wake-up waiting on it, the wake-up was expedited at
generation settlement while the queued turn sat out its five-second
readiness re-check, so the wake-up claimed the predecessor fence first and
the user's turn waited behind a whole automated turn.
- Generation settlement now also expedites the conversation's queued-turn
deliveries.
- Background and subagent wake-ups defer without consuming an attempt while
a queued turn holds an unexpired claim or is the due lane head, then run
after it, chained to its response.
- hasPendingAgentQueuedTurn answers false for rows that need recovery or a
user decision (reservations, expired claims, indeterminate admissions,
dead heads awaiting dismissal), so a stuck queued turn never holds a
wake-up. The read runs in parallel with the existing conversation read
and fails open.
- Readiness deferral logs now carry the execution error code.
* fix: Read Queued-Turn Precedence in Claim Order and Defer on Unknown State
- Read the live claim after the head read settles, so a queued -> claimed
transition between the two reads cannot answer false.
- Take plain identifiers in hasPendingAgentQueuedTurn and convert the user
id inside data-schemas, keeping Mongoose types out of packages/api.
- A failed precedence read now defers the wake-up without consuming an
attempt (QUEUED_TURN_STATE_UNAVAILABLE) instead of proceeding.
* fix: Read the Active Queued-Turn Lane in One Query
A claim released back to `queued` between the head read and the live-claim
read could still answer false. Read the reserving, queued and claimed rows
in one query over the capacity index, whose `activeSlot` key holds steady
from reservation until a terminal state, so each row is seen exactly once
in one state. Dead heads and indeterminate quarantines stay separate
indexed reads in parallel. Falls back to a planner-chosen read when the
capacity index has not been built yet.
* fix: Fall Back to a Planner Read Whenever the Lane Hint Is Refused
A hint can be refused for reasons other than a missing index on some engines. The hinted read only pins the stable key, so any refusal now retries unhinted; a genuine outage fails that read too and defers the wake-up.
* fix: Read Queued-Turn Blockers After the Turn They Block
The precedence read gathered the active lane, the dead lane head and the
indeterminate quarantine in parallel, so a blocker could be older than the
queued turn it blocked. A dead head dismissed while the reads were in flight
still answered false and let a completion wake-up race the successor it had
just unblocked.
Read the active lane first, and the blockers (a reservation, an expired
claim, an indeterminate admission, a dead row ahead of the head) only
afterwards and only for a due head, in one existence query. A blocker that
has already cleared no longer answers false, and a conversation with no due
queued turn now costs one read instead of three.
* 🦊 feat: Add Claude Fable 5.2 Support
* fix: Preserve Snapshot Version Boundaries in Model Matching
* test: Measure the Snapshot-Safe Token Matcher Search
---------
Co-authored-by: Lia <lia@librechat.ai>