diff --git a/.env.example b/.env.example
index b310ffe2cce..fa196f5e3cb 100644
--- a/.env.example
+++ b/.env.example
@@ -1232,11 +1232,13 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # SCHEDULES_DISABLED=true
 
 # Coalesce streamed model/tool-argument deltas into windowed Redis publications (ms).
-# Unset or 0 (default) publishes per delta. 25 is recommended: it batches the publish
-# EVAL and the durable append across the window (fewer Redis round trips and lower
-# Redis CPU at high token rates) at the cost of up to one window of added delivery
-# latency. Enable only after EVERY replica runs a build with batch-frame support;
-# older subscribers drop coalesced frames. Values are capped at 1000.
+# Defaults to 25ms when unset; explicit 0 publishes per delta. Batches both publish
+# and durable append operations (fewer Redis round trips and repeated guard/TTL work at high
+# token rates), adding up to one window of buffering latency and crash-loss exposure
+# for unflushed deltas. In-memory streams are unchanged. Values are capped at 1000.
+# Batched publications retain individual chunk frames for older subscribers; Pub/Sub
+# message count is unchanged. Incoming chunk_batch frames remain supported for existing
+# opt-in producers. See UPGRADING.md for compatibility guidance.
 # Keep the window <= the stream-smoothing cadence (`streamRate`, default 25ms):
 # each smoothing tick emits its pieces in one burst, so a tick-sized window
 # captures exactly one batch per tick; a larger window re-batches the paced
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 088c0ac33c1..82997ea8bf5 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,39 +1,40 @@
-# Pull Request Template
+# Pull Request
 
-⚠️ Before Submitting a PR, Please Review:
-- Please ensure that you have thoroughly read and understood the [Contributing Docs](https://github.com/danny-avila/LibreChat/blob/main/.github/CONTRIBUTING.md) before submitting your Pull Request.
-
-⚠️ Documentation Updates Notice:
-- Kindly note that documentation updates are managed in this repository: [librechat.ai](https://github.com/LibreChat-AI/librechat.ai)
+> Before submitting, please review the [Contributing Guide](https://github.com/danny-avila/LibreChat/blob/main/.github/CONTRIBUTING.md).
+>
+> Documentation changes belong in the [LibreChat documentation repository](https://github.com/LibreChat-AI/librechat.ai).
 
 ## Summary
 
 <!--
-Say what breaks or is missing today, what triggers it, and how it behaves after this
-change. Link the issue with `Fixes #N`, and list any dependency your change needs.
-Two or three sentences is usually enough:
-
-"Pasting an image while the composer had focus left Send disabled until the user
-clicked back into the textarea: the upload dialog took focus and never returned it.
-Focus now returns to the composer as soon as the attachment mounts."
-
-Describe the code as it stands. A reader who has not followed the branch has no
-context for what earlier commits tried or what a review round changed. Naming the
-merged pull request that caused the bug is different — that is history the reader
-needs.
+Briefly explain:
+- What problem or limitation exists today?
+- What triggers it (input, state, or configuration)?
+- What does this PR change?
+- What is the resulting behavior?
+
+Keep this focused on the final state of the code rather than the history of the
+branch or previous review iterations. Naming the merged pull request that
+introduced a regression is the exception: that is history the reader needs.
+
+Link related issues, and name any dependency this change needs:
+Fixes #123
+Related to #123
+Depends on danny-avila/agents#123
 -->
 
 ## How it works
 
 <!--
-Optional. Delete this section when the summary already explains the change.
+Optional. Remove this section if the implementation is already obvious from the
+summary and diff.
 
-Pick one or two views that make the change reviewable, and put a sentence beside
-each. These show the format, not a required implementation pattern — replace them
-with real names from your change. Do not paste the whole diff or list every file
-you touched.
+Explain the mechanism reviewers need to understand. Pick one or two of the views
+below, whichever make the change reviewable, and put a sentence beside each rather
+than describing every changed file. Show a whole block instead of a diff when most
+of it is new, or when the omitted context would hide execution order or ownership.
 
-The mechanism, as a focused diff, when the surrounding shape already exists:
+Focused diff:
 
 ```diff
 -const parts = content.filter(isText);
@@ -41,7 +42,7 @@ The mechanism, as a focused diff, when the surrounding shape already exists:
 +const { parts, files } = splitContent(content);
 ```
 
-Runtime order, as a call tree, keeping only the calls that carry the change:
+Runtime flow:
 
 ```text
 submitMessage
@@ -50,16 +51,16 @@ submitMessage
     setSubmission   # opens the SSE stream
 ```
 
-Ownership, as a shallow file tree, for a new module or a broad refactor:
+Ownership:
 
 ```text
 packages/api/src/agents/
-├── run.ts      # builds the run and its callbacks
+├── run.ts      # builds the run and callbacks
 ├── tools.ts    # resolves tools for the request
-└── client.ts   # streams provider output back to the route
+└── client.ts   # streams provider output
 ```
 
-Client/server or cross-service flow, as Mermaid:
+Cross-service flow:
 
 ```mermaid
 sequenceDiagram
@@ -72,41 +73,92 @@ sequenceDiagram
     API->>Client: SSE events
 ```
 
-Editing this file: keep the arrows in the example above solid (`->>`). A dashed
-Mermaid arrow spells the comment terminator, so it would close this comment early
-and spill the rest of the guidance into every description. Your own diagram sits
-outside the comment, where dashed arrows are fine.
-
-Show a whole block instead of a diff when most of it is new, or when the omitted
-context would hide execution order or ownership.
+Keep the arrows in this example solid (`->>`). A dashed Mermaid arrow spells the
+HTML comment terminator, so it would close this block early and spill the rest of
+the guidance into every description. Diagrams you write outside this comment can
+use dashed arrows freely.
 -->
 
-## Change Type
+## Type of change
 
-Please delete any irrelevant options.
+<!-- Select all that apply. -->
 
-- [ ] Bug fix (non-breaking change which fixes an issue)
-- [ ] New feature (non-breaking change which adds functionality)
-- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
-- [ ] This change requires a documentation update
-- [ ] Translation update
+* [ ] Bug fix
+* [ ] Feature
+* [ ] Refactor
+* [ ] Performance improvement
+* [ ] Breaking change
+* [ ] Documentation
+* [ ] Translation
+* [ ] Tests / tooling / CI
 
 ## Testing
 
-Please describe your test process and include instructions so that we can reproduce your test. If there are any important variables for your testing configuration, list them here.
+<!--
+Describe how you verified the change.
+
+Include only the configuration that matters for reproducing the test.
+
+Example:
+
+1. Start LibreChat with Agents enabled.
+2. Create an agent using an Ollama endpoint.
+3. Add the Ask User tool.
+4. Send a message that triggers the tool.
+5. Confirm the question is rendered and the conversation continues after answering.
+-->
 
-### **Test Configuration**:
+**Tested environments/configuration:**
+
+<!--
+Examples:
+- Browser:
+- Provider/model:
+- Database:
+- Feature flags:
+- OS:
+-->
+
+**Automated tests:**
+
+<!--
+Examples:
+- `npm run test:client`
+- `npm run test:api`
+- Added tests in `foo.spec.ts`
+
+Write "Not applicable" when appropriate.
+-->
+
+## Screenshots / recordings
+
+<!--
+For user-facing changes, include before/after screenshots or a short recording.
+Remove this section when not applicable.
+-->
+
+## Risk / compatibility
+
+<!--
+Optional for small changes.
+
+Call out anything reviewers should pay particular attention to, such as:
+- migrations or schema changes
+- API/configuration changes
+- provider-specific behavior
+- backwards compatibility
+- performance implications
+- security-sensitive behavior
+
+Write "None" when there are no notable risks.
+-->
 
 ## Checklist
 
-Please delete any irrelevant options.
-
-- [ ] My code adheres to this project's style guidelines
-- [ ] I have performed a self-review of my own code
-- [ ] I have commented in any complex areas of my code
-- [ ] I have made pertinent documentation changes
-- [ ] My changes do not introduce new warnings
-- [ ] I have written tests demonstrating that my changes are effective or that my feature works
-- [ ] Local unit tests pass with my changes
-- [ ] Any changes dependent on mine have been merged and published in downstream modules.
-- [ ] A pull request for updating the documentation has been submitted.
+* [ ] I reviewed my own changes
+* [ ] Relevant tests have been added or updated
+* [ ] Existing relevant tests pass
+* [ ] The change does not introduce new warnings or errors
+* [ ] User-facing or complex behavior is documented where necessary
+* [ ] Required dependency changes have been merged/published
+* [ ] Required documentation PR: <!-- link or N/A -->
diff --git a/.github/workflows/backend-review.yml b/.github/workflows/backend-review.yml
index 6271abc91f2..82d0088cdc9 100644
--- a/.github/workflows/backend-review.yml
+++ b/.github/workflows/backend-review.yml
@@ -433,7 +433,9 @@ jobs:
       - name: Run unit tests (shard ${{ matrix.shard }}/3)
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.api_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-api-${{ matrix.shard }}.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           cd api
           # A selected path can be stale in exactly two ways at this checkout (Codex P2, #15145 r6):
           # deleted on the branch — dropped, which matches full CI (the file runs nowhere) — or
@@ -448,14 +450,26 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci -- --shard=${{ matrix.shard }}/3
+              npm run test:ci -- --shard=${{ matrix.shard }}/3 $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --shard=${{ matrix.shard }}/3 --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --shard=${{ matrix.shard }}/3 --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci -- --shard=${{ matrix.shard }}/3
+            npm run test:ci -- --shard=${{ matrix.shard }}/3 $JEST_JSON
           fi
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-api-${{ matrix.shard }}
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
 
   test-data-provider:
     name: 'Tests: data-provider'
@@ -509,7 +523,9 @@ jobs:
       - name: Run unit tests
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.dataprovider_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-data-provider.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           cd packages/data-provider
           if [ -n "$SELECTED" ]; then
             KEEP=""
@@ -519,14 +535,26 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci
+              npm run test:ci -- $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci
+            npm run test:ci -- $JEST_JSON
           fi
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-data-provider
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
 
   test-data-schemas:
     name: 'Tests: data-schemas'
@@ -586,7 +614,9 @@ jobs:
       - name: Run unit tests
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.dataschemas_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-data-schemas.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           cd packages/data-schemas
           if [ -n "$SELECTED" ]; then
             KEEP=""
@@ -596,14 +626,26 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci
+              npm run test:ci -- $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci
+            npm run test:ci -- $JEST_JSON
           fi
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-data-schemas
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
 
   test-packages-api:
     name: 'Tests: @librechat/api (shard ${{ matrix.shard }}/4)'
@@ -677,7 +719,9 @@ jobs:
       - name: Run unit tests (shard ${{ matrix.shard }}/4)
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.pkgapi_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-packages-api-${{ matrix.shard }}.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           cd packages/api
           if [ -n "$SELECTED" ]; then
             KEEP=""
@@ -687,11 +731,23 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci -- --shard=${{ matrix.shard }}/4
+              npm run test:ci -- --shard=${{ matrix.shard }}/4 $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --shard=${{ matrix.shard }}/4 --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --shard=${{ matrix.shard }}/4 --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci -- --shard=${{ matrix.shard }}/4
+            npm run test:ci -- --shard=${{ matrix.shard }}/4 $JEST_JSON
           fi
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-packages-api-${{ matrix.shard }}
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
diff --git a/.github/workflows/frontend-review.yml b/.github/workflows/frontend-review.yml
index 8fec3bac4c1..40ebe5b7221 100644
--- a/.github/workflows/frontend-review.yml
+++ b/.github/workflows/frontend-review.yml
@@ -304,7 +304,9 @@ jobs:
       - name: Run unit tests
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.clientpkg_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-packages-client.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           # A selected path can be stale in exactly two ways at this checkout (Codex P2, #15145 r6):
           # deleted on the branch — dropped, which matches full CI (the file runs nowhere) — or
           # renamed, where the NEW path is a changed test file and is selected independently. If
@@ -318,15 +320,27 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci
+              npm run test:ci -- $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci
+            npm run test:ci -- $JEST_JSON
           fi
         working-directory: packages/client
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-packages-client
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
 
   test-ubuntu:
     name: 'Tests: Ubuntu (shard ${{ matrix.shard }}/2)'
@@ -378,7 +392,9 @@ jobs:
       - name: Run unit tests (shard ${{ matrix.shard }}/2)
         env:
           SELECTED: ${{ needs.codegraph_select.outputs.client_files }}
+          JEST_JSON: --json --outputFile=${{ github.workspace }}/jest-results/jest-results-client-${{ matrix.shard }}.json
         run: |
+          mkdir -p "$GITHUB_WORKSPACE/jest-results"
           if [ -n "$SELECTED" ]; then
             KEEP=""
             for f in $SELECTED; do
@@ -387,15 +403,27 @@ jobs:
             KEEP="${KEEP# }"
             if [ -z "$KEEP" ]; then
               echo "no selected test file exists at HEAD (stale selection); running FULL"
-              npm run test:ci -- --shard=${{ matrix.shard }}/2
+              npm run test:ci -- --shard=${{ matrix.shard }}/2 $JEST_JSON
             else
               echo "codegraph: $(echo $KEEP | wc -w) selected test files (safe mode)"
-              npm run test:ci -- --shard=${{ matrix.shard }}/2 --passWithNoTests --runTestsByPath $KEEP
+              npm run test:ci -- --shard=${{ matrix.shard }}/2 --passWithNoTests --runTestsByPath $KEEP $JEST_JSON
             fi
           else
-            npm run test:ci -- --shard=${{ matrix.shard }}/2
+            npm run test:ci -- --shard=${{ matrix.shard }}/2 $JEST_JSON
           fi
         working-directory: client
+      # Per-test results keyed by head SHA (run.head_sha), for the codegraph test-evidence feed.
+      # Never part of the gate: it cannot fail the job, and a re-run overwrites its own artifact.
+      - name: Upload Jest results
+        if: ${{ !cancelled() }}
+        continue-on-error: true
+        uses: actions/upload-artifact@v6
+        with:
+          name: jest-results-client-${{ matrix.shard }}
+          path: jest-results/
+          retention-days: 7
+          if-no-files-found: ignore
+          overwrite: true
 
   build-verify:
     name: Vite build verification
diff --git a/UPGRADING.md b/UPGRADING.md
index 51eab7cc678..aecd00630c6 100644
--- a/UPGRADING.md
+++ b/UPGRADING.md
@@ -1,5 +1,29 @@
 # Upgrading LibreChat
 
+## Redis streaming now coalesces deltas by default
+
+Redis-backed streams now batch model and tool-argument deltas in a **25 ms**
+window when `STREAM_DELTA_COALESCE_MS` is unset. Explicit `0` keeps per-delta
+publication; existing explicit values retain their behavior. In-memory streams
+are unchanged, including deployments using `USE_REDIS_STREAMS=false`.
+
+The same window batches durable appends and publications. It reduces Redis
+round trips and repeated guard/TTL work, but not Pub/Sub message count at the cost of up to one window of buffering latency and possible loss
+of unflushed deltas on process crash. Terminal and non-coalescable barriers still
+flush pending batches before proceeding.
+
+Coalescing batches Redis requests, not the subscriber wire format: each event
+still publishes as an individually sequenced `chunk` frame. Subscribers from
+before batch-frame support can read these publications without a preparatory
+configuration change. New subscribers also retain `chunk_batch` decoding for
+interoperation with existing opt-in batching producers.
+
+This removes the new default's batch-frame compatibility hazard; it does not
+promise compatibility across unrelated generation-protocol changes. If an
+existing producer already emits `chunk_batch` frames through explicit opt-in,
+keep those producers away from subscribers that predate batch-frame support,
+or disable coalescing on those producers before introducing older subscribers.
+
 ## Tenant index migration (v0.8.7 and earlier databases)
 
 Upgrading an existing database can log `Index build failed` for User, Role,
diff --git a/api/app/clients/BaseClient.js b/api/app/clients/BaseClient.js
index a685ee3091d..4a4f6975bda 100644
--- a/api/app/clients/BaseClient.js
+++ b/api/app/clients/BaseClient.js
@@ -21,9 +21,15 @@ const {
   collectModelBoundHistoricalFileIdState,
   projectModelBoundSourceFiles,
   isModelBoundAttachmentFile,
+  isToolOwnedAttachment,
   withBalanceReservations,
   findCheckpointSummaryPart,
   getSummaryPartText,
+  runAfterSeed,
+  saveTurnConversation,
+  seedTurnConversation,
+  needsRetentionConversation,
+  getConversationWriteContext,
 } = require('@librechat/api');
 const {
   Constants,
@@ -32,11 +38,9 @@ const {
   ErrorTypes,
   ContentTypes,
   isCompactedLeaf,
-  excludedKeys,
   EModelEndpoint,
   isParamEndpoint,
   isAgentsEndpoint,
-  isEphemeralAgentId,
   supportsBalanceCheck,
   isBedrockDocumentType,
   HITL_MESSAGE_FILTER_FIELDS,
@@ -282,6 +286,12 @@ class BaseClient {
     return false;
   }
 
+  /** Whether a deferred parent write may still create a new conversation's row up front, so
+   * the conversation lists can return it while the run is in flight. */
+  shouldSeedDeferredConversation() {
+    return false;
+  }
+
   /** Returns the request-scoped deferred parent-write controller, when any. */
   getModelBoundUserMessagePersistence() {
     return this.modelBoundUserMessagePersistence;
@@ -909,6 +919,18 @@ class BaseClient {
       if (this.shouldDeferUserMessagePersistence()) {
         let state = 'pending';
         let startPersistence = startUserMessagePersistence;
+        if (!this.skipSaveConvo && this.shouldSeedDeferredConversation()) {
+          const seed = seedTurnConversation(
+            db,
+            this.getTurnConversationFields(
+              this.options,
+              userMessage.conversationId,
+              saveOptions,
+              'api/app/clients/BaseClient.js - sendMessage #seedConversation',
+            ),
+          );
+          startPersistence = runAfterSeed(seed, startUserMessagePersistence);
+        }
         let resolvePersistence;
         let removeAbortListener = () => {};
         const persistencePromise = new Promise((resolve) => {
@@ -1323,25 +1345,10 @@ class BaseClient {
 
     const hasAddedConvo = options?.req?.body?.addedConvo != null;
     const req = options?.req;
-    if (
-      req?.config?.interfaceConfig?.retentionMode === 'all' &&
-      req?.config?.interfaceConfig?.generalChatRetention !== undefined &&
-      !Object.prototype.hasOwnProperty.call(req, 'resolvedConversation')
-    ) {
+    if (needsRetentionConversation(req)) {
       req.resolvedConversation = await db.getConvo(req.user.id, message.conversationId);
     }
-    const hasResolvedConversation =
-      req != null && Object.prototype.hasOwnProperty.call(req, 'resolvedConversation');
-    const resolvedRetention = hasResolvedConversation ? req.resolvedConversation : null;
-    const reqCtx = {
-      userId: req?.user?.id,
-      isTemporary:
-        req?._agentEventBindingRetention?.isTemporary ??
-        resolvedRetention?.isTemporary ??
-        req?.body?.isTemporary,
-      expiredAt: req?._agentEventBindingRetention?.expiredAt ?? resolvedRetention?.expiredAt,
-      interfaceConfig: req?.config?.interfaceConfig,
-    };
+    const reqCtx = getConversationWriteContext(req);
     const savedMessage = await db.saveMessage(
       reqCtx,
       {
@@ -1358,72 +1365,43 @@ class BaseClient {
       return { message: savedMessage };
     }
 
-    const fieldsToKeep = {
-      conversationId: message.conversationId,
-      endpoint: options.endpoint,
-      endpointType: options.endpointType,
-      ...endpointOptions,
-    };
-    const conversationCreatedAt = options?.req?.conversationCreatedAt;
-    const createdAtOnInsert =
-      conversationCreatedAt != null ? new Date(conversationCreatedAt) : undefined;
-    const validCreatedAtOnInsert =
-      createdAtOnInsert && !Number.isNaN(createdAtOnInsert.getTime())
-        ? createdAtOnInsert
-        : undefined;
-
-    const skippedExistingConvoLookup = this.fetchedConvo === true;
-    let existingConvo = null;
-    if (!skippedExistingConvoLookup && hasResolvedConversation) {
-      existingConvo = req.resolvedConversation;
-    } else if (!skippedExistingConvoLookup) {
-      existingConvo = await db.getConvo(req?.user?.id, message.conversationId);
-    }
-    // Keep the authenticated conversation available for response, abort, and retry saves.
-    // fetchedConvo already prevents repeating the conversation initialization work.
-    const shouldSetCreatedAtOnInsert = !skippedExistingConvoLookup && existingConvo == null;
-
-    const unsetFields = {};
-    const exceptions = new Set(['spec', 'iconURL']);
-    const hasNonEphemeralAgent =
-      isAgentsEndpoint(options.endpoint) &&
-      endpointOptions?.agent_id &&
-      !isEphemeralAgentId(endpointOptions.agent_id);
-    if (hasNonEphemeralAgent) {
-      exceptions.add('model');
-    }
-    if (existingConvo != null) {
-      this.fetchedConvo = true;
-      for (const key in existingConvo) {
-        if (!key) {
-          continue;
-        }
-        if (excludedKeys.has(key) && !exceptions.has(key)) {
-          continue;
-        }
-
-        if (endpointOptions?.[key] === undefined) {
-          unsetFields[key] = 1;
-        }
-      }
-    }
-
-    const conversation = await db.saveConvo(reqCtx, fieldsToKeep, {
-      context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo',
-      unsetFields,
-      noUpsert: req?._agentEventBindingParentConversationId != null,
-      initialAgentId: hasNonEphemeralAgent ? options.agent?.id : null,
-      createdAtOnInsert: shouldSetCreatedAtOnInsert ? validCreatedAtOnInsert : undefined,
-      ...(savedMessage?._id != null ? { appendMessageIds: [savedMessage._id] } : {}),
+    const { conversation, initialized } = await saveTurnConversation(db, {
+      ...this.getTurnConversationFields(
+        options,
+        message.conversationId,
+        endpointOptions,
+        'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo',
+      ),
+      ctx: reqCtx,
+      initialized: this.fetchedConvo === true,
+      savedMessageId: savedMessage?._id,
     });
-
-    if (req != null && conversation != null) {
-      req.resolvedConversation = conversation;
+    if (initialized) {
+      this.fetchedConvo = true;
     }
 
     return { message: savedMessage, conversation };
   }
 
+  /**
+   * The conversation fields a turn's writes share.
+   * @param {Object} options - The client options snapshot.
+   * @param {string} conversationId
+   * @param {Partial<TConversation>} endpointOptions
+   * @param {string} context - Names the write in the save log.
+   */
+  getTurnConversationFields(options, conversationId, endpointOptions, context) {
+    return {
+      req: options.req,
+      conversationId,
+      endpoint: options.endpoint,
+      endpointType: options.endpointType,
+      endpointOptions,
+      agentId: options.agent?.id,
+      context,
+    };
+  }
+
   /**
    * Update a message in the database.
    * @param {Partial<TMessage>} message
@@ -1844,13 +1822,7 @@ class BaseClient {
       /* An explicit `provider` path is authoritative: lazy provisioning stamps
        * `embedded`/`codeEnvRef` on files that are still meant for the model, so the
        * legacy tool-provisioning exclusion only applies to records without one. */
-      if (
-        deliveryPath !== 'provider' &&
-        (file.embedded === true ||
-          file.metadata?.codeEnvRef != null ||
-          file.metadata?.codeEnvRefs != null ||
-          file.metadata?.fileIdentifier != null)
-      ) {
+      if (deliveryPath !== 'provider' && isToolOwnedAttachment(file)) {
         allFiles.push(file);
         continue;
       }
diff --git a/api/app/clients/specs/BaseClient.test.js b/api/app/clients/specs/BaseClient.test.js
index 7277e634879..2c675aa5dcd 100644
--- a/api/app/clients/specs/BaseClient.test.js
+++ b/api/app/clients/specs/BaseClient.test.js
@@ -839,6 +839,124 @@ describe('BaseClient', () => {
       );
     });
 
+    describe('seeding the conversation for a deferred user message', () => {
+      const seedContext = 'api/app/clients/BaseClient.js - sendMessage #seedConversation';
+      const flush = () => new Promise((resolve) => setImmediate(resolve));
+      const savedUserMessage = () =>
+        saveMessage.mock.calls.some(([, message]) => message.isCreatedByUser === true);
+
+      beforeEach(() => {
+        saveMessage.mockReset();
+        saveConvo.mockReset().mockImplementation(async (_ctx, fields) => ({ ...fields }));
+        getConvo.mockReset().mockResolvedValue(null);
+        /** A fresh options object: the suite-level one is shared by reference across clients. */
+        TestClient.options = {
+          ...TestClient.options,
+          req: { user: { id: 'seed-user' }, body: {} },
+        };
+        TestClient.shouldDeferUserMessagePersistence = jest.fn(() => true);
+        TestClient.shouldSeedDeferredConversation = jest.fn(() => true);
+      });
+
+      afterEach(() => {
+        saveMessage.mockReset();
+        saveConvo.mockReset();
+        getConvo.mockReset();
+      });
+
+      test('creates a new conversation row while the message itself waits for admission', async () => {
+        TestClient.sendCompletion.mockImplementation(async () => {
+          await flush();
+          expect(savedUserMessage()).toBe(false);
+          expect(saveConvo).toHaveBeenCalledTimes(1);
+          const [, fields, seedOptions] = saveConvo.mock.calls[0];
+          expect(fields).toEqual(expect.objectContaining({ conversationId: expect.any(String) }));
+          expect(seedOptions).toEqual(expect.objectContaining({ context: seedContext }));
+          /** An empty append set spares `saveConvo` the read of a message list the seed lacks. */
+          expect(seedOptions).toEqual(expect.objectContaining({ appendMessageIds: [] }));
+          return { completion: 'Safe response', metadata: undefined };
+        });
+
+        await TestClient.sendMessage('Message with an attachment');
+
+        expect(savedUserMessage()).toBe(true);
+        /** The message save reuses the seeded row instead of looking the conversation up again. */
+        expect(getConvo).toHaveBeenCalledTimes(1);
+      });
+
+      test('leaves an existing conversation to the deferred message write', async () => {
+        getConvo.mockResolvedValue({ conversationId: 'existing-convo', endpoint: 'openAI' });
+        TestClient.sendCompletion.mockImplementation(async () => {
+          await flush();
+          expect(saveConvo).not.toHaveBeenCalled();
+          return { completion: 'Safe response', metadata: undefined };
+        });
+
+        await TestClient.sendMessage('Message with an attachment');
+
+        expect(savedUserMessage()).toBe(true);
+        expect(saveConvo.mock.calls.every(([, , opts]) => opts.context !== seedContext)).toBe(true);
+      });
+
+      test('holds the deferred message write until an in-flight seed lands', async () => {
+        const seedWrite = deferred();
+        saveConvo.mockImplementationOnce(() => seedWrite.promise);
+        const completionStarted = deferred();
+        const completionResult = deferred();
+        const abortController = new AbortController();
+        TestClient.sendCompletion.mockImplementation(() => {
+          completionStarted.resolve();
+          return completionResult.promise;
+        });
+
+        const sendPromise = TestClient.sendMessage('Message with an attachment', {
+          abortController,
+        });
+        await completionStarted.promise;
+        await flush();
+        expect(saveConvo).toHaveBeenCalledTimes(1);
+
+        abortController.abort();
+        await flush();
+        expect(savedUserMessage()).toBe(false);
+
+        seedWrite.resolve({ conversationId: 'seeded-convo' });
+        await flush();
+        expect(savedUserMessage()).toBe(true);
+
+        completionResult.resolve({ completion: 'Partial response', metadata: undefined });
+        await sendPromise;
+      });
+
+      test('keeps the deferral cancellable after seeding when the model boundary rejects content', async () => {
+        const policyError = new ContentFilterError({ source: 'message', field: 'text' });
+        TestClient.sendCompletion.mockImplementation(async () => {
+          await flush();
+          throw policyError;
+        });
+
+        await expect(TestClient.sendMessage('Message with an attachment')).rejects.toBe(
+          policyError,
+        );
+
+        expect(savedUserMessage()).toBe(false);
+        expect(saveConvo).toHaveBeenCalledTimes(1);
+      });
+
+      test('does not seed when the client holds back every write', async () => {
+        TestClient.shouldSeedDeferredConversation = jest.fn(() => false);
+        TestClient.sendCompletion.mockImplementation(async () => {
+          await flush();
+          expect(saveConvo).not.toHaveBeenCalled();
+          return { completion: 'Safe response', metadata: undefined };
+        });
+
+        await TestClient.sendMessage('Message with an attachment');
+
+        expect(savedUserMessage()).toBe(true);
+      });
+    });
+
     test('preserves eager user-message persistence for non-policy provider failures', async () => {
       saveMessage.mockClear();
       saveConvo.mockClear();
@@ -3584,13 +3702,13 @@ describe('BaseClient', () => {
       expect(TestClient.getTextContextAttachments([file])).toEqual([]);
     });
 
-    test('delivers the text when the tool that would read the file has yet to receive it', () => {
-      /* An upload that named no destination is filed under no tool, so the enabled tool alone
-       * cannot serve it and withholding the text left it readable by nothing. */
+    test('delivers the text when File Search has yet to receive the file', () => {
+      /* An upload that named no destination is filed under no tool, so an enabled search tool
+       * alone cannot serve it and withholding the text left it readable by nothing. */
       routeCsvToTools();
       TestClient.options.agent = {
         provider: EModelEndpoint.openAI,
-        fileConsumers: { executeCode: true, fileSearch: true },
+        fileConsumers: { executeCode: false, fileSearch: true },
       };
       TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
         agent: TestClient.options.agent,
@@ -3614,6 +3732,32 @@ describe('BaseClient', () => {
       ]);
     });
 
+    test('leaves a file Run Code can read with Run Code before the sandbox holds it', () => {
+      /* Run Code uploads the file on its first call, so the text stays off the prompt, where it
+       * would otherwise count toward the history limits until that call. */
+      routeCsvToTools();
+      TestClient.options.agent = {
+        provider: EModelEndpoint.openAI,
+        fileConsumers: { executeCode: true, fileSearch: true },
+      };
+      TestClient.options.agent.deliveryRouting = resolveTurnDeliveryRouting({
+        agent: TestClient.options.agent,
+        config: TestClient.options.req?.config,
+      });
+      const file = {
+        file_id: 'unprovisioned-csv',
+        filename: 'sales.csv',
+        type: 'text/csv',
+        text: 'region,total',
+        llmDeliveryPath: 'none',
+        metadata: { destinationChosen: false },
+      };
+
+      expect(TestClient.getAttachmentDeliveryPath(file)).toBe('none');
+      expect(TestClient.getTextContextAttachments([file])).toEqual([]);
+      expect(TestClient.resolveTurnAttachments([file])).toEqual([file]);
+    });
+
     test('does not fall back on an endpoint that has not enabled it', () => {
       routeCsvToTools({ textFallbackWithoutTools: false });
       TestClient.options.agent = {
@@ -3931,6 +4075,29 @@ describe('BaseClient', () => {
       expect(message.image_urls).toEqual(['encoded-image']);
     });
 
+    test('keeps a code output out of the prompt once its expired sandbox reference is cleared', async () => {
+      /* Priming clears a dead sandbox reference on the turn's copy of the record so the file
+       * is re-provisioned. The output still belongs to the sandbox that wrote it. */
+      const message = {};
+      const file = {
+        user: 'user1',
+        file_id: 'code-output-chart',
+        filename: 'chart.png',
+        filepath: '/uploads/chart.png',
+        type: 'image/png',
+        bytes: 100,
+        source: 'local',
+        context: 'execute_code',
+        metadata: {},
+      };
+
+      const result = await TestClient.processAttachments(message, [file]);
+
+      expect(result).toEqual([file]);
+      expect(TestClient.addImageURLs).not.toHaveBeenCalled();
+      expect(message.image_urls).toBeUndefined();
+    });
+
     test('keeps excluding embedded legacy files that have no delivery path', async () => {
       const message = {};
       const file = {
diff --git a/api/cache/logViolation.js b/api/cache/logViolation.js
index 1ff65c6ccdd..fd2549c58dd 100644
--- a/api/cache/logViolation.js
+++ b/api/cache/logViolation.js
@@ -13,7 +13,7 @@ const banViolation = require('./banViolation');
  * @param {number | string} [score=1] - The severity of the violation. Defaults to 1
  */
 const logViolation = async (req, res, type, errorMessage, score = 1) => {
-  const userId = req.user?.id ?? req.user?._id;
+  const userId = req.user?.id ?? req.user?._id?.toString();
   if (!userId) {
     return;
   }
diff --git a/api/package.json b/api/package.json
index f226bf0f558..6c925bfad76 100644
--- a/api/package.json
+++ b/api/package.json
@@ -46,7 +46,7 @@
     "@azure/storage-blob": "^12.30.0",
     "@google/genai": "^2.8.0",
     "@keyv/redis": "5.1.6",
-    "@librechat/agents": "^3.8.7",
+    "@librechat/agents": "^3.8.8",
     "@librechat/api": "*",
     "@librechat/data-schemas": "*",
     "@microsoft/microsoft-graph-client": "^3.0.7",
diff --git a/api/server/controllers/agents/__tests__/openai.spec.js b/api/server/controllers/agents/__tests__/openai.spec.js
index 6fac81d9768..b02664babc4 100644
--- a/api/server/controllers/agents/__tests__/openai.spec.js
+++ b/api/server/controllers/agents/__tests__/openai.spec.js
@@ -1355,7 +1355,10 @@ describe('OpenAIChatCompletionController', () => {
       const { loadAgentTools, loadToolsForExecution } = require('~/server/services/ToolService');
       const { filterFilesByAgentAccess } = require('~/server/services/Files/permissions');
 
-      req.config.endpoints.agents.backgroundTasks = { ordinaryToolCancellation: true };
+      req.config.endpoints.agents.backgroundTasks = {
+        ordinaryToolCancellation: true,
+        completionResultMaxChars: 4096,
+      };
       await OpenAIChatCompletionController(req, res);
 
       const [initializeParams, dbMethods] = initializeAgent.mock.calls.at(-1);
@@ -1384,6 +1387,7 @@ describe('OpenAIChatCompletionController', () => {
 
       const toolExecuteOptions = createToolExecuteHandler.mock.calls.at(-1)[0];
       expect(toolExecuteOptions.ordinaryToolCancellation).toBe(true);
+      expect(toolExecuteOptions.backgroundCompletionResultMaxChars).toBe(4096);
       expect(toolExecuteOptions.runSignal).toBe(mockExecution.signal);
       expect(toolExecuteOptions.foregroundRunId).toBe(initializeParams.requestBody.messageId);
       const effectiveSignal = new AbortController().signal;
diff --git a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
index 90b9c89a330..e4524db39ab 100644
--- a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
+++ b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js
@@ -67,6 +67,8 @@ jest.mock('@librechat/api', () => ({
   resolveRunCodeWorkspaces: jest.requireActual('@librechat/api').resolveRunCodeWorkspaces,
   shouldPersistCodeWorkspaceInitializationError:
     jest.requireActual('@librechat/api').shouldPersistCodeWorkspaceInitializationError,
+  resolvePersistableCodeEnvironmentDecision: (...args) =>
+    jest.requireActual('@librechat/api').resolvePersistableCodeEnvironmentDecision(...args),
   getSafeErrorMetadata: jest.requireActual('@librechat/api').getSafeErrorMetadata,
   getSafeErrorText: jest.requireActual('@librechat/api').getSafeErrorText,
   GenerationJobManager: mockGenerationJobManager,
diff --git a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
index d778f6b2e58..eebe5f35186 100644
--- a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
+++ b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
@@ -281,6 +281,8 @@ jest.mock('@librechat/api', () => ({
     jest.requireActual('@librechat/api').getCodeWorkspaceSelectionErrorDetails,
   shouldPersistCodeWorkspaceInitializationError:
     jest.requireActual('@librechat/api').shouldPersistCodeWorkspaceInitializationError,
+  resolvePersistableCodeEnvironmentDecision: (...args) =>
+    jest.requireActual('@librechat/api').resolvePersistableCodeEnvironmentDecision(...args),
   getSafeErrorMetadata: jest.requireActual('@librechat/api').getSafeErrorMetadata,
   getSafeErrorText: jest.requireActual('@librechat/api').getSafeErrorText,
   resolveFailedTurnContent: jest.requireActual('@librechat/api').resolveFailedTurnContent,
@@ -3999,6 +4001,68 @@ describe('ResumableAgentController resume metadata', () => {
         expect.objectContaining({ initialAgentId: null }),
       );
     });
+
+    it('records the decision a failed turn of a saved chat ran under', async () => {
+      const codeWorkspaces = [{ environmentId: 'personal-vm', workspaceId: 'project-a' }];
+      const initializeClient = jest.fn().mockImplementation(async ({ req: request }) => {
+        request._codeEnvironmentDecision = { mode: 'attached', codeWorkspaces };
+        throw new Error('model unavailable');
+      });
+
+      await AgentController(
+        createFailedRequest(),
+        createResumableResponse(),
+        jest.fn(),
+        initializeClient,
+        null,
+      );
+
+      expect(mockSaveConvo).toHaveBeenCalledWith(
+        expect.objectContaining({ userId: 'user-123' }),
+        { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces },
+        expect.objectContaining({ noUpsert: true }),
+      );
+    });
+
+    it('does not rewrite the decision a chat already holds', async () => {
+      const req = createFailedRequest();
+      req.resolvedConversation = {
+        conversationId,
+        codeEnvironmentMode: 'attached',
+        codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],
+      };
+      const initializeClient = jest.fn().mockImplementation(async ({ req: request }) => {
+        request._codeEnvironmentDecision = {
+          mode: 'attached',
+          codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-b' }],
+        };
+        throw new Error('model unavailable');
+      });
+
+      await AgentController(req, createResumableResponse(), jest.fn(), initializeClient, null);
+
+      expect(mockSaveConvo).toHaveBeenCalledWith(
+        expect.objectContaining({ userId: 'user-123' }),
+        { conversationId },
+        expect.objectContaining({ noUpsert: true }),
+      );
+    });
+
+    it('leaves a saved chat undecided when the turn resolved no decision', async () => {
+      await AgentController(
+        createFailedRequest(),
+        createResumableResponse(),
+        jest.fn(),
+        jest.fn().mockRejectedValue(new Error('model unavailable')),
+        null,
+      );
+
+      expect(mockSaveConvo).toHaveBeenCalledWith(
+        expect.objectContaining({ userId: 'user-123' }),
+        { conversationId },
+        expect.objectContaining({ noUpsert: true }),
+      );
+    });
   });
 
   it('finalizes the failed job before releasing the idempotency claim', async () => {
diff --git a/api/server/controllers/agents/__tests__/responses.unit.spec.js b/api/server/controllers/agents/__tests__/responses.unit.spec.js
index 45d00b56842..70f0e937545 100644
--- a/api/server/controllers/agents/__tests__/responses.unit.spec.js
+++ b/api/server/controllers/agents/__tests__/responses.unit.spec.js
@@ -2065,7 +2065,10 @@ describe('createResponse controller', () => {
         const { loadAgentTools, loadToolsForExecution } = require('~/server/services/ToolService');
         const { filterFilesByAgentAccess } = require('~/server/services/Files/permissions');
 
-        req.config.endpoints.agents.backgroundTasks = { ordinaryToolCancellation: true };
+        req.config.endpoints.agents.backgroundTasks = {
+          ordinaryToolCancellation: true,
+          completionResultMaxChars: 4096,
+        };
         req.body.stream = stream;
         await createResponse(req, res);
 
@@ -2095,6 +2098,7 @@ describe('createResponse controller', () => {
 
         const toolExecuteOptions = createToolExecuteHandler.mock.calls.at(-1)[0];
         expect(toolExecuteOptions.ordinaryToolCancellation).toBe(true);
+        expect(toolExecuteOptions.backgroundCompletionResultMaxChars).toBe(4096);
         expect(toolExecuteOptions.runSignal).toBe(mockExecution.signal);
         expect(toolExecuteOptions.foregroundRunId).toBe(initializeParams.requestBody.messageId);
         const effectiveSignal = new AbortController().signal;
diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js
index d11da051856..451fcf83fcd 100644
--- a/api/server/controllers/agents/client.js
+++ b/api/server/controllers/agents/client.js
@@ -1989,6 +1989,15 @@ class AgentClient extends BaseClient {
     );
   }
 
+  /** Attachments alone defer only the message, so a new conversation still gets its row when
+   * the run starts, as it did before that deferral. A content policy holds back every write. */
+  shouldSeedDeferredConversation() {
+    return !hasModelBoundContentProtection(
+      this.options.req?.config?.filters,
+      this.options.req?.config?.messageFilter?.pii,
+    );
+  }
+
   /** Legacy `messageFilter.pii` historically covered the restored branch
    * before model-input construction and persistence. Retain that contract
    * without scanning new source-aware filters before SDK pruning. */
diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js
index 82ccb23afd7..c646df0436d 100644
--- a/api/server/controllers/agents/client.test.js
+++ b/api/server/controllers/agents/client.test.js
@@ -6314,6 +6314,26 @@ describe('AgentClient - titleConvo', () => {
       expect(client.shouldDeferUserMessagePersistence()).toBe(true);
     });
 
+    it('still seeds the conversation row when only attachments defer the message', () => {
+      client.modelBoundCurrentFiles = [makeTextFile('pending', 'pending.txt', 'context')];
+
+      expect(client.shouldDeferUserMessagePersistence()).toBe(true);
+      expect(client.shouldSeedDeferredConversation()).toBe(true);
+    });
+
+    it('holds back the conversation row while a content policy defers every write', () => {
+      client.modelBoundCurrentFiles = [makeTextFile('pending', 'pending.txt', 'context')];
+      mockReq.config.messageFilter = {
+        pii: {
+          starterPatterns: [],
+          customPatterns: [{ id: 'secret', label: 'secret', regex: 'SECRET-[A-Z]+' }],
+        },
+      };
+
+      expect(client.shouldDeferUserMessagePersistence()).toBe(true);
+      expect(client.shouldSeedDeferredConversation()).toBe(false);
+    });
+
     it('keeps repeated lazy scoped-text admission cumulative across resolutions', () => {
       mockReq.config.fileConfig = { fileContextCharLimit: 1_000_000 };
       const repeated = makeTextFile('lazy-context', 'lazy.txt', 'x'.repeat(600_000));
diff --git a/api/server/controllers/agents/openai.js b/api/server/controllers/agents/openai.js
index 7bcbe4b9fae..65e22305943 100644
--- a/api/server/controllers/agents/openai.js
+++ b/api/server/controllers/agents/openai.js
@@ -490,6 +490,8 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {
       const allowedProviders = new Set(agentsEConfig?.allowedProviders);
       const ordinaryToolCancellationEnabled =
         agentsEConfig?.backgroundTasks?.ordinaryToolCancellation === true;
+      const backgroundCompletionResultMaxChars =
+        agentsEConfig?.backgroundTasks?.completionResultMaxChars;
 
       // Create tool loader
       const loadTools = createToolLoader({ req, res, signal: execution.signal });
@@ -840,6 +842,7 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {
         runSignal: execution.signal,
         foregroundRunId: responseId,
         ordinaryToolCancellation: ordinaryToolCancellationEnabled,
+        backgroundCompletionResultMaxChars,
         provisionFiles: createProvisionFilesCallback({
           req,
           agentToolContexts,
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index 9f9b5935d74..c1a4cfb3894 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -45,6 +45,7 @@ const {
   logAgentMemorySnapshot,
   getCodeWorkspaceSelectionErrorDetails,
   shouldPersistCodeWorkspaceInitializationError,
+  resolvePersistableCodeEnvironmentDecision,
   getFailedTurnTraceFields,
   resolveFailedTurnContent,
 } = require('@librechat/api');
@@ -502,7 +503,16 @@ async function saveErrorTurn(
     const agentId = endpointOption?.agent_id ?? req.body?.agent_id;
     const chatProjectId = endpointOption?.chatProjectId ?? req.body?.chatProjectId;
     const seedConvo = isNewConvo || req.resolvedConversation === null;
-    const codeEnvironmentDecision = req._codeEnvironmentDecision;
+    /** A stored turn seals the decision it ran under, on a saved chat as much as on a new one: the
+     * error turn below enters the conversation, so leaving its validated decision out would let a
+     * retry choose a different workspace than the failure already recorded. The resolver the
+     * streaming saves already use decides what this turn may write, so an error turn and a
+     * completed one record a decision under one rule. */
+    const decisionFields = resolvePersistableCodeEnvironmentDecision({
+      conversationId,
+      decision: req._codeEnvironmentDecision,
+      conversation: req.resolvedConversation,
+    });
     const convoFields = seedConvo
       ? {
           ...(endpoint != null && { endpoint }),
@@ -514,14 +524,9 @@ async function saveErrorTurn(
           ...(endpointOption?.spec != null && { spec: endpointOption.spec }),
           ...(agentId != null && { agent_id: agentId }),
           ...(typeof chatProjectId === 'string' && chatProjectId.length > 0 && { chatProjectId }),
-          ...(codeEnvironmentDecision?.mode != null && {
-            codeEnvironmentMode: codeEnvironmentDecision.mode,
-            ...(codeEnvironmentDecision.codeWorkspaces != null && {
-              codeWorkspaces: codeEnvironmentDecision.codeWorkspaces,
-            }),
-          }),
+          ...decisionFields,
         }
-      : {};
+      : decisionFields;
     await saveConvo(
       reqCtx,
       { conversationId, ...convoFields },
diff --git a/api/server/controllers/agents/responses.js b/api/server/controllers/agents/responses.js
index 24e668576b1..1b4772ffd07 100644
--- a/api/server/controllers/agents/responses.js
+++ b/api/server/controllers/agents/responses.js
@@ -732,6 +732,8 @@ const executeResponse = async (envelope, { req, res }) => {
       const agentsEConfig = appConfig?.endpoints?.[EModelEndpoint.agents];
       const ordinaryToolCancellationEnabled =
         agentsEConfig?.backgroundTasks?.ordinaryToolCancellation === true;
+      const backgroundCompletionResultMaxChars =
+        agentsEConfig?.backgroundTasks?.completionResultMaxChars;
       const previousMessages = request.previous_response_id
         ? await loadPreviousMessages(request.previous_response_id, principal.userId)
         : [];
@@ -1194,6 +1196,7 @@ const executeResponse = async (envelope, { req, res }) => {
           runSignal: execution.signal,
           foregroundRunId: responseId,
           ordinaryToolCancellation: ordinaryToolCancellationEnabled,
+          backgroundCompletionResultMaxChars,
           provisionFiles: createProvisionFilesCallback({
             req,
             agentToolContexts,
@@ -1424,6 +1427,7 @@ const executeResponse = async (envelope, { req, res }) => {
           runSignal: execution.signal,
           foregroundRunId: responseId,
           ordinaryToolCancellation: ordinaryToolCancellationEnabled,
+          backgroundCompletionResultMaxChars,
           provisionFiles: createProvisionFilesCallback({
             req,
             agentToolContexts,
diff --git a/api/server/experimental.js b/api/server/experimental.js
index ef3de373cea..d6b610a5956 100644
--- a/api/server/experimental.js
+++ b/api/server/experimental.js
@@ -705,7 +705,11 @@ if (cluster.isMaster) {
         await initializeMCPs();
         await initializeOAuthReconnectManager();
         await checkMigrations();
-        await initializeAgentTriggerService({ address: server.address() });
+        await initializeAgentTriggerService({
+          address: server.address(),
+          completionResultBatchSize:
+            baseAppConfig?.endpoints?.agents?.backgroundTasks?.completionResultBatchSize,
+        });
       } catch (initErr) {
         logger.error(`Worker ${process.pid} post-listen initialization failed:`, initErr);
         process.exit(1);
diff --git a/api/server/index.js b/api/server/index.js
index 610d5c2c9a2..b4555e7b262 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -498,7 +498,11 @@ const startServer = async () => {
       if (inspectFlags || isEnabled(process.env.MEM_DIAG)) {
         memoryDiagnostics.start();
       }
-      await initializeAgentTriggerService({ address: server.address() });
+      await initializeAgentTriggerService({
+        address: server.address(),
+        completionResultBatchSize:
+          appConfig?.endpoints?.agents?.backgroundTasks?.completionResultBatchSize,
+      });
       const scheduleEngineArmed = (await initializeScheduleEngine()) != null;
       scheduleEngineState = scheduleEngineArmed ? 'armed' : 'unavailable';
       if (!scheduleEngineArmed) {
diff --git a/api/server/middleware/checkBan.js b/api/server/middleware/checkBan.js
index 7194a555b0e..0871e51c047 100644
--- a/api/server/middleware/checkBan.js
+++ b/api/server/middleware/checkBan.js
@@ -88,7 +88,7 @@ const checkBan = async (req, res, next = () => {}) => {
     }
 
     req.ip = removePorts(req);
-    let userId = req.user?.id ?? req.user?._id ?? null;
+    let userId = req.user?.id ?? req.user?._id?.toString() ?? null;
 
     if (!userId && req?.body?.email) {
       const user = await findUser({ email: req.body.email }, '_id');
diff --git a/api/server/middleware/checkBan.spec.js b/api/server/middleware/checkBan.spec.js
new file mode 100644
index 00000000000..ee83f0bef8f
--- /dev/null
+++ b/api/server/middleware/checkBan.spec.js
@@ -0,0 +1,96 @@
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { ErrorTypes, ViolationTypes } = require('librechat-data-provider');
+
+/** Violation logs are file-backed in production; keep the real namespaced Keyv, swap only the store. */
+jest.mock('~/cache/getLogStores', () => {
+  const { Keyv } = jest.requireActual('keyv');
+  const { ViolationTypes } = jest.requireActual('librechat-data-provider');
+  const getLogStores = jest.requireActual('~/cache/getLogStores');
+  const violationLogs = new Map();
+  return (type) => {
+    if (type === ViolationTypes.BAN) {
+      return getLogStores(type);
+    }
+    if (!violationLogs.has(type)) {
+      const namespace = type === ViolationTypes.GENERAL ? 'violations' : `violations:${type}`;
+      violationLogs.set(type, new Keyv({ store: new Map(), namespace }));
+    }
+    return violationLogs.get(type);
+  };
+});
+
+jest.mock('~/models', () => ({
+  ...jest.requireActual('~/models'),
+  deleteAllUserSessions: jest.fn().mockResolvedValue(true),
+}));
+
+process.env.BAN_VIOLATIONS = 'true';
+process.env.BAN_INTERVAL = '20';
+delete process.env.USE_REDIS;
+
+const logViolation = require('~/cache/logViolation');
+const checkBan = require('./checkBan');
+
+/** Passport's social strategies hand the callback a lean user: an ObjectId `_id` and no `id`. */
+const createOAuthCallbackReq = (userId, ip) => ({
+  ip,
+  user: { _id: userId },
+  method: 'GET',
+  headers: { 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/140.0.0.0' },
+  body: {},
+  baseUrl: '/oauth',
+  originalUrl: '/oauth/google/callback',
+  isOAuthNavigation: true,
+});
+
+const createRes = () => ({
+  status: jest.fn().mockReturnThis(),
+  json: jest.fn().mockReturnThis(),
+  redirect: jest.fn().mockReturnThis(),
+  clearCookie: jest.fn(),
+});
+
+describe('checkBan with namespaced Keyv stores and ObjectId user ids', () => {
+  let mongoServer;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    await mongoose.connect(mongoServer.getUri());
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  it('lets an unbanned OAuth user through without Redis', async () => {
+    const next = jest.fn();
+    const req = createOAuthCallbackReq(new mongoose.Types.ObjectId(), '10.0.0.1');
+
+    await checkBan(req, createRes(), next);
+
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(next).toHaveBeenCalledWith();
+    expect(req.banned).toBeUndefined();
+  });
+
+  it('enforces a ban recorded for the same user from another address', async () => {
+    const userId = new mongoose.Types.ObjectId();
+    const violationReq = createOAuthCallbackReq(userId, '10.0.0.2');
+    const errorMessage = { type: ViolationTypes.LOGINS };
+
+    await logViolation(violationReq, createRes(), ViolationTypes.LOGINS, errorMessage, 20);
+    expect(errorMessage.ban).toBe(true);
+
+    const next = jest.fn();
+    const res = createRes();
+    const req = createOAuthCallbackReq(new mongoose.Types.ObjectId(userId.toString()), '10.0.0.3');
+
+    await checkBan(req, res, next);
+
+    expect(next).not.toHaveBeenCalled();
+    expect(req.banned).toBe(true);
+    expect(res.redirect).toHaveBeenCalledWith(expect.stringContaining(ErrorTypes.AUTH_BANNED));
+  });
+});
diff --git a/api/server/routes/files/files.js b/api/server/routes/files/files.js
index de84c67c950..f6b97e587f4 100644
--- a/api/server/routes/files/files.js
+++ b/api/server/routes/files/files.js
@@ -8,6 +8,7 @@ const {
   refreshS3FileUrls,
   handleFilesUsageRequest,
   buildDeleteFilesResponse,
+  deleteAgentResourceFiles,
   shouldUseUploadSse,
   startUploadSseStream,
   sendUploadPolicyError,
@@ -245,20 +246,36 @@ router.delete('/', async (req, res) => {
         });
       }
 
-      const toolResourceFiles = agent.tool_resources?.[req.body.tool_resource]?.file_ids ?? [];
-      const agentFiles = files
-        .filter((f) => toolResourceFiles.includes(f.file_id))
-        .map((file) => ({ tool_resource: req.body.tool_resource, file_id: file.file_id }));
-      if (agentFiles.length === 0) {
+      const agentDeletion = await deleteAgentResourceFiles(
+        {
+          agentId: req.body.agent_id,
+          agentObjectId: agent._id.toString(),
+          toolResource: req.body.tool_resource,
+          requestedFileIds: fileIds,
+          attachedFileIds: agent.tool_resources?.[req.body.tool_resource]?.file_ids ?? [],
+          files: dbFiles.map((file) => ({
+            file_id: file.file_id,
+            owner: file.user?.toString() ?? null,
+            file,
+          })),
+          userId: req.user.id.toString(),
+        },
+        {
+          getSharedResourceFileIds: db.getSharedResourceFileIds,
+          removeAgentResourceFiles: db.removeAgentResourceFiles,
+          deleteFiles: (agentFiles) => processDeleteRequest({ req, files: agentFiles }),
+        },
+      );
+
+      if (agentDeletion.outcome == null) {
         res.status(200).json({ message: 'File associations removed successfully from agent' });
         return;
       }
 
-      await db.removeAgentResourceFiles({
-        agent_id: req.body.agent_id,
-        files: agentFiles,
-      });
-      res.status(200).json({ message: 'File associations removed successfully from agent' });
+      logger.debug(
+        `[/files] Agent files deleted successfully: ${agentDeletion.destroyedFileIds.join(', ')}`,
+      );
+      sendDeleteResult(agentDeletion.outcome, 'Files deleted successfully');
       return;
     }
 
diff --git a/api/server/routes/files/files.test.js b/api/server/routes/files/files.test.js
index 2ad58d350dd..9df2acb0623 100644
--- a/api/server/routes/files/files.test.js
+++ b/api/server/routes/files/files.test.js
@@ -327,6 +327,245 @@ describe('File Routes - Delete with Agent Access', () => {
       expect(updatedAgent.tool_resources.file_search.file_ids).toEqual([]);
     });
 
+    it('deletes storage and embeddings for an attached file the caller owns', async () => {
+      const ownedFileId = uuidv4();
+      await createFile({
+        user: otherUserId,
+        file_id: ownedFileId,
+        filename: 'owned-knowledge.txt',
+        filepath: '/uploads/owned-knowledge.txt',
+        bytes: 100,
+        type: 'text/plain',
+        source: FileSources.vectordb,
+        embedded: true,
+      });
+
+      const agent = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: {
+          file_search: {
+            file_ids: [ownedFileId],
+          },
+        },
+      });
+
+      const response = await request(app)
+        .delete('/files')
+        .send({
+          agent_id: agent.id,
+          tool_resource: 'file_search',
+          files: [{ file_id: ownedFileId, filepath: '/uploads/owned-knowledge.txt' }],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body.message).toBe('Files deleted successfully');
+      expect(processDeleteRequest).toHaveBeenCalledTimes(1);
+
+      const [{ req, files: deletedFiles }] = processDeleteRequest.mock.calls[0];
+      expect(deletedFiles.map((file) => file.file_id)).toEqual([ownedFileId]);
+      expect(deletedFiles[0].source).toBe(FileSources.vectordb);
+      expect(req.body.agent_id).toBe(agent.id);
+      expect(req.body.tool_resource).toBe('file_search');
+    });
+
+    it('unlinks another user’s attached file while deleting the caller’s own', async () => {
+      const ownedFileId = uuidv4();
+      await createFile({
+        user: otherUserId,
+        file_id: ownedFileId,
+        filename: 'owned-knowledge.txt',
+        filepath: '/uploads/owned-knowledge.txt',
+        bytes: 100,
+        type: 'text/plain',
+        source: FileSources.vectordb,
+        embedded: true,
+      });
+
+      const agent = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: {
+          file_search: {
+            file_ids: [ownedFileId, fileId],
+          },
+        },
+      });
+
+      const response = await request(app)
+        .delete('/files')
+        .send({
+          agent_id: agent.id,
+          tool_resource: 'file_search',
+          files: [
+            { file_id: ownedFileId, filepath: '/uploads/owned-knowledge.txt' },
+            { file_id: fileId, filepath: '/uploads/test.txt' },
+          ],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body.message).toBe('Files deleted successfully');
+
+      const [{ files: deletedFiles }] = processDeleteRequest.mock.calls[0];
+      expect(deletedFiles.map((file) => file.file_id)).toEqual([ownedFileId]);
+
+      const updatedAgent = await Agent.findOne({ id: agent.id }).lean();
+      expect(updatedAgent.tool_resources.file_search.file_ids).toEqual([ownedFileId]);
+
+      const retainedFile = await File.findOne({ file_id: fileId }).lean();
+      expect(retainedFile).toBeTruthy();
+    });
+
+    it('keeps a file the same agent holds under another tool resource', async () => {
+      const sharedFileId = uuidv4();
+      await createFile({
+        user: otherUserId,
+        file_id: sharedFileId,
+        filename: 'dual-purpose.txt',
+        filepath: '/uploads/dual-purpose.txt',
+        bytes: 100,
+        type: 'text/plain',
+        source: FileSources.vectordb,
+        embedded: true,
+      });
+
+      /* One agent can hold the same file under two resources, so the reference being removed is the
+         `(agent, tool_resource)` pair rather than the agent. */
+      const agent = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: {
+          file_search: { file_ids: [sharedFileId] },
+          context: { file_ids: [sharedFileId] },
+        },
+      });
+
+      const response = await request(app)
+        .delete('/files')
+        .send({
+          agent_id: agent.id,
+          tool_resource: 'file_search',
+          files: [{ file_id: sharedFileId, filepath: '/uploads/dual-purpose.txt' }],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body.message).toBe('File associations removed successfully from agent');
+      expect(processDeleteRequest).not.toHaveBeenCalled();
+
+      const updatedAgent = await Agent.findOne({ id: agent.id }).lean();
+      expect(updatedAgent.tool_resources.file_search.file_ids).toEqual([]);
+      expect(updatedAgent.tool_resources.context.file_ids).toEqual([sharedFileId]);
+
+      const retainedFile = await File.findOne({ file_id: sharedFileId }).lean();
+      expect(retainedFile).toBeTruthy();
+    });
+
+    it('keeps a file a duplicated agent still references, unlinking it here only', async () => {
+      const sharedFileId = uuidv4();
+      await createFile({
+        user: otherUserId,
+        file_id: sharedFileId,
+        filename: 'shared-knowledge.txt',
+        filepath: '/uploads/shared-knowledge.txt',
+        bytes: 100,
+        type: 'text/plain',
+        source: FileSources.vectordb,
+        embedded: true,
+      });
+
+      const agent = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: { file_search: { file_ids: [sharedFileId] } },
+      });
+
+      /* Duplicating an agent copies file_ids rather than the files behind them, and lands them
+         under `context`, so the second holder is found across tool resources. */
+      const duplicate = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent (copy)',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: { context: { file_ids: [sharedFileId] } },
+      });
+
+      const response = await request(app)
+        .delete('/files')
+        .send({
+          agent_id: agent.id,
+          tool_resource: 'file_search',
+          files: [{ file_id: sharedFileId, filepath: '/uploads/shared-knowledge.txt' }],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body.message).toBe('File associations removed successfully from agent');
+      expect(processDeleteRequest).not.toHaveBeenCalled();
+
+      const updatedAgent = await Agent.findOne({ id: agent.id }).lean();
+      expect(updatedAgent.tool_resources.file_search.file_ids).toEqual([]);
+
+      const untouchedDuplicate = await Agent.findOne({ id: duplicate.id }).lean();
+      expect(untouchedDuplicate.tool_resources.context.file_ids).toEqual([sharedFileId]);
+
+      const retainedFile = await File.findOne({ file_id: sharedFileId }).lean();
+      expect(retainedFile).toBeTruthy();
+    });
+
+    it('leaves an owned file alone when the tool resource does not hold it', async () => {
+      const ownedFileId = uuidv4();
+      await createFile({
+        user: otherUserId,
+        file_id: ownedFileId,
+        filename: 'detached-knowledge.txt',
+        filepath: '/uploads/detached-knowledge.txt',
+        bytes: 100,
+        type: 'text/plain',
+        source: FileSources.vectordb,
+        embedded: true,
+      });
+
+      const agent = await createAgent({
+        id: uuidv4(),
+        name: 'Test Agent',
+        provider: 'openai',
+        model: 'gpt-4',
+        author: otherUserId,
+        tool_resources: {
+          file_search: {
+            file_ids: [fileId],
+          },
+        },
+      });
+
+      const response = await request(app)
+        .delete('/files')
+        .send({
+          agent_id: agent.id,
+          tool_resource: 'file_search',
+          files: [{ file_id: ownedFileId, filepath: '/uploads/detached-knowledge.txt' }],
+        });
+
+      expect(response.status).toBe(200);
+      expect(response.body.message).toBe('File associations removed successfully from agent');
+      expect(processDeleteRequest).not.toHaveBeenCalled();
+
+      const updatedAgent = await Agent.findOne({ id: agent.id }).lean();
+      expect(updatedAgent.tool_resources.file_search.file_ids).toEqual([fileId]);
+    });
+
     it('rejects invalid agent tool_resource values before unlinking', async () => {
       const agent = await createAgent({
         id: uuidv4(),
diff --git a/api/server/routes/skills.test.js b/api/server/routes/skills.test.js
index 3508cb512dd..992cb2d8497 100644
--- a/api/server/routes/skills.test.js
+++ b/api/server/routes/skills.test.js
@@ -553,6 +553,54 @@ describe('Skill routes', () => {
       );
     });
 
+    it('rolls back the skill, files, ACL, and stored blob when a bundled file fails', async () => {
+      const saveBuffer = jest.fn().mockResolvedValue('/uploads/test/queries.sql');
+      const deleteFile = jest.fn().mockResolvedValue(undefined);
+      const { getStrategyFunctions } = require('~/server/services/Files/strategies');
+      /** Both the write and the rollback delete resolve a strategy, so the
+       *  override outlives a single call and is restored below. */
+      const defaultStrategies = getStrategyFunctions();
+      getStrategyFunctions.mockReturnValue({ saveBuffer, deleteFile });
+
+      const zip = new JSZip();
+      zip.file(
+        'SKILL.md',
+        [
+          '---',
+          'name: partial-import',
+          'description: Imported skill that loses one bundled file.',
+          '---',
+          '# Partial Import',
+        ].join('\n'),
+      );
+      zip.file('queries.sql', 'select 1;');
+      /** A space is outside the stored path charset, so this entry can never
+       *  persist — the import must fail instead of dropping it silently. */
+      zip.file('references/region mapping.md', '# regions');
+      const buffer = await zip.generateAsync({ type: 'nodebuffer' });
+
+      const res = await request(app).post('/api/skills/import').attach('file', buffer, {
+        filename: 'partial-import.skill',
+        contentType: 'application/zip',
+      });
+      getStrategyFunctions.mockReturnValue(defaultStrategies);
+
+      expect(res.status).toBe(422);
+      expect(res.body).toEqual(
+        expect.objectContaining({
+          error: 'skill_import_incomplete',
+          failedFiles: [{ path: 'references/region mapping.md', reason: 'invalid_path' }],
+        }),
+      );
+      expect(await Skill.countDocuments({ name: 'partial-import' })).toBe(0);
+      expect(await SkillFile.countDocuments()).toBe(0);
+      expect(await AclEntry.countDocuments({ resourceType: ResourceType.SKILL })).toBe(0);
+      expect(deleteFile).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ filepath: '/uploads/test/queries.sql' }),
+      );
+    });
+
     it('blocks filtered Markdown before creating the imported skill', async () => {
       mockFilters = {
         files: {
diff --git a/api/server/services/Agents/triggers.js b/api/server/services/Agents/triggers.js
index 66926c2991a..0f2d81218e7 100644
--- a/api/server/services/Agents/triggers.js
+++ b/api/server/services/Agents/triggers.js
@@ -28,6 +28,7 @@ const subagentCompletionAdapter = createSubagentCompletionWakeupResolver({
 const backgroundToolCompletionAdapter = createBackgroundToolCompletionWakeupResolver({
   methods,
   getGenerationJob: (conversationId) => GenerationJobManager.getJob(conversationId),
+  getResultBatchSize: () => service.getBackgroundCompletionResultBatchSize(),
 });
 const eventActorAdapter = createAgentEventContinueResolver({
   methods,
@@ -86,6 +87,9 @@ module.exports = {
   requeueAgentTrigger: service.requeue,
   retireAgentTrigger: service.retire,
   renewAgentTriggerProducerLease: service.renewProducerLease,
+  persistAgentBackgroundToolResult: service.persistBackgroundToolResult,
+  getAgentBackgroundToolResultClaim: service.getBackgroundToolResultClaim,
+  releaseAgentBackgroundToolResultClaims: service.releaseBackgroundToolResultClaims,
   drainAgentTriggerDeliveriesForUser: service.drainUser,
   prepareAgentTriggerUserPurge: service.prepareUserPurge,
   cancelAgentTriggerUserPurge: service.cancelUserPurge,
diff --git a/api/server/services/Agents/triggers.spec.js b/api/server/services/Agents/triggers.spec.js
index 16965b5abe8..4c636f46928 100644
--- a/api/server/services/Agents/triggers.spec.js
+++ b/api/server/services/Agents/triggers.spec.js
@@ -1,4 +1,5 @@
 const mockCreateAgentTriggerService = jest.fn();
+const mockCreateBackgroundToolCompletionWakeupResolver = jest.fn(() => jest.fn());
 const mockGenerationJobManager = {
   supportsDetachedAgentEventActions: true,
   getJob: jest.fn(),
@@ -21,7 +22,8 @@ jest.mock('@librechat/api', () => ({
   createAgentTriggerService: (...args) => mockCreateAgentTriggerService(...args),
   createAgentContinuationResolver: jest.fn(() => jest.fn()),
   createAgentEventContinueResolver: jest.fn(() => jest.fn()),
-  createBackgroundToolCompletionWakeupResolver: jest.fn(() => jest.fn()),
+  createBackgroundToolCompletionWakeupResolver: (...args) =>
+    mockCreateBackgroundToolCompletionWakeupResolver(...args),
   createSubagentCompletionWakeupResolver: jest.fn(() => jest.fn()),
   createAgentQueuedTurnLifecycle: jest.fn(() => mockQueuedTurnLifecycle),
   BACKGROUND_TOOL_COMPLETION_SOURCE: 'background-tool-completion',
@@ -39,8 +41,11 @@ describe('agent trigger service composition', () => {
     jest.resetModules();
     jest.clearAllMocks();
     mockGenerationJobManager.supportsDetachedAgentEventActions = true;
+    let completionResultBatchSize = 8;
     mockCreateAgentTriggerService.mockReturnValue({
-      initialize: jest.fn(),
+      initialize: jest.fn(async (options) => {
+        completionResultBatchSize = options.completionResultBatchSize ?? 8;
+      }),
       stop: jest.fn(),
       dispatch: jest.fn(),
       enqueue: jest.fn(),
@@ -52,6 +57,7 @@ describe('agent trigger service composition', () => {
       prepareUserPurge: jest.fn(),
       cancelUserPurge: jest.fn(),
       purgeUser: jest.fn(),
+      getBackgroundCompletionResultBatchSize: () => completionResultBatchSize,
     });
   });
 
@@ -73,4 +79,16 @@ describe('agent trigger service composition', () => {
     mockGenerationJobManager.supportsDetachedAgentEventActions = false;
     expect(supportsDetachedActionCompletion()).toBe(false);
   });
+
+  it('injects the configured background completion batch size', async () => {
+    const { initializeAgentTriggerService } = require('./triggers');
+    await initializeAgentTriggerService({ address: 'local', completionResultBatchSize: 12 });
+
+    const resolverDeps = mockCreateBackgroundToolCompletionWakeupResolver.mock.calls[0][0];
+    expect(resolverDeps.getResultBatchSize()).toBe(12);
+    expect(mockCreateAgentTriggerService.mock.results[0].value.initialize).toHaveBeenCalledWith({
+      address: 'local',
+      completionResultBatchSize: 12,
+    });
+  });
 });
diff --git a/api/server/services/Endpoints/agents/backgroundCompletion.js b/api/server/services/Endpoints/agents/backgroundCompletion.js
index 6fc0996e623..8ca1cae6efc 100644
--- a/api/server/services/Endpoints/agents/backgroundCompletion.js
+++ b/api/server/services/Endpoints/agents/backgroundCompletion.js
@@ -2,9 +2,13 @@ const {
   createBackgroundToolCompletionWakeupHandler,
   createBackgroundToolDeadClaimRecovery,
   createBackgroundToolResultHandler,
+  claimBackgroundToolResult: claimResult,
 } = require('@librechat/api');
 const {
   enqueueAgentTrigger,
+  persistAgentBackgroundToolResult,
+  getAgentBackgroundToolResultClaim,
+  releaseAgentBackgroundToolResultClaims,
   renewAgentTriggerProducerLease,
   retireAgentTrigger,
 } = require('../../Agents/triggers');
@@ -13,12 +17,17 @@ const preregisterBackgroundToolCompletion = createBackgroundToolCompletionWakeup
   enqueueAgentTrigger,
   retireAgentTrigger,
   renewAgentTriggerProducerLease,
+  (deliveryKey, sourceId, result) =>
+    persistAgentBackgroundToolResult({ deliveryKey, sourceId, result }),
 );
 
 function createBackgroundToolResultPersistence({ req, updateToolCallResult }) {
   return createBackgroundToolResultHandler({ req, updateToolCallResult });
 }
 
+const claimBackgroundToolResult = (db, input) =>
+  claimResult(db, getAgentBackgroundToolResultClaim, input);
+
 function createDeadBackgroundToolClaimRecovery(
   releaseBackgroundToolResultClaims,
   getGenerationJob,
@@ -29,11 +38,13 @@ function createDeadBackgroundToolClaimRecovery(
     releaseBackgroundToolResultClaims,
     getGenerationJob,
     fenceGenerationClaim,
+    releaseAgentBackgroundToolResultClaims,
   );
 }
 
 module.exports = {
   preregisterBackgroundToolCompletion,
   createBackgroundToolResultPersistence,
+  claimBackgroundToolResult,
   createDeadBackgroundToolClaimRecovery,
 };
diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.js
index ee8ebb207d8..875d085951b 100644
--- a/api/server/services/Endpoints/agents/initialize.js
+++ b/api/server/services/Endpoints/agents/initialize.js
@@ -95,6 +95,7 @@ const subagentThreadTaskStore = require('./subagentThreadStore');
 const {
   preregisterBackgroundToolCompletion,
   createBackgroundToolResultPersistence,
+  claimBackgroundToolResult,
   createDeadBackgroundToolClaimRecovery,
 } = require('./backgroundCompletion');
 const { logViolation } = require('~/cache');
@@ -215,6 +216,8 @@ const initializeClientWithProvider = async ({
   const ordinaryToolCancellationEnabled =
     appConfig?.endpoints?.[EModelEndpoint.agents]?.backgroundTasks?.ordinaryToolCancellation ===
     true;
+  const backgroundCompletionResultMaxChars =
+    appConfig?.endpoints?.[EModelEndpoint.agents]?.backgroundTasks?.completionResultMaxChars;
   /** The normal controller resolves this once for timestamp anchoring. Reuse
    * that trusted document for child-thread execution policy; resume and direct
    * callers fall back to the same owner-scoped lookup. */
@@ -440,6 +443,7 @@ const initializeClientWithProvider = async ({
     runSignal: signal,
     foregroundRunId,
     ordinaryToolCancellation: ordinaryToolCancellationEnabled,
+    backgroundCompletionResultMaxChars,
     loadTools: async (
       toolNames,
       agentId,
@@ -515,7 +519,7 @@ const initializeClientWithProvider = async ({
         req,
         updateToolCallResult: db.updateToolCallResult,
       }),
-      claim: db.claimBackgroundToolResults,
+      claim: (input) => claimBackgroundToolResult(db, input),
       recoverDeadClaim: createDeadBackgroundToolClaimRecovery(
         db.releaseBackgroundToolResultClaims,
         (conversationId) => GenerationJobManager.getJob(conversationId),
diff --git a/api/server/services/Endpoints/agents/initialize.spec.js b/api/server/services/Endpoints/agents/initialize.spec.js
index b01af987604..fe65c2493ab 100644
--- a/api/server/services/Endpoints/agents/initialize.spec.js
+++ b/api/server/services/Endpoints/agents/initialize.spec.js
@@ -408,10 +408,11 @@ describe('initializeClient — processAgent ACL gate', () => {
       endpointOption: makeEndpointOption(),
     });
     expect(capturedToolExecuteOptions.ordinaryToolCancellation).toBe(false);
+    expect(capturedToolExecuteOptions.backgroundCompletionResultMaxChars).toBeUndefined();
 
     const enabledReq = makeReq();
     enabledReq.config.endpoints.agents = {
-      backgroundTasks: { ordinaryToolCancellation: true },
+      backgroundTasks: { ordinaryToolCancellation: true, completionResultMaxChars: 4096 },
     };
     await initializeClient({
       req: enabledReq,
@@ -420,6 +421,7 @@ describe('initializeClient — processAgent ACL gate', () => {
       endpointOption: makeEndpointOption(),
     });
     expect(capturedToolExecuteOptions.ordinaryToolCancellation).toBe(true);
+    expect(capturedToolExecuteOptions.backgroundCompletionResultMaxChars).toBe(4096);
   });
 
   it('propagates an expected-MCP-tools failure from the runtime tool loader', async () => {
diff --git a/api/server/services/Files/Code/process.js b/api/server/services/Files/Code/process.js
index ed800aaf37a..73efab77009 100644
--- a/api/server/services/Files/Code/process.js
+++ b/api/server/services/Files/Code/process.js
@@ -1112,6 +1112,7 @@ async function readSandboxFile({
  * @param {Object} params
  * @param {string} params.file_path
  * @param {string} params.workspace_id
+ * @param {string} [params.workspace_instance_id]
  * @param {number} params.start_line
  * @param {number} params.max_lines
  * @param {string} params.codeApiBaseUrl
@@ -1123,6 +1124,7 @@ async function readSandboxFile({
 async function readWorkspaceFile({
   file_path,
   workspace_id,
+  workspace_instance_id,
   start_line,
   max_lines,
   codeApiBaseUrl,
@@ -1130,18 +1132,21 @@ async function readWorkspaceFile({
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'read_file',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       path: file_path,
       startLine: start_line,
       maxLines: max_lines,
@@ -1156,6 +1161,7 @@ async function readWorkspaceFile({
  * @param {Object} params
  * @param {string} params.query
  * @param {string} params.workspace_id
+ * @param {string} [params.workspace_instance_id]
  * @param {string} [params.path]
  * @param {number} params.max_results
  * @param {string} params.codeApiBaseUrl
@@ -1167,6 +1173,7 @@ async function readWorkspaceFile({
 async function searchWorkspace({
   query,
   workspace_id,
+  workspace_instance_id,
   path,
   max_results,
   codeApiBaseUrl,
@@ -1174,18 +1181,21 @@ async function searchWorkspace({
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'search_text',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       query,
       ...(path ? { path } : {}),
       maxResults: max_results,
@@ -1199,6 +1209,7 @@ async function searchWorkspace({
  *
  * @param {Object} params
  * @param {string} params.workspace_id
+ * @param {string} [params.workspace_instance_id]
  * @param {string} [params.path]
  * @param {string} [params.after_path]
  * @param {number} params.max_results
@@ -1210,6 +1221,7 @@ async function searchWorkspace({
  */
 async function listWorkspaceFiles({
   workspace_id,
+  workspace_instance_id,
   path,
   after_path,
   max_results,
@@ -1218,18 +1230,21 @@ async function listWorkspaceFiles({
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'list_files',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       ...(path ? { path } : {}),
       ...(after_path ? { afterPath: after_path } : {}),
       maxResults: max_results,
@@ -1244,23 +1259,27 @@ async function writeWorkspaceFile({
   content,
   overwrite,
   workspace_id,
+  workspace_instance_id,
   codeApiBaseUrl,
   executionProfile,
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'write_file',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       path: file_path,
       content,
       overwrite,
@@ -1275,23 +1294,27 @@ async function editWorkspaceFile({
   edits,
   expected_base_sha256,
   workspace_id,
+  workspace_instance_id,
   codeApiBaseUrl,
   executionProfile,
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'edit_file',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       path: file_path,
       edits,
       ...(expected_base_sha256 ? { expectedBaseSha256: expected_base_sha256 } : {}),
@@ -1305,23 +1328,27 @@ async function previewWorkspaceEdit({
   file_path,
   edits,
   workspace_id,
+  workspace_instance_id,
   codeApiBaseUrl,
   executionProfile,
   bridgeWorkerId,
   req,
   signal,
+  maxQueueWaitMs,
 }) {
-  const authHeaders = await getCodeApiAuthHeaders(req, bridgeWorkerId);
   return executeWorkspaceTool({
     baseURL: codeApiBaseUrl,
-    authHeaders: {
-      ...authHeaders,
+    maxQueueWaitMs,
+    /** Minted per admission attempt: a queued call outlives one token TTL. */
+    authHeaders: async () => ({
+      ...(await getCodeApiAuthHeaders(req, bridgeWorkerId)),
       ...codeExecutionHeaders({ executionProfile, bridgeWorkerId }),
-    },
+    }),
     request: {
       protocolVersion: 1,
       operation: 'preview_edit',
       workspaceId: workspace_id,
+      ...(workspace_instance_id ? { workspaceInstanceId: workspace_instance_id } : {}),
       path: file_path,
       edits,
     },
diff --git a/api/server/services/Files/Code/process.spec.js b/api/server/services/Files/Code/process.spec.js
index 0a87df47bcc..176bf2229b6 100644
--- a/api/server/services/Files/Code/process.spec.js
+++ b/api/server/services/Files/Code/process.spec.js
@@ -2050,6 +2050,7 @@ describe('Code Process', () => {
         readWorkspaceFile({
           file_path: 'src/app.ts',
           workspace_id: 'primary',
+          workspace_instance_id: 'a'.repeat(64),
           start_line: 1,
           max_lines: 200,
           codeApiBaseUrl: 'https://attached-code.example.com/v1',
@@ -2057,21 +2058,32 @@ describe('Code Process', () => {
           bridgeWorkerId: 'worker-user-1',
           req: mockReq,
           signal: controller.signal,
+          maxQueueWaitMs: 0,
         }),
       ).resolves.toBe(result);
 
-      expect(getCodeApiAuthHeaders).toHaveBeenCalledWith(mockReq, 'worker-user-1');
+      expect(getCodeApiAuthHeaders).not.toHaveBeenCalled();
+      const { authHeaders } = mockExecuteWorkspaceTool.mock.calls[0][0];
+      await expect(authHeaders()).resolves.toEqual({
+        Authorization: 'Bearer workspace-token',
+        'X-CodeAPI-Expected-Profile': 'stateful',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      getCodeApiAuthHeaders.mockResolvedValueOnce({ Authorization: 'Bearer refreshed-token' });
+      await expect(authHeaders()).resolves.toMatchObject({
+        Authorization: 'Bearer refreshed-token',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      expect(getCodeApiAuthHeaders).toHaveBeenNthCalledWith(2, mockReq, 'worker-user-1');
       expect(mockExecuteWorkspaceTool).toHaveBeenCalledWith({
         baseURL: 'https://attached-code.example.com/v1',
-        authHeaders: {
-          Authorization: 'Bearer workspace-token',
-          'X-CodeAPI-Expected-Profile': 'stateful',
-          'X-LibreChat-Code-Worker-ID': 'worker-user-1',
-        },
+        authHeaders: expect.any(Function),
+        maxQueueWaitMs: 0,
         request: {
           protocolVersion: 1,
           operation: 'read_file',
           workspaceId: 'primary',
+          workspaceInstanceId: 'a'.repeat(64),
           path: 'src/app.ts',
           startLine: 1,
           maxLines: 200,
@@ -2105,16 +2117,27 @@ describe('Code Process', () => {
           bridgeWorkerId: 'worker-user-1',
           req: mockReq,
           signal: controller.signal,
+          maxQueueWaitMs: 0,
         }),
       ).resolves.toBe(result);
 
+      expect(getCodeApiAuthHeaders).not.toHaveBeenCalled();
+      const { authHeaders } = mockExecuteWorkspaceTool.mock.calls[0][0];
+      await expect(authHeaders()).resolves.toEqual({
+        Authorization: 'Bearer workspace-token',
+        'X-CodeAPI-Expected-Profile': 'stateful',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      getCodeApiAuthHeaders.mockResolvedValueOnce({ Authorization: 'Bearer refreshed-token' });
+      await expect(authHeaders()).resolves.toMatchObject({
+        Authorization: 'Bearer refreshed-token',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      expect(getCodeApiAuthHeaders).toHaveBeenNthCalledWith(2, mockReq, 'worker-user-1');
       expect(mockExecuteWorkspaceTool).toHaveBeenCalledWith({
         baseURL: 'https://attached-code.example.com/v1',
-        authHeaders: {
-          Authorization: 'Bearer workspace-token',
-          'X-CodeAPI-Expected-Profile': 'stateful',
-          'X-LibreChat-Code-Worker-ID': 'worker-user-1',
-        },
+        authHeaders: expect.any(Function),
+        maxQueueWaitMs: 0,
         request: {
           protocolVersion: 1,
           operation: 'search_text',
@@ -2152,16 +2175,27 @@ describe('Code Process', () => {
           bridgeWorkerId: 'worker-user-1',
           req: mockReq,
           signal: controller.signal,
+          maxQueueWaitMs: 0,
         }),
       ).resolves.toBe(result);
 
+      expect(getCodeApiAuthHeaders).not.toHaveBeenCalled();
+      const { authHeaders } = mockExecuteWorkspaceTool.mock.calls[0][0];
+      await expect(authHeaders()).resolves.toEqual({
+        Authorization: 'Bearer workspace-token',
+        'X-CodeAPI-Expected-Profile': 'stateful',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      getCodeApiAuthHeaders.mockResolvedValueOnce({ Authorization: 'Bearer refreshed-token' });
+      await expect(authHeaders()).resolves.toMatchObject({
+        Authorization: 'Bearer refreshed-token',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      expect(getCodeApiAuthHeaders).toHaveBeenNthCalledWith(2, mockReq, 'worker-user-1');
       expect(mockExecuteWorkspaceTool).toHaveBeenCalledWith({
         baseURL: 'https://attached-code.example.com/v1',
-        authHeaders: {
-          Authorization: 'Bearer workspace-token',
-          'X-CodeAPI-Expected-Profile': 'stateful',
-          'X-LibreChat-Code-Worker-ID': 'worker-user-1',
-        },
+        authHeaders: expect.any(Function),
+        maxQueueWaitMs: 0,
         request: {
           protocolVersion: 1,
           operation: 'list_files',
@@ -2195,25 +2229,38 @@ describe('Code Process', () => {
           content: 'ready',
           overwrite: false,
           workspace_id: 'primary',
+          workspace_instance_id: 'b'.repeat(64),
           codeApiBaseUrl: 'https://attached-code.example.com/v1',
           executionProfile: 'stateful',
           bridgeWorkerId: 'worker-user-1',
           req: mockReq,
           signal: controller.signal,
+          maxQueueWaitMs: 0,
         }),
       ).resolves.toBe(result);
 
+      expect(getCodeApiAuthHeaders).not.toHaveBeenCalled();
+      const { authHeaders } = mockExecuteWorkspaceTool.mock.calls[0][0];
+      await expect(authHeaders()).resolves.toEqual({
+        Authorization: 'Bearer workspace-token',
+        'X-CodeAPI-Expected-Profile': 'stateful',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      getCodeApiAuthHeaders.mockResolvedValueOnce({ Authorization: 'Bearer refreshed-token' });
+      await expect(authHeaders()).resolves.toMatchObject({
+        Authorization: 'Bearer refreshed-token',
+        'X-LibreChat-Code-Worker-ID': 'worker-user-1',
+      });
+      expect(getCodeApiAuthHeaders).toHaveBeenNthCalledWith(2, mockReq, 'worker-user-1');
       expect(mockExecuteWorkspaceTool).toHaveBeenCalledWith({
         baseURL: 'https://attached-code.example.com/v1',
-        authHeaders: {
-          Authorization: 'Bearer workspace-token',
-          'X-CodeAPI-Expected-Profile': 'stateful',
-          'X-LibreChat-Code-Worker-ID': 'worker-user-1',
-        },
+        authHeaders: expect.any(Function),
+        maxQueueWaitMs: 0,
         request: {
           protocolVersion: 1,
           operation: 'write_file',
           workspaceId: 'primary',
+          workspaceInstanceId: 'b'.repeat(64),
           path: 'src/new.ts',
           content: 'ready',
           overwrite: false,
@@ -2859,6 +2906,7 @@ describe('Code Process', () => {
           tool_resources: { execute_code: { file_ids: [dbFile.file_id], files: [] } },
           agentId: 'agent-id',
           signal: controller.signal,
+          maxQueueWaitMs: 0,
         }),
       ).rejects.toMatchObject({ name: 'AbortError' });
       expect(handleFileUpload).toHaveBeenCalledTimes(1);
diff --git a/api/server/services/Files/Local/__tests__/crud-delete.spec.js b/api/server/services/Files/Local/__tests__/crud-delete.spec.js
new file mode 100644
index 00000000000..7a7a30340ab
--- /dev/null
+++ b/api/server/services/Files/Local/__tests__/crud-delete.spec.js
@@ -0,0 +1,70 @@
+/** Exactly what `deleteLocalFile` reaches for, so the double does not depend on a built package. */
+jest.mock('@librechat/api', () => ({
+  deleteRagFile: jest.fn().mockResolvedValue(undefined),
+  stripCacheBust: (filepath) => String(filepath).split('?')[0],
+}));
+jest.mock('@librechat/data-schemas', () => ({
+  logger: { warn: jest.fn(), error: jest.fn() },
+}));
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { deleteLocalFile } = require('../crud');
+
+/* The resolved promise of a delete is what `processDeleteRequest` reads to decide that a record may
+   lose its metadata and its agent references, so this adapter may only resolve once the bytes are
+   actually gone. Storage that was already missing is the one benign case. */
+describe('deleteLocalFile failure reporting', () => {
+  const userId = 'user-1';
+  let tmpBase;
+  let req;
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'crud-delete-'));
+    fs.mkdirSync(path.join(tmpBase, 'uploads', userId), { recursive: true });
+    req = {
+      user: { id: userId },
+      config: {
+        paths: {
+          publicPath: path.join(tmpBase, 'public'),
+          uploads: path.join(tmpBase, 'uploads'),
+        },
+      },
+    };
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  const uploadedFile = (filename) => {
+    const filepath = path.join(tmpBase, 'uploads', userId, filename);
+    fs.writeFileSync(filepath, 'contents');
+    return { file_id: 'file-1', filepath: `/uploads/${userId}/${filename}` };
+  };
+
+  it('removes the file and resolves', async () => {
+    const file = uploadedFile('knowledge.txt');
+
+    await expect(deleteLocalFile(req, file)).resolves.toBeUndefined();
+    expect(fs.existsSync(path.join(tmpBase, 'uploads', userId, 'knowledge.txt'))).toBe(false);
+  });
+
+  it('resolves when the file is already gone', async () => {
+    await expect(
+      deleteLocalFile(req, { file_id: 'file-1', filepath: `/uploads/${userId}/missing.txt` }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('rejects when the bytes survive the delete', async () => {
+    const file = uploadedFile('locked.txt');
+    jest
+      .spyOn(fs.promises, 'unlink')
+      .mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
+
+    await expect(deleteLocalFile(req, file)).rejects.toThrow('permission denied');
+    expect(fs.existsSync(path.join(tmpBase, 'uploads', userId, 'locked.txt'))).toBe(true);
+  });
+});
diff --git a/api/server/services/Files/Local/crud.js b/api/server/services/Files/Local/crud.js
index fe524550986..9555df49c03 100644
--- a/api/server/services/Files/Local/crud.js
+++ b/api/server/services/Files/Local/crud.js
@@ -208,11 +208,21 @@ const isValidPath = (req, base, subfolder, filepath) => {
 /**
  * @param {string} filepath
  */
+/**
+ * A file whose bytes are still on disk must not be reported as deleted: callers use the resolved
+ * promise to decide that a record may lose its metadata and its agent references. Storage that was
+ * already gone is the one benign case, and `processDeleteRequest` treats it as deleted by design.
+ */
 const unlinkFile = async (filepath) => {
   try {
     await fs.promises.unlink(filepath);
   } catch (error) {
+    if (error?.code === 'ENOENT') {
+      logger.warn('Local file was already missing during delete:', error);
+      return;
+    }
     logger.error('Error deleting file:', error);
+    throw error;
   }
 };
 
diff --git a/api/server/services/Files/process.js b/api/server/services/Files/process.js
index 05b02ae6df6..35117ab248e 100644
--- a/api/server/services/Files/process.js
+++ b/api/server/services/Files/process.js
@@ -265,16 +265,8 @@ const processDeleteRequest = async ({ req, files }) => {
     await initializeClients();
   }
 
-  const agentFiles = [];
-
   for (const file of files) {
     const source = file.source ?? FileSources.local;
-    if (req.body.agent_id && req.body.tool_resource) {
-      agentFiles.push({
-        tool_resource: req.body.tool_resource,
-        file_id: file.file_id,
-      });
-    }
 
     if (source === FileSources.text) {
       resolvedFileIds.add(file.file_id);
@@ -313,15 +305,6 @@ const processDeleteRequest = async ({ req, files }) => {
     });
   }
 
-  if (agentFiles.length > 0) {
-    promises.push(
-      db.removeAgentResourceFiles({
-        agent_id: req.body.agent_id,
-        files: agentFiles,
-      }),
-    );
-  }
-
   await Promise.allSettled(promises);
   const deletedFileIds = [...resolvedFileIds];
   let metadataDeletedFileIds = deletedFileIds;
@@ -334,6 +317,9 @@ const processDeleteRequest = async ({ req, files }) => {
       metadataDeletedFileIds = [];
       throw error;
     }
+    /* The only place a delete removes agent references, and it runs after the metadata delete
+       succeeded: a file that kept its storage, its chunks or its record keeps its references too,
+       so the agent it was removed from can be asked again (see issue #12776). */
     if (metadataDeletedFileIds.length > 0) {
       try {
         await db.removeAgentResourceFilesFromAllAgents({ file_ids: metadataDeletedFileIds });
diff --git a/api/server/services/Files/process.spec.js b/api/server/services/Files/process.spec.js
index efbb8a1b008..33ec48b7861 100644
--- a/api/server/services/Files/process.spec.js
+++ b/api/server/services/Files/process.spec.js
@@ -2610,6 +2610,89 @@ describe('processDeleteRequest', () => {
     expect(result).toEqual({ deletedFileIds: [], failedFileIds: ['embedded-file'] });
   });
 
+  it('keeps a failed agent file attached so the delete can be retried', async () => {
+    const deleteFile = jest.fn().mockRejectedValue(new Error('rag unavailable'));
+    getStrategyFunctions.mockReturnValue({ deleteFile });
+    const req = {
+      body: { agent_id: 'agent_1', tool_resource: 'file_search' },
+      config: {},
+      user: { id: 'user-123', tenantId: 'tenant-a' },
+    };
+
+    const result = await processDeleteRequest({
+      req,
+      files: [
+        {
+          file_id: 'knowledge-file',
+          filepath: '/uploads/knowledge.txt',
+          source: FileSources.local,
+        },
+      ],
+    });
+
+    expect(result).toEqual({ deletedFileIds: [], failedFileIds: ['knowledge-file'] });
+    expect(db.deleteFiles).not.toHaveBeenCalled();
+    expect(db.removeAgentResourceFiles).not.toHaveBeenCalled();
+    expect(db.removeAgentResourceFilesFromAllAgents).not.toHaveBeenCalled();
+  });
+
+  it('strips agent references only for the files it deleted', async () => {
+    getStrategyFunctions.mockReturnValue({
+      deleteFile: jest
+        .fn()
+        .mockImplementation((_req, file) =>
+          file.file_id === 'kept-file'
+            ? Promise.reject(new Error('rag unavailable'))
+            : Promise.resolve(undefined),
+        ),
+    });
+    db.deleteFiles.mockResolvedValue({ deletedCount: 1 });
+    const req = {
+      body: { agent_id: 'agent_1', tool_resource: 'file_search' },
+      config: {},
+      user: { id: 'user-123', tenantId: 'tenant-a' },
+    };
+
+    const result = await processDeleteRequest({
+      req,
+      files: [
+        { file_id: 'gone-file', filepath: '/uploads/gone.txt', source: FileSources.local },
+        { file_id: 'kept-file', filepath: '/uploads/kept.txt', source: FileSources.local },
+      ],
+    });
+
+    expect(result).toEqual({ deletedFileIds: ['gone-file'], failedFileIds: ['kept-file'] });
+    expect(db.removeAgentResourceFilesFromAllAgents).toHaveBeenCalledWith({
+      file_ids: ['gone-file'],
+    });
+  });
+
+  it('keeps agent references when the metadata delete fails', async () => {
+    getStrategyFunctions.mockReturnValue({ deleteFile: jest.fn().mockResolvedValue(undefined) });
+    db.deleteFiles.mockRejectedValue(new Error('mongo unavailable'));
+    const req = {
+      body: { agent_id: 'agent_1', tool_resource: 'file_search' },
+      config: {},
+      user: { id: 'user-123', tenantId: 'tenant-a' },
+    };
+
+    await expect(
+      processDeleteRequest({
+        req,
+        files: [
+          {
+            file_id: 'knowledge-file',
+            filepath: '/uploads/knowledge.txt',
+            source: FileSources.local,
+          },
+        ],
+      }),
+    ).rejects.toThrow('mongo unavailable');
+
+    expect(db.removeAgentResourceFiles).not.toHaveBeenCalled();
+    expect(db.removeAgentResourceFilesFromAllAgents).not.toHaveBeenCalled();
+  });
+
   it('does not delete vector storage when primary embedded file deletion fails', async () => {
     const primaryDelete = jest.fn().mockRejectedValue(new Error('permission denied'));
     const vectorDelete = jest.fn().mockResolvedValue(undefined);
diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.js
index 7e4ceca5451..05126536df4 100644
--- a/api/server/services/ToolService.js
+++ b/api/server/services/ToolService.js
@@ -51,6 +51,7 @@ const {
   createRepositoryInstructionSource,
   createRepositoryInstructionLoader,
   resolveAttachedWorkspaceCommandTimeoutMax,
+  resolveAttachedWorkspaceQueueWaitMs,
   createContextProgrammaticBashTool,
   resolveCodeExecutionContext,
   resolveCodeExecutionWorkspaceContext,
@@ -2295,10 +2296,15 @@ async function loadToolsForExecution({
               authHeaders,
               baseUrl: codeExecutionContext.baseUrl,
               workspaceId: codeExecutionContext.codeWorkspace.workspaceId,
+              workspaceInstanceId: codeExecutionContext.codeWorkspace.workspaceInstanceId,
               environment: codeExecutionContext.codeWorkspace.environment,
               gitIdentity: agent?.git_identity,
               maxTimeoutMs: resolveAttachedWorkspaceCommandTimeoutMax(
                 codeExecutionContext.codeEnvironmentConfigSchema,
+                codeExecutionContext.codeWorkspace?.maxCommandTimeoutMs,
+              ),
+              maxQueueWaitMs: resolveAttachedWorkspaceQueueWaitMs(
+                codeExecutionContext.codeEnvironmentConfigSchema,
               ),
             })
           : createBashExecutionTool({
diff --git a/api/server/services/__tests__/ToolService.spec.js b/api/server/services/__tests__/ToolService.spec.js
index 05641b3a671..558be1d5e0f 100644
--- a/api/server/services/__tests__/ToolService.spec.js
+++ b/api/server/services/__tests__/ToolService.spec.js
@@ -2898,7 +2898,7 @@ describe('ToolService - Action Capability Gating', () => {
         environmentType: 'attached',
         environmentId: 'personal-machine',
         bridgeWorkerId: 'worker-abc',
-        codeEnvironmentConfigSchema: { limits: { maxCommandTimeoutMs: 120000 } },
+        codeEnvironmentConfigSchema: { limits: { maxCommandTimeoutMs: 120000, maxQueueWaitMs: 0 } },
       });
       const toolRegistry = new Map([
         [AgentConstants.BASH_TOOL, { name: AgentConstants.BASH_TOOL }],
@@ -2925,6 +2925,7 @@ describe('ToolService - Action Capability Gating', () => {
         workspaceId: 'project-a',
         gitIdentity: { name: 'LibreChat Agent', email: 'agent@example.com' },
         maxTimeoutMs: 120000,
+        maxQueueWaitMs: 0,
       });
       expect(mockResolveCodeExecutionWorkspaceContext).toHaveBeenCalledWith(
         expect.objectContaining({ requestedSelections: req.body.codeWorkspaces }),
diff --git a/api/test/server/middleware/checkBan.test.js b/api/test/server/middleware/checkBan.test.js
index 237282d9d0b..39775c389a4 100644
--- a/api/test/server/middleware/checkBan.test.js
+++ b/api/test/server/middleware/checkBan.test.js
@@ -401,6 +401,55 @@ describe('checkBan middleware', () => {
     });
   });
 
+  describe('non-string cache keys (#16025)', () => {
+    const objectIdHex = '507f1f77bcf86cd799439011';
+    const objectId = {
+      toString() {
+        return objectIdHex;
+      },
+    };
+
+    it('stringifies ObjectId user keys when Redis is off', async () => {
+      const next = jest.fn();
+      const req = createReq({ user: { _id: objectId } });
+
+      await checkBan(req, createRes(), next);
+
+      expect(next).toHaveBeenCalledWith();
+      expect(mockBanCacheGet).toHaveBeenCalledWith(objectIdHex);
+      expect(mockBanLogsGet).toHaveBeenCalledWith(objectIdHex);
+      for (const [key] of mockBanCacheGet.mock.calls) {
+        expect(typeof key).toBe('string');
+      }
+    });
+
+    it('stringifies numeric user keys when Redis is off', async () => {
+      await checkBan(createReq({ user: { _id: 12345 } }), createRes(), jest.fn());
+
+      expect(mockBanCacheGet).toHaveBeenCalledWith('12345');
+      expect(mockBanLogsGet).toHaveBeenCalledWith('12345');
+    });
+
+    it('stringifies ObjectId user keys in Redis-prefixed cache lookups', async () => {
+      process.env.USE_REDIS = 'true';
+
+      await checkBan(createReq({ user: { _id: objectId } }), createRes(), jest.fn());
+
+      expect(mockBanCacheGet).toHaveBeenCalledWith(`ban_cache:user:${objectIdHex}`);
+      expect(mockBanLogsGet).toHaveBeenCalledWith(objectIdHex);
+    });
+
+    it('stringifies ObjectId user keys from email lookup', async () => {
+      findUser.mockResolvedValueOnce({ _id: objectId });
+      const req = createReq({ user: null, body: { email: 'oauth@example.com' } });
+
+      await checkBan(req, createRes(), jest.fn());
+
+      expect(mockBanCacheGet).toHaveBeenCalledWith(objectIdHex);
+      expect(mockBanLogsGet).toHaveBeenCalledWith(objectIdHex);
+    });
+  });
+
   describe('Redis key paths (Finding 2 regression)', () => {
     beforeEach(() => {
       process.env.USE_REDIS = 'true';
diff --git a/client/src/Providers/AuthorContext.tsx b/client/src/Providers/AuthorContext.tsx
new file mode 100644
index 00000000000..e8cec934465
--- /dev/null
+++ b/client/src/Providers/AuthorContext.tsx
@@ -0,0 +1,17 @@
+import { createContext, useContext } from 'react';
+import type { ReactNode } from 'react';
+
+/** The author a message restates wherever its content resumes after a steer. */
+export type TMessageAuthor = {
+  icon: ReactNode;
+  label: string;
+};
+
+/**
+ * Carries the message author to the headers inside its content. The author can
+ * resolve after the message paints, when an agent's name and avatar arrive with the
+ * agents list, and a context change reaches only the headers that read it rather
+ * than every part of the message.
+ */
+export const AuthorContext = createContext<TMessageAuthor | null>(null);
+export const useAuthorContext = () => useContext(AuthorContext);
diff --git a/client/src/Providers/index.ts b/client/src/Providers/index.ts
index 76aad5b4560..3e499921fca 100644
--- a/client/src/Providers/index.ts
+++ b/client/src/Providers/index.ts
@@ -10,6 +10,7 @@ export * from './EditorContext';
 export * from './ChatFormContext';
 export * from './BookmarkContext';
 export * from './MessageContext';
+export * from './AuthorContext';
 export * from './AssistantsContext';
 export * from './AgentsContext';
 export * from './AssistantsMapContext';
diff --git a/client/src/components/Chat/Messages/Content/Markdown.tsx b/client/src/components/Chat/Messages/Content/Markdown.tsx
index 24b3cc26249..222c3d0a0d3 100644
--- a/client/src/components/Chat/Messages/Content/Markdown.tsx
+++ b/client/src/components/Chat/Messages/Content/Markdown.tsx
@@ -19,7 +19,8 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TCont
   const LaTeXParsing = useRecoilValue<boolean>(store.LaTeXParsing);
   const isInitializing = content === '';
 
-  const animate = smoothStreaming && isLatestMessage && isSubmitting;
+  const streaming = isLatestMessage && isSubmitting;
+  const animate = smoothStreaming && streaming;
 
   // Hydration signal for the fade: substantial content already present at the
   // render where `animate` flips on means resumed/switched-to/follow-up
@@ -52,6 +53,7 @@ const Markdown = memo(function Markdown({ content = '', isLatestMessage }: TCont
     <MarkdownErrorBoundary content={content} codeExecution={true}>
       <MarkdownBlocks
         content={content}
+        streaming={streaming}
         remarkPlugins={getRemarkPlugins(LaTeXParsing)}
         rehypePlugins={getRehypePlugins()}
         components={getMarkdownComponents()}
diff --git a/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx b/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx
index 6dc10e8dd60..e982f0b558d 100644
--- a/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx
+++ b/client/src/components/Chat/Messages/Content/MarkdownBlocks.bench.tsx
@@ -5,13 +5,15 @@ import { render } from '@testing-library/react';
 import { getRemarkPlugins, getRehypePlugins, getMarkdownComponents } from './markdownConfig';
 import { ArtifactProvider, CodeBlockProvider, MessageContext } from '~/Providers';
 import CodeBlock from '~/components/Messages/Content/CodeBlock';
+import MarkdownBlocks from './MarkdownBlocks';
 import Markdown from './Markdown';
 
 /**
- * Streaming render benchmark comparing the previous whole-message renderer
- * (one ReactMarkdown re-parsing everything per token) against the per-block
- * memoized renderer. This file lives outside `__tests__/` and is named
- * `.bench.tsx` so the default jest run skips it; execute it explicitly with:
+ * Render benchmark comparing the previous whole-message renderer (one
+ * ReactMarkdown re-parsing everything per token) against the per-block memoized
+ * renderer, both while a message streams and when a finished message mounts.
+ * This file lives outside `__tests__/` and is named `.bench.tsx` so the default
+ * jest run skips it; execute it explicitly with:
  *
  *   node node_modules/jest/bin/jest.js --runInBand --coverage=false \
  *     --testMatch '**\/MarkdownBlocks.bench.tsx'
@@ -83,8 +85,20 @@ const OldMarkdown = ({ content }: { content: string }) => (
   </ArtifactProvider>
 );
 
+/** The per-block renderer a streaming message uses, without the fade. */
 const NewMarkdown = ({ content }: { content: string }) => (
-  <Markdown content={content} isLatestMessage={true} />
+  <MarkdownBlocks
+    content={content}
+    streaming={true}
+    remarkPlugins={getRemarkPlugins()}
+    rehypePlugins={getRehypePlugins()}
+    components={getMarkdownComponents()}
+  />
+);
+
+/** A finished message as a conversation opens with it. */
+const SettledMarkdown = ({ content }: { content: string }) => (
+  <Markdown content={content} isLatestMessage={false} />
 );
 
 const streamingContext = {
@@ -186,4 +200,53 @@ describe('Markdown streaming benchmark (OLD whole-message vs NEW per-block)', ()
     // Memoization should cut total code-block renders by a wide margin.
     expect(newRenders).toBeLessThan(oldRenders * 0.5);
   });
+
+  it('reports mount cost for a message that was already finished', () => {
+    const iterations = 5;
+    const rows = [12, 40].map((sections) => {
+      const prefixes = [buildMessage(sections)];
+      measure(OldMarkdown, prefixes);
+      measure(NewMarkdown, prefixes);
+      measure(SettledMarkdown, prefixes);
+
+      const old: Array<{ totalMs: number; codeBlockRenders: number }> = [];
+      const perBlock: Array<{ totalMs: number; codeBlockRenders: number }> = [];
+      const settled: Array<{ totalMs: number; codeBlockRenders: number }> = [];
+      for (let i = 0; i < iterations; i += 1) {
+        old.push(measure(OldMarkdown, prefixes));
+        perBlock.push(measure(NewMarkdown, prefixes));
+        settled.push(measure(SettledMarkdown, prefixes));
+      }
+      const minMs = (rs: Array<{ totalMs: number }>) => Math.min(...rs.map((r) => r.totalMs));
+      return {
+        chars: prefixes[0].length,
+        oldMs: minMs(old),
+        perBlockMs: minMs(perBlock),
+        settledMs: minMs(settled),
+        oldRenders: old[0].codeBlockRenders,
+        settledRenders: settled[0].codeBlockRenders,
+      };
+    });
+
+    console.log(
+      [
+        '',
+        '================ Markdown finished-message mount benchmark ================',
+        `min of ${iterations} mounts, summed Profiler actualDuration; jsdom`,
+        ...rows.map(
+          (r) =>
+            `  ${r.chars} chars: OLD ${r.oldMs.toFixed(1)} ms | PER-BLOCK ${r.perBlockMs.toFixed(1)} ms | ` +
+            `SETTLED ${r.settledMs.toFixed(1)} ms (${(r.perBlockMs / r.settledMs).toFixed(2)}x faster than per-block)`,
+        ),
+        '==========================================================================',
+        '',
+      ].join('\n'),
+    );
+
+    // A finished message mounts through the whole-message pipeline: every code
+    // block renders exactly once, as it did before per-block rendering existed.
+    for (const r of rows) {
+      expect(r.settledRenders).toBe(r.oldRenders);
+    }
+  });
 });
diff --git a/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx b/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx
index d5b76f3ae62..256bc9cc753 100644
--- a/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx
+++ b/client/src/components/Chat/Messages/Content/MarkdownBlocks.tsx
@@ -1,4 +1,4 @@
-import React, { memo, useMemo, useLayoutEffect } from 'react';
+import React, { memo, useMemo, useState, useLayoutEffect } from 'react';
 import ReactMarkdown from 'react-markdown';
 import type { PluggableList } from 'unified';
 import type { ElementType } from 'react';
@@ -86,46 +86,103 @@ MarkdownBlock.displayName = 'MarkdownBlock';
 
 type MarkdownBlocksProps = SharedProps & {
   content: string;
+  /** Whether this message is the one generating right now. */
+  streaming: boolean;
+};
+
+type BlockEntry = {
+  /**
+   * Code and artifact blocks capture their index in a ref when they mount, so a
+   * block has to remount whenever an index it holds could shift, and must not
+   * remount otherwise.
+   */
+  key: string;
+  raw: string;
+  codeBaseIndex: number;
+  artifactBaseIndex: number;
+  mermaidBaseIndex: number;
+};
+
+/**
+ * Each top-level block, seeded with the code, artifact and Mermaid indices of the
+ * blocks before it. The key carries those bases, so an in-place edit that inserts
+ * a block before existing code or artifacts remounts the blocks it shifted, while
+ * append-only streaming keeps completed blocks mounted.
+ */
+const toBlockEntries = (content: string): BlockEntry[] => {
+  let codeBaseIndex = 0;
+  let artifactBaseIndex = 0;
+  let mermaidBaseIndex = 0;
+  return splitMarkdownIntoBlocks(content).map((block, index) => {
+    const entry = {
+      key: `${index}-${codeBaseIndex}-${artifactBaseIndex}-${mermaidBaseIndex}`,
+      raw: block.raw,
+      codeBaseIndex,
+      artifactBaseIndex,
+      mermaidBaseIndex,
+    };
+    codeBaseIndex += block.codeBlockCount;
+    artifactBaseIndex += block.artifactCount;
+    mermaidBaseIndex += block.mermaidCount;
+    return entry;
+  });
 };
 
 /**
- * Splits a message into top-level blocks and renders each independently so
- * that, during streaming, only the last block re-parses while earlier blocks
- * (tables, code, etc.) stay memoized. Each block's executable code and artifact
- * indices are preserved in document order via per-block providers seeded with
- * prefix-summed base indices.
+ * The whole message as one block, which numbers its code and artifacts from zero
+ * itself. It only ever renders the message exactly as it mounted, so no index it
+ * assigns can go stale and its key never has to change.
+ */
+const toWholeMessage = (content: string): BlockEntry[] =>
+  content
+    ? [{ key: 'whole', raw: content, codeBaseIndex: 0, artifactBaseIndex: 0, mermaidBaseIndex: 0 }]
+    : [];
+
+/**
+ * Renders a message's markdown.
+ *
+ * While the message streams, each top-level block renders and memoizes on its
+ * own, so only the last, still-growing block re-parses on each token. Each
+ * block's executable code and artifact indices stay in document order through
+ * per-block providers seeded with prefix-summed base indices.
+ *
+ * A message that mounts finished renders as one pipeline instead, for as long as
+ * it stays exactly as it mounted. Splitting it would buy memoization nothing
+ * uses, at the price of a whole extra parse to find block boundaries and one
+ * pipeline per block, which is most of the cost of opening a long conversation.
+ *
+ * Once the message generates or its content changes, it moves to the split for
+ * good. Code and artifact blocks capture their index at mount, and per block only
+ * the blocks a change touches re-render, so finishing an answer never remounts its
+ * blocks and neither do repeated edits such as artifact saves. The move itself
+ * remounts the message once.
  */
 const MarkdownBlocks = memo(function MarkdownBlocks({
   content,
+  streaming,
   remarkPlugins,
   rehypePlugins,
   components,
   animate,
   hydrated,
 }: MarkdownBlocksProps) {
-  const blocks = useMemo(() => {
-    let codeBaseIndex = 0;
-    let artifactBaseIndex = 0;
-    let mermaidBaseIndex = 0;
-    return splitMarkdownIntoBlocks(content).map((block) => {
-      const entry = { raw: block.raw, codeBaseIndex, artifactBaseIndex, mermaidBaseIndex };
-      codeBaseIndex += block.codeBlockCount;
-      artifactBaseIndex += block.artifactCount;
-      mermaidBaseIndex += block.mermaidCount;
-      return entry;
-    });
-  }, [content]);
+  const [mountedContent] = useState(content);
+  const [hasChanged, setHasChanged] = useState(streaming);
+  const changing = streaming || content !== mountedContent;
+  if (changing && !hasChanged) {
+    setHasChanged(true);
+  }
+  const perBlock = hasChanged || changing;
+  const blocks = useMemo(
+    () => (perBlock ? toBlockEntries(content) : toWholeMessage(content)),
+    [content, perBlock],
+  );
 
   return (
     <>
-      {blocks.map((block, index) => (
-        // Key includes the base indices so that an in-place edit which inserts a
-        // block before existing code/artifact blocks (shifting their base) forces
-        // a remount, refreshing the index each code/artifact block captures in a
-        // ref. During append-only streaming these stay constant, so completed
-        // blocks keep a stable key and are not remounted.
+      {blocks.map((block) => (
         <MarkdownBlock
-          key={`${index}-${block.codeBaseIndex}-${block.artifactBaseIndex}-${block.mermaidBaseIndex}`}
+          key={block.key}
           content={block.raw}
           codeBaseIndex={block.codeBaseIndex}
           artifactBaseIndex={block.artifactBaseIndex}
diff --git a/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsx b/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsx
new file mode 100644
index 00000000000..297319b99f6
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/ResumeAuthorHeader.tsx
@@ -0,0 +1,22 @@
+import { memo } from 'react';
+import { useAuthorContext } from '~/Providers';
+import AuthorHeader from './AuthorHeader';
+
+/**
+ * Restates the message author where content resumes after a steer, reading the
+ * author from `AuthorContext`.
+ *
+ * A header element built from the author changes identity when the author
+ * resolves, and handing that element to the memoized parts tree re-rendered every
+ * part of the message. Rendered through this component, the element a caller hands
+ * down never changes, and an author update re-renders only the headers on screen.
+ */
+const ResumeAuthorHeader = memo(function ResumeAuthorHeader() {
+  const author = useAuthorContext();
+  if (author == null) {
+    return null;
+  }
+  return <AuthorHeader icon={author.icon} label={author.label} />;
+});
+
+export default ResumeAuthorHeader;
diff --git a/client/src/components/Chat/Messages/Content/Parts/index.ts b/client/src/components/Chat/Messages/Content/Parts/index.ts
index 229db2fe36a..56ef2380ee0 100644
--- a/client/src/components/Chat/Messages/Content/Parts/index.ts
+++ b/client/src/components/Chat/Messages/Content/Parts/index.ts
@@ -18,3 +18,4 @@ export { default as PtcToolTrace } from './PtcToolTrace';
 export { default as SubagentCall } from './SubagentCall';
 export { default as SteerPart } from './SteerPart';
 export { default as AuthorHeader } from './AuthorHeader';
+export { default as ResumeAuthorHeader } from './ResumeAuthorHeader';
diff --git a/client/src/components/Chat/Messages/Content/ToolCall.tsx b/client/src/components/Chat/Messages/Content/ToolCall.tsx
index ee14b6971e1..6bd9e522300 100644
--- a/client/src/components/Chat/Messages/Content/ToolCall.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolCall.tsx
@@ -10,10 +10,10 @@ import {
 } from 'librechat-data-provider';
 import type { TAttachment, PartMetadata } from 'librechat-data-provider';
 import { useLocalize, useProgress, useExpandCollapse, useLazyCollapseBody } from '~/hooks';
+import { cn, getToolDisplayLabel, logger, openInNewTab } from '~/utils';
 import { ToolIcon, getToolIconType, isError } from './ToolOutput';
 import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
 import { resolveToolCallPhase } from '~/utils/toolCallPhase';
-import { cn, getToolDisplayLabel, logger } from '~/utils';
 import { toolPanelSpacingClassName } from './disclosure';
 import { useToolCallIntent } from './Parts/intent';
 import { AttachmentGroup } from './Parts';
@@ -54,6 +54,7 @@ export default function ToolCall({
 }) {
   const localize = useLocalize();
   const [oauthError, setOAuthError] = useState<string | null>(null);
+  const [oauthBinding, setOAuthBinding] = useState<'pending' | 'bound' | 'failed'>('pending');
   const autoExpand = useRecoilValue(store.autoExpandTools);
   const hasOutput = (output?.length ?? 0) > 0;
   const [showInfo, setShowInfo] = useState(() => autoExpand && hasOutput);
@@ -139,24 +140,23 @@ export default function ToolCall({
     return match?.[1] || '';
   }, [parsedAuthUrl, isMCPToolCall]);
 
-  const handleOAuthClick = useCallback(async () => {
-    if (!auth) {
-      return;
+  /**
+   * Sets the CSRF cookie the OAuth callback checks when the provider redirects back, or returns
+   * null when this prompt has nothing to bind.
+   */
+  const bindOAuth = useCallback((): Promise<void> | null => {
+    const bindsMCP = isMCPToolCall && mcpServerName.length > 0;
+    if (!bindsMCP && !actionId) {
+      return null;
     }
-    setOAuthError(null);
-    try {
-      if (isMCPToolCall && mcpServerName) {
+    return (async () => {
+      if (bindsMCP) {
         await dataService.bindMCPOAuth(mcpServerName);
-      } else if (actionId) {
+      } else {
         await dataService.bindActionOAuth(actionId);
       }
-    } catch (e) {
-      logger.error('Failed to bind OAuth CSRF cookie', e);
-      setOAuthError(localize('com_ui_oauth_error_generic'));
-      return;
-    }
-    window.open(auth, '_blank', 'noopener,noreferrer');
-  }, [auth, isMCPToolCall, mcpServerName, actionId, localize]);
+    })();
+  }, [isMCPToolCall, mcpServerName, actionId]);
 
   const hasError = (typeof output === 'string' && isError(output)) || runStepStatus === 'failed';
   /**
@@ -216,6 +216,72 @@ export default function ToolCall({
     isSubmitting,
     hasError,
   });
+  const showOAuth = Boolean(auth) && phase === 'running';
+
+  /**
+   * Binds when the sign-in prompt appears instead of on tap, so the tap opens the provider
+   * synchronously: an iOS home-screen app drops a tab opened after an awaited request. The button
+   * stays disabled until the bind lands, so the provider cannot redirect back before its cookie.
+   */
+  useEffect(() => {
+    if (!showOAuth) {
+      return;
+    }
+    const binding = bindOAuth();
+    if (binding == null) {
+      setOAuthBinding('bound');
+      return;
+    }
+    let active = true;
+    setOAuthBinding('pending');
+    binding.then(
+      () => {
+        if (active) {
+          setOAuthBinding('bound');
+        }
+      },
+      (error: unknown) => {
+        logger.error('Failed to bind OAuth CSRF cookie', error);
+        if (active) {
+          setOAuthBinding('failed');
+        }
+      },
+    );
+    return () => {
+      active = false;
+    };
+  }, [showOAuth, auth, bindOAuth]);
+
+  const handleOAuthClick = useCallback(() => {
+    if (!auth || oauthBinding === 'pending') {
+      return;
+    }
+    if (oauthBinding === 'bound') {
+      setOAuthError(null);
+      openInNewTab(auth);
+      /**
+       * Live prompts share one CSRF cookie per callback path, so the last prompt to bind owns it.
+       * The tapped prompt claims it again after opening; the provider cannot redirect back before
+       * the user signs in, and the session cookie from the earlier bind covers a faster callback.
+       */
+      bindOAuth()?.catch((error: unknown) => {
+        logger.error('Failed to bind OAuth CSRF cookie', error);
+      });
+      return;
+    }
+    setOAuthError(localize('com_ui_oauth_error_generic'));
+    setOAuthBinding('pending');
+    (bindOAuth() ?? Promise.resolve()).then(
+      () => {
+        setOAuthBinding('bound');
+        setOAuthError(null);
+      },
+      (error: unknown) => {
+        logger.error('Failed to bind OAuth CSRF cookie', error);
+        setOAuthBinding('failed');
+      },
+    );
+  }, [auth, oauthBinding, bindOAuth, localize]);
 
   const handleToggleInfo = useCallback(() => {
     mountBody();
@@ -329,13 +395,15 @@ export default function ToolCall({
           )}
         </div>
       </div>
-      {auth != null && auth && phase === 'running' && (
+      {showOAuth && (
         <div className="flex w-full flex-col gap-2.5">
           <div className="mb-1 mt-2">
             <Button
               className="inline-flex items-center justify-center rounded-xl px-4 py-2 text-sm font-medium"
               variant="default"
               rel="noopener noreferrer"
+              disabled={oauthBinding === 'pending'}
+              aria-busy={oauthBinding === 'pending'}
               onClick={handleOAuthClick}
             >
               {localize('com_ui_sign_in_to_domain', { 0: authDomain })}
diff --git a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx
index f055d6e46a7..65437ef434c 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.artifacts.test.tsx
@@ -67,10 +67,41 @@ const readArtifacts = async () =>
     id: el.getAttribute('data-id'),
   }));
 
-describe('MarkdownBlocks artifact-index parity (e2e)', () => {
+/** The latest message of a conversation, generating while `submitting` holds. */
+const liveView = (content: string, submitting: boolean) => (
+  <MemoryRouter>
+    <RecoilRoot>
+      <MessageContext.Provider
+        value={{
+          messageId: 'm1',
+          isExpanded: true,
+          isSubmitting: submitting,
+          isLatestMessage: true,
+        }}
+      >
+        <Markdown content={content} isLatestMessage={true} />
+      </MessageContext.Provider>
+    </RecoilRoot>
+  </MemoryRouter>
+);
+
+/**
+ * A finished message renders through one pipeline; one that streamed in this view
+ * renders per block. Every parity case has to hold on both paths.
+ */
+const renderMessage = (content: string, streamed: boolean) => {
+  const rendered = render(liveView(content, streamed));
+  rendered.rerender(liveView(content, false));
+  return rendered;
+};
+
+describe.each([
+  ['a finished', false],
+  ['a streamed', true],
+])('MarkdownBlocks artifact-index parity (e2e) in %s message', (_label, streamed) => {
   it('assigns document-order indices to multiple artifacts', async () => {
     const content = `${artifact('a', 'A')}\n\n${artifact('b', 'B')}`;
-    render(wrap(<Markdown content={content} isLatestMessage={false} />));
+    renderMessage(content, streamed);
 
     expect(await readArtifacts()).toEqual([
       { idx: '0', id: 'a' },
@@ -85,7 +116,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {
     const oldIdx = await readArtifacts();
     unmount();
 
-    render(wrap(<Markdown content={content} isLatestMessage={false} />));
+    renderMessage(content, streamed);
     const newIdx = await readArtifacts();
 
     expect(newIdx).toEqual(oldIdx);
@@ -95,16 +126,20 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {
     ]);
   });
 
+  /**
+   * A finished message moves to per-block rendering on its first edit, and per
+   * block the base-aware keys remount the blocks whose index shifted.
+   */
   it('refreshes artifact indices when an in-place edit inserts an artifact before another', async () => {
     const before = `Intro.\n\n${artifact('b', 'B')}`;
     const after = `${artifact('a', 'A')}\n\n${artifact('b', 'B')}`;
 
-    const { rerender } = render(wrap(<Markdown content={before} isLatestMessage={false} />));
+    const { rerender } = renderMessage(before, streamed);
     expect(await readArtifacts()).toEqual([{ idx: '0', id: 'b' }]);
 
-    rerender(wrap(<Markdown content={after} isLatestMessage={false} />));
-    // 'b' was index 0; inserting 'a' before it shifts its base to 1. Without the
-    // base-aware block key its ref-cached index would stay 0 (duplicating 'a').
+    rerender(liveView(after, false));
+    // 'b' was index 0; inserting 'a' before it shifts it to 1. Without a remount
+    // its ref-cached index would stay 0 (duplicating 'a').
     expect(await readArtifacts()).toEqual([
       { idx: '0', id: 'a' },
       { idx: '1', id: 'b' },
@@ -115,7 +150,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {
     // `:artifact{}` (text directive) renders as literal text, not an Artifact, so
     // the following real artifact must still be index 0.
     const content = `See :artifact{identifier="x"} inline.\n\n${artifact('a', 'A')}`;
-    render(wrap(<Markdown content={content} isLatestMessage={false} />));
+    renderMessage(content, streamed);
 
     expect(await readArtifacts()).toEqual([{ idx: '0', id: 'a' }]);
   });
@@ -141,7 +176,7 @@ describe('MarkdownBlocks artifact-index parity (e2e)', () => {
       ':::',
     ].join('\n');
 
-    render(wrap(<Markdown content={content} isLatestMessage={false} />));
+    renderMessage(content, streamed);
 
     const [artifactNode] = await screen.findAllByTestId('art');
     expect(artifactNode.getAttribute('data-content')).toBe(`${markdown}\n`);
diff --git a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx
index 835b24ee8aa..9be9d069b7d 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/MarkdownBlocks.test.tsx
@@ -2,10 +2,11 @@ import React from 'react';
 import { RecoilRoot } from 'recoil';
 import ReactMarkdown from 'react-markdown';
 import { MemoryRouter } from 'react-router-dom';
-import { render, screen } from '@testing-library/react';
+import { render, screen, within } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { getRemarkPlugins, getRehypePlugins, getMarkdownComponents } from '../markdownConfig';
-import { ArtifactProvider, CodeBlockProvider } from '~/Providers';
+import { MessageContext, ArtifactProvider, CodeBlockProvider } from '~/Providers';
+import { splitMarkdownIntoBlocks } from '../splitMarkdown';
 import Markdown from '../Markdown';
 
 /**
@@ -13,10 +14,14 @@ import Markdown from '../Markdown';
  * router the same way it has one in the app — without it the diagram throws into its
  * error boundary and the assertions compare two fallbacks instead of two renderers.
  */
+const queryClient = new QueryClient();
+
 const TestProviders = ({ children }: { children: React.ReactNode }) => (
-  <MemoryRouter>
-    <RecoilRoot>{children}</RecoilRoot>
-  </MemoryRouter>
+  <QueryClientProvider client={queryClient}>
+    <MemoryRouter>
+      <RecoilRoot>{children}</RecoilRoot>
+    </MemoryRouter>
+  </QueryClientProvider>
 );
 
 /**
@@ -31,18 +36,48 @@ jest.mock('~/components/Messages/Content/Mermaid', () => ({
   MermaidErrorBoundary: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
+const mockCodeBlockMounts = { count: 0 };
+
 /**
  * Stub CodeBlock so we can read the blockIndex each executable code block
  * receives, while still exercising the real `code` override's skip/single-line
- * decision (which decides whether a CodeBlock renders at all).
+ * decision (which decides whether a CodeBlock renders at all). It also counts
+ * mounts, which is how a remount of an already-rendered block shows up.
  */
 jest.mock('~/components/Messages/Content/CodeBlock', () => ({
   __esModule: true,
-  default: ({ lang, blockIndex }: { lang?: string; blockIndex?: number }) => (
-    <div data-testid="cb" data-block-index={String(blockIndex)} data-lang={String(lang)} />
-  ),
+  default: function MockCodeBlock({
+    lang,
+    blockIndex,
+    codeChildren,
+  }: {
+    lang?: string;
+    blockIndex?: number;
+    codeChildren?: React.ReactNode;
+  }) {
+    const { useEffect } = jest.requireActual<typeof import('react')>('react');
+    useEffect(() => {
+      mockCodeBlockMounts.count += 1;
+    }, []);
+    return (
+      <div
+        data-testid="cb"
+        data-block-index={String(blockIndex)}
+        data-lang={String(lang)}
+        data-code={String(codeChildren)}
+      />
+    );
+  },
 }));
 
+/** The real splitter, observed: whether a render paid for the block-boundary parse. */
+jest.mock('../splitMarkdown', () => {
+  const actual = jest.requireActual<typeof import('../splitMarkdown')>('../splitMarkdown');
+  return { ...actual, splitMarkdownIntoBlocks: jest.fn(actual.splitMarkdownIntoBlocks) };
+});
+
+const splitSpy = jest.mocked(splitMarkdownIntoBlocks);
+
 /** The previous whole-message renderer: a single ReactMarkdown under one set of providers. */
 const OldMarkdown = ({ content }: { content: string }) => (
   <ArtifactProvider>
@@ -60,6 +95,29 @@ const OldMarkdown = ({ content }: { content: string }) => (
   </ArtifactProvider>
 );
 
+/** The latest message of a conversation, generating while `submitting` holds. */
+const LiveMarkdown = ({ content, submitting }: { content: string; submitting: boolean }) => (
+  <MessageContext.Provider
+    value={{
+      messageId: 'live',
+      isExpanded: false,
+      isSubmitting: submitting,
+      isLatestMessage: true,
+    }}
+  >
+    <Markdown content={content} isLatestMessage={true} />
+  </MessageContext.Provider>
+);
+
+const StreamingMarkdown = ({ content }: { content: string }) => (
+  <LiveMarkdown content={content} submitting={true} />
+);
+
+/** A message the conversation opened with, already finished. */
+const SettledMarkdown = ({ content }: { content: string }) => (
+  <Markdown content={content} isLatestMessage={false} />
+);
+
 /**
  * The whole-message renderer emits whitespace-only text nodes ("\n") between
  * top-level block elements; the per-block renderer parses each block in
@@ -95,6 +153,22 @@ const streamThrough = (
   return container;
 };
 
+/** Streams a message line by line as the latest one, then finishes it. */
+const streamAndFinish = (content: string) => {
+  const view = (value: string, submitting: boolean) => (
+    <TestProviders>
+      <LiveMarkdown content={value} submitting={submitting} />
+    </TestProviders>
+  );
+  const lines = content.split('\n');
+  const rendered = render(view(lines[0], true));
+  for (let i = 2; i <= lines.length; i += 1) {
+    rendered.rerender(view(lines.slice(0, i).join('\n'), true));
+  }
+  rendered.rerender(view(content, false));
+  return rendered;
+};
+
 const MIXED = [
   'Intro paragraph.',
   '',
@@ -135,9 +209,10 @@ const EXPECTED = [
   { idx: '3', lang: 'ts' },
 ];
 
-const NewMarkdown = ({ content }: { content: string }) => (
-  <Markdown content={content} isLatestMessage={false} />
-);
+beforeEach(() => {
+  splitSpy.mockClear();
+  mockCodeBlockMounts.count = 0;
+});
 
 describe('MarkdownBlocks code-block index parity', () => {
   it('assigns document-order indices on a direct render (matches whole-message renderer)', () => {
@@ -148,7 +223,7 @@ describe('MarkdownBlocks code-block index parity', () => {
     );
     const { container: newC } = render(
       <TestProviders>
-        <Markdown content={MIXED} isLatestMessage={false} />
+        <SettledMarkdown content={MIXED} />
       </TestProviders>,
     );
 
@@ -158,47 +233,166 @@ describe('MarkdownBlocks code-block index parity', () => {
 
   it('keeps indices correct across a simulated stream (no drift under memoization)', () => {
     const oldC = streamThrough(OldMarkdown, MIXED);
-    const newC = streamThrough(NewMarkdown, MIXED);
+    const newC = streamThrough(StreamingMarkdown, MIXED);
 
     expect(indicesIn(oldC)).toEqual(EXPECTED);
     expect(indicesIn(newC)).toEqual(EXPECTED);
   });
 
   it('streamed indices match a fresh direct render (stable for stored execution results)', () => {
-    const streamed = streamThrough(NewMarkdown, MIXED);
+    const streamed = streamThrough(StreamingMarkdown, MIXED);
     const { container: fresh } = render(
       <TestProviders>
-        <Markdown content={MIXED} isLatestMessage={false} />
+        <SettledMarkdown content={MIXED} />
       </TestProviders>,
     );
     expect(indicesIn(streamed)).toEqual(indicesIn(fresh));
   });
 
-  it('refreshes indices when an in-place edit inserts a code block before existing ones', () => {
-    const before = 'intro\n\n```js\na\n```';
-    const after = '```py\nx\n```\n\n```js\na\n```';
-    const { container, rerender } = render(
+  /**
+   * Code blocks capture their index when they mount. A finished message moves to
+   * per-block rendering on its first edit, and per block the base-aware keys
+   * remount the blocks an edit shifted. The fixture turns a Mermaid fence, which
+   * takes no code index, into an executable one, so the js block keeps a stale
+   * index unless it really remounts.
+   */
+  it.each([
+    ['a finished', false],
+    ['a streamed', true],
+  ])(
+    'refreshes indices when an in-place edit to %s message inserts a code block before existing ones',
+    (_label, streamedFirst) => {
+      const before = '```mermaid\ngraph TD\n```\n\n```js\na\n```';
+      const after = '```py\nx\n```\n\n```js\na\n```';
+      const view = (content: string, submitting: boolean) => (
+        <TestProviders>
+          <LiveMarkdown content={content} submitting={submitting} />
+        </TestProviders>
+      );
+      const { container, rerender } = render(view(before, streamedFirst));
+      rerender(view(before, false));
+      expect(indicesIn(container)).toEqual([{ idx: '0', lang: 'js' }]);
+
+      rerender(view(after, false));
+      // The js block's index shifted 0 -> 1; without forcing a remount its ref-cached
+      // index would stay 0 (duplicating py). It must become 1.
+      expect(indicesIn(container)).toEqual([
+        { idx: '0', lang: 'py' },
+        { idx: '1', lang: 'js' },
+      ]);
+    },
+  );
+});
+
+describe('MarkdownBlocks finished and streamed messages', () => {
+  const PROSE = '# H\n\nPara with `code`.\n\n| x | y |\n| - | - |\n| 1 | 2 |\n\n- a\n- b';
+
+  it('renders a finished message through one pipeline, without the block-boundary parse', () => {
+    const { container: oldC } = render(
       <TestProviders>
-        <Markdown content={before} isLatestMessage={false} />
+        <OldMarkdown content={PROSE} />
+      </TestProviders>,
+    );
+    const { container: settledC } = render(
+      <TestProviders>
+        <SettledMarkdown content={PROSE} />
       </TestProviders>,
     );
-    expect(indicesIn(container)).toEqual([{ idx: '0', lang: 'js' }]);
 
-    rerender(
+    expect(splitSpy).not.toHaveBeenCalled();
+    // One pipeline reproduces the whole-message renderer exactly, down to the
+    // whitespace between blocks that separately parsed blocks cannot carry.
+    expect(settledC.innerHTML).toBe(oldC.innerHTML);
+  });
+
+  it('splits the message that is generating, so only its last block re-parses', () => {
+    render(
       <TestProviders>
-        <Markdown content={after} isLatestMessage={false} />
+        <StreamingMarkdown content={PROSE} />
       </TestProviders>,
     );
-    // The js block's base shifted 0 -> 1; without forcing a remount its ref-cached
-    // index would stay 0 (duplicating py). It must become 1.
-    expect(indicesIn(container)).toEqual([
-      { idx: '0', lang: 'py' },
-      { idx: '1', lang: 'js' },
-    ]);
+
+    expect(splitSpy).toHaveBeenCalledWith(PROSE);
+  });
+
+  it('keeps a streamed message split once it finishes, so no block remounts', () => {
+    const view = (content: string, submitting: boolean) => (
+      <TestProviders>
+        <LiveMarkdown content={content} submitting={submitting} />
+      </TestProviders>
+    );
+    const lines = MIXED.split('\n');
+    const { container, rerender } = render(view(lines[0], true));
+    for (let i = 2; i <= lines.length; i += 1) {
+      rerender(view(lines.slice(0, i).join('\n'), true));
+    }
+    const mountsWhileStreaming = mockCodeBlockMounts.count;
+    splitSpy.mockClear();
+
+    rerender(view(MIXED, false));
+
+    expect(mockCodeBlockMounts.count).toBe(mountsWhileStreaming);
+    expect(splitSpy).not.toHaveBeenCalled();
+    expect(indicesIn(container)).toEqual(EXPECTED);
+  });
+
+  /**
+   * Moving to per-block rendering remounts the message once, since the two paths
+   * build different trees; it happens as generation starts, so the fade baseline
+   * is set on the blocks it mounts. After that the message never remounts again.
+   */
+  it('moves a finished message to per-block rendering once when it starts generating again', () => {
+    const view = (content: string, submitting: boolean) => (
+      <TestProviders>
+        <LiveMarkdown content={content} submitting={submitting} />
+      </TestProviders>
+    );
+    const opening = MIXED.split('\n').slice(0, 12).join('\n');
+    const { container, rerender } = render(view(opening, false));
+    expect(splitSpy).not.toHaveBeenCalled();
+    const mountsAtOpen = mockCodeBlockMounts.count;
+
+    rerender(view(opening, true));
+    expect(splitSpy).toHaveBeenCalledWith(opening);
+    expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);
+
+    // A generation that stops before producing anything must not move it back.
+    rerender(view(opening, false));
+    expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);
+
+    const mountsOnceSplit = mockCodeBlockMounts.count;
+    rerender(view(MIXED, true));
+    rerender(view(MIXED, false));
+    expect(indicesIn(container)).toEqual(EXPECTED);
+    expect(mockCodeBlockMounts.count - mountsOnceSplit).toBe(EXPECTED.length - mountsAtOpen);
+  });
+
+  /**
+   * An artifact editor saves the message it lives in every few hundred
+   * milliseconds while the user types. Only the first save may remount the
+   * message; after it, a save re-renders just the block it touched.
+   */
+  it('moves a finished message to per-block rendering on its first edit, and edits in place after it', () => {
+    const view = (content: string) => (
+      <TestProviders>
+        <SettledMarkdown content={content} />
+      </TestProviders>
+    );
+    const { container, rerender } = render(view(MIXED));
+    expect(splitSpy).not.toHaveBeenCalled();
+    const mountsAtOpen = mockCodeBlockMounts.count;
+
+    rerender(view(MIXED.replace('Intro paragraph.', 'Intro paragraph, edited.')));
+    expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);
+
+    rerender(view(MIXED.replace('Intro paragraph.', 'Intro paragraph, edited twice.')));
+    rerender(view(MIXED.replace('Some `inline` code here.', 'Some edited `inline` code.')));
+    expect(mockCodeBlockMounts.count).toBe(mountsAtOpen * 2);
+    expect(indicesIn(container)).toEqual(EXPECTED);
   });
 });
 
-describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {
+describe('MarkdownBlocks DOM equivalence', () => {
   const cases: Array<[string, string]> = [
     ['paragraphs', 'First paragraph.\n\nSecond paragraph.'],
     ['gfm table', ['| a | b |', '| - | - |', '| 1 | 2 |', '| 3 | 4 |'].join('\n')],
@@ -208,6 +402,37 @@ describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {
     ['blockquote', '> quoted line one\n> quoted line two'],
     ['inline code', 'Use the `useMemo` hook for memoization.'],
     ['mixed', '# H\n\nPara with `code`.\n\n| x | y |\n| - | - |\n| 1 | 2 |\n\n- a\n- b'],
+    /* A fence indented too little to belong to item 10 is a top-level block whose
+     * indentation the whole-message parse strips from every code line. */
+    [
+      'fence indented under a two-digit list item',
+      [
+        '9. Build:',
+        '',
+        '   make',
+        '',
+        '10. Run the tests:',
+        '',
+        '   ```python',
+        '   def test():',
+        '       assert True',
+        '   ```',
+      ].join('\n'),
+    ],
+    [
+      'list indented by two spaces',
+      [
+        '  - Step one',
+        '',
+        '      Note: run this',
+        '',
+        '  - Step two',
+        '',
+        '    ```python',
+        '    print(1)',
+        '    ```',
+      ].join('\n'),
+    ],
   ];
 
   it.each(cases)('renders identical DOM to the whole-message renderer: %s', (_label, content) => {
@@ -216,12 +441,14 @@ describe('MarkdownBlocks DOM equivalence (non-code blocks)', () => {
         <OldMarkdown content={content} />
       </TestProviders>,
     );
-    const { container: newC } = render(
+    const { container: settledC } = render(
       <TestProviders>
-        <Markdown content={content} isLatestMessage={false} />
+        <SettledMarkdown content={content} />
       </TestProviders>,
     );
-    expect(normalizeHtml(newC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));
+    const { container: streamedC } = streamAndFinish(content);
+    expect(normalizeHtml(settledC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));
+    expect(normalizeHtml(streamedC.innerHTML)).toBe(normalizeHtml(oldC.innerHTML));
   });
 });
 
@@ -238,27 +465,48 @@ describe('MarkdownBlocks rendering smoke', () => {
   it('renders executable code blocks for a multi-code message', () => {
     render(
       <TestProviders>
-        <Markdown content={MIXED} isLatestMessage={false} />
+        <SettledMarkdown content={MIXED} />
       </TestProviders>,
     );
     expect(screen.getAllByTestId('cb')).toHaveLength(4);
   });
 });
 
-describe('MarkdownBlocks document-level definitions', () => {
+/**
+ * Constructs that need the whole document render as one block on both paths: a
+ * finished message always does, and the splitter falls back to it for a message
+ * that streamed.
+ */
+describe.each([
+  ['a finished', false],
+  ['a streamed', true],
+])('MarkdownBlocks document-level constructs in %s message', (_label, streamed) => {
+  const renderMessage = (content: string) =>
+    streamed
+      ? streamAndFinish(content)
+      : render(
+          <TestProviders>
+            <SettledMarkdown content={content} />
+          </TestProviders>,
+        );
+
   it('resolves a reference-style link whose definition is in a separate block', () => {
-    const queryClient = new QueryClient();
     const content = 'See [docs][d] for details.\n\n[d]: https://example.com/docs';
-    render(
-      <QueryClientProvider client={queryClient}>
-        <TestProviders>
-          <Markdown content={content} isLatestMessage={false} />
-        </TestProviders>
-      </QueryClientProvider>,
-    );
-    expect(screen.getByRole('link', { name: 'docs' })).toHaveAttribute(
+    const { container } = renderMessage(content);
+    expect(within(container).getByRole('link', { name: 'docs' })).toHaveAttribute(
       'href',
       'https://example.com/docs',
     );
   });
+
+  it('keeps the separator between adjacent raw HTML blocks', () => {
+    const content = '<div>one</div>\n\n<div>two</div>';
+    const { container: oldC } = render(
+      <TestProviders>
+        <OldMarkdown content={content} />
+      </TestProviders>,
+    );
+    const { container } = renderMessage(content);
+    expect(container.innerHTML).toBe(oldC.innerHTML);
+  });
 });
diff --git a/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx
index 9d31ba34e06..829a8d85772 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/MermaidBlockIds.test.tsx
@@ -25,59 +25,102 @@ jest.mock('~/components/Messages/Content/CodeBlock', () => ({
   ),
 }));
 
-const renderMarkdown = (content: string) =>
-  render(
-    <MarkdownBlocks
-      content={content}
-      remarkPlugins={getRemarkPlugins()}
-      rehypePlugins={getRehypePlugins()}
-      components={getMarkdownComponents()}
-    />,
-  );
+const view = (content: string, streaming: boolean) => (
+  <MarkdownBlocks
+    content={content}
+    streaming={streaming}
+    remarkPlugins={getRemarkPlugins()}
+    rehypePlugins={getRehypePlugins()}
+    components={getMarkdownComponents()}
+  />
+);
+
+const renderMarkdown = (content: string, streaming: boolean) => render(view(content, streaming));
 
 const mermaidIds = () =>
   screen.getAllByTestId('mermaid').map((element) => element.getAttribute('data-mermaid-id'));
 
 describe('Mermaid block ids', () => {
-  it('gives each Mermaid fence in a message a distinct id', () => {
-    renderMarkdown(
-      ['```mermaid', 'graph TD', 'A-->B', '```', '', '```mermaid', 'graph TD', 'C-->D', '```'].join(
-        '\n',
-      ),
-    );
+  /** A finished message renders as one pipeline and a streaming one per block; both number alike. */
+  describe.each([
+    ['a finished', false],
+    ['a streaming', true],
+  ])('in %s message', (_label, streaming) => {
+    it('gives each Mermaid fence in a message a distinct id', () => {
+      renderMarkdown(
+        [
+          '```mermaid',
+          'graph TD',
+          'A-->B',
+          '```',
+          '',
+          '```mermaid',
+          'graph TD',
+          'C-->D',
+          '```',
+        ].join('\n'),
+        streaming,
+      );
 
-    const ids = mermaidIds();
-    expect(ids).toHaveLength(2);
-    expect(new Set(ids).size).toBe(2);
-  });
+      const ids = mermaidIds();
+      expect(ids).toHaveLength(2);
+      expect(new Set(ids).size).toBe(2);
+    });
 
-  it('keeps Mermaid ids distinct across intervening executable code blocks', () => {
-    renderMarkdown(
-      [
-        '```mermaid',
-        'graph TD',
-        'A-->B',
-        '```',
-        '',
-        '```python',
-        'print("hi")',
-        '```',
-        '',
-        '```mermaid',
-        'graph TD',
-        'C-->D',
-        '```',
-        '',
-        '```mermaid',
-        'graph TD',
-        'E-->F',
-        '```',
-      ].join('\n'),
-    );
+    it('keeps Mermaid ids distinct across intervening executable code blocks', () => {
+      renderMarkdown(
+        [
+          '```mermaid',
+          'graph TD',
+          'A-->B',
+          '```',
+          '',
+          '```python',
+          'print("hi")',
+          '```',
+          '',
+          '```mermaid',
+          'graph TD',
+          'C-->D',
+          '```',
+          '',
+          '```mermaid',
+          'graph TD',
+          'E-->F',
+          '```',
+        ].join('\n'),
+        streaming,
+      );
+
+      const ids = mermaidIds();
+      expect(ids).toHaveLength(3);
+      expect(new Set(ids).size).toBe(3);
+    });
+
+    it('does not let a Mermaid fence disturb executable code block indices', () => {
+      renderMarkdown(
+        [
+          '```python',
+          'print("first")',
+          '```',
+          '',
+          '```mermaid',
+          'graph TD',
+          'A-->B',
+          '```',
+          '',
+          '```python',
+          'print("second")',
+          '```',
+        ].join('\n'),
+        streaming,
+      );
 
-    const ids = mermaidIds();
-    expect(ids).toHaveLength(3);
-    expect(new Set(ids).size).toBe(3);
+      const indices = screen
+        .getAllByTestId('code-block')
+        .map((element) => element.getAttribute('data-block-index'));
+      expect(indices).toEqual(['0', '1']);
+    });
   });
 
   /**
@@ -102,46 +145,13 @@ describe('Mermaid block ids', () => {
     ].join('\n');
     const listStillGrowing = [listWithTwo, '', '- step three'].join('\n');
 
-    const { rerender } = renderMarkdown(listWithOne);
+    const { rerender } = renderMarkdown(listWithOne, true);
     expect(mermaidIds()).toEqual(['mermaid-0']);
 
-    const view = (content: string) => (
-      <MarkdownBlocks
-        content={content}
-        remarkPlugins={getRemarkPlugins()}
-        rehypePlugins={getRehypePlugins()}
-        components={getMarkdownComponents()}
-      />
-    );
-
-    rerender(view(listWithTwo));
+    rerender(view(listWithTwo, true));
     expect(mermaidIds()).toEqual(['mermaid-0', 'mermaid-1']);
 
-    rerender(view(listStillGrowing));
+    rerender(view(listStillGrowing, true));
     expect(mermaidIds()).toEqual(['mermaid-0', 'mermaid-1']);
   });
-
-  it('does not let a Mermaid fence disturb executable code block indices', () => {
-    renderMarkdown(
-      [
-        '```python',
-        'print("first")',
-        '```',
-        '',
-        '```mermaid',
-        'graph TD',
-        'A-->B',
-        '```',
-        '',
-        '```python',
-        'print("second")',
-        '```',
-      ].join('\n'),
-    );
-
-    const indices = screen
-      .getAllByTestId('code-block')
-      .map((element) => element.getAttribute('data-block-index'));
-    expect(indices).toEqual(['0', '1']);
-  });
 });
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ToolCall.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ToolCall.test.tsx
index ea68deae294..aa60aedfd22 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ToolCall.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ToolCall.test.tsx
@@ -1,9 +1,10 @@
 import React from 'react';
 import { RecoilRoot } from 'recoil';
-import { Tools, Constants } from 'librechat-data-provider';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { Tools, Constants, dataService } from 'librechat-data-provider';
+import { render, screen, waitFor, fireEvent } from '@testing-library/react';
 import { ToolAuthWarningContext } from '../auth';
 import ToolCall from '../ToolCall';
+import { logger } from '~/utils';
 
 // Mock dependencies
 jest.mock('~/hooks', () => ({
@@ -105,8 +106,21 @@ jest.mock('~/utils', () => ({
   cn: (...classes: any[]) => classes.filter(Boolean).join(' '),
   getToolDisplayLabel: (name: string, localize: (key: string) => string) =>
     name === 'set_memory' ? localize('com_ui_tool_name_set_memory') : name,
+  openInNewTab: jest.requireActual('~/utils/links').openInNewTab,
 }));
 
+jest.mock('librechat-data-provider', () => {
+  const actual = jest.requireActual('librechat-data-provider');
+  return {
+    ...actual,
+    dataService: {
+      ...actual.dataService,
+      bindMCPOAuth: jest.fn(),
+      bindActionOAuth: jest.fn(),
+    },
+  };
+});
+
 describe('ToolCall', () => {
   const mockProps = {
     args: '{"test": "input"}',
@@ -335,8 +349,10 @@ describe('ToolCall', () => {
 
   describe('authentication flow', () => {
     it('should show sign-in button when auth URL is provided', () => {
-      const originalOpen = window.open;
-      window.open = jest.fn();
+      const open = jest.spyOn(window, 'open').mockImplementation(() => null);
+      const click = jest
+        .spyOn(HTMLAnchorElement.prototype, 'click')
+        .mockImplementation(() => undefined);
 
       renderWithRecoil(
         <ToolCall
@@ -351,13 +367,122 @@ describe('ToolCall', () => {
       expect(signInButton).toBeInTheDocument();
 
       fireEvent.click(signInButton);
-      expect(window.open).toHaveBeenCalledWith(
-        'https://auth.example.com',
-        '_blank',
-        'noopener,noreferrer',
-      );
+      expect(click).toHaveBeenCalledTimes(1);
+      const link = click.mock.instances[0] as unknown as HTMLAnchorElement;
+      expect(link.href).toBe('https://auth.example.com/');
+      expect(link.target).toBe('_blank');
+      expect(link.rel).toBe('noopener noreferrer');
+      /** A features string makes WebKit request a popup window, which iOS web apps cannot open. */
+      expect(open).not.toHaveBeenCalled();
+
+      click.mockRestore();
+      open.mockRestore();
+    });
 
-      window.open = originalOpen;
+    describe('MCP sign-in', () => {
+      const callbackUrl = 'https://chat.example.com/api/mcp/clickhouse/oauth/callback';
+      const mcpAuth = `https://mcp.example.com/authorize?redirect_uri=${encodeURIComponent(callbackUrl)}`;
+      const mcpProps = {
+        ...mockProps,
+        name: `oauth${Constants.mcp_delimiter}clickhouse`,
+        auth: mcpAuth,
+        initialProgress: 0.5,
+        isSubmitting: true,
+      };
+      let click: jest.SpyInstance;
+
+      beforeEach(() => {
+        click = jest
+          .spyOn(HTMLAnchorElement.prototype, 'click')
+          .mockImplementation(() => undefined);
+      });
+
+      afterEach(() => {
+        click.mockRestore();
+      });
+
+      const signInButton = () => screen.getByRole('button', { name: 'Sign in to mcp.example.com' });
+
+      it('binds when the prompt appears and opens the provider within the tap', async () => {
+        (dataService.bindMCPOAuth as jest.Mock).mockResolvedValue({ success: true });
+        renderWithRecoil(<ToolCall {...mcpProps} />);
+        expect(dataService.bindMCPOAuth).toHaveBeenCalledWith('clickhouse');
+        await waitFor(() => expect(signInButton()).toBeEnabled());
+
+        fireEvent.click(signInButton());
+
+        expect(click).toHaveBeenCalledTimes(1);
+        expect((click.mock.instances[0] as unknown as HTMLAnchorElement).href).toBe(mcpAuth);
+        expect(dataService.bindMCPOAuth).toHaveBeenCalledTimes(2);
+        expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('clickhouse');
+      });
+
+      it('claims the shared CSRF binding for the prompt the user taps', async () => {
+        (dataService.bindMCPOAuth as jest.Mock).mockResolvedValue({ success: true });
+        const notionCallback = 'https://chat.example.com/api/mcp/notion/oauth/callback';
+        const notionAuth = `https://notion.example.com/authorize?redirect_uri=${encodeURIComponent(notionCallback)}`;
+        const notionButton = () =>
+          screen.getByRole('button', { name: 'Sign in to notion.example.com' });
+        renderWithRecoil(
+          <>
+            <ToolCall {...mcpProps} />
+            <ToolCall
+              {...mcpProps}
+              name={`oauth${Constants.mcp_delimiter}notion`}
+              auth={notionAuth}
+            />
+          </>,
+        );
+        await waitFor(() => expect(signInButton()).toBeEnabled());
+        await waitFor(() => expect(notionButton()).toBeEnabled());
+        expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('notion');
+
+        fireEvent.click(signInButton());
+
+        expect(click).toHaveBeenCalledTimes(1);
+        expect((click.mock.instances[0] as unknown as HTMLAnchorElement).href).toBe(mcpAuth);
+        expect(dataService.bindMCPOAuth).toHaveBeenLastCalledWith('clickhouse');
+      });
+
+      it('keeps sign-in disabled until the bind lands', async () => {
+        let finishBind: (() => void) | undefined;
+        (dataService.bindMCPOAuth as jest.Mock).mockReturnValue(
+          new Promise((resolve) => {
+            finishBind = () => resolve({ success: true });
+          }),
+        );
+        renderWithRecoil(<ToolCall {...mcpProps} />);
+
+        expect(signInButton()).toBeDisabled();
+        expect(signInButton()).toHaveAttribute('aria-busy', 'true');
+        fireEvent.click(signInButton());
+        expect(click).not.toHaveBeenCalled();
+
+        finishBind!();
+        await waitFor(() => expect(signInButton()).toBeEnabled());
+        fireEvent.click(signInButton());
+        expect(click).toHaveBeenCalledTimes(1);
+      });
+
+      it('retries a failed bind on tap instead of opening the provider', async () => {
+        (dataService.bindMCPOAuth as jest.Mock)
+          .mockRejectedValueOnce(new Error('bind failed'))
+          .mockResolvedValue({ success: true });
+        renderWithRecoil(<ToolCall {...mcpProps} />);
+        await waitFor(() => expect(logger.error).toHaveBeenCalled());
+        await waitFor(() => expect(signInButton()).toBeEnabled());
+
+        fireEvent.click(signInButton());
+
+        expect(click).not.toHaveBeenCalled();
+        expect(screen.getByRole('alert')).toHaveTextContent('com_ui_oauth_error_generic');
+        await waitFor(() => expect(screen.queryByRole('alert')).not.toBeInTheDocument());
+        expect(dataService.bindMCPOAuth).toHaveBeenCalledTimes(2);
+        await waitFor(() => expect(signInButton()).toBeEnabled());
+
+        fireEvent.click(signInButton());
+        expect(click).toHaveBeenCalledTimes(1);
+      });
     });
 
     it('should not show auth section when cancelled', () => {
diff --git a/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts b/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts
index 100a984f47c..5aed247c151 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts
+++ b/client/src/components/Chat/Messages/Content/__tests__/splitMarkdown.test.ts
@@ -39,6 +39,12 @@ describe('splitMarkdownIntoBlocks', () => {
     expect(raws(content)).toEqual(['Lead.', artifact, 'Tail.']);
   });
 
+  it("keeps a top-level block's indentation, which decides how it parses", () => {
+    const fence = ['   ```python', '   def test():', '       assert True', '   ```'].join('\n');
+    const content = ['9. Build:', '', '   make', '', '10. Run the tests:', '', fence].join('\n');
+    expect(raws(content)).toEqual([content.slice(0, content.indexOf('\n\n   ```')), fence]);
+  });
+
   it('keeps a list as one block (does not split items)', () => {
     const list = '- one\n- two\n- three';
     expect(raws(list)).toEqual([list]);
diff --git a/client/src/components/Chat/Messages/Content/splitMarkdown.ts b/client/src/components/Chat/Messages/Content/splitMarkdown.ts
index 21f8e75b67b..2fc3d6d0f64 100644
--- a/client/src/components/Chat/Messages/Content/splitMarkdown.ts
+++ b/client/src/components/Chat/Messages/Content/splitMarkdown.ts
@@ -101,6 +101,18 @@ const parseToMdast = (content: string): MdastNode =>
     mdastExtensions: [gfmFromMarkdown(), directiveFromMarkdown(), mathFromMarkdown()],
   }) as MdastNode;
 
+/**
+ * Where the line holding a top-level block begins, when only indentation precedes
+ * the block on it. mdast starts a node after its indentation, but that indentation
+ * carries meaning: it is stripped from an indented fence's code lines, and it
+ * decides which list item a later indented line belongs to. A block parsed on its
+ * own has to keep it to parse the way it does inside the whole message.
+ */
+const lineStartOf = (content: string, offset: number): number => {
+  const lineStart = content.lastIndexOf('\n', offset - 1) + 1;
+  return /^[ \t]*$/.test(content.slice(lineStart, offset)) ? lineStart : offset;
+};
+
 /**
  * Split a markdown string into its top-level blocks, returning the exact source
  * slice for each block plus the index counts it consumes. Completed blocks
@@ -149,7 +161,7 @@ export function splitMarkdownIntoBlocks(content: string): MarkdownBlock[] {
     const counts = { code: 0, artifact: 0, mermaid: 0 };
     countWithin(node, counts);
     blocks.push({
-      raw: content.slice(start, end),
+      raw: content.slice(lineStartOf(content, start), end),
       codeBlockCount: counts.code,
       artifactCount: counts.artifact,
       mermaidCount: counts.mermaid,
diff --git a/client/src/components/Chat/Messages/MessageParts.tsx b/client/src/components/Chat/Messages/MessageParts.tsx
index eaacbc8d888..64c1b9d1f41 100644
--- a/client/src/components/Chat/Messages/MessageParts.tsx
+++ b/client/src/components/Chat/Messages/MessageParts.tsx
@@ -10,7 +10,7 @@ import {
   getHeaderPrefixForScreenReader,
 } from '~/utils';
 import { useLocalize, useAttachments, useMessageHelpers, useContentMetadata } from '~/hooks';
-import AuthorHeader from '~/components/Chat/Messages/Content/Parts/AuthorHeader';
+import ResumeAuthorHeader from '~/components/Chat/Messages/Content/Parts/ResumeAuthorHeader';
 import { ErrorSourceProvider } from '~/components/Messages/Content/Error/source';
 import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
 import { revealOnRowHoverClasses, messageFooterClasses } from './styles';
@@ -20,10 +20,17 @@ import { showThinkingAtom } from '~/store/showThinking';
 import Elapsed, { shouldShowElapsed } from './Elapsed';
 import ContentParts from './Content/ContentParts';
 import SiblingSwitch from './SiblingSwitch';
+import { AuthorContext } from '~/Providers';
 import HoverButtons from './HoverButtons';
 import SubRow from './SubRow';
 import store from '~/store';
 
+/**
+ * The one header every assistant message hands its parts. It reads the author from
+ * `AuthorContext`, so the author resolving after paint cannot break the parts' memo.
+ */
+const RESUME_AUTHOR_HEADER = <ResumeAuthorHeader />;
+
 function MessageParts(props: TMessageProps) {
   const localize = useLocalize();
   const { message, siblingIdx, siblingCount, setSiblingIdx } = props;
@@ -86,15 +93,12 @@ function MessageParts(props: TMessageProps) {
     ],
   );
 
-  const authorHeader = useMemo(
-    () =>
-      isCreatedByUser === true ? undefined : (
-        <AuthorHeader
-          icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}
-          label={name}
-        />
-      ),
-    [isCreatedByUser, iconData, assistant, agent, name],
+  const author = useMemo(
+    () => ({
+      icon: <MessageIcon iconData={iconData} assistant={assistant} agent={agent} />,
+      label: name,
+    }),
+    [iconData, assistant, agent, name],
   );
 
   const { hasParallelContent } = useContentMetadata(message);
@@ -112,8 +116,8 @@ function MessageParts(props: TMessageProps) {
       <div className="m-auto justify-center px-4 py-3 sm:px-0">
         <MessageRow
           id={messageId ?? ''}
-          icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}
-          label={name}
+          icon={author.icon}
+          label={author.label}
           hoverLabel={getHeaderHoverLabel(
             hasConfiguredSender,
             agent?.model,
@@ -169,26 +173,28 @@ function MessageParts(props: TMessageProps) {
             </SubRow>
           }
         >
-          <ErrorSourceProvider message={message}>
-            <ContentParts
-              edit={edit}
-              isLast={isLast}
-              enterEdit={enterEdit}
-              siblingIdx={siblingIdx}
-              attachments={attachments}
-              isSubmitting={isSubmitting}
-              searchResults={searchResults}
-              manualSkills={message.manualSkills}
-              messageId={message.messageId}
-              authorHeader={authorHeader}
-              setSiblingIdx={setSiblingIdx}
-              isCreatedByUser={message.isCreatedByUser}
-              conversationId={conversation?.conversationId}
-              showThinking={showThinking}
-              isLatestMessage={messageId === latestMessageId}
-              content={message.content as Array<TMessageContentParts | undefined>}
-            />
-          </ErrorSourceProvider>
+          <AuthorContext.Provider value={author}>
+            <ErrorSourceProvider message={message}>
+              <ContentParts
+                edit={edit}
+                isLast={isLast}
+                enterEdit={enterEdit}
+                siblingIdx={siblingIdx}
+                attachments={attachments}
+                isSubmitting={isSubmitting}
+                searchResults={searchResults}
+                manualSkills={message.manualSkills}
+                messageId={message.messageId}
+                authorHeader={isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}
+                setSiblingIdx={setSiblingIdx}
+                isCreatedByUser={message.isCreatedByUser}
+                conversationId={conversation?.conversationId}
+                showThinking={showThinking}
+                isLatestMessage={messageId === latestMessageId}
+                content={message.content as Array<TMessageContentParts | undefined>}
+              />
+            </ErrorSourceProvider>
+          </AuthorContext.Provider>
         </MessageRow>
       </div>
     </div>
diff --git a/client/src/components/Chat/Trace/Conversation.tsx b/client/src/components/Chat/Trace/Conversation.tsx
new file mode 100644
index 00000000000..d9ef6860a8d
--- /dev/null
+++ b/client/src/components/Chat/Trace/Conversation.tsx
@@ -0,0 +1,164 @@
+import { memo } from 'react';
+import { User, Sparkles, ScrollText } from 'lucide-react';
+import type { TTracePrompt, TTraceMessage, TTraceContent } from 'librechat-data-provider';
+import type { RecordPresentation } from './present';
+import type { TranslationKeys } from '~/hooks';
+import StackedToolIcons from '~/components/Chat/Messages/Content/ToolOutput/StackedToolIcons';
+import { formatJSON } from '~/utils/json';
+import { useLocalize } from '~/hooks';
+
+type ToolTitle = (name: string) => Pick<RecordPresentation, 'title' | 'caption'>;
+
+const ROLE_LABELS: Record<Exclude<TTraceMessage['role'], 'tool'>, TranslationKeys> = {
+  system: 'com_ui_trace_message_system',
+  user: 'com_ui_trace_message_user',
+  assistant: 'com_ui_model',
+};
+
+function Text({ content }: { content: TTraceContent }) {
+  const localize = useLocalize();
+  return (
+    <>
+      <p className="max-h-48 overflow-auto whitespace-pre-wrap break-words text-sm text-text-primary">
+        {content.value}
+      </p>
+      {content.truncated && (
+        <p className="text-xs text-text-secondary">{localize('com_ui_trace_truncated')}</p>
+      )}
+    </>
+  );
+}
+
+function Message({
+  message,
+  toolTitleFor,
+  mcpIconMap,
+}: {
+  message: TTraceMessage;
+  toolTitleFor: ToolTitle;
+  mcpIconMap: Map<string, string>;
+}) {
+  const localize = useLocalize();
+  const tool = message.role === 'tool' && message.toolName != null ? message.toolName : undefined;
+  const toolTitle = tool != null ? toolTitleFor(tool) : undefined;
+  return (
+    <li className="flex flex-col gap-1 rounded-lg border border-border-light bg-surface-primary-alt p-2">
+      <span className="flex items-center gap-1.5 text-xs font-medium text-text-secondary">
+        {message.role === 'user' && <User className="size-3.5" aria-hidden="true" />}
+        {message.role === 'assistant' && <Sparkles className="size-3.5" aria-hidden="true" />}
+        {message.role === 'tool' && (
+          <StackedToolIcons toolNames={[tool ?? '']} mcpIconMap={mcpIconMap} />
+        )}
+        {message.role === 'tool'
+          ? localize('com_ui_trace_message_tool', {
+              0: toolTitle?.title ?? localize('com_ui_trace_kind_tool'),
+            })
+          : localize(ROLE_LABELS[message.role])}
+        {toolTitle?.caption != null && <span className="font-normal">{toolTitle.caption}</span>}
+      </span>
+      {message.text != null && <Text content={message.text} />}
+      {message.attachments != null && (
+        <p className="text-xs text-text-secondary">
+          {localize('com_ui_trace_message_attachments', { 0: message.attachments.join(', ') })}
+        </p>
+      )}
+      {message.toolCalls?.map((call, index) => {
+        const { title, caption } = toolTitleFor(call.name);
+        return (
+          <details key={`${call.name}-${index}`} className="group text-xs">
+            <summary className="flex cursor-pointer items-center gap-1.5 rounded-md py-0.5 text-text-primary marker:content-none hover:bg-surface-hover">
+              <StackedToolIcons toolNames={[call.name]} mcpIconMap={mcpIconMap} />
+              <span className="min-w-0 truncate">
+                {localize('com_ui_trace_message_asked_tool', { 0: title })}
+              </span>
+              {caption != null && <span className="truncate text-text-secondary">{caption}</span>}
+            </summary>
+            {call.args != null && (
+              <pre className="mt-1 max-h-40 overflow-auto whitespace-pre-wrap break-words font-mono text-xs text-text-secondary">
+                {call.args.truncated ? call.args.value : formatJSON(call.args.value)}
+              </pre>
+            )}
+          </details>
+        );
+      })}
+    </li>
+  );
+}
+
+/**
+ * A model call as a conversation: what it wrote, then what it was given. The
+ * instructions stay folded, since they are long and the same on every call, and
+ * the newest messages, which the call answered, are what opens.
+ */
+function Conversation({
+  prompt,
+  reply,
+  toolTitleFor,
+  mcpIconMap,
+}: {
+  prompt?: TTracePrompt;
+  reply?: TTraceMessage;
+  toolTitleFor: ToolTitle;
+  mcpIconMap: Map<string, string>;
+}) {
+  const localize = useLocalize();
+  const heading = 'text-xs font-semibold uppercase tracking-wide text-text-secondary';
+  const [first, ...rest] = prompt?.messages ?? [];
+  const system = first?.role === 'system' ? first : undefined;
+  const messages = system != null ? rest : (prompt?.messages ?? []);
+  return (
+    <div className="flex flex-col gap-4">
+      {reply != null && (
+        <section className="flex flex-col gap-1.5">
+          <h4 className={heading}>{localize('com_ui_trace_reply')}</h4>
+          <ul className="flex flex-col gap-1.5">
+            <Message message={reply} toolTitleFor={toolTitleFor} mcpIconMap={mcpIconMap} />
+          </ul>
+        </section>
+      )}
+      {prompt != null && (
+        <section className="flex flex-col gap-1.5">
+          <h4 className={heading}>{localize('com_ui_trace_prompt')}</h4>
+          {system?.text != null && (
+            <details className="rounded-lg border border-border-light bg-surface-primary-alt p-2 text-sm">
+              <summary className="flex cursor-pointer items-center gap-1.5 text-xs font-medium text-text-secondary marker:content-none">
+                <ScrollText className="size-3.5" aria-hidden="true" />
+                {localize('com_ui_trace_message_system')}
+              </summary>
+              <div className="mt-1.5 flex flex-col gap-1">
+                <Text content={system.text} />
+              </div>
+            </details>
+          )}
+          {prompt.omitted > 0 && (
+            <p className="px-2 text-xs text-text-secondary">
+              {localize('com_ui_trace_prompt_omitted', { 0: String(prompt.omitted) })}
+            </p>
+          )}
+          <ul className="flex flex-col gap-1.5">
+            {messages.map((message, index) => (
+              <Message
+                key={index}
+                message={message}
+                toolTitleFor={toolTitleFor}
+                mcpIconMap={mcpIconMap}
+              />
+            ))}
+          </ul>
+          {prompt.tools != null && (
+            <details className="px-2 text-xs text-text-secondary">
+              <summary className="cursor-pointer">
+                {localize('com_ui_trace_prompt_tools', { 0: String(prompt.tools.length) })}
+              </summary>
+              <p className="mt-1 break-words">
+                {prompt.tools.map((name) => toolTitleFor(name).title).join(', ')}
+              </p>
+            </details>
+          )}
+        </section>
+      )}
+    </div>
+  );
+}
+
+export default memo(Conversation);
diff --git a/client/src/components/Chat/Trace/Inspector.tsx b/client/src/components/Chat/Trace/Inspector.tsx
index cf931d64be3..2b9e310f90c 100644
--- a/client/src/components/Chat/Trace/Inspector.tsx
+++ b/client/src/components/Chat/Trace/Inspector.tsx
@@ -1,19 +1,25 @@
-import { memo, useId } from 'react';
-import { X } from 'lucide-react';
-import { Button, Spinner } from '@librechat/client';
-import type { TTraceContent } from 'librechat-data-provider';
+import { memo, useId, useState } from 'react';
+import copy from 'copy-to-clipboard';
+import { Link } from 'react-router-dom';
+import { X, Copy, Check, MessageSquare } from 'lucide-react';
+import { Button, Spinner, buttonVariants } from '@librechat/client';
+import type { TTraceContent, TTraceRecordDetail } from 'librechat-data-provider';
 import type { ReactNode } from 'react';
+import type { RecordPresentation, ToolCallView } from './present';
 import type { TranslationKeys } from '~/hooks';
 import type { TraceNode } from './model';
+import StackedToolIcons from '~/components/Chat/Messages/Content/ToolOutput/StackedToolIcons';
 import { useConversationTraceRecordQuery } from '~/data-provider';
 import { useTraceFormat, recordDurationText } from './format';
 import { formatCost, formatTokens } from '~/utils/tokens';
-import { KIND_APPEARANCE, STATUS_LABEL } from './kinds';
+import { appearanceOf, STATUS_LABEL } from './kinds';
+import { cn, renderAgentAvatar } from '~/utils';
+import Conversation from './Conversation';
 import { formatJSON } from '~/utils/json';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 
 type Field = { label: TranslationKeys; value: ReactNode };
+type ToolFor = (name: string) => Pick<RecordPresentation, 'title' | 'caption'>;
 
 function Section({ title, fields }: { title: TranslationKeys; fields: Field[] }) {
   const localize = useLocalize();
@@ -65,13 +71,21 @@ function RecordContent({
   recordId,
   messageId,
   sourceId,
+  toolFor,
+  mcpIconMap,
+  placeholder,
 }: {
   conversationId: string;
   recordId: string;
   messageId: string;
   sourceId?: string;
+  toolFor: ToolFor;
+  mcpIconMap: Map<string, string>;
+  /** What the chat already knows the record wrote: shown at once, until the record's own reply loads. */
+  placeholder?: ReactNode;
 }) {
   const localize = useLocalize();
+  const [raw, setRaw] = useState(false);
   const { data, isLoading, isError, refetch } = useConversationTraceRecordQuery(
     { conversationId, recordId, messageId, sourceId },
     true,
@@ -79,10 +93,13 @@ function RecordContent({
 
   if (isLoading) {
     return (
-      <div className="flex justify-center py-4" role="status">
-        <Spinner className="size-4 text-text-secondary" />
-        <span className="sr-only">{localize('com_ui_trace_loading')}</span>
-      </div>
+      <>
+        {placeholder}
+        <div className="flex justify-center py-4" role="status">
+          <Spinner className="size-4 text-text-secondary" />
+          <span className="sr-only">{localize('com_ui_trace_loading')}</span>
+        </div>
+      </>
     );
   }
   if (isError || !data) {
@@ -101,18 +118,145 @@ function RecordContent({
   if (!data.input && !data.output && !data.metadata) {
     return <p className="text-sm text-text-secondary">{localize('com_ui_trace_content_empty')}</p>;
   }
+  const readable = data.prompt != null || data.reply != null;
   return (
     <div className="flex flex-col gap-3">
-      <ContentBlock label="com_ui_trace_input" content={data.input} />
-      <ContentBlock label="com_ui_trace_output" content={data.output} />
-      <ContentBlock label="com_ui_trace_metadata" content={data.metadata} />
+      {data.reply == null && placeholder}
+      {readable && (
+        <Button
+          size="sm"
+          variant="ghost"
+          aria-pressed={raw}
+          className="self-end"
+          onClick={() => setRaw((current) => !current)}
+        >
+          {localize(raw ? 'com_ui_trace_view_conversation' : 'com_ui_trace_view_raw')}
+        </Button>
+      )}
+      {readable && !raw && (
+        <Conversation
+          prompt={data.prompt}
+          reply={data.reply}
+          toolTitleFor={toolFor}
+          mcpIconMap={mcpIconMap}
+        />
+      )}
+      {(!readable || raw) && (
+        <RawContent input={data.input} output={data.output} metadata={data.metadata} />
+      )}
     </div>
   );
 }
 
+function RawContent({
+  input,
+  output,
+  metadata,
+}: Pick<TTraceRecordDetail, 'input' | 'output' | 'metadata'>) {
+  return (
+    <div className="flex flex-col gap-3">
+      <ContentBlock label="com_ui_trace_input" content={input} />
+      <ContentBlock label="com_ui_trace_output" content={output} />
+      <ContentBlock label="com_ui_trace_metadata" content={metadata} />
+    </div>
+  );
+}
+
+const COPIED_MS = 2000;
+const CALL_CONTENT_LENGTH = 4000;
+
+function toContent(value?: string): TTraceContent | undefined {
+  if (value == null) {
+    return undefined;
+  }
+  const truncated = value.length > CALL_CONTENT_LENGTH;
+  return { value: truncated ? value.slice(0, CALL_CONTENT_LENGTH) : value, truncated };
+}
+
+/** The saved agent a record ran: who it is, its id to copy, and a chat with it one click away. */
+function AgentCard({ agent, agentId }: { agent: RecordPresentation['agent']; agentId: string }) {
+  const localize = useLocalize();
+  const [copied, setCopied] = useState(false);
+  const copyId = () => {
+    copy(agentId);
+    setCopied(true);
+    setTimeout(() => setCopied(false), COPIED_MS);
+  };
+  return (
+    <section className="flex flex-col gap-3">
+      {agent?.description != null && agent.description !== '' && (
+        <p className="text-sm text-text-secondary">{agent.description}</p>
+      )}
+      {agent == null && (
+        <p className="text-sm text-text-secondary">{localize('com_ui_trace_agent_unavailable')}</p>
+      )}
+      <div className="flex items-center gap-1 rounded-lg border border-border-light bg-surface-primary-alt py-0.5 pl-2.5 pr-0.5">
+        <span className="min-w-0 flex-1 select-all truncate font-mono text-xs text-text-secondary">
+          {agentId}
+        </span>
+        <Button
+          size="icon-sm"
+          variant="ghost"
+          onClick={copyId}
+          aria-label={localize(copied ? 'com_ui_copied' : 'com_ui_trace_copy_agent_id')}
+        >
+          {copied ? (
+            <Check className="size-4" aria-hidden="true" />
+          ) : (
+            <Copy className="size-4" aria-hidden="true" />
+          )}
+        </Button>
+      </div>
+      {agent != null && (
+        <Link
+          to={`/c/new?agent_id=${encodeURIComponent(agentId)}`}
+          className={cn(buttonVariants({ variant: 'default', size: 'sm' }), 'self-start')}
+        >
+          <MessageSquare className="size-4" aria-hidden="true" />
+          {localize('com_ui_trace_chat_with_agent')}
+        </Link>
+      )}
+    </section>
+  );
+}
+
+/** A tool round's calls as the chat's own tool cards hold them: no trace read, no content gate. */
+function ToolCalls({
+  calls,
+  mcpIconMap,
+}: {
+  calls: ToolCallView[];
+  mcpIconMap: Map<string, string>;
+}) {
+  const localize = useLocalize();
+  return (
+    <section className="flex flex-col gap-3">
+      {calls.map((call, index) => (
+        <div key={`${call.name}-${index}`} className="flex flex-col gap-1.5">
+          <h4 className="flex items-center gap-1.5 text-sm font-medium">
+            <StackedToolIcons toolNames={[call.name]} mcpIconMap={mcpIconMap} />
+            <span className="min-w-0 truncate">{call.title}</span>
+            {call.caption != null && (
+              <span className="truncate text-xs font-normal text-text-secondary">
+                {call.caption}
+              </span>
+            )}
+          </h4>
+          <ContentBlock label="com_ui_trace_tool_sent" content={toContent(call.input)} />
+          <ContentBlock label="com_ui_trace_tool_returned" content={toContent(call.output)} />
+        </div>
+      ))}
+      <p className="text-xs text-text-secondary">{localize('com_ui_trace_from_conversation')}</p>
+    </section>
+  );
+}
+
 /** Details for the selected record; input and output load only when the deployment allows them. */
 function Inspector({
   node,
+  presentation,
+  mcpIconMap,
+  toolFor,
   turnStart,
   sourceId,
   conversationId,
@@ -122,6 +266,9 @@ function Inspector({
   onClose,
 }: {
   node: TraceNode;
+  presentation: RecordPresentation;
+  mcpIconMap: Map<string, string>;
+  toolFor: ToolFor;
   turnStart: number;
   /** The page source that listed this record. */
   sourceId?: string;
@@ -135,7 +282,7 @@ function Inspector({
   const format = useTraceFormat();
   const headingId = useId();
   const { record } = node;
-  const appearance = KIND_APPEARANCE[record.kind];
+  const appearance = appearanceOf(record);
   const Icon = appearance.icon;
   const { usage } = record;
 
@@ -179,6 +326,25 @@ function Inspector({
     });
   }
 
+  const preview = presentation.calls == null && presentation.preview != null && (
+    <p className="whitespace-pre-wrap break-words rounded-lg border border-border-light bg-surface-primary-alt p-2 text-sm">
+      {presentation.preview}
+    </p>
+  );
+  /** A model call is read as a conversation, which is what the panel is opened for, so it leads. */
+  const leadsWithContent = showContent && record.kind === 'generation';
+  const content = (
+    <RecordContent
+      conversationId={conversationId}
+      recordId={record.id}
+      messageId={record.messageId}
+      sourceId={sourceId}
+      toolFor={toolFor}
+      mcpIconMap={mcpIconMap}
+      placeholder={leadsWithContent ? preview : undefined}
+    />
+  );
+
   return (
     <aside
       aria-labelledby={headingId}
@@ -186,9 +352,21 @@ function Inspector({
       className="flex min-h-0 flex-col border-border-light bg-presentation max-md:absolute max-md:inset-x-0 max-md:bottom-0 max-md:z-20 max-md:max-h-[65%] max-md:rounded-t-2xl max-md:border-t max-md:shadow-lg md:w-[22rem] md:shrink-0 md:border-l"
     >
       <div className="flex items-center gap-2 border-b border-border-light px-3 py-2">
-        <Icon aria-hidden="true" className="size-4 shrink-0 text-text-secondary" />
+        {presentation.agent !== undefined &&
+          renderAgentAvatar(presentation.agent, { size: 'icon', showBorder: false })}
+        {presentation.agent === undefined && presentation.toolNames != null && (
+          <StackedToolIcons toolNames={presentation.toolNames} mcpIconMap={mcpIconMap} />
+        )}
+        {presentation.agent === undefined && presentation.toolNames == null && (
+          <Icon aria-hidden="true" className="size-4 shrink-0 text-text-secondary" />
+        )}
         <h3 id={headingId} className="min-w-0 flex-1 truncate text-sm font-semibold">
-          {record.name}
+          {presentation.title}
+          {presentation.caption != null && (
+            <span className="ml-1.5 text-xs font-normal text-text-secondary">
+              {presentation.caption}
+            </span>
+          )}
         </h3>
         <Button
           size="icon-sm"
@@ -230,6 +408,14 @@ function Inspector({
             {record.statusMessage}
           </p>
         )}
+        {record.agentId != null && presentation.agent !== undefined && (
+          <AgentCard agent={presentation.agent} agentId={record.agentId} />
+        )}
+        {!leadsWithContent && preview}
+        {leadsWithContent && content}
+        {presentation.calls != null && (
+          <ToolCalls calls={presentation.calls} mcpIconMap={mcpIconMap} />
+        )}
         <Section title="com_ui_trace_timing" fields={timing} />
         <Section
           title="com_ui_trace_model"
@@ -241,6 +427,14 @@ function Inspector({
         <Section
           title="com_ui_trace_identifiers"
           fields={[
+            ...(presentation.technicalName != null
+              ? [
+                  {
+                    label: 'com_ui_trace_recorded_as' as const,
+                    value: <span className="font-mono text-xs">{presentation.technicalName}</span>,
+                  },
+                ]
+              : []),
             {
               label: 'com_ui_trace_record_id',
               value: <span className="select-all font-mono text-xs">{record.id}</span>,
@@ -251,17 +445,12 @@ function Inspector({
             },
           ]}
         />
-        {showContent && (
+        {showContent && !leadsWithContent && (
           <section className="flex flex-col gap-2">
             <h4 className="text-xs font-semibold uppercase tracking-wide text-text-secondary">
               {localize('com_ui_trace_content')}
             </h4>
-            <RecordContent
-              conversationId={conversationId}
-              recordId={record.id}
-              messageId={record.messageId}
-              sourceId={sourceId}
-            />
+            {content}
           </section>
         )}
       </div>
diff --git a/client/src/components/Chat/Trace/Ledger.tsx b/client/src/components/Chat/Trace/Ledger.tsx
index e979cc082a0..af2f2ac86fd 100644
--- a/client/src/components/Chat/Trace/Ledger.tsx
+++ b/client/src/components/Chat/Trace/Ledger.tsx
@@ -1,6 +1,7 @@
 import { memo, useId, useMemo, useState } from 'react';
 import { ChevronRight, CircleAlert, CircleDashed } from 'lucide-react';
 import type { RefObject, CSSProperties, KeyboardEvent } from 'react';
+import type { Agent } from 'librechat-data-provider';
 import type {
   TraceRow,
   TraceNode,
@@ -11,13 +12,15 @@ import type {
   TraceScale,
   TraceWindow,
 } from './model';
-import { spanOf, stepSpan, turnSpan, turnKey, boundsOf } from './model';
+import type { RecordPresentation } from './present';
+import StackedToolIcons from '~/components/Chat/Messages/Content/ToolOutput/StackedToolIcons';
+import { spanOf, stepSpan, turnSpan, turnKey, boundsOf, isLabelRecord } from './model';
 import { useTraceFormat, recordDurationText } from './format';
-import { KIND_APPEARANCE, STATUS_LABEL } from './kinds';
+import { appearanceOf, STATUS_LABEL } from './kinds';
+import { cn, renderAgentAvatar } from '~/utils';
 import { formatTokens } from '~/utils/tokens';
 import { useRowWindow } from './virtual';
 import { useLocalize } from '~/hooks';
-import { cn } from '~/utils';
 
 const ROW_HEIGHT = 32;
 const HEADER_HEIGHT = 28;
@@ -47,7 +50,7 @@ function RecordBar({
   domain: Domain;
 }) {
   const { record } = node;
-  const appearance = KIND_APPEARANCE[record.kind];
+  const appearance = appearanceOf(record);
   const solid = record.status === 'error' ? 'bg-status-error' : appearance.bar;
 
   if (scale === 'time' && node.end == null) {
@@ -122,7 +125,12 @@ function Ledger({
   view,
   selectedId,
   treeRef,
-  previewFor,
+  presentFor,
+  askedFor,
+  toolTitleFor,
+  agentOf,
+  unrecordedCalls,
+  mcpIconMap,
   onSelect,
   onToggle,
 }: {
@@ -132,7 +140,15 @@ function Ledger({
   view: TraceWindow | null;
   selectedId: string | null;
   treeRef: RefObject<HTMLDivElement>;
-  previewFor: (node: TraceNode) => string | undefined;
+  presentFor: (node: TraceNode) => RecordPresentation;
+  /** The user message a response answered, which tells one response from another. */
+  askedFor: (messageId: string) => string | undefined;
+  /** A tool's name as the chat's tool cards give it. */
+  toolTitleFor: (name: string) => string;
+  agentOf: (agentId: string) => Agent | undefined;
+  /** Tool calls the trace names no record for, by response, as the chat's messages count them. */
+  unrecordedCalls: ReadonlyMap<string, number>;
+  mcpIconMap: Map<string, string>;
   onSelect: (id: string) => void;
   onToggle: (key: string) => void;
 }) {
@@ -255,25 +271,33 @@ function Ledger({
     />
   );
 
-  const turnSummary = (turn: TraceTurn) =>
-    [
-      localize(turn.steps === 1 ? 'com_ui_trace_steps_count_one' : 'com_ui_trace_steps_count', {
-        count: turn.steps,
-      }),
+  const turnSummary = (turn: TraceTurn) => {
+    const toolCalls = turn.toolCalls + (unrecordedCalls.get(turn.messageId) ?? 0);
+    const asked = askedFor(turn.messageId);
+    /** The counts come first: the question is the part a narrow row can afford to truncate. */
+    return [
       localize(
-        turn.toolCalls === 1
-          ? 'com_ui_trace_tool_calls_count_one'
-          : 'com_ui_trace_tool_calls_count',
-        { count: turn.toolCalls },
+        turn.generations === 1
+          ? 'com_ui_trace_model_calls_count_one'
+          : 'com_ui_trace_model_calls_count',
+        { count: turn.generations },
       ),
+      localize(
+        toolCalls === 1 ? 'com_ui_trace_tool_calls_count_one' : 'com_ui_trace_tool_calls_count',
+        { count: toolCalls },
+      ),
+      ...(asked ? [localize('com_ui_trace_asked', { 0: asked })] : []),
     ].join(' · ');
+  };
 
   const stepDescription = (step: TraceStep) => {
     const names = [...step.toolNames];
     const tools = names
       .slice(0, STEP_TOOL_NAMES)
       .map(([name, count]) =>
-        count > 1 ? localize('com_ui_trace_tool_times', { 0: name, 1: String(count) }) : name,
+        count > 1
+          ? localize('com_ui_trace_tool_times', { 0: toolTitleFor(name), 1: String(count) })
+          : toolTitleFor(name),
       );
     if (names.length > STEP_TOOL_NAMES) {
       tools.push(
@@ -294,6 +318,7 @@ function Ledger({
       span,
       messageId,
       indent,
+      agents = [],
     }: {
       label: string;
       description: string;
@@ -302,6 +327,7 @@ function Ledger({
       span: TraceSpan;
       messageId: string;
       indent: number;
+      agents?: TraceTurn['agents'];
     },
   ) => {
     const active = activeRow?.key === row.key;
@@ -330,7 +356,32 @@ function Ledger({
         <span className="flex min-w-0 items-center gap-1.5" style={{ paddingLeft: indent }}>
           {chevron(row.expanded)}
           <span className="shrink-0 truncate">{label}</span>
-          <span className="min-w-0 truncate font-normal text-text-secondary">{description}</span>
+          {agents.map(({ agentId, recordId }) => {
+            const agent = agentOf(agentId);
+            const name = agent?.name || localize('com_ui_agent');
+            return (
+              <button
+                key={agentId}
+                type="button"
+                aria-label={localize('com_ui_trace_agent_details', { 0: name })}
+                onClick={(event) => {
+                  event.stopPropagation();
+                  onSelect(recordId);
+                }}
+                onKeyDown={(event) => event.stopPropagation()}
+                className={cn(
+                  'flex max-w-[45%] shrink-0 items-center gap-1 rounded-full border border-border-light py-0.5 pl-0.5 pr-2 font-medium hover:bg-surface-hover',
+                  selectedId === recordId && 'bg-surface-active-alt',
+                )}
+              >
+                {renderAgentAvatar(agent ?? null, { size: 'icon', showBorder: false })}
+                <span className="truncate">{name}</span>
+              </button>
+            );
+          })}
+          <span className="min-w-0 shrink-[3] truncate font-normal text-text-secondary">
+            {description}
+          </span>
           {errorCount > 0 && (
             <CircleAlert aria-hidden="true" className="size-3.5 shrink-0 text-status-error" />
           )}
@@ -359,6 +410,7 @@ function Ledger({
         span: turnSpan(turn, scale),
         messageId: turn.messageId,
         indent: 0,
+        agents: turn.agents,
       });
     }
     if (row.type === 'step') {
@@ -381,7 +433,7 @@ function Ledger({
     const { record } = node;
     const active = activeRow?.key === row.key;
     const turnStart = model.turns.find((turn) => turn.messageId === record.messageId)?.start;
-    const appearance = KIND_APPEARANCE[record.kind];
+    const appearance = appearanceOf(record);
     const Icon = appearance.icon;
     const running = record.status === 'running';
     const duration = recordDurationText(node, format, localize(STATUS_LABEL.running));
@@ -389,8 +441,12 @@ function Ledger({
       record.status === 'error' || record.status === 'warning'
         ? `${duration}, ${localize(STATUS_LABEL[record.status])}`
         : duration;
-    const preview = previewFor(node);
-    const name = preview != null ? `${record.name}: ${preview}` : record.name;
+    const presentation = presentFor(node);
+    const { title, caption, preview, technicalName, toolNames } = presentation;
+    const name = [caption != null ? `${title} (${caption})` : title, preview]
+      .filter((part) => part != null)
+      .join(': ');
+    const isLabel = isLabelRecord(record);
 
     return (
       <div
@@ -433,16 +489,47 @@ function Ledger({
           >
             {row.hasChildren && chevron(row.expanded)}
           </span>
-          <Icon aria-hidden="true" className="size-3.5 shrink-0 text-text-secondary" />
-          <span className="min-w-[3ch] max-w-[60%] truncate">{record.name}</span>
+          {presentation.agent !== undefined &&
+            renderAgentAvatar(presentation.agent, { size: 'icon', showBorder: false })}
+          {presentation.agent === undefined && toolNames != null && (
+            <span className="flex shrink-0 items-center">
+              <StackedToolIcons toolNames={toolNames} mcpIconMap={mcpIconMap} />
+            </span>
+          )}
+          {presentation.agent === undefined && toolNames == null && (
+            <Icon aria-hidden="true" className="size-3.5 shrink-0 text-text-secondary" />
+          )}
+          <span
+            className={cn(
+              'max-w-[60%] truncate',
+              isLabel ? 'shrink-0 text-text-secondary' : 'min-w-[3ch] shrink-[0.25]',
+            )}
+          >
+            {title}
+          </span>
+          {caption != null && (
+            <span className="hidden shrink-[2] truncate text-xs text-text-secondary sm:inline">
+              {caption}
+            </span>
+          )}
           {preview != null && (
             <span
-              className="min-w-[4ch] flex-1 truncate text-xs text-text-secondary"
+              className={cn(
+                'min-w-[4ch] shrink-[3] truncate text-xs',
+                isLabel
+                  ? 'rounded-full bg-surface-tertiary px-2 py-0.5 font-medium text-text-primary'
+                  : 'flex-1 text-text-secondary',
+              )}
               title={preview}
             >
               {preview}
             </span>
           )}
+          {model.mode === 'full' && technicalName != null && (
+            <span className="hidden min-w-0 shrink-[6] truncate font-mono text-[11px] text-text-tertiary lg:inline">
+              {technicalName}
+            </span>
+          )}
           {record.model != null && (
             <span className="hidden min-w-0 shrink-[4] truncate text-xs text-text-secondary sm:inline">
               {record.model}
diff --git a/client/src/components/Chat/Trace/Summary.tsx b/client/src/components/Chat/Trace/Summary.tsx
index 6287623643b..862db535802 100644
--- a/client/src/components/Chat/Trace/Summary.tsx
+++ b/client/src/components/Chat/Trace/Summary.tsx
@@ -10,15 +10,22 @@ type SummaryItem = { key: string; label: TranslationKeys; value: string; alert?:
 
 function TraceSummaryBar({
   summary,
+  unrecordedCalls,
   showCost,
   currency,
 }: {
   summary: TraceSummary;
+  /** Tool calls the trace names no record for, by response, as the chat's messages count them. */
+  unrecordedCalls?: ReadonlyMap<string, number>;
   showCost: boolean;
   currency?: { code: string; rate: number };
 }) {
   const localize = useLocalize();
   const format = useTraceFormat();
+  let toolCalls = summary.toolCalls;
+  for (const count of unrecordedCalls?.values() ?? []) {
+    toolCalls += count;
+  }
   const items: SummaryItem[] = [
     {
       key: 'duration',
@@ -31,7 +38,16 @@ function TraceSummaryBar({
       label: 'com_ui_trace_summary_generations',
       value: String(summary.generations),
     },
-    { key: 'tools', label: 'com_ui_trace_summary_tools', value: String(summary.toolCalls) },
+    { key: 'tools', label: 'com_ui_trace_summary_tools', value: String(toolCalls) },
+    ...(summary.labels > 0
+      ? [
+          {
+            key: 'labels',
+            label: 'com_ui_trace_summary_labels' as const,
+            value: String(summary.labels),
+          },
+        ]
+      : []),
     {
       key: 'tokens',
       label: 'com_ui_trace_summary_tokens',
diff --git a/client/src/components/Chat/Trace/Timeline.tsx b/client/src/components/Chat/Trace/Timeline.tsx
index 0e616b24ab0..2c95c252d41 100644
--- a/client/src/components/Chat/Trace/Timeline.tsx
+++ b/client/src/components/Chat/Trace/Timeline.tsx
@@ -13,8 +13,8 @@ import {
   minimumSpan,
   sequenceLane,
 } from './model';
-import { KIND_APPEARANCE } from './kinds';
 import { useTraceFormat } from './format';
+import { appearanceOf } from './kinds';
 import { useLocalize } from '~/hooks';
 import { cn } from '~/utils';
 
@@ -200,7 +200,7 @@ function Timeline({
             const lane = lanes?.get(record.id) ?? sequenceLane(record);
             const y = TOP_PADDING + lane * (LANE_HEIGHT + LANE_GAP);
             const fill =
-              record.status === 'error' ? 'fill-status-error' : KIND_APPEARANCE[record.kind].fill;
+              record.status === 'error' ? 'fill-status-error' : appearanceOf(record).fill;
             if (scale === 'time' && node.end == null) {
               return (
                 <rect
diff --git a/client/src/components/Chat/Trace/Viewer.tsx b/client/src/components/Chat/Trace/Viewer.tsx
index 5a10159cf8e..6530514f184 100644
--- a/client/src/components/Chat/Trace/Viewer.tsx
+++ b/client/src/components/Chat/Trace/Viewer.tsx
@@ -42,9 +42,12 @@ import {
   buildTraceModel,
   collapsibleKeys,
 } from './model';
-import { buildPreviews, buildPreviewIndex } from './preview';
+import { buildPreviews, buildPreviewIndex, buildActivityIndex } from './preview';
+import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
 import { traceModeAtom, traceScaleAtom } from './store';
-import { KIND_APPEARANCE, STATUS_LABEL } from './kinds';
+import { presentTool, presentRecord } from './present';
+import { appearanceOf, STATUS_LABEL } from './kinds';
+import { useAgentsMapContext } from '~/Providers';
 import { useTraceFormat } from './format';
 import { useLocalize } from '~/hooks';
 import Inspector from './Inspector';
@@ -63,6 +66,8 @@ const ERROR_MESSAGES: Partial<Record<TTraceErrorCode, TranslationKeys>> = {
 };
 
 const PRESSED = 'bg-surface-active-alt';
+/** A response's header quotes the question it answered; the row truncates what does not fit. */
+const ASKED_LENGTH = 120;
 
 function errorCodeOf(error: unknown): TTraceErrorCode | undefined {
   return axios.isAxiosError<TTraceErrorResponse>(error)
@@ -170,17 +175,68 @@ export default function Viewer({
     (node: TraceNode) => previewIndex.get(node.record.id),
     [previewIndex],
   );
+  const activity = useMemo(
+    () => buildActivityIndex(model, previews, partialMessageId),
+    [model, previews, partialMessageId],
+  );
+  const agentsMap = useAgentsMapContext();
+  const mcpIconMap = useMCPIconMap();
+  const mcpServerNames = useMCPServerNames();
+  const agentOf = useCallback((agentId: string) => agentsMap?.[agentId], [agentsMap]);
+  const presentFor = useMemo(() => {
+    const sources = { localize, activity, previewOf, mcpServerNames, agentOf };
+    const presented = new Map<string, ReturnType<typeof presentRecord>>();
+    return (node: TraceNode) => {
+      const cached = presented.get(node.record.id);
+      if (cached != null) {
+        return cached;
+      }
+      const presentation = presentRecord(node, sources);
+      presented.set(node.record.id, presentation);
+      return presentation;
+    };
+  }, [localize, activity, previewOf, mcpServerNames, agentOf]);
+  const toolFor = useCallback(
+    (name: string) => presentTool(name, { localize, mcpServerNames }),
+    [localize, mcpServerNames],
+  );
+  const toolTitleFor = useCallback((name: string) => toolFor(name).title, [toolFor]);
+  /** The user message each response answered: what tells one response from another in the ledger. */
+  const askedByResponse = useMemo(() => {
+    const textById = new Map<string, string>();
+    const asked = new Map<string, string>();
+    for (const message of messages ?? []) {
+      if (message.isCreatedByUser) {
+        textById.set(message.messageId, message.text);
+      }
+    }
+    for (const message of messages ?? []) {
+      const text = message.isCreatedByUser
+        ? undefined
+        : textById.get(message.parentMessageId ?? '')?.trim();
+      if (text) {
+        asked.set(message.messageId, text.replace(/\s+/g, ' ').slice(0, ASKED_LENGTH));
+      }
+    }
+    return asked;
+  }, [messages]);
+  const askedFor = useCallback(
+    (messageId: string) => askedByResponse.get(messageId),
+    [askedByResponse],
+  );
   const labelsFor = useCallback(
     (record: TTraceRecord) => {
       const node = model.nodes.get(record.id);
-      const preview = node != null ? previewOf(node) : undefined;
+      const presentation = node != null ? presentFor(node) : undefined;
       return [
-        localize(KIND_APPEARANCE[record.kind].label),
+        localize(appearanceOf(record).label),
         localize(STATUS_LABEL[record.status]),
-        ...(preview != null ? [preview] : []),
+        ...[presentation?.title, presentation?.caption, presentation?.preview].filter(
+          (label): label is string => label != null,
+        ),
       ];
     },
-    [localize, model, previewOf],
+    [localize, model, presentFor],
   );
   const rows = useMemo(
     () => flattenRows(model, { collapsed, query: deferredQuery, window: view, scale, labelsFor }),
@@ -193,7 +249,11 @@ export default function Viewer({
   useEffect(() => {
     const previous = previousModel.current;
     previousModel.current = model;
-    setSelectedId((id) => (id != null && model.nodes.get(id)?.shown !== true ? null : id));
+    /** An agent is opened from its response's header, which lists it whether or not the mode does. */
+    setSelectedId((id) => {
+      const node = id != null ? model.nodes.get(id) : undefined;
+      return node != null && (node.shown || node.record.role === 'agent') ? id : null;
+    });
     setView((current) =>
       current != null ? rebaseWindow(current, previous, model, scale) : current,
     );
@@ -350,7 +410,12 @@ export default function Viewer({
       <>
         <div className="flex flex-col gap-3 border-b border-border-light px-3 py-3 md:px-4">
           <div className="flex flex-wrap items-center justify-between gap-2">
-            <Summary summary={model.summary} showCost={showCost} currency={currency} />
+            <Summary
+              summary={model.summary}
+              unrecordedCalls={activity.unrecordedCalls}
+              showCost={showCost}
+              currency={currency}
+            />
             {recordsQuery.hasNextPage === true && (
               <p className="text-xs text-text-secondary">
                 {localize('com_ui_trace_partial', { 0: String(records.length) })}
@@ -460,7 +525,12 @@ export default function Viewer({
                 view={view}
                 selectedId={selectedId}
                 treeRef={treeRef}
-                previewFor={previewOf}
+                presentFor={presentFor}
+                askedFor={askedFor}
+                toolTitleFor={toolTitleFor}
+                agentOf={agentOf}
+                unrecordedCalls={activity.unrecordedCalls}
+                mcpIconMap={mcpIconMap}
                 onSelect={setSelectedId}
                 onToggle={toggle}
               />
@@ -505,6 +575,9 @@ export default function Viewer({
           {selectedNode && (
             <Inspector
               node={selectedNode}
+              presentation={presentFor(selectedNode)}
+              mcpIconMap={mcpIconMap}
+              toolFor={toolFor}
               turnStart={selectedTurnStart}
               sourceId={recordSources.get(selectedNode.record.id)}
               conversationId={conversationId}
diff --git a/client/src/components/Chat/Trace/__tests__/Viewer.test.tsx b/client/src/components/Chat/Trace/__tests__/Viewer.test.tsx
index ea2a8e72d90..f02436fb71f 100644
--- a/client/src/components/Chat/Trace/__tests__/Viewer.test.tsx
+++ b/client/src/components/Chat/Trace/__tests__/Viewer.test.tsx
@@ -1,11 +1,19 @@
 import React from 'react';
 import { Provider } from 'jotai';
+import { MemoryRouter } from 'react-router-dom';
 import userEvent from '@testing-library/user-event';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { ContentTypes, QueryKeys, dataService } from 'librechat-data-provider';
 import { act, render, screen, waitFor, within, fireEvent } from '@testing-library/react';
-import type { TMessage, TTracePage, TTraceRecord, TStartupConfig } from 'librechat-data-provider';
+import type {
+  TMessage,
+  TAgentsMap,
+  TTracePage,
+  TTraceRecord,
+  TStartupConfig,
+} from 'librechat-data-provider';
 import { keepNewestTracePage } from '~/data-provider/Traces/queries';
+import { AgentsMapContext } from '~/Providers/AgentsMapContext';
 import Viewer from '../Viewer';
 
 jest.mock('librechat-data-provider', () => {
@@ -141,14 +149,16 @@ describe('Trace Viewer', () => {
     expect(screen.getByRole('status')).toHaveTextContent('com_ui_trace_loading');
     expect(await recordRow('llm')).toHaveAttribute('aria-level', '3');
     expect(
-      screen.getByRole('treeitem', { name: recordName('web_search.*com_ui_trace_status_error') }),
+      screen.getByRole('treeitem', {
+        name: recordName('com_ui_tool_name_web_search.*com_ui_trace_status_error'),
+      }),
     ).toBeInTheDocument();
     const turn = screen.getByRole('treeitem', { name: /^com_ui_trace_turn/ });
     expect(turn).toHaveAttribute('aria-level', '1');
-    expect(turn).toHaveAccessibleName(/com_ui_trace_steps_count_one 1/);
+    expect(turn).toHaveAccessibleName(/com_ui_trace_model_calls_count_one 1/);
     expect(turn).toHaveAccessibleName(/com_ui_trace_tool_calls_count_one 1/);
     expect(stepRow(1)).toHaveAttribute('aria-level', '2');
-    expect(stepRow(1)).toHaveAccessibleName(/web_search/);
+    expect(stepRow(1)).toHaveAccessibleName(/com_ui_tool_name_web_search/);
     expect(
       screen.queryByRole('treeitem', { name: recordName('AgentGraph') }),
     ).not.toBeInTheDocument();
@@ -297,7 +307,9 @@ describe('Trace Viewer', () => {
 
     expect(await recordRow('llm: Let me look that up\\.')).toBeInTheDocument();
     expect(
-      screen.getByRole('treeitem', { name: recordName('web_search: query: weather') }),
+      screen.getByRole('treeitem', {
+        name: recordName('com_ui_tool_name_web_search: query: weather'),
+      }),
     ).toBeInTheDocument();
     expect(dataService.getMessagesByConvoId).not.toHaveBeenCalled();
   });
@@ -403,7 +415,7 @@ describe('Trace Viewer', () => {
   it('shows the error message for a failed record', async () => {
     renderViewer();
 
-    await userEvent.click(await recordRow('web_search'));
+    await userEvent.click(await recordRow('com_ui_tool_name_web_search'));
 
     expect(
       within(screen.getByTestId('trace-inspector')).getByText('Error: search backend unavailable'),
@@ -444,7 +456,9 @@ describe('Trace Viewer', () => {
       expect(screen.queryByRole('treeitem', { name: recordName('llm') })).not.toBeInTheDocument(),
     );
     expect(stepRow(1)).toBeInTheDocument();
-    expect(screen.getByRole('treeitem', { name: recordName('web_search') })).toBeInTheDocument();
+    expect(
+      screen.getByRole('treeitem', { name: recordName('com_ui_tool_name_web_search') }),
+    ).toBeInTheDocument();
 
     await userEvent.clear(screen.getByLabelText('com_ui_trace_search'));
     await userEvent.type(screen.getByLabelText('com_ui_trace_search'), 'nothing matches');
@@ -706,11 +720,11 @@ describe('Trace Viewer', () => {
       within(screen.getByTestId('trace-inspector')).getByRole('heading', { level: 3 });
 
     await userEvent.click(await screen.findByRole('button', { name: 'com_ui_trace_load_older' }));
-    await userEvent.click(await recordRow('web_search'));
+    await userEvent.click(await recordRow('com_ui_tool_name_web_search'));
     act(() => keepNewestTracePage(client, 'convo-1'));
 
     expect(await screen.findByRole('button', { name: 'com_ui_trace_load_older' })).toBeVisible();
-    expect(inspectorHeading()).toHaveTextContent('web_search');
+    expect(inspectorHeading()).toHaveTextContent('com_ui_tool_name_web_search');
 
     await userEvent.click(screen.getByRole('button', { name: 'com_ui_trace_load_older' }));
     await userEvent.click(toggle('com_ui_trace_all_spans'));
@@ -860,4 +874,192 @@ describe('Trace Viewer', () => {
 
     expect(screen.getByRole('button', { name: 'com_ui_trace_close' })).toHaveFocus();
   });
+
+  describe('a run as the agents SDK records it', () => {
+    const scout = { id: 'agent_scout', name: 'Codebase Scout', description: 'Reads the repo.' };
+    const sdkRecords: TTraceRecord[] = [
+      record({ id: 'run', kind: 'agent', role: 'run', name: 'AgentGraph', endTime: at(5000) }),
+      record({
+        id: 'scout',
+        parentId: 'run',
+        role: 'agent',
+        agentId: 'agent_scout',
+        name: 'agent_scout',
+        endTime: at(5000),
+      }),
+      record({
+        id: 'llm-1',
+        parentId: 'scout',
+        kind: 'generation',
+        role: 'model',
+        name: 'llm',
+        startTime: at(100),
+      }),
+      record({
+        id: 'label-1',
+        parentId: 'scout',
+        kind: 'generation',
+        role: 'stepLabel',
+        name: 'StepLabel',
+        startTime: at(1050),
+      }),
+      record({
+        id: 'round-1',
+        parentId: 'scout',
+        role: 'tools',
+        name: 'tool-dispatch',
+        startTime: at(1100),
+        endTime: at(2000),
+      }),
+      record({
+        id: 'llm-2',
+        parentId: 'scout',
+        kind: 'generation',
+        role: 'model',
+        name: 'llm',
+        startTime: at(2100),
+      }),
+    ];
+    const messages = [
+      {
+        messageId: 'user-1',
+        conversationId: 'convo-1',
+        parentMessageId: null,
+        isCreatedByUser: true,
+        text: 'Where does the  trace viewer\nread from?',
+      },
+      {
+        ...responseMessage,
+        content: [
+          { type: ContentTypes.TEXT, text: 'Let me look that up.' },
+          { type: ContentTypes.ACTIVITY_LABEL, activity_label: 'Finding the trace reader' },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: { name: 'web_search', args: { query: 'weather' }, output: 'Sunny.' },
+          },
+          { type: ContentTypes.TEXT, text: 'It reads from Langfuse.' },
+        ],
+      },
+    ] as unknown as TMessage[];
+
+    function renderSdkRun() {
+      jest
+        .spyOn(dataService, 'getConversationTraceRecords')
+        .mockResolvedValue({ records: sdkRecords, sourceId: 'tenant-project' });
+      const client = new QueryClient({
+        defaultOptions: { queries: { retry: false } },
+        logger: { log: () => undefined, warn: () => undefined, error: () => undefined },
+      });
+      client.setQueryData([QueryKeys.messages, 'convo-1'], messages);
+      return render(
+        <MemoryRouter>
+          <Provider>
+            <QueryClientProvider client={client}>
+              <AgentsMapContext.Provider value={{ agent_scout: scout } as unknown as TAgentsMap}>
+                <Viewer conversationId="convo-1" onClose={jest.fn()} />
+              </AgentsMapContext.Provider>
+            </QueryClientProvider>
+          </Provider>
+        </MemoryRouter>,
+      );
+    }
+
+    it('reads as the chat does: the question, the model, the label it showed and the tools it ran', async () => {
+      renderSdkRun();
+
+      expect(await recordRow('com_ui_model: Let me look that up\\.')).toBeInTheDocument();
+      const turn = screen.getByRole('treeitem', { name: /^com_ui_trace_turn/ });
+      expect(turn).toHaveAccessibleName(/Where does the trace viewer read from\?/);
+      expect(turn).toHaveAccessibleName(/com_ui_trace_model_calls_count 2/);
+      expect(turn).toHaveAccessibleName(/com_ui_trace_tool_calls_count_one 1/);
+      expect(
+        screen.getByRole('treeitem', {
+          name: recordName('com_ui_trace_role_step_label: Finding the trace reader'),
+        }),
+      ).toBeInTheDocument();
+      expect(screen.queryByRole('treeitem', { name: /tool-dispatch|StepLabel/ })).toBeNull();
+      const summary = screen.getByLabelText('com_ui_trace_summary');
+      expect(within(summary).getByText('com_ui_trace_summary_tools').nextSibling).toHaveTextContent(
+        '1',
+      );
+
+      await userEvent.click(await recordRow('com_ui_tool_name_web_search: query: weather'));
+
+      const inspector = screen.getByTestId('trace-inspector');
+      expect(within(inspector).getByText(/"query": "weather"/)).toBeInTheDocument();
+      expect(within(inspector).getByText('Sunny.')).toBeInTheDocument();
+      expect(within(inspector).getByText('tool-dispatch')).toBeInTheDocument();
+      expect(dataService.getConversationTraceRecord).not.toHaveBeenCalled();
+    });
+
+    it('shows a model call as a conversation, newest messages open, with the raw form one click away', async () => {
+      mockStartupConfig = {
+        interface: { traceViewer: { enabled: true, showInputOutput: true } },
+      };
+      const content = (value: string) => ({ value, truncated: false });
+      jest.spyOn(dataService, 'getConversationTraceRecord').mockResolvedValue({
+        record: sdkRecords[2],
+        contentAvailable: true,
+        input: { value: '{"messages":[{"role":"sys', truncated: true },
+        prompt: {
+          total: 40,
+          omitted: 37,
+          tools: ['web_search', 'read_file'],
+          messages: [
+            { role: 'system', text: content('You are Codebase Scout.') },
+            { role: 'user', text: content('Where does it read from?') },
+            { role: 'tool', toolName: 'web_search', text: content('ten results') },
+          ],
+        },
+        reply: {
+          role: 'assistant',
+          text: content('Let me look that up.'),
+          toolCalls: [{ name: 'web_search', args: content('{"query":"weather"}') }],
+        },
+      });
+      renderSdkRun();
+
+      await userEvent.click(await recordRow('com_ui_model: Let me look that up\\.'));
+
+      const inspector = screen.getByTestId('trace-inspector');
+      expect(await within(inspector).findByText('com_ui_trace_reply')).toBeInTheDocument();
+      expect(within(inspector).getByText('Where does it read from?')).toBeVisible();
+      expect(within(inspector).getByText('com_ui_trace_prompt_omitted 37')).toBeInTheDocument();
+      expect(
+        within(inspector).getByText('com_ui_trace_message_tool com_ui_tool_name_web_search'),
+      ).toBeInTheDocument();
+      expect(
+        within(inspector).getByText('com_ui_trace_message_asked_tool com_ui_tool_name_web_search'),
+      ).toBeInTheDocument();
+      expect(
+        within(inspector).getByText('You are Codebase Scout.').closest('details'),
+      ).not.toHaveAttribute('open');
+      expect(within(inspector).queryByText(/"messages":\[/)).not.toBeInTheDocument();
+
+      await userEvent.click(
+        within(inspector).getByRole('button', { name: 'com_ui_trace_view_raw' }),
+      );
+
+      expect(within(inspector).getByText(/"messages":\[/)).toBeInTheDocument();
+      expect(within(inspector).queryByText('com_ui_trace_reply')).not.toBeInTheDocument();
+    });
+
+    it('shows the agent by name with its id to copy and a chat one click away', async () => {
+      renderSdkRun();
+      await recordRow('com_ui_model: Let me look that up\\.');
+
+      await userEvent.click(toggle('com_ui_trace_all_spans'));
+      await userEvent.click(await recordRow('Codebase Scout'));
+
+      const inspector = screen.getByTestId('trace-inspector');
+      expect(within(inspector).getByText('Reads the repo.')).toBeInTheDocument();
+      expect(within(inspector).getByText('agent_scout', { selector: '.select-all' })).toBeVisible();
+      expect(
+        within(inspector).getByRole('link', { name: 'com_ui_trace_chat_with_agent' }),
+      ).toHaveAttribute('href', '/c/new?agent_id=agent_scout');
+      expect(
+        within(inspector).getByRole('button', { name: 'com_ui_trace_copy_agent_id' }),
+      ).toBeInTheDocument();
+    });
+  });
 });
diff --git a/client/src/components/Chat/Trace/__tests__/model.test.ts b/client/src/components/Chat/Trace/__tests__/model.test.ts
index 24d875169d4..822c33159f9 100644
--- a/client/src/components/Chat/Trace/__tests__/model.test.ts
+++ b/client/src/components/Chat/Trace/__tests__/model.test.ts
@@ -234,6 +234,7 @@ describe('buildTraceModel', () => {
       duration: 4000,
       turns: 1,
       generations: 2,
+      labels: 0,
       toolCalls: 1,
       errors: 1,
       running: 0,
@@ -882,3 +883,87 @@ describe('lanes', () => {
     expect(sequenceLane(record({ id: 'e', kind: 'event' }))).toBe(2);
   });
 });
+
+/** A response as the agents SDK exports it: wrappers around each model call, tool rounds the host ran, label calls. */
+const sdkRun: TTraceRecord[] = [
+  record({ id: 'run', kind: 'agent', role: 'run', name: 'AgentGraph', endTime: at(9000) }),
+  record({
+    id: 'scout',
+    parentId: 'run',
+    role: 'agent',
+    agentId: 'agent_scout',
+    name: 'agent_scout',
+    endTime: at(9000),
+  }),
+  record({ id: 'graph', parentId: 'scout', kind: 'agent', role: 'run', name: 'AgentGraph' }),
+  record({ id: 'node-1', parentId: 'graph', kind: 'agent', role: 'plumbing', name: 'agent' }),
+  record({
+    id: 'llm-1',
+    parentId: 'node-1',
+    kind: 'generation',
+    role: 'model',
+    name: 'llm',
+    startTime: at(100),
+    endTime: at(1000),
+    usage: { input: 100, output: 10, total: 110 },
+  }),
+  record({
+    id: 'label-1',
+    parentId: 'graph',
+    kind: 'generation',
+    role: 'stepLabel',
+    name: 'StepLabel',
+    startTime: at(1050),
+    endTime: at(1400),
+    usage: { input: 20, output: 5, total: 25 },
+  }),
+  record({
+    id: 'round-1',
+    parentId: 'graph',
+    role: 'tools',
+    name: 'tool-dispatch',
+    startTime: at(1100),
+    endTime: at(3000),
+  }),
+  record({ id: 'node-2', parentId: 'graph', kind: 'agent', role: 'plumbing', name: 'agent' }),
+  record({
+    id: 'llm-2',
+    parentId: 'node-2',
+    kind: 'generation',
+    role: 'model',
+    name: 'llm',
+    startTime: at(3100),
+    endTime: at(4000),
+    usage: { input: 200, output: 20, total: 220 },
+  }),
+];
+
+describe('roles', () => {
+  const model = buildTraceModel(sdkRun, 'simple');
+  const [turn] = model.turns;
+
+  it('counts a label call as spend, never as a model call or a step of the response', () => {
+    expect(turn.steps).toBe(2);
+    expect(turn.generations).toBe(2);
+    expect(turn.labels).toBe(1);
+    expect(model.summary).toMatchObject({ generations: 2, labels: 1, totalTokens: 355 });
+  });
+
+  it('lists a tool round the host ran and the label beside the model call that led to them', () => {
+    const first = model.steps.get(turn.stepKeys[0]);
+    expect(first?.generationId).toBe('llm-1');
+    expect(first?.rootIds).toEqual(['llm-1', 'label-1', 'round-1']);
+    expect(model.nodes.get('round-1')?.shown).toBe(true);
+    expect(model.nodes.get('node-1')?.shown).toBe(false);
+    expect(sequenceLane(sdkRun[6])).toBe(1);
+    expect(sequenceLane(sdkRun[5])).toBe(2);
+  });
+
+  it('stamps every record beneath a saved agent with that agent', () => {
+    expect(model.nodes.get('llm-2')?.agentId).toBe('agent_scout');
+    expect(model.nodes.get('round-1')?.agentId).toBe('agent_scout');
+    expect(model.nodes.get('run')?.agentId).toBeUndefined();
+    expect(model.steps.get(turn.stepKeys[1])?.agentId).toBe('agent_scout');
+    expect(turn.agents).toEqual([{ agentId: 'agent_scout', recordId: 'scout' }]);
+  });
+});
diff --git a/client/src/components/Chat/Trace/__tests__/present.test.ts b/client/src/components/Chat/Trace/__tests__/present.test.ts
new file mode 100644
index 00000000000..8c94ce43f7b
--- /dev/null
+++ b/client/src/components/Chat/Trace/__tests__/present.test.ts
@@ -0,0 +1,178 @@
+import { ContentTypes } from 'librechat-data-provider';
+import type { Agent, TMessage, TTraceRecord } from 'librechat-data-provider';
+import type { PresentationSources } from '../present';
+import { buildPreviews, buildActivityIndex } from '../preview';
+import { presentRecord } from '../present';
+import { buildTraceModel } from '../model';
+
+const BASE = Date.UTC(2026, 8, 12, 11, 30, 0);
+const at = (offsetMs: number) => new Date(BASE + offsetMs).toISOString();
+
+function record(overrides: Partial<TTraceRecord> & Pick<TTraceRecord, 'id'>): TTraceRecord {
+  return {
+    traceId: 'trace-1',
+    messageId: 'response-1',
+    parentId: null,
+    kind: 'span',
+    name: overrides.id,
+    startTime: at(0),
+    endTime: at(1000),
+    status: 'ok',
+    ...overrides,
+  };
+}
+
+const generation = (id: string, role: TTraceRecord['role'], name: string, start: number) =>
+  record({ id, parentId: 'scout', kind: 'generation', role, name, startTime: at(start) });
+const round = (id: string, start: number) =>
+  record({ id, parentId: 'scout', role: 'tools', name: 'tool-dispatch', startTime: at(start) });
+
+const records: TTraceRecord[] = [
+  record({ id: 'run', kind: 'agent', role: 'run', name: 'AgentGraph' }),
+  record({
+    id: 'scout',
+    parentId: 'run',
+    role: 'agent',
+    agentId: 'agent_scout',
+    name: 'agent_scout',
+  }),
+  generation('llm-1', 'model', 'llm', 100),
+  generation('label-1', 'stepLabel', 'StepLabel', 1050),
+  round('paused', 1100),
+  round('round-1', 1500),
+  generation('llm-2', 'model', 'llm', 3000),
+  round('round-2', 4000),
+  generation('llm-3', 'model', 'llm', 5000),
+];
+
+const response = {
+  messageId: 'response-1',
+  conversationId: 'convo-1',
+  parentMessageId: 'user-1',
+  isCreatedByUser: false,
+  text: '',
+  content: [
+    { type: ContentTypes.TEXT, text: 'Looking.' },
+    { type: ContentTypes.ACTIVITY_LABEL, activity_label: 'Finding the trace reader' },
+    {
+      type: ContentTypes.TOOL_CALL,
+      tool_call: { name: 'web_search', args: { query: 'langfuse' }, output: 'ten results' },
+    },
+    {
+      type: ContentTypes.TOOL_CALL,
+      tool_call: { name: 'search_code_mcp_github', args: { q: 'TraceReader' } },
+    },
+    { type: ContentTypes.TEXT, text: 'One more.' },
+    { type: ContentTypes.TOOL_CALL, tool_call: { name: 'read_file', args: { path: 'a.ts' } } },
+    { type: ContentTypes.TEXT, text: 'Done.' },
+  ],
+} as unknown as TMessage;
+
+const scout = { id: 'agent_scout', name: 'Codebase Scout', model: 'claude-opus-5' } as Agent;
+
+function present(messages: TMessage[], agents: Record<string, Agent> = { agent_scout: scout }) {
+  const model = buildTraceModel(records, 'full');
+  const activity = buildActivityIndex(model, buildPreviews(messages));
+  const sources: PresentationSources = {
+    localize: (key, values) => (values ? `${key} ${Object.values(values).join(' ')}` : key),
+    activity,
+    previewOf: () => undefined,
+    agentOf: (agentId) => agents[agentId],
+    mcpServerNames: ['github'],
+  };
+  const of = (id: string) => {
+    const node = model.nodes.get(id);
+    if (node == null) {
+      throw new Error(`no record ${id}`);
+    }
+    return presentRecord(node, sources);
+  };
+  return { activity, of };
+}
+
+describe('buildActivityIndex', () => {
+  it("gives a round's calls to the tool round that ran them, not the one an approval paused", () => {
+    const { activity } = present([response]);
+
+    expect(activity.calls.get('paused')).toBeUndefined();
+    expect(activity.calls.get('round-1')?.map((call) => call.name)).toEqual([
+      'web_search',
+      'search_code_mcp_github',
+    ]);
+    expect(activity.calls.get('round-1')?.[0]).toMatchObject({
+      args: 'query: langfuse',
+      input: '{"query":"langfuse"}',
+      output: 'ten results',
+    });
+    expect(activity.calls.get('round-2')?.map((call) => call.name)).toEqual(['read_file']);
+    expect(activity.unrecordedCalls.get('response-1')).toBe(3);
+  });
+
+  it('pairs a label with the model call that wrote it only while the counts agree', () => {
+    expect(present([response]).activity.labels.get('label-1')).toBe('Finding the trace reader');
+
+    const twoLabels = {
+      ...response,
+      content: [
+        ...(response.content ?? []),
+        { type: ContentTypes.ACTIVITY_LABEL, activity_label: 'Another' },
+      ],
+    } as TMessage;
+    expect(present([twoLabels]).activity.labels.size).toBe(0);
+  });
+
+  it('attributes nothing when the message and the trace disagree on the rounds', () => {
+    const short = { ...response, content: response.content?.slice(0, 4) } as TMessage;
+    const { activity } = present([short]);
+
+    expect(activity.calls.size).toBe(0);
+    expect(activity.unrecordedCalls.size).toBe(0);
+  });
+});
+
+describe('presentRecord', () => {
+  it("reads a record in the chat's words and keeps the recorded name for the details", () => {
+    const { of } = present([response]);
+
+    expect(of('llm-1')).toMatchObject({ title: 'com_ui_model', technicalName: 'llm' });
+    expect(of('run')).toMatchObject({
+      title: 'com_ui_trace_role_run',
+      technicalName: 'AgentGraph',
+    });
+    expect(of('label-1')).toMatchObject({
+      title: 'com_ui_trace_role_step_label',
+      preview: 'Finding the trace reader',
+    });
+    expect(of('scout')).toMatchObject({
+      title: 'Codebase Scout',
+      caption: 'claude-opus-5',
+      agent: scout,
+    });
+  });
+
+  it('names a tool round by its tools, as the chat names them', () => {
+    const { of } = present([response]);
+
+    expect(of('round-1')).toMatchObject({
+      title: 'com_ui_trace_role_tools_count 2',
+      preview: 'com_ui_tool_name_web_search, search_code',
+      toolNames: ['web_search', 'search_code_mcp_github'],
+    });
+    expect(of('round-1').calls?.[1]).toMatchObject({ title: 'search_code', caption: 'github' });
+    expect(of('round-2')).toMatchObject({
+      title: 'com_ui_tool_name_read_file',
+      preview: 'path: a.ts',
+    });
+    expect(of('paused')).toEqual({
+      title: 'com_ui_trace_role_tools',
+      technicalName: 'tool-dispatch',
+    });
+  });
+
+  it('keeps the agent row when the agent can no longer be loaded', () => {
+    expect(present([response], {}).of('scout')).toMatchObject({
+      title: 'com_ui_agent',
+      agent: null,
+    });
+  });
+});
diff --git a/client/src/components/Chat/Trace/__tests__/preview.test.ts b/client/src/components/Chat/Trace/__tests__/preview.test.ts
index 8888bce1637..d9a7355dcf4 100644
--- a/client/src/components/Chat/Trace/__tests__/preview.test.ts
+++ b/client/src/components/Chat/Trace/__tests__/preview.test.ts
@@ -66,9 +66,17 @@ describe('buildStepPreviews', () => {
       {
         text: 'Let me check the weather for you.',
         toolCalls: [
-          { name: 'web_search', args: 'query: weather in Paris, limit: 3' },
-          { name: 'web_search', args: 'query: weather in Lyon' },
-          { name: 'read_file', args: 'path: notes.md' },
+          {
+            name: 'web_search',
+            args: 'query: weather in Paris, limit: 3',
+            input: '{"query":"weather in Paris","limit":3}',
+          },
+          {
+            name: 'web_search',
+            args: 'query: weather in Lyon',
+            input: '{"query":"weather in Lyon"}',
+          },
+          { name: 'read_file', args: 'path: notes.md', input: '{"path":"notes.md"}' },
         ],
       },
       { text: 'Paris is sunny, Lyon is not.', toolCalls: [] },
@@ -95,11 +103,11 @@ describe('buildStepPreviews', () => {
       {
         text: '',
         toolCalls: [
-          { name: 'ls', args: '' },
-          { name: 'cat', args: 'path: a' },
+          { name: 'ls', args: '', input: '{}' },
+          { name: 'cat', args: 'path: a', input: '{"path":"a"}' },
         ],
       },
-      { text: '', toolCalls: [{ name: 'cat', args: 'path: b' }] },
+      { text: '', toolCalls: [{ name: 'cat', args: 'path: b', input: '{"path":"b"}' }] },
       { text: 'Both read.', toolCalls: [] },
     ]);
   });
@@ -114,8 +122,8 @@ describe('buildStepPreviews', () => {
     } as Partial<TMessage>);
 
     expect(buildStepPreviews(rounds)).toEqual([
-      { text: '', toolCalls: [{ name: 'ls', args: '' }] },
-      { text: '', toolCalls: [{ name: 'cat', args: 'path: a' }] },
+      { text: '', toolCalls: [{ name: 'ls', args: '', input: '{}' }] },
+      { text: '', toolCalls: [{ name: 'cat', args: 'path: a', input: '{"path":"a"}' }] },
     ]);
   });
 
@@ -132,7 +140,7 @@ describe('buildStepPreviews', () => {
     expect(buildStepPreviews(compacted)).toEqual([
       { text: 'Before.', toolCalls: [] },
       { text: '', toolCalls: [] },
-      { text: '', toolCalls: [{ name: 'ls', args: '' }] },
+      { text: '', toolCalls: [{ name: 'ls', args: '', input: '{}' }] },
       { text: 'After.', toolCalls: [] },
     ]);
   });
@@ -376,7 +384,7 @@ describe('buildPreviewIndex', () => {
     );
 
     expect(handoff).toEqual([
-      { text: 'Agent A.', toolCalls: [{ name: 'ls', args: '' }] },
+      { text: 'Agent A.', toolCalls: [{ name: 'ls', args: '', input: '{}' }] },
       { text: 'Agent B.', toolCalls: [] },
     ]);
   });
diff --git a/client/src/components/Chat/Trace/kinds.ts b/client/src/components/Chat/Trace/kinds.ts
index 3f1e047f9b1..45deb32ac84 100644
--- a/client/src/components/Chat/Trace/kinds.ts
+++ b/client/src/components/Chat/Trace/kinds.ts
@@ -1,5 +1,5 @@
-import { Bot, Zap, Wrench, Sparkles, Workflow } from 'lucide-react';
-import type { TTraceRecordKind, TTraceStatus } from 'librechat-data-provider';
+import { Bot, Tag, Zap, Wrench, Sparkles, Workflow } from 'lucide-react';
+import type { TTraceRecord, TTraceRecordKind, TTraceStatus } from 'librechat-data-provider';
 import type { LucideIcon } from 'lucide-react';
 import type { TranslationKeys } from '~/hooks';
 
@@ -51,6 +51,29 @@ export const KIND_APPEARANCE: Record<TTraceRecordKind, KindAppearance> = {
   },
 };
 
+const LABEL_APPEARANCE: KindAppearance = {
+  icon: Tag,
+  label: 'com_ui_trace_kind_label',
+  bar: 'bg-series-4',
+  tint: 'bg-series-4/30',
+  fill: 'fill-series-4',
+};
+
+/** A record's role says more than its kind: a tool round is recorded as a plain span, a label as a model call. */
+const ROLE_APPEARANCE: Partial<Record<NonNullable<TTraceRecord['role']>, KindAppearance>> = {
+  tools: KIND_APPEARANCE.tool,
+  agent: KIND_APPEARANCE.agent,
+  stepLabel: LABEL_APPEARANCE,
+  reasoningLabel: LABEL_APPEARANCE,
+  phaseLabel: LABEL_APPEARANCE,
+};
+
+export function appearanceOf(record: Pick<TTraceRecord, 'kind' | 'role'>): KindAppearance {
+  return (
+    (record.role != null ? ROLE_APPEARANCE[record.role] : undefined) ?? KIND_APPEARANCE[record.kind]
+  );
+}
+
 export const STATUS_LABEL: Record<TTraceStatus, TranslationKeys> = {
   ok: 'com_ui_trace_status_ok',
   running: 'com_ui_trace_status_running',
diff --git a/client/src/components/Chat/Trace/model.ts b/client/src/components/Chat/Trace/model.ts
index c291567b9f9..568725a836c 100644
--- a/client/src/components/Chat/Trace/model.ts
+++ b/client/src/components/Chat/Trace/model.ts
@@ -29,6 +29,8 @@ export type TraceNode = {
   stepKey: string | null;
   /** Order among shown records: the record's position on the sequence scale. */
   sequence: number;
+  /** The saved agent the record ran under: its nearest `agent` ancestor's. */
+  agentId?: string;
 };
 
 export type TraceStep = {
@@ -38,6 +40,7 @@ export type TraceStep = {
   index: number;
   origin: 'run' | 'title';
   generationId: string | null;
+  agentId?: string;
   rootIds: string[];
   start: number;
   end: number;
@@ -61,7 +64,11 @@ export type TraceTurn = {
   recordCount: number;
   errorCount: number;
   generations: number;
+  /** Model calls that wrote an activity label; they are spend, not work of the response. */
+  labels: number;
   toolCalls: number;
+  /** Saved agents that ran in the response, each with the record that stands for it. */
+  agents: Array<{ agentId: string; recordId: string }>;
   sequence: TraceSpan;
 };
 
@@ -69,6 +76,7 @@ export type TraceSummary = {
   duration: number;
   turns: number;
   generations: number;
+  labels: number;
   toolCalls: number;
   errors: number;
   running: number;
@@ -117,6 +125,7 @@ const EMPTY_SUMMARY: TraceSummary = {
   duration: 0,
   turns: 0,
   generations: 0,
+  labels: 0,
   toolCalls: 0,
   errors: 0,
   running: 0,
@@ -151,11 +160,32 @@ const byStart = (nodes: Map<string, TraceNode>) => (a: string, b: string) => {
   );
 };
 
+const LABEL_ROLES: ReadonlySet<TTraceRecord['role']> = new Set([
+  'stepLabel',
+  'reasoningLabel',
+  'phaseLabel',
+]);
+
+/** A model call that wrote one of the activity labels the chat shows while a response runs. */
+export function isLabelRecord(record: TTraceRecord): boolean {
+  return LABEL_ROLES.has(record.role);
+}
+
+/** A model call of the response itself: it starts a step, and the chat's message describes it. */
+export function isModelCall(record: TTraceRecord): boolean {
+  return record.kind === 'generation' && !isLabelRecord(record);
+}
+
+/** A tool, or the round of tool calls a host ran without recording each one. */
+export function isToolWork(record: TTraceRecord): boolean {
+  return record.kind === 'tool' || record.role === 'tools';
+}
+
 /** The records the simple mode lists: what the model did, anything that failed, and the title run. */
 function isSimpleRecord(record: TTraceRecord): boolean {
   return (
     record.kind === 'generation' ||
-    record.kind === 'tool' ||
+    isToolWork(record) ||
     record.status === 'error' ||
     record.origin === 'title'
   );
@@ -163,7 +193,7 @@ function isSimpleRecord(record: TTraceRecord): boolean {
 
 /** The records others hang from: what the model called. A failed wrapper stays visible but holds nothing. */
 function isStepAnchor(record: TTraceRecord): boolean {
-  return record.kind === 'generation' || record.kind === 'tool';
+  return record.kind === 'generation' || isToolWork(record);
 }
 
 function toNode(record: TTraceRecord): TraceNode | null {
@@ -395,11 +425,15 @@ function groupSteps(
     const latestByLane = new Map<string, { rootIds: string[]; lane: string }>();
     let leading: string[] = [];
     for (const id of roots) {
-      const kind = nodes.get(id)?.record.kind;
+      const record = nodes.get(id)?.record;
       const lane = laneOf(id);
       const current = groups[groups.length - 1];
-      /** A tool whose lane has no model call loaded yet (an older page holds it) leads its own step. */
-      if (kind === 'generation' || (kind === 'tool' && !latestByLane.has(lane))) {
+      /** A tool whose lane has no model call loaded yet (an older page holds it) leads its own step.
+       *  A label's model call describes a step; it never starts one. */
+      if (
+        record != null &&
+        (isModelCall(record) || (isToolWork(record) && !latestByLane.has(lane)))
+      ) {
         const group = { rootIds: [...leading, id], lane };
         groups.push(group);
         latestByLane.set(lane, group);
@@ -422,6 +456,7 @@ function groupSteps(
         index: index + 1,
         origin,
         generationId,
+        agentId: nodes.get(generationId ?? rootIds[0])?.agentId,
         rootIds,
         start: Number.POSITIVE_INFINITY,
         end: Number.NEGATIVE_INFINITY,
@@ -470,8 +505,36 @@ function groupSteps(
   });
 }
 
-const isGenerationId = (nodes: Map<string, TraceNode>) => (id: string) =>
-  nodes.get(id)?.record.kind === 'generation';
+const isGenerationId = (nodes: Map<string, TraceNode>) => (id: string) => {
+  const record = nodes.get(id)?.record;
+  return record != null && isModelCall(record);
+};
+
+/** Stamps each record with its nearest `agent` ancestor's saved agent, caching every path walked. */
+function resolveAgents(nodes: Map<string, TraceNode>): void {
+  const resolved = new Map<string, string | undefined>();
+  for (const node of nodes.values()) {
+    const path: TraceNode[] = [];
+    let current: TraceNode | undefined = node;
+    let agentId: string | undefined;
+    while (current != null) {
+      if (resolved.has(current.record.id)) {
+        agentId = resolved.get(current.record.id);
+        break;
+      }
+      path.push(current);
+      if (current.record.agentId != null) {
+        agentId = current.record.agentId;
+        break;
+      }
+      current = current.parentId != null ? nodes.get(current.parentId) : undefined;
+    }
+    for (const visited of path) {
+      resolved.set(visited.record.id, agentId);
+      visited.agentId = agentId;
+    }
+  }
+}
 
 /** Walks a shown subtree in ledger order, setting depth and the sequence position. */
 function numberSubtree(nodes: Map<string, TraceNode>, rootIds: string[], next: number): number {
@@ -512,6 +575,7 @@ export function buildTraceModel(
   }
 
   resolveParents(nodes);
+  resolveAgents(nodes);
   const turnsWithWork = turnsWithSimpleRecords(nodes);
   const ancestors = new Map<string, string | null>();
   resolveViewTree(nodes, mode, turnsWithWork, ancestors);
@@ -548,7 +612,9 @@ export function buildTraceModel(
         recordCount: 0,
         errorCount: 0,
         generations: 0,
+        labels: 0,
         toolCalls: 0,
+        agents: [],
         sequence: EMPTY_SPAN,
       };
       turnsByMessage.set(record.messageId, turn);
@@ -570,9 +636,17 @@ export function buildTraceModel(
       turn.toolCalls++;
       summary.toolCalls++;
     }
+    if (record.agentId != null && !turn.agents.some((agent) => agent.agentId === record.agentId)) {
+      turn.agents.push({ agentId: record.agentId, recordId: id });
+    }
     if (record.kind === 'generation') {
-      turn.generations++;
-      summary.generations++;
+      if (isLabelRecord(record)) {
+        turn.labels++;
+        summary.labels++;
+      } else {
+        turn.generations++;
+        summary.generations++;
+      }
       const input = record.usage?.input ?? 0;
       const output = record.usage?.output ?? 0;
       const total = record.usage?.total ?? input + output;
@@ -850,10 +924,10 @@ export function assignLanes(model: TraceModel, laneCount: number): Map<string, n
 
 /** On the sequence scale nothing overlaps, so lanes separate kinds: model calls, tools, the rest. */
 export function sequenceLane(record: TTraceRecord): number {
-  if (record.kind === 'generation') {
+  if (isModelCall(record)) {
     return 0;
   }
-  return record.kind === 'tool' ? 1 : 2;
+  return isToolWork(record) ? 1 : 2;
 }
 
 /** Clamps a zoom window inside the trace and keeps it at least `minSpan` wide. */
diff --git a/client/src/components/Chat/Trace/present.ts b/client/src/components/Chat/Trace/present.ts
new file mode 100644
index 00000000000..2849c7bdb33
--- /dev/null
+++ b/client/src/components/Chat/Trace/present.ts
@@ -0,0 +1,114 @@
+import type { Agent, TTraceRecord, TTraceRecordRole } from 'librechat-data-provider';
+import type { ActivityIndex, ToolCallPreview } from './preview';
+import type { TranslationKeys } from '~/hooks';
+import type { TraceNode } from './model';
+import { parseToolName } from '~/utils/toolLabels';
+
+type Localize = (key: TranslationKeys, values?: Record<string, string | number>) => string;
+
+/** How a row reads to someone who has never seen a trace: the record in the chat's own words. */
+export type RecordPresentation = {
+  title: string;
+  /** Where the work ran, beside the title: an MCP server, or the saved agent's model. */
+  caption?: string;
+  /** What the record produced or was given, taken from the chat's own message. */
+  preview?: string;
+  /** Set when `title` replaced the backend's name, which the technical details still show. */
+  technicalName?: string;
+  /** The saved agent the row stands for; `null` when the record names one this user cannot load. */
+  agent?: Agent | null;
+  /** The tools a row stands for, for their icons: a recorded tool, or an unrecorded round's calls. */
+  toolNames?: string[];
+  calls?: ToolCallView[];
+};
+
+/** A call of an unrecorded tool round, named the way its chat tool card names it. */
+export type ToolCallView = ToolCallPreview & Pick<RecordPresentation, 'title' | 'caption'>;
+
+export type PresentationSources = {
+  localize: Localize;
+  activity: ActivityIndex;
+  previewOf: (node: TraceNode) => string | undefined;
+  agentOf: (agentId: string) => Agent | undefined;
+  mcpServerNames?: readonly string[];
+};
+
+const ROLE_TITLES: Record<
+  Exclude<TTraceRecordRole, 'agent' | 'tools' | 'plumbing'>,
+  TranslationKeys
+> = {
+  run: 'com_ui_trace_role_run',
+  model: 'com_ui_model',
+  stepLabel: 'com_ui_trace_role_step_label',
+  reasoningLabel: 'com_ui_trace_role_reasoning_label',
+  phaseLabel: 'com_ui_trace_role_phase_label',
+};
+
+/** A tool's name as the chat's tool cards give it: a built-in's friendly name, or an MCP tool beside its server. */
+export function presentTool(
+  name: string,
+  { localize, mcpServerNames }: Pick<PresentationSources, 'localize' | 'mcpServerNames'>,
+): Pick<RecordPresentation, 'title' | 'caption'> {
+  const parsed = parseToolName(name, mcpServerNames);
+  if (parsed.friendlyKey != null) {
+    return { title: localize(parsed.friendlyKey) };
+  }
+  return { title: parsed.toolName, caption: parsed.mcpServer || undefined };
+}
+
+function presentToolRound(record: TTraceRecord, sources: PresentationSources): RecordPresentation {
+  const { localize, activity } = sources;
+  const calls = activity.calls.get(record.id);
+  const technicalName = record.name;
+  if (calls == null || calls.length === 0) {
+    return { title: localize('com_ui_trace_role_tools'), technicalName };
+  }
+  const views = calls.map((call) => ({ ...call, ...presentTool(call.name, sources) }));
+  const toolNames = calls.map((call) => call.name);
+  if (views.length === 1) {
+    const [{ title, caption, args }] = views;
+    return { title, caption, preview: args, technicalName, toolNames, calls: views };
+  }
+  const titles = [...new Set(views.map((view) => view.title))];
+  return {
+    title: localize('com_ui_trace_role_tools_count', { count: calls.length }),
+    preview: titles.join(', '),
+    technicalName,
+    toolNames,
+    calls: views,
+  };
+}
+
+export function presentRecord(node: TraceNode, sources: PresentationSources): RecordPresentation {
+  const { record } = node;
+  const { localize, activity, previewOf, agentOf } = sources;
+  if (record.role === 'agent' && record.agentId != null) {
+    const agent = agentOf(record.agentId) ?? null;
+    return {
+      title: agent?.name || localize('com_ui_agent'),
+      caption: agent?.model ?? undefined,
+      technicalName: record.name,
+      agent,
+    };
+  }
+  if (record.role === 'tools') {
+    return presentToolRound(record, sources);
+  }
+  /** A wrapper only frames a model call; every span as recorded is where it shows, under its own name. */
+  if (record.role != null && record.role !== 'agent' && record.role !== 'plumbing') {
+    const named = record.role === 'model' && record.origin === 'title';
+    return {
+      title: localize(named ? 'com_ui_trace_role_title' : ROLE_TITLES[record.role]),
+      preview: activity.labels.get(record.id) ?? previewOf(node),
+      technicalName: record.name,
+    };
+  }
+  if (record.kind === 'tool') {
+    return {
+      ...presentTool(record.name, sources),
+      preview: previewOf(node),
+      toolNames: [record.name],
+    };
+  }
+  return { title: record.name, preview: previewOf(node) };
+}
diff --git a/client/src/components/Chat/Trace/preview.ts b/client/src/components/Chat/Trace/preview.ts
index 85a2dc82bb7..d67612f7e37 100644
--- a/client/src/components/Chat/Trace/preview.ts
+++ b/client/src/components/Chat/Trace/preview.ts
@@ -1,12 +1,15 @@
 import { ContentTypes } from 'librechat-data-provider';
 import type { TMessage, TMessageContentParts } from 'librechat-data-provider';
 import type { TraceModel } from './model';
+import { getActivityLabelPart, getActivityLabelText, isPhaseActivityLabel } from '~/utils';
+import { isModelCall, isToolWork } from './model';
 import { hasParallelLanes } from '~/utils/lanes';
 
 const PREVIEW_LENGTH = 160;
 const ELLIPSIS = '…';
 
-type ToolCallPreview = { name: string; args: string };
+/** `args` is the one-line preview; `input` and `output` are what the chat's own tool card holds. */
+export type ToolCallPreview = { name: string; args: string; input?: string; output?: string };
 
 /** What one model call of a response produced: the text it wrote and the tools it called. */
 export type StepPreview = { text: string; toolCalls: ToolCallPreview[] };
@@ -21,8 +24,12 @@ export type MessagePreview = {
   finalOnly: boolean;
   /** Agents ran in parallel lanes, whose output cannot be told apart by order. */
   parallel: boolean;
+  /** The activity labels the chat showed, in the order they were written, by the kind of label. */
+  labels: Record<LabelRole, string[]>;
 };
 
+type LabelRole = 'stepLabel' | 'phaseLabel';
+
 function compact(text: string): string {
   const collapsed = text.replace(/\s+/g, ' ').trim();
   return collapsed.length > PREVIEW_LENGTH
@@ -58,6 +65,13 @@ function argsPreview(args: string | object | undefined): string {
   return compact(pairs.join(', '));
 }
 
+function contentOf(value: string | object | null | undefined): string | undefined {
+  if (value == null || value === '') {
+    return undefined;
+  }
+  return typeof value === 'string' ? value : JSON.stringify(value);
+}
+
 type ToolCallPart = Extract<TMessageContentParts, { type: ContentTypes.TOOL_CALL }>['tool_call'];
 
 /** A tool call's name and arguments, whichever of the persisted call shapes carries them. */
@@ -66,10 +80,16 @@ function callOf(call: ToolCallPart | undefined): ToolCallPreview | null {
     return null;
   }
   if ('function' in call && call.function != null) {
-    return { name: call.function.name, args: argsPreview(call.function.arguments) };
+    const { name, arguments: input, output } = call.function;
+    return { name, args: argsPreview(input), input: contentOf(input), output: contentOf(output) };
   }
   if ('name' in call && typeof call.name === 'string') {
-    return { name: call.name, args: argsPreview(call.args) };
+    return {
+      name: call.name,
+      args: argsPreview(call.args),
+      input: contentOf(call.args),
+      output: 'output' in call ? contentOf(call.output) : undefined,
+    };
   }
   return null;
 }
@@ -95,6 +115,7 @@ export function buildMessagePreview(message: TMessage | undefined): MessagePrevi
   let lastRunStep: string | undefined;
   let roundAgent: string | undefined;
   const parallel = hasParallelLanes(parts);
+  const labels: MessagePreview['labels'] = { stepLabel: [], phaseLabel: [] };
   let sealed = false;
   const begin = () => {
     current = { text: '', toolCalls: [] };
@@ -115,6 +136,14 @@ export function buildMessagePreview(message: TMessage | undefined): MessagePrevi
     if (part == null) {
       continue;
     }
+    if (part.type === ContentTypes.ACTIVITY_LABEL) {
+      const label = getActivityLabelPart(part);
+      const text = getActivityLabelText(label);
+      if (text) {
+        labels[isPhaseActivityLabel(label) ? 'phaseLabel' : 'stepLabel'].push(text);
+      }
+      continue;
+    }
     if (part.type === ContentTypes.TOOL_CALL) {
       const runStep = runStepOf(part.tool_call);
       const handedOff = handoff(part);
@@ -161,7 +190,12 @@ export function buildMessagePreview(message: TMessage | undefined): MessagePrevi
     parts.some((part) => part?.type === ContentTypes.ERROR);
   /** A failed turn's row stores the failure as its text; the model never wrote it. */
   if (steps.length === 0 && message?.text && !endedEarly) {
-    return { steps: [{ text: compact(message.text), toolCalls: [] }], finalOnly: true, parallel };
+    return {
+      steps: [{ text: compact(message.text), toolCalls: [] }],
+      finalOnly: true,
+      parallel,
+      labels,
+    };
   }
   const finalOnly =
     !endedEarly &&
@@ -169,7 +203,7 @@ export function buildMessagePreview(message: TMessage | undefined): MessagePrevi
     steps.length === 1 &&
     steps[0].toolCalls.length === 0 &&
     steps[0].text !== '';
-  return { steps, finalOnly, parallel };
+  return { steps, finalOnly, parallel, labels };
 }
 
 export function buildStepPreviews(message: TMessage | undefined): StepPreview[] {
@@ -246,7 +280,7 @@ export function buildPreviewIndex(
     const ordinals = new Map<string, number>();
     for (const node of roots) {
       const { record } = node;
-      if (record.kind === 'generation') {
+      if (isModelCall(record)) {
         if (round.text) {
           index.set(record.id, round.text);
         }
@@ -280,3 +314,97 @@ export function buildPreviews(
   }
   return previews;
 }
+
+/** What the chat's messages say about records the trace only names: tool rounds and activity labels. */
+export type ActivityIndex = {
+  /** The calls of a tool round the host ran without recording each one, by the round's record id. */
+  calls: Map<string, ToolCallPreview[]>;
+  /** The text a label's model call wrote, by its record id. */
+  labels: Map<string, string>;
+  /** Tool calls the trace holds no record of, by response: what a turn's own count misses. */
+  unrecordedCalls: Map<string, number>;
+};
+
+const hasToolRecord = (model: TraceModel) => (id: string) => {
+  const record = model.nodes.get(id)?.record;
+  return record != null && isToolWork(record);
+};
+
+/**
+ * Attributes the message's tool calls and activity labels to trace records. A
+ * round's calls go to its one tool-round record that holds no recorded tools (a
+ * round re-entered after an approval pause has several, and only the last one
+ * ran them). Labels pair with their model calls in the order both were written,
+ * and only when the counts agree, under the rule the previews follow.
+ */
+export function buildActivityIndex(
+  model: TraceModel,
+  previewsByMessage: ReadonlyMap<string, MessagePreview>,
+  partialMessageId?: string,
+): ActivityIndex {
+  const calls: ActivityIndex['calls'] = new Map();
+  const labels: ActivityIndex['labels'] = new Map();
+  const unrecordedCalls: ActivityIndex['unrecordedCalls'] = new Map();
+  const stepsByTurn = new Map(model.turns.map((turn) => [turn.messageId, turn.steps]));
+  const aligned = (messageId: string): MessagePreview | undefined => {
+    const message = previewsByMessage.get(messageId);
+    return message == null || message.parallel || messageId === partialMessageId
+      ? undefined
+      : message;
+  };
+
+  for (const step of model.steps.values()) {
+    const message = aligned(step.messageId);
+    if (
+      message == null ||
+      message.finalOnly ||
+      step.origin === 'title' ||
+      message.steps.length !== stepsByTurn.get(step.messageId)
+    ) {
+      continue;
+    }
+    const round = message.steps[step.index - 1];
+    let target: string | undefined;
+    for (const id of step.rootIds) {
+      const node = model.nodes.get(id);
+      if (node?.record.role === 'tools' && !node.childIds.some(hasToolRecord(model))) {
+        target = id;
+      }
+    }
+    if (target == null || round == null || round.toolCalls.length === 0) {
+      continue;
+    }
+    calls.set(target, round.toolCalls);
+    unrecordedCalls.set(
+      step.messageId,
+      (unrecordedCalls.get(step.messageId) ?? 0) + round.toolCalls.length,
+    );
+  }
+
+  const labelRecords = new Map<string, Record<LabelRole, Array<{ id: string; start: number }>>>();
+  for (const node of model.nodes.values()) {
+    const { role, messageId, id } = node.record;
+    if (role !== 'stepLabel' && role !== 'phaseLabel') {
+      continue;
+    }
+    const byRole = labelRecords.get(messageId) ?? { stepLabel: [], phaseLabel: [] };
+    byRole[role].push({ id, start: node.start });
+    labelRecords.set(messageId, byRole);
+  }
+  for (const [messageId, byRole] of labelRecords) {
+    const message = aligned(messageId);
+    if (message == null) {
+      continue;
+    }
+    for (const role of ['stepLabel', 'phaseLabel'] as const) {
+      const records = byRole[role];
+      const texts = message.labels[role];
+      if (records.length !== texts.length) {
+        continue;
+      }
+      records.sort((a, b) => a.start - b.start || a.id.localeCompare(b.id));
+      records.forEach((record, index) => labels.set(record.id, texts[index]));
+    }
+  }
+  return { calls, labels, unrecordedCalls };
+}
diff --git a/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx b/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
index 72a66c62bc5..310c773cb05 100644
--- a/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
+++ b/client/src/components/Chat/__tests__/ChatView.subagent.spec.tsx
@@ -68,6 +68,9 @@ jest.mock('../Presentation', () => ({ children }: { children: React.ReactNode })
 ));
 jest.mock('../Input/ChatForm', () => () => <div data-testid="chat-form" />);
 jest.mock('../Landing', () => () => <div data-testid="landing" />);
+jest.mock('../Trace', () => ({
+  TraceSurface: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
 jest.mock('../Footer', () => ({
   __esModule: true,
   default: () => <div data-testid="footer" />,
diff --git a/client/src/components/MCP/McpOAuthDialog.tsx b/client/src/components/MCP/McpOAuthDialog.tsx
index 873478b184c..8b9007c32fe 100644
--- a/client/src/components/MCP/McpOAuthDialog.tsx
+++ b/client/src/components/MCP/McpOAuthDialog.tsx
@@ -11,7 +11,7 @@ import {
 } from '@librechat/client';
 import CopyButton from '~/components/Messages/Content/CopyButton';
 import { useLocalize, useCopyToClipboard } from '~/hooks';
-import { cn } from '~/utils';
+import { cn, openInNewTab } from '~/utils';
 
 interface McpOAuthDialogProps {
   open: boolean;
@@ -143,7 +143,7 @@ export default function McpOAuthDialog({
               type="button"
               variant="submit"
               className="flex-1"
-              onClick={() => window.open(oauthUrl, '_blank', 'noopener,noreferrer')}
+              onClick={() => openInNewTab(oauthUrl)}
             >
               {localize('com_ui_continue_oauth')}
               <ExternalLink className="size-4" aria-hidden="true" />
diff --git a/client/src/components/MCP/ServerInitializationSection.tsx b/client/src/components/MCP/ServerInitializationSection.tsx
index 9890d901f40..5adf98b3069 100644
--- a/client/src/components/MCP/ServerInitializationSection.tsx
+++ b/client/src/components/MCP/ServerInitializationSection.tsx
@@ -3,6 +3,7 @@ import { RefreshCw, Trash2 } from 'lucide-react';
 import { Button, Spinner } from '@librechat/client';
 import { useLocalize, useMCPServerManager } from '~/hooks';
 import { useMCPRefresh } from '~/hooks/MCP/useMCPRefresh';
+import { openInNewTab } from '~/utils';
 
 interface ServerInitializationSectionProps {
   sidePanel?: boolean;
@@ -97,11 +98,7 @@ export default function ServerInitializationSection({
           >
             {localize('com_ui_cancel')}
           </Button>
-          <Button
-            variant="submit"
-            onClick={() => window.open(serverOAuthUrl, '_blank', 'noopener,noreferrer')}
-            className="flex-1"
-          >
+          <Button variant="submit" onClick={() => openInNewTab(serverOAuthUrl)} className="flex-1">
             {localize('com_ui_continue_oauth')}
           </Button>
         </div>
diff --git a/client/src/components/MCP/__tests__/McpOAuthDialog.spec.tsx b/client/src/components/MCP/__tests__/McpOAuthDialog.spec.tsx
index 1a747ca32ff..d0cbdccb254 100644
--- a/client/src/components/MCP/__tests__/McpOAuthDialog.spec.tsx
+++ b/client/src/components/MCP/__tests__/McpOAuthDialog.spec.tsx
@@ -87,9 +87,19 @@ describe('McpOAuthDialog', () => {
 
   test('Continue opens the OAuth URL in a new tab', () => {
     const openSpy = jest.spyOn(window, 'open').mockImplementation(() => null);
+    const clickSpy = jest
+      .spyOn(HTMLAnchorElement.prototype, 'click')
+      .mockImplementation(() => undefined);
     render(<McpOAuthDialog {...baseProps} />);
     fireEvent.click(screen.getByText('com_ui_continue_oauth'));
-    expect(openSpy).toHaveBeenCalledWith(baseProps.oauthUrl, '_blank', 'noopener,noreferrer');
+    expect(clickSpy).toHaveBeenCalledTimes(1);
+    const link = clickSpy.mock.instances[0] as unknown as HTMLAnchorElement;
+    expect(link.href).toBe(baseProps.oauthUrl);
+    expect(link.target).toBe('_blank');
+    expect(link.rel).toBe('noopener noreferrer');
+    /** A features string makes WebKit request a popup window, which iOS web apps cannot open. */
+    expect(openSpy).not.toHaveBeenCalled();
+    clickSpy.mockRestore();
     openSpy.mockRestore();
   });
 
diff --git a/client/src/components/Messages/ContentRender.tsx b/client/src/components/Messages/ContentRender.tsx
index c3b954583db..e2dba90a299 100644
--- a/client/src/components/Messages/ContentRender.tsx
+++ b/client/src/components/Messages/ContentRender.tsx
@@ -12,8 +12,8 @@ import {
 } from '~/utils';
 import { revealOnRowHoverClasses, messageFooterClasses } from '~/components/Chat/Messages/styles';
 import { useLocalize, useAttachments, useMessageActions, useContentMetadata } from '~/hooks';
+import ResumeAuthorHeader from '~/components/Chat/Messages/Content/Parts/ResumeAuthorHeader';
 import ToolCallLimitNotice from '~/components/Chat/Messages/Content/ToolCallLimitNotice';
-import AuthorHeader from '~/components/Chat/Messages/Content/Parts/AuthorHeader';
 import { ErrorSourceProvider } from '~/components/Messages/Content/Error/source';
 import Elapsed, { shouldShowElapsed } from '~/components/Chat/Messages/Elapsed';
 import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
@@ -24,8 +24,15 @@ import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
 import MessageIcon from '~/components/Chat/Messages/MessageIcon';
 import { showThinkingAtom } from '~/store/showThinking';
 import SubRow from '~/components/Chat/Messages/SubRow';
+import { AuthorContext } from '~/Providers';
 import store from '~/store';
 
+/**
+ * The one header every assistant message hands its parts. It reads the author from
+ * `AuthorContext`, so the author resolving after paint cannot break the parts' memo.
+ */
+const RESUME_AUTHOR_HEADER = <ResumeAuthorHeader />;
+
 type ContentRenderProps = {
   message?: TMessage;
   /**
@@ -138,15 +145,12 @@ const ContentRender = memo(function ContentRender({
     ],
   );
 
-  const authorHeader = useMemo(
-    () =>
-      msg?.isCreatedByUser === true ? undefined : (
-        <AuthorHeader
-          icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}
-          label={messageLabel ?? ''}
-        />
-      ),
-    [msg?.isCreatedByUser, iconData, assistant, agent, messageLabel],
+  const author = useMemo(
+    () => ({
+      icon: <MessageIcon iconData={iconData} assistant={assistant} agent={agent} />,
+      label: messageLabel ?? '',
+    }),
+    [iconData, assistant, agent, messageLabel],
   );
 
   const { hasParallelContent } = useContentMetadata(msg);
@@ -158,8 +162,8 @@ const ContentRender = memo(function ContentRender({
   return (
     <MessageRow
       id={msg.messageId}
-      icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}
-      label={messageLabel ?? ''}
+      icon={author.icon}
+      label={author.label}
       hoverLabel={getHeaderHoverLabel(
         hasConfiguredSender,
         agent?.model,
@@ -214,27 +218,29 @@ const ContentRender = memo(function ContentRender({
         </SubRow>
       }
     >
-      <ErrorSourceProvider message={msg}>
-        <ContentParts
-          edit={edit}
-          isLast={isLast}
-          enterEdit={enterEdit}
-          siblingIdx={siblingIdx}
-          messageId={msg.messageId}
-          attachments={attachments}
-          searchResults={searchResults}
-          manualSkills={msg.manualSkills}
-          authorHeader={authorHeader}
-          setSiblingIdx={setSiblingIdx}
-          isLatestMessage={isLatestMessage}
-          isSubmitting={isSubmitting}
-          isCreatedByUser={msg.isCreatedByUser}
-          createdAt={msg.createdAt ?? msg.clientTimestamp}
-          showThinking={showThinking}
-          conversationId={conversation?.conversationId}
-          content={msg.content as Array<TMessageContentParts | undefined>}
-        />
-      </ErrorSourceProvider>
+      <AuthorContext.Provider value={author}>
+        <ErrorSourceProvider message={msg}>
+          <ContentParts
+            edit={edit}
+            isLast={isLast}
+            enterEdit={enterEdit}
+            siblingIdx={siblingIdx}
+            messageId={msg.messageId}
+            attachments={attachments}
+            searchResults={searchResults}
+            manualSkills={msg.manualSkills}
+            authorHeader={msg.isCreatedByUser === true ? undefined : RESUME_AUTHOR_HEADER}
+            setSiblingIdx={setSiblingIdx}
+            isLatestMessage={isLatestMessage}
+            isSubmitting={isSubmitting}
+            isCreatedByUser={msg.isCreatedByUser}
+            createdAt={msg.createdAt ?? msg.clientTimestamp}
+            showThinking={showThinking}
+            conversationId={conversation?.conversationId}
+            content={msg.content as Array<TMessageContentParts | undefined>}
+          />
+        </ErrorSourceProvider>
+      </AuthorContext.Provider>
       {/** A turn that ran out of agent steps is incomplete, not broken. Rendered
        *   here rather than inside `ContentParts` because it is a message-level
        *   outcome, and `ContentParts` also serves surfaces (subagent panels,
diff --git a/client/src/components/Messages/__tests__/ContentRender.test.tsx b/client/src/components/Messages/__tests__/ContentRender.test.tsx
new file mode 100644
index 00000000000..2af2d9351bf
--- /dev/null
+++ b/client/src/components/Messages/__tests__/ContentRender.test.tsx
@@ -0,0 +1,170 @@
+import React from 'react';
+import { RecoilRoot } from 'recoil';
+import { render, screen, within } from '@testing-library/react';
+import type { Agent, TConversation, TMessage } from 'librechat-data-provider';
+import type { TMessageChatContext } from '~/common';
+import ContentRender from '../ContentRender';
+
+const mockRenders = { parts: 0 };
+
+/**
+ * Memoized like the real parts tree with its default comparator, and rendering the
+ * resume header it is handed where a steer would place it.
+ */
+jest.mock('~/components/Chat/Messages/Content/ContentParts', () => {
+  const { memo } = jest.requireActual<typeof import('react')>('react');
+  return {
+    __esModule: true,
+    default: memo(function MockContentParts({ authorHeader }: { authorHeader?: React.ReactNode }) {
+      mockRenders.parts += 1;
+      return <div data-testid="parts">{authorHeader}</div>;
+    }),
+  };
+});
+
+jest.mock('~/components/Chat/Messages/MessageIcon', () => ({
+  __esModule: true,
+  default: ({ agent }: { agent?: { name?: string } }) => (
+    <span data-testid="message-icon" data-agent={agent?.name ?? ''} />
+  ),
+}));
+
+jest.mock('~/components/Chat/Messages/HoverButtons', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+jest.mock('~/components/Chat/Messages/ui/MessageTimestamp', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+/**
+ * Stands in for the agents map: `useMessageActions` reads it through context, so the
+ * agents list landing re-renders the memoized row without any new props.
+ */
+const mockAgentContext = React.createContext<Agent | undefined>(undefined);
+const mockActions = {
+  enterEdit: jest.fn(),
+  handleContinue: jest.fn(),
+  handleFeedback: jest.fn(),
+  copyToClipboard: jest.fn(),
+  getCanCopy: jest.fn(() => true),
+  regenerateMessage: jest.fn(),
+};
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+  useAttachments: () => ({ attachments: undefined, searchResults: undefined }),
+  useContentMetadata: () => ({ hasParallelContent: false }),
+  useMessageActions: ({
+    message,
+    chatContext,
+  }: {
+    message?: TMessage;
+    chatContext: TMessageChatContext;
+  }) => {
+    const { useContext } = jest.requireActual<typeof import('react')>('react');
+    const agent = useContext(mockAgentContext);
+    return {
+      ...mockActions,
+      edit: false,
+      index: chatContext.index,
+      agent,
+      assistant: undefined,
+      conversation: chatContext.conversation,
+      messageLabel: agent?.name ?? message?.sender,
+      latestMessageId: chatContext.latestMessageId,
+      latestMessageDepth: chatContext.latestMessageDepth,
+      hasConfiguredSender: false,
+    };
+  },
+}));
+
+const conversation = {
+  conversationId: 'convo-1',
+  endpoint: 'agents',
+  agent_id: 'agent_lia',
+} as TConversation;
+
+const chatContext: TMessageChatContext = {
+  ask: jest.fn(),
+  index: 0,
+  regenerate: jest.fn(),
+  conversation,
+  latestMessageId: 'user-1',
+  latestMessageDepth: 1,
+  handleContinue: jest.fn(),
+  feedbackEnabled: false,
+  isSubmitting: false,
+};
+
+const assistantMessage = {
+  messageId: 'assistant-1',
+  parentMessageId: 'user-1',
+  conversationId: conversation.conversationId,
+  sender: 'agent_lia',
+  isCreatedByUser: false,
+  text: '',
+  content: [{ type: 'text', text: 'Done.' }],
+  createdAt: '2026-09-17T00:00:00.000Z',
+} as TMessage;
+
+const lia = { id: 'agent_lia', name: 'Lia' } as Agent;
+const setSiblingIdx = jest.fn();
+const setCurrentEditId = jest.fn();
+
+/** Renders one row with no agent resolved yet, and lets the test land the agents list. */
+const renderRow = (message: TMessage) => {
+  const view = (agent?: Agent) => (
+    <RecoilRoot>
+      <mockAgentContext.Provider value={agent}>
+        <ContentRender
+          message={message}
+          chatContext={chatContext}
+          siblingIdx={0}
+          siblingCount={1}
+          setSiblingIdx={setSiblingIdx}
+          currentEditId={null}
+          setCurrentEditId={setCurrentEditId}
+        />
+      </mockAgentContext.Provider>
+    </RecoilRoot>
+  );
+  const result = render(view());
+  return { ...result, resolveAgent: (agent: Agent) => result.rerender(view(agent)) };
+};
+
+describe('ContentRender resume author header', () => {
+  beforeEach(() => {
+    mockRenders.parts = 0;
+  });
+
+  it('keeps the parts tree from re-rendering when the agent resolves after paint', () => {
+    const { resolveAgent } = renderRow(assistantMessage);
+    const partsRendersAtPaint = mockRenders.parts;
+
+    resolveAgent(lia);
+
+    // The row itself did re-render: its own header now names the agent.
+    expect(screen.getAllByTestId('message-icon')[0]).toHaveAttribute('data-agent', 'Lia');
+    expect(mockRenders.parts).toBe(partsRendersAtPaint);
+  });
+
+  it('still restates the resolved author inside the message', () => {
+    const { resolveAgent } = renderRow(assistantMessage);
+    const parts = screen.getByTestId('parts');
+    expect(within(parts).getByRole('heading', { level: 2 })).toHaveTextContent('agent_lia');
+
+    resolveAgent(lia);
+
+    expect(within(parts).getByRole('heading', { level: 2 })).toHaveTextContent('Lia');
+    expect(within(parts).getByTestId('message-icon')).toHaveAttribute('data-agent', 'Lia');
+  });
+
+  it('hands a user message no resume header', () => {
+    renderRow({ ...assistantMessage, messageId: 'user-2', isCreatedByUser: true });
+
+    expect(screen.getByTestId('parts')).toBeEmptyDOMElement();
+  });
+});
diff --git a/client/src/components/Nav/AccountSettings.tsx b/client/src/components/Nav/AccountSettings.tsx
index bb17bdcefa4..be97547701a 100644
--- a/client/src/components/Nav/AccountSettings.tsx
+++ b/client/src/components/Nav/AccountSettings.tsx
@@ -15,6 +15,7 @@ import {
 import { ArchivedChatsModal } from '~/components/Nav/SettingsTabs/General/ArchivedChatsModal';
 import { useGetStartupConfig, useGetUserBalance } from '~/data-provider';
 import { useAuthContext } from '~/hooks/AuthContext';
+import { openInNewTab } from '~/utils';
 import { useLocalize } from '~/hooks';
 import Settings from './Settings';
 import store from '~/store';
@@ -55,7 +56,7 @@ function HelpSubmenu({
       >
         {hasHelpFaq && (
           <Menu.MenuItem
-            onClick={() => window.open(helpAndFaqURL, '_blank', 'noopener,noreferrer')}
+            onClick={() => openInNewTab(helpAndFaqURL)}
             className="select-item text-sm"
           >
             <LifeBuoy className="icon-md" aria-hidden="true" />
@@ -69,7 +70,7 @@ function HelpSubmenu({
         {showLegalDivider && (hasTos || hasPrivacy) && <DropdownMenuSeparator />}
         {hasTos && (
           <Menu.MenuItem
-            onClick={() => window.open(termsOfServiceURL, '_blank', 'noopener,noreferrer')}
+            onClick={() => openInNewTab(termsOfServiceURL)}
             className="select-item text-sm"
           >
             <Scale className="icon-md" aria-hidden="true" />
@@ -78,7 +79,7 @@ function HelpSubmenu({
         )}
         {hasPrivacy && (
           <Menu.MenuItem
-            onClick={() => window.open(privacyPolicyURL, '_blank', 'noopener,noreferrer')}
+            onClick={() => openInNewTab(privacyPolicyURL)}
             className="select-item text-sm"
           >
             <ShieldCheck className="icon-md" aria-hidden="true" />
diff --git a/client/src/components/SharePoint/SharePointPickerDialog.tsx b/client/src/components/SharePoint/SharePointPickerDialog.tsx
index fd10ffac62f..db942465996 100644
--- a/client/src/components/SharePoint/SharePointPickerDialog.tsx
+++ b/client/src/components/SharePoint/SharePointPickerDialog.tsx
@@ -1,11 +1,5 @@
 import React, { useState, useEffect } from 'react';
-import {
-  OGDialog,
-  OGDialogTitle,
-  OGDialogPortal,
-  OGDialogOverlay,
-  OGDialogContent,
-} from '@librechat/client';
+import { OGDialog, OGDialogTitle, OGDialogContent } from '@librechat/client';
 import type { SharePointBatchProgress } from '~/data-provider/Files/sharepoint';
 import { useSharePointPicker, useLocalize } from '~/hooks';
 
@@ -63,75 +57,77 @@ export default function SharePointPickerDialog({
   }, [containerNode, isOpen]);
   return (
     <OGDialog open={isOpen} onOpenChange={handleOpenChange}>
-      <OGDialogPortal>
-        <OGDialogOverlay className="bg-black/50" />
-        <OGDialogContent
-          className="sharepoint-picker-bg fixed left-1/2 top-1/2 z-50 h-[680px] max-h-[90vh] max-w-[90vw] -translate-x-1/2 -translate-y-1/2 rounded-lg border bg-surface-dialog p-2 shadow-lg focus:outline-none"
-          showCloseButton={true}
-        >
-          <OGDialogTitle className="sr-only">
-            {localize('com_files_sharepoint_picker_title')}
-          </OGDialogTitle>
-          <div ref={containerCallbackRef} className="sharepoint-picker-bg relative flex p-2">
-            {/* SharePoint iframe will be injected here by the hook */}
+      {/** The content portals the app's scrim itself. This dialog used to render
+       *  a second overlay beside it asking for a lighter black, which the
+       *  primitive's own overlay painted over — same depth, mounted later — so
+       *  it never reached the screen. The dialog is opaque, so nothing here
+       *  needed a scrim of its own: it takes the theme's. */}
+      <OGDialogContent
+        className="sharepoint-picker-bg fixed left-1/2 top-1/2 z-50 h-[680px] max-h-[90vh] max-w-[90vw] -translate-x-1/2 -translate-y-1/2 rounded-lg border bg-surface-dialog p-2 shadow-lg focus:outline-none"
+        showCloseButton={true}
+      >
+        <OGDialogTitle className="sr-only">
+          {localize('com_files_sharepoint_picker_title')}
+        </OGDialogTitle>
+        <div ref={containerCallbackRef} className="sharepoint-picker-bg relative flex p-2">
+          {/* SharePoint iframe will be injected here by the hook */}
 
-            {isDownloading && (
-              <div className="absolute inset-0 z-10 flex items-center justify-center rounded-lg bg-black/30 backdrop-blur-sm">
-                <div className="mx-4 w-full max-w-sm rounded-lg bg-surface-primary p-6 shadow-lg">
-                  <div className="text-center">
-                    <div className="mx-auto mb-4 h-8 w-8 animate-spin rounded-full border-b-2 border-blue-600"></div>
-                    <h3 className="mb-2 text-lg font-semibold text-text-primary">
-                      {localize('com_files_downloading')}
-                    </h3>
-                    {downloadProgress && (
-                      <div className="space-y-2">
-                        <p className="text-sm text-text-secondary">
-                          {localize('com_files_download_progress', {
-                            0: downloadProgress.completed,
-                            1: downloadProgress.total,
-                          })}
-                        </p>
-                        {downloadProgress.currentFile && (
-                          <p className="truncate text-xs text-text-tertiary">
-                            {downloadProgress.currentFile}
-                          </p>
-                        )}
-                        <div className="h-2 w-full rounded-full bg-surface-tertiary">
-                          <div
-                            className="h-2 rounded-full bg-blue-600 transition-all duration-300"
-                            style={{
-                              width: `${Math.round((downloadProgress.completed / downloadProgress.total) * 100)}%`,
-                            }}
-                          ></div>
-                        </div>
-                        <p className="text-xs text-text-tertiary">
-                          {localize('com_files_download_percent_complete', {
-                            0: Math.round(
-                              (downloadProgress.completed / downloadProgress.total) * 100,
-                            ),
-                          })}
+          {isDownloading && (
+            <div className="absolute inset-0 z-10 flex items-center justify-center rounded-lg bg-black/30 backdrop-blur-sm">
+              <div className="mx-4 w-full max-w-sm rounded-lg bg-surface-primary p-6 shadow-lg">
+                <div className="text-center">
+                  <div className="mx-auto mb-4 h-8 w-8 animate-spin rounded-full border-b-2 border-blue-600"></div>
+                  <h3 className="mb-2 text-lg font-semibold text-text-primary">
+                    {localize('com_files_downloading')}
+                  </h3>
+                  {downloadProgress && (
+                    <div className="space-y-2">
+                      <p className="text-sm text-text-secondary">
+                        {localize('com_files_download_progress', {
+                          0: downloadProgress.completed,
+                          1: downloadProgress.total,
+                        })}
+                      </p>
+                      {downloadProgress.currentFile && (
+                        <p className="truncate text-xs text-text-tertiary">
+                          {downloadProgress.currentFile}
                         </p>
-                        {downloadProgress.failed.length > 0 && (
-                          <p className="text-xs text-text-destructive">
-                            {localize('com_files_download_failed', {
-                              0: downloadProgress.failed.length,
-                            })}
-                          </p>
-                        )}
+                      )}
+                      <div className="h-2 w-full rounded-full bg-surface-tertiary">
+                        <div
+                          className="h-2 rounded-full bg-blue-600 transition-all duration-300"
+                          style={{
+                            width: `${Math.round((downloadProgress.completed / downloadProgress.total) * 100)}%`,
+                          }}
+                        ></div>
                       </div>
-                    )}
-                    {!downloadProgress && (
-                      <p className="text-sm text-text-secondary">
-                        {localize('com_files_preparing_download')}
+                      <p className="text-xs text-text-tertiary">
+                        {localize('com_files_download_percent_complete', {
+                          0: Math.round(
+                            (downloadProgress.completed / downloadProgress.total) * 100,
+                          ),
+                        })}
                       </p>
-                    )}
-                  </div>
+                      {downloadProgress.failed.length > 0 && (
+                        <p className="text-xs text-text-destructive">
+                          {localize('com_files_download_failed', {
+                            0: downloadProgress.failed.length,
+                          })}
+                        </p>
+                      )}
+                    </div>
+                  )}
+                  {!downloadProgress && (
+                    <p className="text-sm text-text-secondary">
+                      {localize('com_files_preparing_download')}
+                    </p>
+                  )}
                 </div>
               </div>
-            )}
-          </div>
-        </OGDialogContent>
-      </OGDialogPortal>
+            </div>
+          )}
+        </div>
+      </OGDialogContent>
     </OGDialog>
   );
 }
diff --git a/client/src/components/SharePoint/__tests__/SharePointPickerDialog.spec.tsx b/client/src/components/SharePoint/__tests__/SharePointPickerDialog.spec.tsx
new file mode 100644
index 00000000000..db5f30611a1
--- /dev/null
+++ b/client/src/components/SharePoint/__tests__/SharePointPickerDialog.spec.tsx
@@ -0,0 +1,59 @@
+import { render } from '@testing-library/react';
+import { OGDialog, OGDialogContent, OGDialogTitle } from '@librechat/client';
+import SharePointPickerDialog from '../SharePointPickerDialog';
+
+/**
+ * The picker used to render an overlay of its own, beside the one
+ * `OGDialogContent` portals anyway, asking for a lighter black backdrop. Both
+ * sat at the same depth, so the primitive's — mounted second — painted over it
+ * and the requested color never reached the screen. The dialog itself is
+ * opaque, so it needs no backdrop of its own: it scrims with the theme's
+ * overlay role like every other OGDialog, and exactly once.
+ */
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+  useSharePointPicker: () => ({
+    openSharePointPicker: jest.fn(),
+    closeSharePointPicker: jest.fn(),
+    cleanup: jest.fn(),
+  }),
+}));
+
+/** The overlay is the only full-bleed layer while no download is in flight. */
+const scrims = () => Array.from(document.querySelectorAll<HTMLElement>('div.inset-0'));
+
+/** What any OGDialog scrims with, read from the primitive rather than pinned. */
+const REFERENCE_TITLE = 'reference dialog';
+
+function appScrim(): string {
+  const { unmount } = render(
+    <OGDialog open={true}>
+      <OGDialogContent>
+        <OGDialogTitle>{REFERENCE_TITLE}</OGDialogTitle>
+      </OGDialogContent>
+    </OGDialog>,
+  );
+  const [scrim, ...extra] = scrims();
+  expect(extra).toEqual([]);
+  const painted = scrim.className;
+  unmount();
+  return painted;
+}
+
+describe('SharePoint picker dialog', () => {
+  it('paints the app scrim once, and none of its own', () => {
+    const expected = appScrim();
+    render(<SharePointPickerDialog isOpen={true} onOpenChange={jest.fn()} />);
+
+    const [scrim, ...extra] = scrims();
+    expect(extra).toEqual([]);
+    expect(scrim.className).toBe(expected);
+  });
+
+  it('paints no backdrop while closed', () => {
+    render(<SharePointPickerDialog isOpen={false} onOpenChange={jest.fn()} />);
+
+    expect(scrims()).toEqual([]);
+  });
+});
diff --git a/client/src/components/SidePanel/Agents/Tools/ItemDialog/ItemDialog.tsx b/client/src/components/SidePanel/Agents/Tools/ItemDialog/ItemDialog.tsx
index 5d96880ebba..9bc726a286d 100644
--- a/client/src/components/SidePanel/Agents/Tools/ItemDialog/ItemDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ItemDialog/ItemDialog.tsx
@@ -16,13 +16,13 @@ export default function ItemDialog({ item, agentId, onClose }: Props) {
     <OGDialog open={item !== null} onOpenChange={(next) => !next && onClose()}>
       <OGDialogContent
         className={cn(
-          'w-11/12 gap-0 overflow-hidden rounded-2xl p-0 md:max-h-[85vh]',
+          'w-11/12 gap-0 overflow-hidden rounded-2xl p-0 md:max-h-[85dvh]',
           isAction ? 'max-w-5xl' : 'max-w-[560px]',
         )}
         data-testid="item-dialog"
       >
         {item && (
-          <div className="flex max-h-[85vh] flex-col">
+          <div className="flex max-h-[85dvh] flex-col">
             <ItemDialogHeader item={item} />
             <div
               className={cn(
diff --git a/client/src/components/SidePanel/Agents/Tools/MarketplaceSidebar.tsx b/client/src/components/SidePanel/Agents/Tools/MarketplaceSidebar.tsx
index e4f3f8f3387..143831daf37 100644
--- a/client/src/components/SidePanel/Agents/Tools/MarketplaceSidebar.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/MarketplaceSidebar.tsx
@@ -22,7 +22,8 @@ interface MarketplaceSidebarProps {
   onCreateNew?: (kind: 'mcp' | 'action') => void;
 }
 
-interface SidebarItemProps {
+interface SidebarEntry {
+  id: string;
   icon: ReactNode;
   label: string;
   active: boolean;
@@ -30,39 +31,90 @@ interface SidebarItemProps {
   count?: number;
 }
 
-function SidebarItem({ icon, label, active, onClick, count }: SidebarItemProps) {
-  return (
-    <button
-      type="button"
-      onClick={onClick}
-      aria-pressed={active}
-      className={cn(
-        'flex w-full items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-left text-sm transition-colors',
-        active
-          ? 'bg-surface-active font-medium text-text-primary'
-          : 'text-text-secondary hover:bg-surface-hover hover:text-text-primary',
-      )}
-    >
-      <span className="flex size-4 shrink-0 items-center justify-center">{icon}</span>
-      <span className="flex-1 truncate">{label}</span>
-      {count !== undefined && count > 0 && (
-        <span className="text-[11px] tabular-nums text-text-secondary">{count}</span>
-      )}
-    </button>
-  );
-}
-
-export default function MarketplaceSidebar({
+/** Kind and view navigation shared by the desktop rail and the mobile chip row. */
+function useMarketplaceNav({
   activeView,
   activeKind,
   onSelectView,
   onSelectKind,
   counts,
   totalCount,
-  onCreateNew,
 }: MarketplaceSidebarProps) {
   const localize = useLocalize();
-  const [createOpen, setCreateOpen] = useState(false);
+  const selectKind = (kind: Kind) => {
+    onSelectView('marketplace');
+    onSelectKind(kind);
+  };
+  const selectView = (view: View) => {
+    onSelectView(view);
+    onSelectKind('all');
+  };
+
+  const kindEntries: SidebarEntry[] = [
+    {
+      id: 'all',
+      icon: <LayoutGrid className="size-4" />,
+      label: localize('com_ui_all_proper'),
+      active: activeKind === 'all' && activeView === 'marketplace',
+      onClick: () => selectKind('all'),
+      count: totalCount,
+    },
+    {
+      id: 'builtin',
+      icon: <ListFilter className="size-4" />,
+      label: localize('com_ui_tools_kind_official'),
+      active: activeKind === 'builtin' && activeView === 'marketplace',
+      onClick: () => selectKind('builtin'),
+      count: counts.builtin,
+    },
+    {
+      id: 'tool',
+      icon: <Wrench className="size-4" />,
+      label: localize('com_ui_tools_kind_tools'),
+      active: activeKind === 'tool' && activeView === 'marketplace',
+      onClick: () => selectKind('tool'),
+      count: counts.tool,
+    },
+    {
+      id: 'mcp',
+      icon: <Server className="size-4" />,
+      label: localize('com_ui_tools_kind_mcp'),
+      active: activeKind === 'mcp' && activeView === 'marketplace',
+      onClick: () => selectKind('mcp'),
+      count: counts.mcp,
+    },
+    {
+      id: 'action',
+      icon: <Workflow className="size-4" />,
+      label: localize('com_ui_tools_kind_actions'),
+      active: activeKind === 'action' && activeView === 'marketplace',
+      onClick: () => selectKind('action'),
+      count: counts.action,
+    },
+  ];
+
+  const viewEntries: SidebarEntry[] = [
+    {
+      id: 'mine',
+      icon: <User className="size-4" />,
+      label: localize('com_ui_tools_view_made_by_you'),
+      active: activeView === 'mine',
+      onClick: () => selectView('mine'),
+    },
+    {
+      id: 'favorites',
+      icon: <Star className="size-4" />,
+      label: localize('com_ui_tools_view_favorites'),
+      active: activeView === 'favorites',
+      onClick: () => selectView('favorites'),
+    },
+  ];
+
+  return { kindEntries, viewEntries };
+}
+
+function useCreateItems(onCreateNew?: (kind: 'mcp' | 'action') => void) {
+  const localize = useLocalize();
   const { agentsConfig } = useAgentPanelContext();
   const hasMcpCreateAccess = useHasAccess({
     permissionType: PermissionTypes.MCP_SERVERS,
@@ -73,7 +125,7 @@ export default function MarketplaceSidebar({
     [agentsConfig],
   );
 
-  const createItems = useMemo(() => {
+  return useMemo(() => {
     const items: Array<{ label: string; icon: ReactNode; onClick: () => void }> = [];
     if (hasMcpCreateAccess) {
       items.push({
@@ -91,6 +143,61 @@ export default function MarketplaceSidebar({
     }
     return items;
   }, [localize, onCreateNew, hasMcpCreateAccess, actionsEnabled]);
+}
+
+function SidebarItem({ icon, label, active, onClick, count }: SidebarEntry) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      aria-pressed={active}
+      className={cn(
+        'flex w-full items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-left text-sm transition-colors',
+        active
+          ? 'bg-surface-active font-medium text-text-primary'
+          : 'text-text-secondary hover:bg-surface-hover hover:text-text-primary',
+      )}
+    >
+      <span className="flex size-4 shrink-0 items-center justify-center">{icon}</span>
+      <span className="flex-1 truncate">{label}</span>
+      {count !== undefined && count > 0 && (
+        <span className="text-[11px] tabular-nums text-text-secondary">{count}</span>
+      )}
+    </button>
+  );
+}
+
+/** The chip row is this layout's primary navigation, and it only exists where a
+ *  finger is what reaches it, so the chips carry the shared tap-target floor
+ *  rather than the compact height a mouse would be happy with. */
+function SidebarChip({ icon, label, active, onClick, count }: SidebarEntry) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      aria-pressed={active}
+      className={cn(
+        'flex shrink-0 items-center gap-1.5 rounded-full border px-3 py-1.5 text-xs transition-colors',
+        'touch:min-h-theme-control-touch touch:px-4',
+        active
+          ? 'border-border-medium bg-surface-active font-medium text-text-primary'
+          : 'border-border-light text-text-secondary hover:bg-surface-hover hover:text-text-primary',
+      )}
+    >
+      <span className="flex size-4 shrink-0 items-center justify-center">{icon}</span>
+      <span>{label}</span>
+      {count !== undefined && count > 0 && (
+        <span className="text-[10px] tabular-nums text-text-secondary">{count}</span>
+      )}
+    </button>
+  );
+}
+
+export default function MarketplaceSidebar(props: MarketplaceSidebarProps) {
+  const localize = useLocalize();
+  const [createOpen, setCreateOpen] = useState(false);
+  const { kindEntries, viewEntries } = useMarketplaceNav(props);
+  const createItems = useCreateItems(props.onCreateNew);
 
   return (
     <aside className="flex w-56 shrink-0 flex-col gap-0.5 border-r border-border-light bg-surface-primary-alt p-3">
@@ -125,77 +232,69 @@ export default function MarketplaceSidebar({
         />
       )}
 
-      <SidebarItem
-        icon={<LayoutGrid className="size-4" />}
-        label={localize('com_ui_all_proper')}
-        active={activeKind === 'all' && activeView === 'marketplace'}
-        onClick={() => {
-          onSelectView('marketplace');
-          onSelectKind('all');
-        }}
-        count={totalCount}
-      />
-      <SidebarItem
-        icon={<ListFilter className="size-4" />}
-        label={localize('com_ui_tools_kind_official')}
-        active={activeKind === 'builtin' && activeView === 'marketplace'}
-        onClick={() => {
-          onSelectView('marketplace');
-          onSelectKind('builtin');
-        }}
-        count={counts.builtin}
-      />
-      <SidebarItem
-        icon={<Wrench className="size-4" />}
-        label={localize('com_ui_tools_kind_tools')}
-        active={activeKind === 'tool' && activeView === 'marketplace'}
-        onClick={() => {
-          onSelectView('marketplace');
-          onSelectKind('tool');
-        }}
-        count={counts.tool}
-      />
-      <SidebarItem
-        icon={<Server className="size-4" />}
-        label={localize('com_ui_tools_kind_mcp')}
-        active={activeKind === 'mcp' && activeView === 'marketplace'}
-        onClick={() => {
-          onSelectView('marketplace');
-          onSelectKind('mcp');
-        }}
-        count={counts.mcp}
-      />
-      <SidebarItem
-        icon={<Workflow className="size-4" />}
-        label={localize('com_ui_tools_kind_actions')}
-        active={activeKind === 'action' && activeView === 'marketplace'}
-        onClick={() => {
-          onSelectView('marketplace');
-          onSelectKind('action');
-        }}
-        count={counts.action}
-      />
+      {kindEntries.map((entry) => (
+        <SidebarItem key={entry.id} {...entry} />
+      ))}
 
       <div className="mx-2 my-3 h-px bg-border-light" />
 
-      <SidebarItem
-        icon={<User className="size-4" />}
-        label={localize('com_ui_tools_view_made_by_you')}
-        active={activeView === 'mine'}
-        onClick={() => {
-          onSelectView('mine');
-          onSelectKind('all');
-        }}
-      />
-      <SidebarItem
-        icon={<Star className="size-4" />}
-        label={localize('com_ui_tools_view_favorites')}
-        active={activeView === 'favorites'}
-        onClick={() => {
-          onSelectView('favorites');
-          onSelectKind('all');
-        }}
-      />
+      {viewEntries.map((entry) => (
+        <SidebarItem key={entry.id} {...entry} />
+      ))}
     </aside>
   );
 }
+
+/** Mobile stand-in for the sidebar rail: a horizontally scrollable chip row
+ *  rendered under the search field when the rail is hidden. */
+export function MarketplaceFilterBar(props: MarketplaceSidebarProps) {
+  const localize = useLocalize();
+  const [createOpen, setCreateOpen] = useState(false);
+  const { kindEntries, viewEntries } = useMarketplaceNav(props);
+  const createItems = useCreateItems(props.onCreateNew);
+
+  return (
+    /* The scrollbar hides only where a finger can drag the row instead. A narrow
+       desktop window is below md too, and there a wheel scrolls the page rather
+       than this row, so the bar is the only way to reach the trailing views. */
+    <div
+      role="group"
+      className="flex shrink-0 items-center gap-1.5 overflow-x-auto border-b border-border-light px-4 pb-2.5 touch:[scrollbar-width:none] touch:[&::-webkit-scrollbar]:hidden"
+      aria-label={localize('com_ui_tools_marketplace')}
+    >
+      {createItems.length > 0 && (
+        <DropdownPopup
+          portal={true}
+          mountByState={true}
+          unmountOnHide={true}
+          isOpen={createOpen}
+          setIsOpen={setCreateOpen}
+          menuId="marketplace-create-new-mobile"
+          className="pointer-events-auto"
+          trigger={
+            <Ariakit.MenuButton
+              render={
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="h-8 w-8 shrink-0 justify-center p-0 touch:size-theme-control-touch"
+                  aria-label={localize('com_ui_tools_create_new')}
+                >
+                  <Plus className="size-4" aria-hidden="true" />
+                </Button>
+              }
+            />
+          }
+          items={createItems}
+        />
+      )}
+      {kindEntries.map((entry) => (
+        <SidebarChip key={entry.id} {...entry} />
+      ))}
+      <span className="h-4 w-px shrink-0 bg-border-light" aria-hidden="true" />
+      {viewEntries.map((entry) => (
+        <SidebarChip key={entry.id} {...entry} />
+      ))}
+    </div>
+  );
+}
diff --git a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
index 92e343fd8e2..063481f475c 100644
--- a/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/SkillsDialog.tsx
@@ -11,6 +11,7 @@ import {
   OGDialogTitle,
   OGDialogContent,
   OGDialogDescription,
+  useMediaQuery,
 } from '@librechat/client';
 import type { TSkill, TSkillSummary } from 'librechat-data-provider';
 import type { TranslationKeys } from '~/hooks/useLocalize';
@@ -27,6 +28,7 @@ import ItemDialog from './ItemDialog/ItemDialog';
 import { applyFilter } from './items/filtering';
 import CategoryFilter from './CategoryFilter';
 import { itemKey } from './items/selectors';
+import { cn } from '~/utils';
 
 interface SkillsDialogProps {
   open: boolean;
@@ -46,6 +48,9 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
   const localize = useLocalize();
   const { user } = useAuthContext();
   const { control, getValues, setValue } = useFormContext<AgentForm>();
+  /** The header's two layouts read in different orders, so the breakpoint selects
+   *  which DOM order renders; same query as the marketplace dialog's rail. */
+  const isDesktop = useMediaQuery('(min-width: 768px)');
 
   const hasSkillsAccess = useHasAccess({
     permissionType: PermissionTypes.SKILLS,
@@ -180,65 +185,96 @@ export default function SkillsDialog({ open, onOpenChange, agentId }: SkillsDial
       ? 'com_ui_no_skills_found'
       : undefined;
 
+  /** The header is one row from md and two below it, and the two read in different
+   *  orders, so the breakpoint picks the DOM order rather than `order-*` reshuffling
+   *  one. Each control is built once and placed by whichever branch renders. */
+  const viewRadio = (
+    <Radio
+      wrap
+      options={viewOptions}
+      value={view}
+      onChange={(value) => {
+        setView(value as SkillView);
+        setCategory('all');
+      }}
+      className="p-1"
+      aria-labelledby="skills-view-label"
+    />
+  );
+  const createButton = hasCreateAccess ? (
+    <Button
+      type="button"
+      variant="outline"
+      size="sm"
+      onClick={() => setCreateOpen(true)}
+      aria-label={localize('com_ui_create_skill')}
+      className={cn('h-[42px] w-[42px] shrink-0 p-0', !isDesktop && 'ml-auto')}
+    >
+      <Plus className="size-4" aria-hidden="true" />
+    </Button>
+  ) : null;
+  const filterField = (
+    <div
+      className={cn('flex items-center gap-2', isDesktop ? 'min-w-0 grow basis-0' : 'basis-full')}
+    >
+      <div className="relative min-w-0 flex-1">
+        <Search
+          className="pointer-events-none absolute left-3 top-1/2 z-[1] size-4 -translate-y-1/2 text-text-tertiary"
+          aria-hidden="true"
+        />
+        <Input
+          type="text"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder={localize('com_ui_search_skills')}
+          aria-label={localize('com_ui_search_skills')}
+          className="h-[42px] bg-transparent pl-9"
+        />
+      </div>
+      <CategoryFilter options={categoryOptions} value={category} onChange={setCategory} />
+    </div>
+  );
+
   return (
     <OGDialog open={open} onOpenChange={onOpenChange}>
       <OGDialogContent className="w-11/12 max-w-[900px] overflow-hidden rounded-2xl border-border-medium p-0 shadow-xl md:max-h-[92vh]">
         <OGDialogDescription className="sr-only">
           {localize('com_ui_skills_dialog_description')}
         </OGDialogDescription>
-        <div className="flex h-[80vh] max-h-[760px] flex-col">
-          <div className="flex flex-col gap-3 border-b border-border-light px-6 pb-4 pt-5">
+        <div className="flex h-[80dvh] max-h-[760px] flex-col">
+          <div className="flex flex-col gap-3 border-b border-border-light px-4 pb-3 pt-4 md:px-6 md:pb-4 md:pt-5">
             <div className="flex items-center gap-2 pr-10">
               <OGDialogTitle className="text-base font-semibold text-text-primary">
                 {localize('com_ui_skills')}
               </OGDialogTitle>
             </div>
 
-            <div className="flex items-center gap-2">
-              {hasCreateAccess && (
-                <Button
-                  type="button"
-                  variant="outline"
-                  size="sm"
-                  onClick={() => setCreateOpen(true)}
-                  aria-label={localize('com_ui_create_skill')}
-                  className="h-[42px] w-[42px] shrink-0 p-0"
-                >
-                  <Plus className="size-4" aria-hidden="true" />
-                </Button>
-              )}
-              <div className="relative min-w-0 flex-1">
-                <Search
-                  className="pointer-events-none absolute left-3 top-1/2 z-[1] size-4 -translate-y-1/2 text-text-tertiary"
-                  aria-hidden="true"
-                />
-                <Input
-                  type="text"
-                  value={search}
-                  onChange={(e) => setSearch(e.target.value)}
-                  placeholder={localize('com_ui_search_skills')}
-                  aria-label={localize('com_ui_search_skills')}
-                  className="h-[42px] bg-transparent pl-9"
-                />
-              </div>
-              <CategoryFilter options={categoryOptions} value={category} onChange={setCategory} />
+            {/* DOM order is the order each breakpoint reads in, so tab order follows
+                the eye: from md the row is create, field, radio, exactly as before;
+                below md the radio and the create button take the first line and the
+                field the second. `order-*` would have kept one subtree, but it left
+                desktop tabbing from the rightmost radio back to the create button. */}
+            <div className="flex flex-wrap items-center gap-2">
               <Label id="skills-view-label" className="sr-only">
                 {localize('com_ui_skills_filter')}
               </Label>
-              <Radio
-                options={viewOptions}
-                value={view}
-                onChange={(value) => {
-                  setView(value as SkillView);
-                  setCategory('all');
-                }}
-                className="flex-shrink-0 p-1"
-                aria-labelledby="skills-view-label"
-              />
+              {isDesktop ? (
+                <>
+                  {createButton}
+                  {filterField}
+                  {viewRadio}
+                </>
+              ) : (
+                <>
+                  {viewRadio}
+                  {createButton}
+                  {filterField}
+                </>
+              )}
             </div>
           </div>
 
-          <div className="flex-1 overflow-y-auto px-6 py-4">
+          <div className="min-h-0 flex-1 overflow-y-auto px-4 py-3 md:px-6 md:py-4">
             {isSkillsError && (
               <div
                 role="alert"
diff --git a/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx b/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
index d3cd5e0f7e0..a4397c60184 100644
--- a/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ToolCard.tsx
@@ -105,9 +105,13 @@ function ToolCardImpl({
   const DetailIcon = canConfigure ? Settings : Info;
 
   return (
+    /* touch:h-36 with touch:pb-9 on the content: where a coarse pointer exists the
+     action cluster below is permanent rather than revealed on hover, so the card
+     owes it a strip of its own. Without that the last line of a three-line
+     description sits under the buttons for as long as the card is on screen. */
     <div
       className={cn(
-        'group relative flex h-32 w-full flex-col overflow-hidden rounded-2xl border',
+        'group relative flex h-32 w-full flex-col overflow-hidden rounded-2xl border touch:h-36',
         selected
           ? 'border-status-success bg-status-success/10 shadow-sm'
           : 'border-border-light bg-transparent hover:border-border-medium hover:bg-surface-tertiary hover:shadow-sm',
@@ -118,7 +122,7 @@ function ToolCardImpl({
         onClick={() => onToggle(item)}
         aria-pressed={selected}
         className={cn(
-          'flex h-full w-full cursor-pointer flex-col gap-2 rounded-2xl p-4 text-left',
+          'flex h-full w-full cursor-pointer flex-col gap-2 rounded-2xl p-4 text-left touch:pb-9',
           'focus:outline-none focus-visible:ring-2 focus-visible:ring-ring-primary',
         )}
       >
@@ -204,8 +208,8 @@ function ToolCardImpl({
               }
               className={cn(
                 'flex size-7 items-center justify-center rounded-lg text-text-secondary',
-                'opacity-0 transition duration-150 hover:bg-surface-hover hover:text-text-primary',
-                'group-focus-within:opacity-100 group-hover:opacity-100',
+                'transition duration-150 hover:bg-surface-hover hover:text-text-primary',
+                'group-focus-within:opacity-100 group-hover:opacity-100 no-touch:opacity-0',
                 'focus:outline-none focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring-primary',
               )}
             >
@@ -223,10 +227,11 @@ function ToolCardImpl({
               aria-label={localize(isFavorited ? 'com_ui_unfavorite' : 'com_ui_favorite')}
               className={cn(
                 'flex size-7 items-center justify-center rounded-lg text-text-secondary',
-                'opacity-0 transition duration-150 hover:bg-surface-hover hover:text-text-primary',
+                'transition duration-150 hover:bg-surface-hover hover:text-text-primary',
                 'group-focus-within:opacity-100 group-hover:opacity-100',
                 'focus:outline-none focus-visible:opacity-100 focus-visible:ring-2 focus-visible:ring-ring-primary',
-                isFavorited && 'text-series-4 opacity-100 hover:text-series-4',
+                !isFavorited && 'no-touch:opacity-0',
+                isFavorited && 'text-series-4 hover:text-series-4',
               )}
             >
               <Star className={cn('size-4', isFavorited && 'fill-current')} aria-hidden="true" />
diff --git a/client/src/components/SidePanel/Agents/Tools/ToolRow.tsx b/client/src/components/SidePanel/Agents/Tools/ToolRow.tsx
index ef8d3131f30..398b18fe192 100644
--- a/client/src/components/SidePanel/Agents/Tools/ToolRow.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ToolRow.tsx
@@ -75,8 +75,8 @@ function ToolRowImpl({ item, onInfo, onRemove }: Props) {
       )}
       <div
         className={cn(
-          'flex shrink-0 items-center gap-0.5 opacity-0',
-          'group-focus-within:opacity-100 group-hover:opacity-100',
+          'flex shrink-0 items-center gap-0.5',
+          'group-focus-within:opacity-100 group-hover:opacity-100 no-touch:opacity-0',
         )}
       >
         <Button
diff --git a/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx b/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
index ea1ea38cfff..6db685769a1 100644
--- a/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/ToolsMarketplaceDialog.tsx
@@ -8,6 +8,7 @@ import {
   OGDialogTitle,
   OGDialogContent,
   OGDialogDescription,
+  useMediaQuery,
   useToastContext,
 } from '@librechat/client';
 import type { AgentItem, AgentItemKind, ItemFilter } from './items/types';
@@ -21,11 +22,11 @@ import {
   mcpServerIds,
 } from './items/selectors';
 import { useAgentFileEntries, useAgentItems, useUninstallToolCredentials } from './hooks';
+import MarketplaceSidebar, { MarketplaceFilterBar } from './MarketplaceSidebar';
 import { requiresFileManagerRemoval } from './items/capabilities';
 import AddMcpServerDialog from './ItemDialog/AddMcpServerDialog';
 import { computeToggleAction } from './items/mutations';
 import { useLocalize, useToolFavorites } from '~/hooks';
-import MarketplaceSidebar from './MarketplaceSidebar';
 import MarketplaceCatalog from './MarketplaceCatalog';
 import ItemDialog from './ItemDialog/ItemDialog';
 import { applyFilter } from './items/filtering';
@@ -62,6 +63,9 @@ export default function ToolsMarketplaceDialog({
   const [detailItem, setDetailItem] = useState<AgentItem | null>(null);
   const [addMcpOpen, setAddMcpOpen] = useState(false);
 
+  /** The rail is md+; below it the same navigation renders as a chip row. */
+  const isDesktop = useMediaQuery('(min-width: 768px)');
+
   const handleCreateNew = useCallback(
     (createKind: 'mcp' | 'action') => {
       if (createKind === 'mcp') {
@@ -218,23 +222,36 @@ export default function ToolsMarketplaceDialog({
 
   return (
     <OGDialog open={open} onOpenChange={onOpenChange}>
-      <OGDialogContent className="w-11/12 max-w-[1200px] overflow-hidden rounded-2xl border-border-medium p-0 shadow-xl md:max-h-[92vh]">
+      {/* The body carries the height from md, the way it did before this change, so
+          the shell wraps it and the two cannot disagree: an explicit height on the
+          shell would leave its difference from the body's 840px ceiling as dead
+          space below the catalog on a tall screen. Below md the shell is the
+          full-bleed sheet and the body is capped to the same 100dvh, because its
+          `h-full` resolves against a grid area sized to the whole catalog. */}
+      <OGDialogContent className="h-[100dvh] max-h-[100dvh] w-full max-w-full overflow-hidden rounded-none border-border-medium p-0 shadow-xl md:h-auto md:max-h-[92vh] md:w-11/12 md:max-w-[1200px] md:rounded-2xl">
         <OGDialogTitle className="sr-only">{localize('com_ui_tools_marketplace')}</OGDialogTitle>
         <OGDialogDescription className="sr-only">
           {localize('com_ui_tools_marketplace_description')}
         </OGDialogDescription>
-        <div className="flex h-[88vh] max-h-[840px]">
-          <MarketplaceSidebar
-            activeView={view}
-            activeKind={kind}
-            onSelectView={setView}
-            onSelectKind={setKind}
-            counts={counts}
-            totalCount={catalog.length}
-            onCreateNew={handleCreateNew}
-          />
-          <div className="flex min-w-0 flex-1 flex-col">
-            <div className="flex items-center gap-2 px-6 py-4 pr-12">
+        {/* min-w-0: as a grid item of the dialog content, an `auto` minimum would
+            size this column to the chip row's min-content and overflow the viewport. */}
+        <div className="flex h-full max-h-[100dvh] min-w-0 flex-col md:h-[88vh] md:max-h-[840px] md:flex-row">
+          {isDesktop && (
+            <MarketplaceSidebar
+              activeView={view}
+              activeKind={kind}
+              onSelectView={setView}
+              onSelectKind={setKind}
+              counts={counts}
+              totalCount={catalog.length}
+              onCreateNew={handleCreateNew}
+            />
+          )}
+          <div className="flex min-h-0 min-w-0 flex-1 flex-col">
+            {/* md:pl-6, not md:px-6: a responsive variant is emitted after the base
+                utilities, so md:px-6 would reset the pr-12 that keeps the search
+                field clear of the dialog's close button. */}
+            <div className="flex items-center gap-2 px-4 py-3 pr-12 md:py-4 md:pl-6">
               <div className="relative flex-1">
                 <Search
                   className="pointer-events-none absolute left-3 top-1/2 z-[1] size-4 -translate-y-1/2 text-text-tertiary"
@@ -250,7 +267,18 @@ export default function ToolsMarketplaceDialog({
                 />
               </div>
             </div>
-            <div className="flex-1 overflow-y-auto p-4">
+            {!isDesktop && (
+              <MarketplaceFilterBar
+                activeView={view}
+                activeKind={kind}
+                onSelectView={setView}
+                onSelectKind={setKind}
+                counts={counts}
+                totalCount={catalog.length}
+                onCreateNew={handleCreateNew}
+              />
+            )}
+            <div className="min-h-0 flex-1 overflow-y-auto p-3 md:p-4">
               <MarketplaceCatalog
                 items={filtered}
                 selectedIds={selectedIds}
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx
index a9684d54c63..7c07a94b6d0 100644
--- a/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/SkillsDialog.spec.tsx
@@ -105,6 +105,9 @@ jest.mock('@librechat/client', () => ({
   ),
   OGDialogTitle: ({ children }: { children: React.ReactNode }) => <h2>{children}</h2>,
   OGDialogDescription: ({ children }: { children: React.ReactNode }) => <p>{children}</p>,
+  /** The header renders one DOM order per breakpoint; these cases are about
+   *  pagination, so they run as the desktop one. */
+  useMediaQuery: () => true,
 }));
 
 function makeSkill(id: string, name: string): TSkillSummary {
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
index 3c45b1abfaf..2f713785005 100644
--- a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolCard.spec.tsx
@@ -146,7 +146,6 @@ describe('ToolCard', () => {
       );
       const star = screen.getByRole('button', { name: 'com_ui_unfavorite' });
       expect(star).toHaveAttribute('aria-pressed', 'true');
-      expect(star).toHaveClass('opacity-100');
     });
 
     test('renders no star without an onToggleFavorite handler', () => {
diff --git a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
index 930150ff6bf..0ddb103916b 100644
--- a/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
+++ b/client/src/components/SidePanel/Agents/Tools/__tests__/ToolsMarketplaceDialog.spec.tsx
@@ -8,6 +8,7 @@ const mockGetValues = jest.fn((_: string): unknown => []);
 let mockWatchedTools: string[] = [];
 let mockExecuteCode = false;
 let mockMcpServersMap = new Map<string, object>();
+let mockIsDesktop = true;
 
 jest.mock('react-hook-form', () => ({
   useFormContext: () => ({
@@ -147,6 +148,7 @@ jest.mock('@librechat/client', () => {
         ? React.createElement(React.Fragment, null, children)
         : React.createElement('button', { type: 'button' }, children),
     VerifiedIcon: (props: SVGProps<SVGSVGElement>) => React.createElement('svg', props),
+    useMediaQuery: () => mockIsDesktop,
     useToastContext: () => ({ showToast: jest.fn() }),
   };
 });
@@ -170,6 +172,7 @@ describe('ToolsMarketplaceDialog', () => {
     mockMcpServersMap = new Map();
     mockToggleFavorite.mockClear();
     mockFavoriteKeys = new Set<string>();
+    mockIsDesktop = true;
     mockFileEntries = { contextFiles: [], knowledgeFiles: [], codeFiles: [] };
   });
 
@@ -397,4 +400,13 @@ describe('ToolsMarketplaceDialog', () => {
     fireEvent.click(screen.getByRole('button', { name: /com_ui_tools_view_favorites/ }));
     expect(screen.getByText('com_ui_tools_view_favorites_empty')).toBeInTheDocument();
   });
+
+  test('below md the rail is replaced by a functional filter chip row', () => {
+    mockIsDesktop = false;
+    render(<ToolsMarketplaceDialog open onOpenChange={jest.fn()} agentId="a1" />);
+    expect(screen.getByRole('group', { name: 'com_ui_tools_marketplace' })).toBeInTheDocument();
+    expect(screen.queryByText('com_ui_tools_create_new')).not.toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: /com_ui_tools_view_favorites/ }));
+    expect(screen.getByText('com_ui_tools_view_favorites_empty')).toBeInTheDocument();
+  });
 });
diff --git a/client/src/components/SidePanel/MCPBuilder/MCPServerCard.spec.tsx b/client/src/components/SidePanel/MCPBuilder/MCPServerCard.spec.tsx
new file mode 100644
index 00000000000..617377fba8b
--- /dev/null
+++ b/client/src/components/SidePanel/MCPBuilder/MCPServerCard.spec.tsx
@@ -0,0 +1,151 @@
+import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+import { render, screen, waitFor, fireEvent } from '@testing-library/react';
+import type { MCPServerStatusIconProps } from '~/components/MCP/MCPServerStatusIcon';
+import type { MCPServerDefinition } from '~/hooks';
+import MCPServerCard from './MCPServerCard';
+
+const mockInitializeServer = jest.fn();
+const mockGetOAuthUrl = jest.fn();
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+  useMCPServerManager: () => ({
+    initializeServer: mockInitializeServer,
+    revokeOAuthForServer: jest.fn(),
+    getOAuthUrl: mockGetOAuthUrl,
+  }),
+}));
+
+jest.mock('@librechat/client', () => ({
+  MCPIcon: () => <span />,
+}));
+
+jest.mock('./MCPCardActions', () => ({
+  __esModule: true,
+  default: ({ onInitialize }: { onInitialize: () => void }) => (
+    <button type="button" onClick={onInitialize}>
+      {'com_nav_mcp_connect'}
+    </button>
+  ),
+}));
+
+jest.mock('./MCPServerDialog', () => ({ __esModule: true, default: () => null }));
+jest.mock('./MCPStatusBadge', () => ({ getStatusDotColor: () => '' }));
+jest.mock('~/components/ui/CustomIcon', () => ({ __esModule: true, default: () => null }));
+jest.mock('~/components/MCP/McpOAuthDialog', () => ({
+  __esModule: true,
+  default: ({ open, oauthUrl }: { open: boolean; oauthUrl: string }) =>
+    open ? <div role="dialog">{oauthUrl}</div> : null,
+}));
+
+const server = {
+  serverName: 'clickhouse',
+  config: {},
+  effectivePermissions: 0,
+} as unknown as MCPServerDefinition;
+
+/** Mirrors the manager's shared state: the flow URL exists only while initializing. */
+const renderCard = (isInitializing: boolean, sharedOAuthUrl: string | null = null) => {
+  mockGetOAuthUrl.mockReturnValue(sharedOAuthUrl);
+  const statusProps = {
+    serverName: 'clickhouse',
+    serverStatus: { connectionState: 'disconnected', requiresOAuth: true },
+    onConfigClick: jest.fn(),
+    isInitializing,
+    canCancel: true,
+    onCancel: jest.fn(),
+    hasCustomUserVars: false,
+  } as unknown as MCPServerStatusIconProps;
+  return (
+    <MCPServerCard
+      server={server}
+      getServerStatusIconProps={() => statusProps}
+      canCreateEditMCPs={false}
+    />
+  );
+};
+
+const firstUrl = 'https://auth.example/authorize?flow=1';
+
+describe('MCPServerCard', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('surfaces the authorization URL in the OAuth dialog instead of opening a tab', async () => {
+    const open = jest.spyOn(window, 'open').mockImplementation(() => null);
+    mockInitializeServer.mockResolvedValue({
+      success: true,
+      oauthRequired: true,
+      oauthUrl: firstUrl,
+    });
+    const { rerender } = render(renderCard(false));
+
+    fireEvent.click(screen.getByText('com_nav_mcp_connect'));
+    await waitFor(() => expect(mockInitializeServer).toHaveBeenCalledWith('clickhouse', false));
+    rerender(renderCard(true, firstUrl));
+
+    expect(await screen.findByRole('dialog')).toHaveTextContent(firstUrl);
+    expect(open).not.toHaveBeenCalled();
+
+    rerender(renderCard(false));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    open.mockRestore();
+  });
+
+  test('keeps the OAuth dialog closed when connecting needs no authorization', async () => {
+    mockInitializeServer.mockResolvedValue({ success: true, oauthRequired: false });
+    const { rerender } = render(renderCard(false));
+
+    fireEvent.click(screen.getByText('com_nav_mcp_connect'));
+    await waitFor(() => expect(mockInitializeServer).toHaveBeenCalled());
+    rerender(renderCard(true));
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  test('stays closed for flows it did not start once its own flow ended', async () => {
+    mockInitializeServer.mockResolvedValueOnce({
+      success: true,
+      oauthRequired: true,
+      oauthUrl: firstUrl,
+    });
+    const { rerender } = render(renderCard(false));
+    fireEvent.click(screen.getByText('com_nav_mcp_connect'));
+    rerender(renderCard(true, firstUrl));
+    expect(await screen.findByRole('dialog')).toBeInTheDocument();
+    rerender(renderCard(false));
+
+    /** Another surface, such as the chat's MCP menu, initializes the same server. */
+    rerender(renderCard(true, 'https://auth.example/authorize?flow=2'));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  test('does not reopen a previous flow while the next connect is pending', async () => {
+    mockInitializeServer.mockResolvedValueOnce({
+      success: true,
+      oauthRequired: true,
+      oauthUrl: firstUrl,
+    });
+    const { rerender } = render(renderCard(false));
+    fireEvent.click(screen.getByText('com_nav_mcp_connect'));
+    rerender(renderCard(true, firstUrl));
+    expect(await screen.findByRole('dialog')).toBeInTheDocument();
+    rerender(renderCard(false));
+
+    let finishSecond: ((value: { success: boolean; oauthRequired: boolean }) => void) | undefined;
+    mockInitializeServer.mockReturnValueOnce(
+      new Promise((resolve) => {
+        finishSecond = resolve;
+      }),
+    );
+    fireEvent.click(screen.getByText('com_nav_mcp_connect'));
+    rerender(renderCard(true));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+
+    finishSecond!({ success: true, oauthRequired: false });
+    await waitFor(() => expect(mockInitializeServer).toHaveBeenCalledTimes(2));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+});
diff --git a/client/src/components/SidePanel/MCPBuilder/MCPServerCard.tsx b/client/src/components/SidePanel/MCPBuilder/MCPServerCard.tsx
index e93c9781b6c..2ba0e0ec6c9 100644
--- a/client/src/components/SidePanel/MCPBuilder/MCPServerCard.tsx
+++ b/client/src/components/SidePanel/MCPBuilder/MCPServerCard.tsx
@@ -1,8 +1,9 @@
-import { useState, useRef } from 'react';
+import { useState, useRef, useEffect } from 'react';
 import { MCPIcon } from '@librechat/client';
 import { PermissionBits, hasPermissions } from 'librechat-data-provider';
 import type { MCPServerStatusIconProps } from '~/components/MCP/MCPServerStatusIcon';
 import type { MCPServerDefinition } from '~/hooks';
+import McpOAuthDialog from '~/components/MCP/McpOAuthDialog';
 import { useMCPServerManager, useLocalize } from '~/hooks';
 import { getStatusDotColor } from './MCPStatusBadge';
 import CustomIcon from '~/components/ui/CustomIcon';
@@ -31,8 +32,9 @@ export default function MCPServerCard({
 }: MCPServerCardProps) {
   const localize = useLocalize();
   const triggerRef = useRef<HTMLDivElement>(null);
-  const { initializeServer, revokeOAuthForServer } = useMCPServerManager();
+  const { initializeServer, revokeOAuthForServer, getOAuthUrl } = useMCPServerManager();
   const [dialogOpen, setDialogOpen] = useState(false);
+  const [awaitingOAuth, setAwaitingOAuth] = useState(false);
 
   const statusIconProps = getServerStatusIconProps(server.serverName);
   const {
@@ -49,8 +51,20 @@ export default function MCPServerCard({
   const description = server.config?.description;
   const statusDotColor = getStatusDotColor(serverStatus, isInitializing);
   const canEdit = canCreateEditMCPs && canEditThisServer;
+  /** The shared flow URL is cleared when its initialization ends, so it can never be stale. */
+  const sharedOAuthUrl = getOAuthUrl(server.serverName);
 
-  const handleInitialize = () => {
+  useEffect(() => {
+    if (!isInitializing) {
+      setAwaitingOAuth(false);
+    }
+  }, [isInitializing]);
+
+  /**
+   * `autoOpenOAuth=false` surfaces the authorization URL in the OAuth dialog, whose Continue opens
+   * it inside the tap. A tab opened after the initialize request is blocked on iOS home-screen apps.
+   */
+  const handleInitialize = async () => {
     /** If server has custom user vars and is not already connected, show config dialog first
      *  This ensures users can enter credentials before initialization attempts
      */
@@ -58,7 +72,11 @@ export default function MCPServerCard({
       onConfigClick({ stopPropagation: () => {}, preventDefault: () => {} } as React.MouseEvent);
       return;
     }
-    initializeServer(server.serverName);
+    setAwaitingOAuth(false);
+    const response = await initializeServer(server.serverName, false);
+    if (response?.oauthRequired && response.oauthUrl) {
+      setAwaitingOAuth(true);
+    }
   };
 
   const handleRevoke = () => {
@@ -156,6 +174,17 @@ export default function MCPServerCard({
           server={server}
         />
       )}
+      <McpOAuthDialog
+        open={awaitingOAuth && isInitializing && sharedOAuthUrl != null}
+        onOpenChange={(open) => {
+          if (!open) {
+            setAwaitingOAuth(false);
+          }
+        }}
+        serverName={server.serverName}
+        oauthUrl={sharedOAuthUrl ?? ''}
+        iconUrl={server.config?.iconPath}
+      />
     </>
   );
 }
diff --git a/client/src/components/Skills/dialogs/DeleteSkill.tsx b/client/src/components/Skills/dialogs/DeleteSkill.tsx
index 85a6ece6594..075875f8700 100644
--- a/client/src/components/Skills/dialogs/DeleteSkill.tsx
+++ b/client/src/components/Skills/dialogs/DeleteSkill.tsx
@@ -26,8 +26,12 @@ function DeleteSkill({ skillId, skillName, disabled, onDelete }: DeleteSkillProp
   const localize = useLocalize();
   const { showToast } = useToastContext();
   const deleteSkill = useDeleteSkillMutation({
-    onSuccess: () => {
-      showToast({ status: 'success', message: localize('com_ui_skill_deleted') });
+    onSuccess: (response) => {
+      const cleanupComplete = response.cleanupComplete !== false;
+      showToast({
+        status: cleanupComplete ? 'success' : 'error',
+        message: localize(cleanupComplete ? 'com_ui_skill_deleted' : 'com_ui_skill_delete_partial'),
+      });
       onDelete?.();
     },
     onError: () => {
diff --git a/client/src/components/Skills/dialogs/UploadSkillDialog.tsx b/client/src/components/Skills/dialogs/UploadSkillDialog.tsx
index 6ae501c83bd..d5f97dccf32 100644
--- a/client/src/components/Skills/dialogs/UploadSkillDialog.tsx
+++ b/client/src/components/Skills/dialogs/UploadSkillDialog.tsx
@@ -7,6 +7,12 @@ import {
   mergeFileConfig,
   fileConfig as defaultFileConfig,
 } from 'librechat-data-provider';
+import type {
+  SkillImportFailureReason,
+  TSkillImportFailedFile,
+  TSkillImportFailedResponse,
+} from 'librechat-data-provider';
+import type { TranslationKeys } from '~/hooks';
 import { useGetFileConfig, useImportSkillMutation } from '~/data-provider';
 import { useLocalize } from '~/hooks';
 import { cn } from '~/utils';
@@ -21,12 +27,79 @@ function formatMegabytes(bytes: number): string {
   return Number.isInteger(value) ? `${value}` : value.toFixed(1);
 }
 
+/** Localization key per failure reason; `limitMb` fills `{{0}}` where present. */
+const FAILURE_REASON_KEYS: Record<SkillImportFailureReason, TranslationKeys> = {
+  invalid_path: 'com_ui_skill_upload_reason_invalid_path',
+  file_too_large: 'com_ui_skill_upload_reason_file_too_large',
+  archive_too_large: 'com_ui_skill_upload_reason_archive_too_large',
+  archive_entry_changed: 'com_ui_skill_upload_reason_archive_entry_changed',
+  persistence_failed: 'com_ui_skill_upload_reason_persistence_failed',
+};
+
+type ImportFailure = {
+  /** `skill_import_rollback_failed` also means the leftover skill needs deleting. */
+  code: TSkillImportFailedResponse['error'];
+  files: TSkillImportFailedFile[];
+};
+
+/**
+ * An import that could not persist every bundled file is rolled back whole and
+ * answered with `failedFiles`. Those paths are the only place the user learns
+ * which resources their archive lost, so they are rendered in the dialog
+ * instead of being flattened into a toast that disappears.
+ */
+function getImportFailure(error: unknown): ImportFailure | null {
+  const data = (error as { response?: { data?: unknown } })?.response?.data;
+  if (data == null || typeof data !== 'object') {
+    return null;
+  }
+  const body = data as Partial<TSkillImportFailedResponse>;
+  if (
+    (body.error !== 'skill_import_incomplete' &&
+      body.error !== 'skill_import_rollback_failed' &&
+      body.error !== 'skill_import_cleanup_incomplete') ||
+    !Array.isArray(body.failedFiles)
+  ) {
+    return null;
+  }
+  return { code: body.error, files: body.failedFiles };
+}
+
+function failureMessageKey(code: ImportFailure['code']): TranslationKeys {
+  if (code === 'skill_import_rollback_failed') {
+    return 'com_ui_skill_upload_rollback_failed';
+  }
+  if (code === 'skill_import_cleanup_incomplete') {
+    return 'com_ui_skill_upload_cleanup_incomplete';
+  }
+  return 'com_ui_skill_upload_incomplete';
+}
+
+function failureHeadingKey(code: ImportFailure['code']): TranslationKeys {
+  if (code === 'skill_import_rollback_failed') {
+    return 'com_ui_skill_upload_rollback_failed_files';
+  }
+  if (code === 'skill_import_cleanup_incomplete') {
+    return 'com_ui_skill_upload_cleanup_incomplete_files';
+  }
+  return 'com_ui_skill_upload_failed_files';
+}
+
 export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDialogProps) {
   const localize = useLocalize();
   const navigate = useNavigate();
   const { showToast } = useToastContext();
   const fileInputRef = useRef<HTMLInputElement>(null);
   const [isDragging, setIsDragging] = useState(false);
+  const [failure, setFailure] = useState<ImportFailure | null>(null);
+  /**
+   * The dialog outlives any single upload: `CreateSkillMenu` keeps it mounted
+   * and only toggles `isOpen`. Closing it mid-import cannot cancel the request,
+   * so each session is numbered and a response that resolves after its own
+   * session ended is dropped rather than repopulating a dismissed panel.
+   */
+  const dialogSessionRef = useRef(0);
+  const requestSessionRef = useRef(0);
   const {
     data: skillFileConfig = { configuredSizeLimitMb: undefined, fileConfig: defaultFileConfig },
   } = useGetFileConfig({
@@ -45,15 +118,36 @@ export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDial
 
   const importMutation = useImportSkillMutation({
     onSuccess: (skill) => {
+      if (requestSessionRef.current !== dialogSessionRef.current) {
+        return;
+      }
+      setFailure(null);
       showToast({ status: 'success', message: localize('com_ui_skill_created') });
       setIsOpen(false);
       navigate(`/skills/${skill._id}`);
     },
     onError: (error: unknown) => {
+      if (requestSessionRef.current !== dialogSessionRef.current) {
+        return;
+      }
+      const importFailure = getImportFailure(error);
+      if (importFailure != null) {
+        /** Keep the dialog open: the archive has to be fixed before a retry can
+         *  succeed, and the failed paths are only listed here. */
+        setFailure(importFailure);
+        showToast({
+          status: 'error',
+          message: localize(failureMessageKey(importFailure.code), {
+            0: `${importFailure.files.length}`,
+          }),
+        });
+        return;
+      }
       const errData = (error as { response?: { data?: { error?: string; message?: string } } })
         ?.response?.data;
       const message =
         errData?.message ?? errData?.error ?? localize('com_ui_create_skill_upload_error');
+      setFailure(null);
       showToast({ status: 'error', message });
     },
   });
@@ -63,6 +157,7 @@ export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDial
       if (importMutation.isLoading) {
         return;
       }
+      setFailure(null);
       if (file.size > skillImportSizeLimit) {
         showToast({
           status: 'error',
@@ -72,6 +167,7 @@ export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDial
       }
       const formData = new FormData();
       formData.append('file', file, file.name);
+      requestSessionRef.current = dialogSessionRef.current;
       importMutation.mutate(formData);
     },
     [displayedSizeLimit, importMutation, localize, showToast, skillImportSizeLimit],
@@ -101,7 +197,16 @@ export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDial
   );
 
   return (
-    <OGDialog open={isOpen} onOpenChange={setIsOpen}>
+    <OGDialog
+      open={isOpen}
+      onOpenChange={(open) => {
+        if (!open) {
+          dialogSessionRef.current += 1;
+          setFailure(null);
+        }
+        setIsOpen(open);
+      }}
+    >
       <OGDialogContent className="w-11/12 max-w-lg overflow-hidden">
         <div className="flex flex-col gap-6 p-1 sm:p-2">
           <h2 className="text-lg font-bold text-text-primary">
@@ -135,6 +240,33 @@ export default function UploadSkillDialog({ isOpen, setIsOpen }: UploadSkillDial
               {localize('com_ui_skill_upload_drag')}
             </button>
 
+            {failure != null && failure.files.length > 0 && (
+              <div
+                role="alert"
+                className="flex flex-col gap-1 rounded-lg border border-border-medium bg-surface-secondary p-3 text-xs"
+              >
+                <p className="font-medium text-text-destructive">
+                  {localize(failureHeadingKey(failure.code))}
+                </p>
+                {/* An archive may hold up to 500 entries, and the dialog's own
+                    overflow-hidden would clip a long list past the viewport. */}
+                <ul className="max-h-40 list-inside list-disc overflow-y-auto text-text-secondary">
+                  {failure.files.map((failedFile) => (
+                    <li key={failedFile.path}>
+                      <span className="break-all font-medium text-text-primary">
+                        {failedFile.path}
+                      </span>
+                      {FAILURE_REASON_KEYS[failedFile.reason] != null
+                        ? ` — ${localize(FAILURE_REASON_KEYS[failedFile.reason], {
+                            0: `${failedFile.limitMb ?? ''}`,
+                          })}`
+                        : ''}
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            )}
+
             <div className="flex flex-col gap-3 text-xs text-text-secondary">
               <div>
                 <p className="font-medium">{localize('com_ui_skill_upload_requirements')}</p>
diff --git a/client/src/components/Skills/dialogs/__tests__/UploadSkillDialog.spec.tsx b/client/src/components/Skills/dialogs/__tests__/UploadSkillDialog.spec.tsx
index 5e20ca4f562..f4fe40cf11a 100644
--- a/client/src/components/Skills/dialogs/__tests__/UploadSkillDialog.spec.tsx
+++ b/client/src/components/Skills/dialogs/__tests__/UploadSkillDialog.spec.tsx
@@ -1,4 +1,4 @@
-import { fireEvent, render, screen } from '@testing-library/react';
+import { act, fireEvent, render, screen } from '@testing-library/react';
 import type { FileConfigInput } from 'librechat-data-provider';
 import type { ReactNode } from 'react';
 import UploadSkillDialog from '../UploadSkillDialog';
@@ -7,6 +7,13 @@ const mockMutate = jest.fn();
 const mockNavigate = jest.fn();
 const mockSetIsOpen = jest.fn();
 const mockShowToast = jest.fn();
+interface ImportMutationOptions {
+  onSuccess?: (skill: { _id: string }) => void;
+  onError?: (error: unknown) => void;
+}
+let mockImportOptions: ImportMutationOptions | undefined;
+/** Captured from OGDialog so a test can dismiss the dialog the way Escape does. */
+let mockOnOpenChange: ((open: boolean) => void) | undefined;
 let mockFileConfigInput: FileConfigInput | undefined = {
   skills: {
     fileSizeLimit: 1,
@@ -22,13 +29,23 @@ jest.mock('@librechat/client', () => {
   const React = jest.requireActual<typeof import('react')>('react');
   const ReactDOM = jest.requireActual<typeof import('react-dom')>('react-dom');
   return {
-    OGDialog: ({ open, children }: { open: boolean; children: ReactNode }) =>
-      open
+    OGDialog: ({
+      open,
+      onOpenChange,
+      children,
+    }: {
+      open: boolean;
+      onOpenChange?: (next: boolean) => void;
+      children: ReactNode;
+    }) => {
+      mockOnOpenChange = onOpenChange;
+      return open
         ? ReactDOM.createPortal(
             React.createElement('div', null, children),
             globalThis.document.body,
           )
-        : null,
+        : null;
+    },
     OGDialogContent: ({ children }: { children: ReactNode }) =>
       React.createElement('div', { role: 'dialog', 'data-state': 'open' }, children),
     Spinner: () => React.createElement('div', { 'data-testid': 'spinner' }),
@@ -42,10 +59,13 @@ jest.mock('~/data-provider', () => ({
   useGetFileConfig: ({ select }: { select?: (data: FileConfigInput | undefined) => unknown }) => ({
     data: select != null ? select(mockFileConfigInput) : mockFileConfigInput,
   }),
-  useImportSkillMutation: () => ({
-    mutate: mockMutate,
-    isLoading: false,
-  }),
+  useImportSkillMutation: (options?: ImportMutationOptions) => {
+    mockImportOptions = options;
+    return {
+      mutate: mockMutate,
+      isLoading: false,
+    };
+  },
 }));
 
 jest.mock('~/hooks', () => ({
@@ -63,6 +83,20 @@ jest.mock('~/hooks', () => ({
         com_ui_skill_upload_size_error: `Skill import must not exceed ${params?.[0]} MB`,
         com_ui_skill_created: 'Skill created',
         com_ui_create_skill_upload_error: 'Failed to read the uploaded file',
+        com_ui_skill_upload_failed_files: 'These files could not be imported:',
+        com_ui_skill_upload_cleanup_incomplete: `Import failed for ${params?.[0]} file(s). The incomplete skill was removed, but automatic cleanup did not finish.`,
+        com_ui_skill_upload_cleanup_incomplete_files:
+          'Import failed for these files; automatic cleanup did not finish:',
+        com_ui_skill_upload_incomplete: `Import canceled: ${params?.[0]} file(s) in the archive could not be imported. Fix the archive and upload it again.`,
+        com_ui_skill_upload_reason_invalid_path: 'Unsupported file path',
+        com_ui_skill_upload_reason_file_too_large: `Exceeds the ${params?.[0]} MB file size limit`,
+        com_ui_skill_upload_reason_archive_too_large: `Not imported: the archive exceeds the ${params?.[0]} MB total size limit`,
+        com_ui_skill_upload_reason_archive_entry_changed:
+          'Changed while the archive was being read',
+        com_ui_skill_upload_reason_persistence_failed: 'Could not be saved',
+        com_ui_skill_upload_rollback_failed: `Import failed for ${params?.[0]} file(s), and the incomplete skill could not be removed automatically. Delete it before trying again.`,
+        com_ui_skill_upload_rollback_failed_files:
+          'Import failed for these files, and the incomplete skill was left behind:',
       };
       return translations[key] ?? key;
     },
@@ -86,9 +120,33 @@ function getFileInput(container: HTMLElement): HTMLInputElement {
   return input;
 }
 
+type FailedFile = { path: string; reason: string; limitMb?: number };
+
+function incompleteImportError(failedFiles: FailedFile[], code = 'skill_import_incomplete') {
+  return {
+    response: {
+      data: {
+        error: code,
+        message: `Import canceled: ${failedFiles.length} of 3 files in the archive could not be imported.`,
+        failedFiles,
+      },
+    },
+  };
+}
+
+function uploadArchive(container: HTMLElement, name = 'retry.skill') {
+  fireEvent.change(getFileInput(container), {
+    target: {
+      files: [new File([new Uint8Array(1024)], name, { type: 'application/zip' })],
+    },
+  });
+}
+
 describe('UploadSkillDialog', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    mockImportOptions = undefined;
+    mockOnOpenChange = undefined;
     mockFileConfigInput = {
       skills: {
         fileSizeLimit: 1,
@@ -164,6 +222,165 @@ describe('UploadSkillDialog', () => {
     appendSpy.mockRestore();
   });
 
+  it('lists the files a rolled-back import could not persist, localized, and keeps the dialog open', () => {
+    render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    act(() => {
+      mockImportOptions?.onError?.(
+        incompleteImportError([
+          { path: 'queries.sql', reason: 'file_too_large', limitMb: 10 },
+          { path: 'references/region_mapping.md', reason: 'invalid_path' },
+        ]),
+      );
+    });
+
+    expect(mockShowToast).toHaveBeenCalledWith({
+      status: 'error',
+      message:
+        'Import canceled: 2 file(s) in the archive could not be imported. Fix the archive and upload it again.',
+    });
+    const alert = screen.getByRole('alert');
+    expect(alert).toHaveTextContent('These files could not be imported:');
+    expect(screen.getByText('queries.sql')).toBeInTheDocument();
+    expect(screen.getByText('references/region_mapping.md')).toBeInTheDocument();
+    /** Localized from the reason code, with the limit interpolated — never the
+     *  server's own English text. */
+    expect(alert).toHaveTextContent('Exceeds the 10 MB file size limit');
+    expect(alert).toHaveTextContent('Unsupported file path');
+    expect(mockSetIsOpen).not.toHaveBeenCalled();
+    expect(mockNavigate).not.toHaveBeenCalled();
+  });
+
+  it('keeps a long failure list scrollable inside the dialog', () => {
+    render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+    const manyFiles = Array.from({ length: 60 }, (_, index) => ({
+      path: `files/entry-${index}.txt`,
+      reason: 'invalid_path',
+    }));
+
+    act(() => {
+      mockImportOptions?.onError?.(incompleteImportError(manyFiles));
+    });
+
+    const list = screen.getByRole('alert').querySelector('ul');
+    expect(list).not.toBeNull();
+    expect(list?.className).toContain('overflow-y-auto');
+    expect(list?.className).toMatch(/max-h-/);
+    expect(list?.querySelectorAll('li')).toHaveLength(60);
+  });
+
+  it('tells the user to delete the leftover skill when rollback failed', () => {
+    render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    act(() => {
+      mockImportOptions?.onError?.(
+        incompleteImportError(
+          [{ path: 'queries.sql', reason: 'persistence_failed' }],
+          'skill_import_rollback_failed',
+        ),
+      );
+    });
+
+    expect(mockShowToast).toHaveBeenCalledWith({
+      status: 'error',
+      message:
+        'Import failed for 1 file(s), and the incomplete skill could not be removed automatically. Delete it before trying again.',
+    });
+    expect(screen.getByRole('alert')).toHaveTextContent(
+      'Import failed for these files, and the incomplete skill was left behind:',
+    );
+  });
+
+  it('distinguishes incomplete cleanup from a skill that still needs deletion', () => {
+    render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    act(() => {
+      mockImportOptions?.onError?.(
+        incompleteImportError(
+          [{ path: 'queries.sql', reason: 'persistence_failed' }],
+          'skill_import_cleanup_incomplete',
+        ),
+      );
+    });
+
+    expect(mockShowToast).toHaveBeenCalledWith({
+      status: 'error',
+      message:
+        'Import failed for 1 file(s). The incomplete skill was removed, but automatic cleanup did not finish.',
+    });
+    expect(screen.getByRole('alert')).toHaveTextContent(
+      'Import failed for these files; automatic cleanup did not finish:',
+    );
+  });
+
+  it('clears a previous import failure when a new file is selected', () => {
+    const { container } = render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    act(() => {
+      mockImportOptions?.onError?.(
+        incompleteImportError([{ path: 'queries.sql', reason: 'persistence_failed' }]),
+      );
+    });
+    expect(screen.getByRole('alert')).toBeInTheDocument();
+
+    uploadArchive(container);
+
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(mockMutate).toHaveBeenCalledWith(expect.any(FormData));
+  });
+
+  it('ignores a failure that resolves after the dialog was dismissed', () => {
+    /** The dialog is permanently mounted by CreateSkillMenu, so a 422 can land
+     *  after the user closed it; reopening must not show the stale archive. */
+    const { container, rerender } = render(
+      <UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />,
+    );
+    uploadArchive(container, 'abandoned.skill');
+
+    act(() => {
+      mockOnOpenChange?.(false);
+    });
+    rerender(<UploadSkillDialog isOpen={false} setIsOpen={mockSetIsOpen} />);
+    act(() => {
+      mockImportOptions?.onError?.(
+        incompleteImportError([{ path: 'queries.sql', reason: 'persistence_failed' }]),
+      );
+    });
+    rerender(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(mockShowToast).not.toHaveBeenCalled();
+  });
+
+  it('ignores a success that resolves after the dialog was dismissed', () => {
+    const { container } = render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+    uploadArchive(container, 'abandoned.skill');
+
+    act(() => {
+      mockOnOpenChange?.(false);
+      mockImportOptions?.onSuccess?.({ _id: 'late-skill' });
+    });
+
+    expect(mockShowToast).not.toHaveBeenCalled();
+    expect(mockNavigate).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the server message for import errors without failed files', () => {
+    render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
+
+    act(() => {
+      mockImportOptions?.onError?.({
+        response: { data: { error: 'Archive must contain a SKILL.md file' } },
+      });
+    });
+
+    expect(mockShowToast).toHaveBeenCalledWith({
+      status: 'error',
+      message: 'Archive must contain a SKILL.md file',
+    });
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  });
+
   it('uploads files under the configured skill import limit', () => {
     const appendSpy = jest.spyOn(FormData.prototype, 'append');
     const { container } = render(<UploadSkillDialog isOpen={true} setIsOpen={mockSetIsOpen} />);
diff --git a/client/src/data-provider/Skills/__tests__/mutations.spec.tsx b/client/src/data-provider/Skills/__tests__/mutations.spec.tsx
index 4bd782ba3d1..f75e17e6d9b 100644
--- a/client/src/data-provider/Skills/__tests__/mutations.spec.tsx
+++ b/client/src/data-provider/Skills/__tests__/mutations.spec.tsx
@@ -4,10 +4,16 @@ import { act, renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { TSkill, TSkillListResponse } from 'librechat-data-provider';
 import type { ReactNode } from 'react';
-import { useCreateSkillMutation } from '../mutations';
+import {
+  useCreateSkillMutation,
+  useDeleteSkillMutation,
+  useImportSkillMutation,
+} from '../mutations';
 import { useSkillsInfiniteQuery } from '../queries';
 
 const mockCreateSkill = jest.fn();
+const mockDeleteSkill = jest.fn();
+const mockImportSkill = jest.fn();
 const mockListSkills = jest.fn();
 
 jest.mock('librechat-data-provider', () => {
@@ -17,6 +23,8 @@ jest.mock('librechat-data-provider', () => {
     dataService: {
       ...actual.dataService,
       createSkill: (...args: unknown[]) => mockCreateSkill(...args),
+      deleteSkill: (...args: unknown[]) => mockDeleteSkill(...args),
+      importSkill: (...args: unknown[]) => mockImportSkill(...args),
       listSkills: (...args: unknown[]) => mockListSkills(...args),
     },
   };
@@ -139,4 +147,81 @@ describe('skill creation cache updates', () => {
 
     queryClient.clear();
   });
+
+  it.each([
+    'skill_import_incomplete',
+    'skill_import_rollback_failed',
+    'skill_import_cleanup_incomplete',
+  ])('invalidates skill lists after %s', async (errorCode) => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+    const invalidateQueries = jest.spyOn(queryClient, 'invalidateQueries');
+    const staleListKey = [QueryKeys.skills, 'infinite', '', '', 100];
+    queryClient.setQueryData(staleListKey, {
+      pages: [{ skills: [makeSkill('leftover-skill', 'leftover')], has_more: false, after: null }],
+      pageParams: [undefined],
+    });
+    mockImportSkill.mockRejectedValue({
+      response: {
+        data: {
+          error: errorCode,
+          skillId: 'leftover-skill',
+          failedFiles: [{ path: 'queries.sql', reason: 'persistence_failed' }],
+        },
+      },
+    });
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+    const { result } = renderHook(() => useImportSkillMutation(), { wrapper });
+
+    await act(async () => {
+      await expect(result.current.mutateAsync(new FormData())).rejects.toBeDefined();
+    });
+
+    expect(invalidateQueries).toHaveBeenCalledWith([QueryKeys.skills]);
+    expect(queryClient.getQueryData(staleListKey)).toBeUndefined();
+    queryClient.clear();
+  });
+
+  it('evicts a deleted skill when dependent server cleanup is incomplete', async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+        mutations: { retry: false },
+      },
+    });
+    const skill = makeSkill('deleted-id', 'deleted-skill');
+    const queryKey = [QueryKeys.skills, 'infinite', '', '', 100];
+    queryClient.setQueryData([QueryKeys.skill, skill._id], skill);
+    queryClient.setQueryData(queryKey, {
+      pages: [{ skills: [skill], has_more: false, after: null }],
+      pageParams: [undefined],
+    });
+    mockDeleteSkill.mockResolvedValue({
+      id: skill._id,
+      deleted: true,
+      cleanupComplete: false,
+    });
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+    const { result } = renderHook(() => useDeleteSkillMutation(), { wrapper });
+
+    await act(async () => {
+      await result.current.mutateAsync({ id: skill._id });
+    });
+
+    expect(queryClient.getQueryData([QueryKeys.skill, skill._id])).toBeUndefined();
+    expect(
+      queryClient
+        .getQueryData<{ pages: TSkillListResponse[] }>(queryKey)
+        ?.pages.flatMap((page) => page.skills),
+    ).toEqual([]);
+    queryClient.clear();
+  });
 });
diff --git a/client/src/data-provider/Skills/mutations.ts b/client/src/data-provider/Skills/mutations.ts
index 5d84e9438c2..d97b54bd415 100644
--- a/client/src/data-provider/Skills/mutations.ts
+++ b/client/src/data-provider/Skills/mutations.ts
@@ -3,6 +3,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
 import type {
   TSkill,
   TSkillFile,
+  TSkillImportFailedResponse,
   TCreateSkill,
   TUpdateSkillVariables,
   TUpdateSkillResponse,
@@ -149,7 +150,7 @@ export const useImportSkillMutation = (
   options?: ImportSkillOptions,
 ): UseMutationResult<TSkill, unknown, FormData> => {
   const queryClient = useQueryClient();
-  const { onSuccess, ...rest } = options ?? {};
+  const { onError, onSuccess, ...rest } = options ?? {};
   return useMutation({
     mutationFn: (formData: FormData) => dataService.importSkill(formData),
     ...rest,
@@ -160,6 +161,19 @@ export const useImportSkillMutation = (
       void queryClient.invalidateQueries([QueryKeys.skills]);
       if (onSuccess) onSuccess(skill, variables, context);
     },
+    onError: (error, variables, context) => {
+      const body = (error as { response?: { data?: Partial<TSkillImportFailedResponse> } })
+        ?.response?.data;
+      if (
+        body?.error === 'skill_import_incomplete' ||
+        body?.error === 'skill_import_rollback_failed' ||
+        body?.error === 'skill_import_cleanup_incomplete'
+      ) {
+        queryClient.removeQueries([QueryKeys.skills], { type: 'inactive' });
+        void queryClient.invalidateQueries([QueryKeys.skills]);
+      }
+      if (onError) onError(error, variables, context);
+    },
   });
 };
 
diff --git a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
index 3121d292c9b..b7ce0bf74a9 100644
--- a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
+++ b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
@@ -126,7 +126,7 @@ describe('useCodeWorkspace', () => {
     expect(result.current.resolveSubmission(undefined, 'without_attached')).toBeUndefined();
   });
 
-  it('uses an agent default ahead of the last used workspace only for new chats', () => {
+  it('uses an agent default ahead of the last used workspace while a chat is undecided', () => {
     mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });
     mockAgentPermissions().agent.code_workspace_id = 'project-b';
     mockPreference.mockReturnValue('project-a');
@@ -137,8 +137,12 @@ describe('useCodeWorkspace', () => {
       },
     );
     expect(result.current.selections?.[0].workspaceId).toBe('project-b');
+    /* Saving the chat does not seal a decision it never recorded, so the default still applies and
+     * the composer still offers the choice. */
     rerender({ id: 'existing' });
-    expect(result.current.mode).toBe('without_attached');
+    expect(result.current.locked).toBe(false);
+    expect(result.current.mode).toBe('attached');
+    expect(result.current.selections?.[0].workspaceId).toBe('project-b');
     expect(result.current.canSubmit).toBe(true);
   });
 
@@ -646,18 +650,66 @@ describe('useCodeWorkspace', () => {
       expect(result.current.relocation).toBeUndefined();
     });
 
-    it('does not auto-select a sole workspace the saved decision never covered', () => {
+    it('attaches a sole workspace to a saved chat that never recorded a decision', () => {
       const { result } = renderHook(() =>
         useCodeWorkspace({ ...conversation(), conversationId: 'existing' } as TConversation),
       );
 
-      expect(result.current.state).toBe('without_attached');
-      expect(result.current.selections).toBeUndefined();
+      expect(result.current.locked).toBe(false);
+      expect(result.current.state).toBe('ready');
+      expect(result.current.selections).toEqual([
+        { environmentId: 'personal-vm', workspaceId: 'project-a' },
+      ]);
       expect(result.current.resolveSubmission()).toEqual({
-        codeEnvironmentMode: 'without_attached',
+        codeEnvironmentMode: 'attached',
+        codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],
       });
     });
 
+    /* Switching an existing chat to a coding agent used to leave the composer with a sealed
+     * decision its owner never made: nothing to select, and Send disabled. */
+    it.each([
+      { support: { codeEnvironmentDecisionVersion: 1 } },
+      { support: { codeEnvironmentDecisionVersion: 1, codeEnvironmentMoveVersion: 1 } },
+    ])('lets a saved chat with several workspaces choose one', ({ support }) => {
+      mockStartupConfig.mockReturnValue(support);
+      mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });
+      const chosen = { environmentId: 'personal-vm', workspaceId: 'project-b' };
+
+      const { result } = renderHook(() =>
+        useCodeWorkspace({ ...conversation(), conversationId: 'existing' } as TConversation),
+      );
+
+      expect(result.current.locked).toBe(false);
+      expect(result.current.state).toBe('choose');
+      expect(result.current.relocation).toBeUndefined();
+      /* `useChatFunctions` submits the conversation's latest selections and mode together, the way
+       * the menu writes both when a workspace is picked. */
+      expect(result.current.resolveSubmission([chosen], 'attached')).toEqual({
+        codeEnvironmentMode: 'attached',
+        codeWorkspaces: [chosen],
+      });
+    });
+
+    /* A replica that predates the protocol reads a field-less row as sealed `without_attached`, so
+     * attaching an agent default here would submit a choice it rejects as `locked`. The rollout
+     * window keeps the legacy lock, which is what an unadvertised protocol means. */
+    it('keeps the legacy lock until the deployment advertises the protocol', () => {
+      mockStartupConfig.mockReturnValue({});
+      mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });
+      mockAgentPermissions().agent.code_workspace_id = 'project-b';
+
+      const { result } = renderHook(() =>
+        useCodeWorkspace({ ...conversation(), conversationId: 'existing' } as TConversation),
+      );
+
+      expect(result.current.locked).toBe(true);
+      expect(result.current.mode).toBeUndefined();
+      expect(result.current.selections).toBeUndefined();
+      expect(result.current.canSubmit).toBe(false);
+      expect(result.current.resolveSubmission()).toBeUndefined();
+    });
+
     it('keeps auto-selecting for an API that does not seal decisions', () => {
       mockStartupConfig.mockReturnValue({});
 
diff --git a/client/src/hooks/Agents/useCodeWorkspace.ts b/client/src/hooks/Agents/useCodeWorkspace.ts
index d862cfffa87..a104c5f44a8 100644
--- a/client/src/hooks/Agents/useCodeWorkspace.ts
+++ b/client/src/hooks/Agents/useCodeWorkspace.ts
@@ -242,7 +242,22 @@ export default function useCodeWorkspace(
   const isNewChat =
     conversation != null &&
     (conversation.conversationId == null || conversation.conversationId === 'new');
-  const locked = conversation != null && !isNewChat;
+  /** Only a recorded decision is sealed. A saved chat whose turns never involved a code-capable
+   *  agent stores none, so switching one to a coding agent still gets to choose; treating it as
+   *  sealed leaves the composer showing a decision its owner never made, with no workspace to
+   *  select and no way to submit.
+   *
+   *  Until the deployment advertises the decision protocol, a replica that still reads a
+   *  field-less row as a sealed `without_attached` may serve the next turn and reject an attached
+   *  choice as `locked`, so the legacy lock stays for the whole rollout window. Nothing is lost by
+   *  waiting: the composer only reports that unmade decision once the same flag is on. */
+  const holdsDecision =
+    conversation?.codeEnvironmentMode != null || (storedSelections?.length ?? 0) > 0;
+  const locked =
+    conversation != null && !isNewChat && (holdsDecision || !supportsEnvironmentDecisions);
+  /** A new chat and a saved chat that never decided are both still choosing, so agent defaults, a
+   *  remembered selection, and a sole workspace apply to each. */
+  const undecided = conversation != null && !locked;
   const environmentResults = attachedEnvironments.map((environment, index) => {
     const status = statuses[index];
     const workspaces =
@@ -251,7 +266,7 @@ export default function useCodeWorkspace(
         : [];
     let stored = storedSelections?.find(({ environmentId }) => environmentId === environment.id);
     let conflictingDefaults = false;
-    if (stored == null && isNewChat && !hasForeignStoredSelection) {
+    if (stored == null && undecided && !hasForeignStoredSelection) {
       const defaults = workspaceMetadata.defaults.get(environment.id) ?? new Set<string>();
       let preferred: string | undefined;
       if (defaults.size === 1) preferred = [...defaults][0];
diff --git a/client/src/hooks/MCP/useMCPServerManager.ts b/client/src/hooks/MCP/useMCPServerManager.ts
index 682fef7a4df..160ea9ec1e6 100644
--- a/client/src/hooks/MCP/useMCPServerManager.ts
+++ b/client/src/hooks/MCP/useMCPServerManager.ts
@@ -45,6 +45,7 @@ import {
 import { useGetStartupConfig, useMCPServersQuery, useMCPToolsQuery } from '~/data-provider';
 import { mcpServerInitStatesAtom, getServerInitState } from '~/store/mcp';
 import { getMCPReinitializeErrorMessage } from './errors';
+import { openInNewTab } from '~/utils';
 
 export interface MCPServerDefinition {
   serverName: string;
@@ -514,7 +515,7 @@ export function useMCPServerManager({
           });
 
           if (autoOpenOAuth) {
-            window.open(response.oauthUrl, '_blank', 'noopener,noreferrer');
+            openInNewTab(response.oauthUrl);
           }
 
           startServerPolling(serverName, response.flowId, response.oauthTimeout);
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 416763b458d..ae67d26eeb1 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -697,7 +697,7 @@
   "com_nav_info_save_draft": "When enabled, the text and attachments you enter in the chat form will be automatically saved locally as drafts. These drafts will be available even if you reload the page or switch to a different conversation. Drafts are stored locally on your device and are deleted once the message is sent.",
   "com_nav_info_show_thinking": "When enabled, the chat will display the thinking dropdowns open by default, allowing you to view the AI's reasoning in real-time. When disabled, the thinking dropdowns will remain closed by default for a cleaner and more streamlined interface",
   "com_nav_info_smooth_streaming": "When enabled, newly streamed words fade in smoothly for the latest response. This is purely visual — it does not delay token delivery — and is disabled automatically when your device prefers reduced motion.",
-  "com_nav_info_stateful_sessions": "When enabled, this agent uses the dedicated stateful Code API instead of the default stateless service. Files, installed packages, and working state usually carry over between runs. The workspace may occasionally reset, so save anything important under /mnt/data. Requires Code Interpreter and the app-level stateful sessions capability.",
+  "com_nav_info_stateful_sessions": "When enabled, this agent uses the dedicated stateful Code API instead of the default stateless service. Retained files under /mnt/data carry across runs, but each run starts a fresh process. Shell variables, the working directory, $HOME, temporary files, global installs, and background processes are not durable. The runtime may reset, so keep anything important under /mnt/data. Requires Code Interpreter and the app-level stateful sessions capability.",
   "com_nav_info_stateful_code_environment": "Choose who shares this agent's stateful workspace. This does not share live files with stateless code sessions.",
   "com_nav_info_tool_background": "When enabled, the model can run this tool in the background: the conversation continues immediately while the tool runs, and the model retrieves the result later with the background task tool. Requires the app-level background tools capability.",
   "com_nav_info_user_name_display": "When enabled, the username of the sender will be shown above each message you send. When disabled, you will only see \"You\" above your messages.",
@@ -2301,6 +2301,7 @@
   "com_ui_skill_created": "Skill created",
   "com_ui_skill_delete_confirm": "Are you sure you want to delete \"{{0}}\"? This action cannot be undone.",
   "com_ui_skill_delete_error": "Failed to delete skill",
+  "com_ui_skill_delete_partial": "Skill deleted, but some related cleanup did not finish",
   "com_ui_skill_deleted": "Skill deleted",
   "com_ui_skill_description_field_hint": "Be specific about when this skill should apply.",
   "com_ui_skill_description_placeholder": "Apply Acme Corp brand guidelines to presentations and documents...",
@@ -2344,12 +2345,23 @@
   "com_ui_skill_validation_error": "Check the skill fields and try again",
   "com_ui_skill_updated": "Skill saved",
   "com_ui_skill_upload": "Upload a skill",
+  "com_ui_skill_upload_cleanup_incomplete": "Import failed for {{0}} file(s). The incomplete skill was removed, but automatic cleanup did not finish.",
+  "com_ui_skill_upload_cleanup_incomplete_files": "Import failed for these files; automatic cleanup did not finish:",
   "com_ui_skill_upload_drag": "Drag and drop or click to upload",
+  "com_ui_skill_upload_failed_files": "These files could not be imported:",
   "com_ui_skill_upload_file": "Upload File",
+  "com_ui_skill_upload_incomplete": "Import canceled: {{0}} file(s) in the archive could not be imported. Fix the archive and upload it again.",
+  "com_ui_skill_upload_reason_archive_entry_changed": "Changed while the archive was being read",
+  "com_ui_skill_upload_reason_archive_too_large": "Not imported: the archive exceeds the {{0}} MB total size limit",
+  "com_ui_skill_upload_reason_file_too_large": "Exceeds the {{0}} MB file size limit",
+  "com_ui_skill_upload_reason_invalid_path": "Unsupported file path",
+  "com_ui_skill_upload_reason_persistence_failed": "Could not be saved",
   "com_ui_skill_upload_req_md": ".md file must contain skill name and description formatted in YAML",
   "com_ui_skill_upload_req_size": "File size must not exceed {{0}} MB",
   "com_ui_skill_upload_req_zip": ".zip or .skill file must include a SKILL.md file",
   "com_ui_skill_upload_requirements": "File requirements",
+  "com_ui_skill_upload_rollback_failed": "Import failed for {{0}} file(s), and the incomplete skill could not be removed automatically. Delete it before trying again.",
+  "com_ui_skill_upload_rollback_failed_files": "Import failed for these files, and the incomplete skill was left behind:",
   "com_ui_skill_upload_size_error": "Skill import must not exceed {{0}} MB",
   "com_ui_skill_upload_title": "Upload skill",
   "com_ui_skill_version": "v{{0}}",
@@ -2653,9 +2665,13 @@
   "com_ui_tools_view_favorites_empty": "You haven't favorited anything yet",
   "com_ui_tools_view_made_by_you": "Made by you",
   "com_ui_tools_view_mine_empty": "You haven't created anything yet",
+  "com_ui_trace_agent_details": "{{0}}, agent details",
+  "com_ui_trace_agent_unavailable": "This agent is no longer available to you.",
   "com_ui_trace_all_spans": "All spans",
   "com_ui_trace_all_spans_description": "Show every recorded span, not only model calls and tools",
+  "com_ui_trace_asked": "“{{0}}”",
   "com_ui_trace_bar_description": "{{0}}, starts {{1}} in, {{2}}",
+  "com_ui_trace_chat_with_agent": "Chat with this agent",
   "com_ui_trace_clear_selection": "Clear selection",
   "com_ui_trace_close": "Close trace",
   "com_ui_trace_close_details": "Close details",
@@ -2668,6 +2684,7 @@
   "com_ui_trace_content_empty": "No input, output or metadata was recorded.",
   "com_ui_trace_content_error": "Couldn't load this record's content.",
   "com_ui_trace_content_hidden": "Input and output aren't shown on this deployment.",
+  "com_ui_trace_copy_agent_id": "Copy agent ID",
   "com_ui_trace_decoding": "Decoding",
   "com_ui_trace_empty_description": "The tracing service has no records for this conversation yet. New traces can take a minute to arrive after a response finishes.",
   "com_ui_trace_empty_title": "No trace records yet",
@@ -2680,17 +2697,26 @@
   "com_ui_trace_error_unauthorized": "The tracing service rejected this deployment's credentials.",
   "com_ui_trace_error_unsupported": "This tracing service can't serve traces. Langfuse v4 or later is required.",
   "com_ui_trace_expand_all": "Expand all",
+  "com_ui_trace_from_conversation": "Shown from this conversation's own tool calls.",
   "com_ui_trace_identifiers": "Identifiers",
   "com_ui_trace_input": "Input",
   "com_ui_trace_kind_agent": "Agent",
   "com_ui_trace_kind_event": "Event",
   "com_ui_trace_kind_generation": "Model call",
+  "com_ui_trace_kind_label": "Activity label",
   "com_ui_trace_kind_span": "Step",
   "com_ui_trace_kind_tool": "Tool",
   "com_ui_trace_load_older": "Load older records",
   "com_ui_trace_loading": "Loading trace",
+  "com_ui_trace_message_asked_tool": "Asked for {{0}}",
+  "com_ui_trace_message_attachments": "Attached: {{0}}",
+  "com_ui_trace_message_system": "Instructions",
+  "com_ui_trace_message_tool": "Tool result · {{0}}",
+  "com_ui_trace_message_user": "User",
   "com_ui_trace_metadata": "Metadata",
   "com_ui_trace_model": "Model",
+  "com_ui_trace_model_calls_count": "{{count}} model calls",
+  "com_ui_trace_model_calls_count_one": "{{count}} model call",
   "com_ui_trace_no_matches": "No records match this search or interval.",
   "com_ui_trace_offset": "Into response",
   "com_ui_trace_open_langfuse": "Open in Langfuse",
@@ -2698,9 +2724,21 @@
   "com_ui_trace_overview": "Timeline overview",
   "com_ui_trace_overview_hint": "Drag to focus an interval. Scroll or press plus and minus to zoom, use the arrow keys to pan, and press Escape to reset.",
   "com_ui_trace_partial": "Showing the newest {{0}} records",
+  "com_ui_trace_prompt": "What the model saw",
+  "com_ui_trace_prompt_omitted": "{{0}} earlier messages not shown",
+  "com_ui_trace_prompt_tools": "{{0}} tools available",
   "com_ui_trace_record_id": "Record ID",
+  "com_ui_trace_recorded_as": "Recorded as",
   "com_ui_trace_records": "Trace records",
   "com_ui_trace_refresh": "Refresh trace",
+  "com_ui_trace_reply": "What it wrote",
+  "com_ui_trace_role_phase_label": "Phase label",
+  "com_ui_trace_role_reasoning_label": "Reasoning label",
+  "com_ui_trace_role_run": "Agent run",
+  "com_ui_trace_role_step_label": "Step label",
+  "com_ui_trace_role_title": "Named the conversation",
+  "com_ui_trace_role_tools": "Tool calls",
+  "com_ui_trace_role_tools_count": "Used {{count}} tools",
   "com_ui_trace_scale_duration": "Duration",
   "com_ui_trace_scale_duration_description": "Scale the overview and bars by recorded time instead of one block per record",
   "com_ui_trace_search": "Search records",
@@ -2712,13 +2750,12 @@
   "com_ui_trace_status_running": "In progress",
   "com_ui_trace_status_warning": "Warning",
   "com_ui_trace_step": "Step {{0}}",
-  "com_ui_trace_steps_count": "{{count}} steps",
-  "com_ui_trace_steps_count_one": "{{count}} step",
   "com_ui_trace_summary": "Trace summary",
   "com_ui_trace_summary_cost": "Cost",
   "com_ui_trace_summary_duration": "Duration",
   "com_ui_trace_summary_errors": "Errors",
   "com_ui_trace_summary_generations": "Model calls",
+  "com_ui_trace_summary_labels": "Labels",
   "com_ui_trace_summary_tokens": "Tokens",
   "com_ui_trace_summary_tools": "Tool calls",
   "com_ui_trace_summary_turns": "Responses",
@@ -2727,6 +2764,8 @@
   "com_ui_trace_title_step": "Title",
   "com_ui_trace_tool_calls_count": "{{count}} tool calls",
   "com_ui_trace_tool_calls_count_one": "{{count}} tool call",
+  "com_ui_trace_tool_returned": "What came back",
+  "com_ui_trace_tool_sent": "What the agent sent",
   "com_ui_trace_tool_times": "{{0}}×{{1}}",
   "com_ui_trace_tools_more": "+{{0}} more",
   "com_ui_trace_trace_id": "Trace ID",
@@ -2742,6 +2781,8 @@
   "com_ui_trace_usage_reasoning": "Reasoning",
   "com_ui_trace_usage_total": "Total",
   "com_ui_trace_view": "View trace",
+  "com_ui_trace_view_conversation": "View as conversation",
+  "com_ui_trace_view_raw": "View raw",
   "com_ui_transferred_to": "Transferred to",
   "com_ui_travel": "Travel",
   "com_ui_trust_app": "I trust this application",
diff --git a/client/src/utils/index.ts b/client/src/utils/index.ts
index 30e13a29940..34addf5e1cc 100644
--- a/client/src/utils/index.ts
+++ b/client/src/utils/index.ts
@@ -31,6 +31,7 @@ export * from './messages';
 export * from './focus';
 export * from './tokens';
 export * from './redirect';
+export * from './links';
 export * from './languages';
 export * from './conversation';
 export * from './endpoints';
diff --git a/client/src/utils/links.ts b/client/src/utils/links.ts
new file mode 100644
index 00000000000..a514fddba4f
--- /dev/null
+++ b/client/src/utils/links.ts
@@ -0,0 +1,15 @@
+/**
+ * Opens `url` in a new tab the way a `target="_blank"` link does, without giving the new page an
+ * opener or a referrer. Call it synchronously inside the user's click: `window.open` with a
+ * `noopener,noreferrer` features string asks WebKit for a popup window, which Safari opens as a
+ * separate window and an iOS home-screen web app does not open at all.
+ */
+export function openInNewTab(url: string): void {
+  const link = document.createElement('a');
+  link.href = url;
+  link.target = '_blank';
+  link.rel = 'noopener noreferrer';
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+}
diff --git a/e2e/specs/mock/scenarios/dialog-scrim-role.spec.ts b/e2e/specs/mock/scenarios/dialog-scrim-role.spec.ts
new file mode 100644
index 00000000000..4af63caf501
--- /dev/null
+++ b/e2e/specs/mock/scenarios/dialog-scrim-role.spec.ts
@@ -0,0 +1,292 @@
+import { randomUUID } from 'crypto';
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { getE2EUser } from '../../../setup/user';
+import { deleteConversations, deleteMessagesByConversation, seedConversations } from '../db';
+import { NEW_CHAT_PATH } from '../helpers';
+
+/**
+ * OGDialog is the app's dialog: every confirmation, every settings modal, every
+ * picker sits on its scrim. That scrim used to be a literal `bg-black/80`, so a
+ * theme could restyle every surface it owns and still get a black wash under
+ * its dialogs. It now paints `surface-overlay`, the role the two other dialog
+ * families already use, which makes the scrim part of what a theme defines.
+ *
+ * Switching a color is only safe with the contrast that came with it, so these
+ * scenarios pin all three sides of the decision: the role reaches the scrim, the
+ * themes whose overlay is black (dark and both high-contrast modes) render
+ * exactly the rgba they rendered before, and the light theme — the one theme
+ * whose overlay is gray rather than black — still separates the dialog from its
+ * surround by the 3:1 a non-text boundary needs, alone and stacked on the
+ * settings modal's own scrim.
+ */
+
+/** Radix marks the open content; the scrim is the sibling rendered before it. */
+const OPEN_DIALOG = '[role="dialog"][data-state="open"], [role="alertdialog"][data-state="open"]';
+/** WCAG 1.4.11: a boundary that carries meaning needs 3:1 against its surround. */
+const BOUNDARY_CONTRAST = 3;
+/** Light and dark bundled themes resolve `--surface-overlay` to these. */
+const LIGHT_SCRIM = 'rgba(89, 89, 89, 0.8)';
+const BLACK_SCRIM = 'rgba(0, 0, 0, 0.8)';
+/** No bundled palette holds this triple, so only the definition can produce it. */
+const CUSTOM_SCRIM = 'rgba(10, 20, 30, 0.8)';
+const CONVERSATION_TITLE = 'Dialog scrim role';
+
+/**
+ * Every bundled mode but light resolves the overlay to black, and a contrast
+ * mode outranks any theme definition, so these three must keep rendering the
+ * exact rgba the literal used to produce. The value beside each is the class
+ * pair the client puts on `<html>` once the mode is applied.
+ */
+const BLACK_OVERLAY_MODES: Record<string, string> = {
+  dark: 'html.dark:not(.high-contrast)',
+  'high-contrast-light': 'html.light.high-contrast',
+  'high-contrast-dark': 'html.dark.high-contrast',
+};
+
+const SCRIM_THEME = {
+  version: 1,
+  name: 'e2e-scrim-role',
+  modes: {
+    light: { colors: { 'rgb-surface-overlay': '10 20 30' } },
+    dark: { colors: { 'rgb-surface-overlay': '10 20 30' } },
+  },
+} as const;
+
+type ThemeMode = 'light' | 'dark' | 'high-contrast-light' | 'high-contrast-dark';
+type Pixel = [number, number, number];
+type Point = { x: number; y: number };
+type ScrimReading = { color: string; dialog: Point; scrim: Point };
+
+test.use({ viewport: { width: 1280, height: 800 } });
+
+/**
+ * The client reads its mode out of storage before it mounts, so the mode has to
+ * be there before the first navigation, and a stored mode outranks the
+ * browser's own color scheme — which is what keeps a project running dark from
+ * dragging a light scenario with it. An init script stays registered for the
+ * life of the page and would overwrite any later switch, so the mode rides in
+ * the URL and the script copies whatever the current navigation asks for.
+ */
+const THEME_PARAM = 'e2eThemeMode';
+
+async function installThemeBridge(page: Page, definition?: unknown) {
+  await page.addInitScript((stored) => {
+    const mode = new URL(location.href).searchParams.get('e2eThemeMode');
+    if (mode) {
+      localStorage.setItem('color-theme', mode);
+    }
+    /** The legacy pair would win over a definition; keep them out of the way. */
+    localStorage.removeItem('theme-colors');
+    localStorage.removeItem('theme-name');
+    if (stored) {
+      localStorage.setItem('theme-definition', JSON.stringify(stored));
+      localStorage.setItem('theme-source', 'definition');
+    } else {
+      localStorage.removeItem('theme-definition');
+      localStorage.removeItem('theme-source');
+    }
+  }, definition ?? null);
+}
+
+const chatIn = (mode: ThemeMode): string => `${NEW_CHAT_PATH}?${THEME_PARAM}=${mode}`;
+
+async function seedConversation(title: string): Promise<string> {
+  const conversationId = randomUUID();
+  await seedConversations(getE2EUser().email, [{ conversationId, title, updatedAt: new Date() }]);
+  return conversationId;
+}
+
+/** The row's delete confirmation: an OGDialog with no scrim of its own. */
+async function openConversationDeleteDialog(page: Page, title: string) {
+  const row = page.getByTestId('convo-item').filter({ hasText: title }).first();
+  await expect(row).toBeVisible({ timeout: 20000 });
+  await row.hover();
+  await row.getByRole('button', { name: 'Conversation Menu Options' }).click();
+  await page.getByRole('menuitem', { name: 'Delete' }).click();
+  await expect(page.getByRole('dialog', { name: 'Delete chat?' })).toBeVisible({ timeout: 10000 });
+}
+
+/** The account confirmation, which always opens on top of the settings modal. */
+async function openDeleteAccountDialog(page: Page) {
+  await page.getByTestId('nav-user').click();
+  await page.getByRole('menuitem', { name: 'Settings' }).click();
+  await page.getByRole('tab', { name: 'Account' }).click();
+  await page.getByRole('button', { name: 'Delete account' }).click();
+  await expect(page.getByRole('dialog', { name: 'Delete account - are you sure?' })).toBeVisible({
+    timeout: 15000,
+  });
+}
+
+/**
+ * The scrim of the frontmost open dialog, and the two points whose contrast
+ * decides whether that dialog reads as a separate surface: inside its own
+ * padding, and out on the scrim past the dialog's shadow, which would otherwise
+ * darken the sample and flatter the result.
+ *
+ * Frontmost, not first in the document: a dialog opened from inside another one
+ * mounts after it and sits at a higher z-index, and reading the outer dialog's
+ * scrim instead would measure the wrong layer without failing.
+ */
+async function readScrim(page: Page): Promise<ScrimReading> {
+  return page.evaluate((selector) => {
+    const opened = Array.from(document.querySelectorAll<HTMLElement>(selector));
+    if (opened.length === 0) {
+      throw new Error('no dialog is open');
+    }
+    /** `zIndex` is `auto` on an unpositioned node, which parses to NaN. */
+    const frontmost = opened
+      .map((node) => ({ node, z: Number.parseInt(getComputedStyle(node).zIndex, 10) || 0 }))
+      .reduce((front, candidate) => (candidate.z >= front.z ? candidate : front));
+    const content = frontmost.node;
+    const scrim = content.previousElementSibling;
+    if (!(scrim instanceof HTMLElement)) {
+      throw new Error('the frontmost open dialog is not preceded by a scrim');
+    }
+    const rect = content.getBoundingClientRect();
+    const middle = rect.top + rect.height / 2;
+    return {
+      color: getComputedStyle(scrim).backgroundColor,
+      dialog: { x: rect.left + 6, y: middle },
+      scrim: { x: Math.max(4, rect.left - 48), y: middle },
+    };
+  }, OPEN_DIALOG);
+}
+
+/**
+ * Read the pixels as painted. Compositing the scrim by hand would only
+ * re-derive the arithmetic under test and would miss whatever else lies under
+ * it — the settings modal's own scrim, for one.
+ */
+async function pixelsAt(page: Page, points: Point[]): Promise<Pixel[]> {
+  const shot = await page.screenshot({ animations: 'disabled' });
+  return page.evaluate(
+    async ({ data, samples }) => {
+      const image = new Image();
+      image.src = `data:image/png;base64,${data}`;
+      await image.decode();
+      const canvas = document.createElement('canvas');
+      canvas.width = image.width;
+      canvas.height = image.height;
+      const context = canvas.getContext('2d');
+      if (!context) {
+        throw new Error('the sampling canvas has no 2d context');
+      }
+      context.drawImage(image, 0, 0);
+      /** The shot is in device pixels; the points are in CSS pixels. */
+      const scale = image.width / window.innerWidth;
+      return samples.map(({ x, y }) => {
+        const [r, g, b] = context.getImageData(
+          Math.round(x * scale),
+          Math.round(y * scale),
+          1,
+          1,
+        ).data;
+        return [r, g, b] as [number, number, number];
+      });
+    },
+    { data: shot.toString('base64'), samples: points },
+  );
+}
+
+/**
+ * The relative luminance of one channel, per WCAG 2.x; `welcome-disclaimer`
+ * does the same arithmetic for text and its surround.
+ */
+const channel = (value: number): number => {
+  const ratio = value / 255;
+  return ratio <= 0.04045 ? ratio / 12.92 : ((ratio + 0.055) / 1.055) ** 2.4;
+};
+
+const luminance = ([r, g, b]: Pixel): number =>
+  0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+
+async function boundaryContrast(page: Page, reading: ScrimReading): Promise<number> {
+  const [dialog, scrim] = await pixelsAt(page, [reading.dialog, reading.scrim]);
+  const surface = luminance(dialog);
+  const surround = luminance(scrim);
+  return (Math.max(surface, surround) + 0.05) / (Math.min(surface, surround) + 0.05);
+}
+
+test.describe('OGDialog scrim', () => {
+  test('a theme that redefines the overlay role repaints the scrim @scenario:og-dialog-scrim-follows-the-overlay-role', async ({
+    page,
+  }) => {
+    test.setTimeout(90000);
+    await installThemeBridge(page, SCRIM_THEME);
+    const conversationId = await seedConversation(CONVERSATION_TITLE);
+
+    try {
+      await page.goto(chatIn('light'), { timeout: 10000 });
+      await expect(page.locator('html')).toHaveAttribute('data-theme', SCRIM_THEME.name);
+
+      await openConversationDeleteDialog(page, CONVERSATION_TITLE);
+      expect((await readScrim(page)).color).toBe(CUSTOM_SCRIM);
+    } finally {
+      await page.keyboard.press('Escape');
+      await deleteMessagesByConversation([conversationId]);
+      await deleteConversations([conversationId]);
+    }
+  });
+
+  test('the themes whose overlay is black scrim exactly as before @scenario:og-dialog-scrim-unchanged-where-the-overlay-is-black', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    await installThemeBridge(page);
+    const conversationId = await seedConversation(CONVERSATION_TITLE);
+
+    try {
+      for (const [mode, applied] of Object.entries(BLACK_OVERLAY_MODES)) {
+        await page.goto(chatIn(mode as ThemeMode), { timeout: 15000 });
+        await expect(page.locator(applied)).toHaveCount(1, { timeout: 15000 });
+
+        await openConversationDeleteDialog(page, CONVERSATION_TITLE);
+        expect((await readScrim(page)).color, `${mode} moved the scrim`).toBe(BLACK_SCRIM);
+        await page.keyboard.press('Escape');
+        await expect(page.locator(OPEN_DIALOG)).toHaveCount(0, { timeout: 10000 });
+      }
+    } finally {
+      await deleteMessagesByConversation([conversationId]);
+      await deleteConversations([conversationId]);
+    }
+  });
+
+  test('the light theme keeps the dialog readable against its gray scrim @scenario:og-dialog-scrim-keeps-its-light-boundary', async ({
+    page,
+  }) => {
+    test.setTimeout(90000);
+    await installThemeBridge(page);
+    const conversationId = await seedConversation(CONVERSATION_TITLE);
+
+    try {
+      await page.goto(chatIn('light'), { timeout: 10000 });
+      await openConversationDeleteDialog(page, CONVERSATION_TITLE);
+
+      const reading = await readScrim(page);
+      expect(reading.color).toBe(LIGHT_SCRIM);
+      expect(await boundaryContrast(page, reading)).toBeGreaterThanOrEqual(BOUNDARY_CONTRAST);
+    } finally {
+      await page.keyboard.press('Escape');
+      await deleteMessagesByConversation([conversationId]);
+      await deleteConversations([conversationId]);
+    }
+  });
+
+  test('a dialog stacked on the settings scrim keeps its boundary @scenario:og-dialog-scrim-stacks-on-the-settings-scrim', async ({
+    page,
+  }) => {
+    test.setTimeout(90000);
+    await installThemeBridge(page);
+
+    await page.goto(chatIn('light'), { timeout: 10000 });
+    await openDeleteAccountDialog(page);
+
+    /** The settings modal paints its own scrim; the frontmost is still the role. */
+    const reading = await readScrim(page);
+    expect(reading.color).toBe(LIGHT_SCRIM);
+    expect(await boundaryContrast(page, reading)).toBeGreaterThanOrEqual(BOUNDARY_CONTRAST);
+
+    await page.keyboard.press('Escape');
+  });
+});
diff --git a/e2e/specs/mock/scenarios/skills-picker-narrow-header.spec.ts b/e2e/specs/mock/scenarios/skills-picker-narrow-header.spec.ts
new file mode 100644
index 00000000000..4c77a6a74c4
--- /dev/null
+++ b/e2e/specs/mock/scenarios/skills-picker-narrow-header.spec.ts
@@ -0,0 +1,214 @@
+import { devices, expect, test, type Locator, type Page } from '@playwright/test';
+import { openAgentBuilder } from '../agents.helpers';
+
+const TOLERANCE = 2;
+/** The dialog scales as it opens, so a box read on the first frame is smaller
+ *  than the one the reader sees; poll until two reads agree. */
+const STABLE_EPSILON = 0.5;
+
+type Box = { x: number; y: number; width: number; height: number };
+
+async function settledBox(locator: Locator): Promise<Box> {
+  const last: { box: Box | null } = { box: null };
+  await expect
+    .poll(
+      async () => {
+        const box = await locator.boundingBox();
+        if (!box) {
+          return false;
+        }
+        const previous = last.box;
+        last.box = box;
+        return (
+          previous !== null &&
+          Math.abs(box.x - previous.x) < STABLE_EPSILON &&
+          Math.abs(box.y - previous.y) < STABLE_EPSILON &&
+          Math.abs(box.width - previous.width) < STABLE_EPSILON &&
+          Math.abs(box.height - previous.height) < STABLE_EPSILON
+        );
+      },
+      { timeout: 15000 },
+    )
+    .toBe(true);
+  return last.box!;
+}
+
+async function openSkillsPicker(page: Page): Promise<Locator> {
+  const form = await openAgentBuilder(page);
+  await form.getByRole('radio', { name: 'Selected', exact: true }).click();
+  /** With nothing selected the only trigger is the dashed empty-state card, and
+   *  its accessible name carries the hint line as well as the label. */
+  const addSkill = form.getByRole('button', { name: /Add skill/ }).first();
+  await expect(addSkill).toBeVisible();
+  await addSkill.click();
+
+  const dialog = page.getByRole('dialog', { name: 'Skills', exact: true });
+  await expect(dialog).toBeVisible();
+  await settledBox(dialog);
+  return dialog;
+}
+
+function headerParts(dialog: Locator) {
+  return {
+    header: dialog
+      .getByRole('heading', { name: 'Skills', exact: true })
+      .locator('..')
+      .locator('..'),
+    view: dialog.getByRole('radiogroup', { name: 'Filter skills', exact: true }),
+    create: dialog.getByRole('button', { name: 'Create Skill', exact: true }),
+    filter: dialog.getByRole('textbox', { name: 'Search skills...', exact: true }),
+  };
+}
+
+async function expectNoHeaderOverflow(header: Locator): Promise<void> {
+  await expect
+    .poll(() => header.evaluate((element) => element.scrollWidth === element.clientWidth))
+    .toBe(true);
+}
+
+/** Every option has to sit inside the dialog, which is `overflow-hidden`: an
+ *  option past its edge is not scrollable into view, it is simply gone. */
+async function expectOptionsInsideDialog(dialog: Locator, view: Locator): Promise<void> {
+  const dialogBox = await settledBox(dialog);
+  const options = view.getByRole('radio');
+  const count = await options.count();
+  expect(count).toBeGreaterThan(0);
+
+  for (let index = 0; index < count; index += 1) {
+    const optionBox = await options.nth(index).boundingBox();
+    expect(optionBox).not.toBeNull();
+    expect(optionBox!.x).toBeGreaterThanOrEqual(dialogBox.x - TOLERANCE);
+    expect(optionBox!.y).toBeGreaterThanOrEqual(dialogBox.y - TOLERANCE);
+    expect(optionBox!.x + optionBox!.width).toBeLessThanOrEqual(
+      dialogBox.x + dialogBox.width + TOLERANCE,
+    );
+    expect(optionBox!.y + optionBox!.height).toBeLessThanOrEqual(
+      dialogBox.y + dialogBox.height + TOLERANCE,
+    );
+  }
+}
+
+test.describe('skills picker header on a phone', () => {
+  test.use({ viewport: devices['Pixel 7'].viewport, hasTouch: true });
+
+  test('@scenario:skills-picker-header-splits-on-a-phone-viewport splits the skills header into two rows on a phone', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openSkillsPicker(page);
+    const { header, view, create, filter } = headerParts(dialog);
+    const row = view.locator('..');
+    const dialogBox = await settledBox(dialog);
+    const viewBox = await settledBox(view);
+    const createBox = await settledBox(create);
+    const filterBox = await settledBox(filter);
+    const rowBox = await settledBox(row);
+
+    expect(Math.abs(viewBox.y - createBox.y)).toBeLessThanOrEqual(TOLERANCE);
+    expect(createBox.x).toBeGreaterThan(viewBox.x);
+    expect(createBox.x + createBox.width).toBeLessThanOrEqual(
+      dialogBox.x + dialogBox.width + TOLERANCE,
+    );
+    /** `ml-auto` puts the create button on the row's right edge. */
+    expect(Math.abs(createBox.x + createBox.width - (rowBox.x + rowBox.width))).toBeLessThanOrEqual(
+      TOLERANCE,
+    );
+    expect(filterBox.y).toBeGreaterThan(viewBox.y + viewBox.height);
+    expect(Math.abs(filterBox.x - rowBox.x)).toBeLessThanOrEqual(TOLERANCE);
+    expect(Math.abs(filterBox.x + filterBox.width - (rowBox.x + rowBox.width))).toBeLessThanOrEqual(
+      TOLERANCE,
+    );
+
+    /** DOM order is tab order, so it has to read the way this layout does:
+     *  radio, then create, then the field on the line below. */
+    await view.getByRole('radio', { name: 'All', exact: true }).focus();
+    await page.keyboard.press('Tab');
+    await expect(create).toBeFocused();
+    await page.keyboard.press('Tab');
+    await expect(filter).toBeFocused();
+    await expectNoHeaderOverflow(header);
+  });
+});
+
+test.describe('skills picker view options at narrow widths', () => {
+  test.use({ viewport: { width: 320, height: 800 }, hasTouch: true });
+
+  test('@scenario:skills-picker-view-options-stay-reachable-at-320px keeps every wrapped view option reachable at narrow widths', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openSkillsPicker(page);
+    const { header, view } = headerParts(dialog);
+
+    await expectOptionsInsideDialog(dialog, view);
+    await expectNoHeaderOverflow(header);
+
+    /** Narrower than the group's own 261px minimum, so the segments have to flow
+     *  onto a second row rather than run past the dialog. */
+    await page.setViewportSize({ width: 280, height: 800 });
+    await expect(dialog).toBeVisible();
+    await expectOptionsInsideDialog(dialog, view);
+    await expectNoHeaderOverflow(header);
+
+    const favorites = view.getByRole('radio', { name: 'Favorites', exact: true });
+    await favorites.click();
+    await expect(favorites).toHaveAttribute('aria-checked', 'true');
+    await expect(
+      dialog.getByText("You haven't favorited anything yet", { exact: true }),
+    ).toBeVisible();
+
+    /** The moving indicator has to follow the checked segment onto the second
+     *  row: it reproduced `inset-y-1` by assuming the group had no vertical
+     *  padding, which left it 8px short of a padded group's segment. */
+    const indicator = view.locator(':scope > div').first();
+    await expect(indicator).toBeVisible();
+    await expect
+      .poll(async () => {
+        const indicatorBox = await indicator.boundingBox();
+        const checkedBox = await favorites.boundingBox();
+        if (!indicatorBox || !checkedBox) {
+          return false;
+        }
+        return (
+          Math.abs(indicatorBox.x - checkedBox.x) <= TOLERANCE &&
+          Math.abs(indicatorBox.y - checkedBox.y) <= TOLERANCE &&
+          Math.abs(indicatorBox.width - checkedBox.width) <= TOLERANCE &&
+          Math.abs(indicatorBox.height - checkedBox.height) <= TOLERANCE
+        );
+      })
+      .toBe(true);
+  });
+});
+
+/** The point of this one is that the rearrangement did not reach desktop, so it
+ *  pins a desktop context instead of inheriting the run's project. */
+test.describe('skills picker header on a desktop viewport', () => {
+  test.use({ viewport: { width: 1280, height: 860 }, hasTouch: false, isMobile: false });
+
+  test('@scenario:skills-picker-header-is-one-row-on-desktop keeps desktop header controls on one row', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openSkillsPicker(page);
+    const { view, create, filter } = headerParts(dialog);
+    const createBox = await settledBox(create);
+    const filterBox = await settledBox(filter);
+    const viewBox = await settledBox(view);
+
+    expect(Math.abs(createBox.y - filterBox.y)).toBeLessThanOrEqual(TOLERANCE);
+    expect(Math.abs(filterBox.y - viewBox.y)).toBeLessThanOrEqual(TOLERANCE);
+    expect(createBox.x).toBeLessThan(filterBox.x);
+    expect(filterBox.x).toBeLessThan(viewBox.x);
+    expect(filterBox.width).toBeGreaterThan(createBox.width);
+    expect(filterBox.width).toBeGreaterThan(viewBox.width);
+
+    /** Tab order follows the eye here too: create, then the field, then the radio.
+     *  A visual-only reorder left desktop tabbing from the rightmost radio back to
+     *  the create button. */
+    await create.focus();
+    await page.keyboard.press('Tab');
+    await expect(filter).toBeFocused();
+    await page.keyboard.press('Tab');
+    await expect(view.getByRole('radio', { name: 'All', exact: true })).toBeFocused();
+  });
+});
diff --git a/e2e/specs/mock/scenarios/tool-library-small-screen.spec.ts b/e2e/specs/mock/scenarios/tool-library-small-screen.spec.ts
new file mode 100644
index 00000000000..99bf1ab7356
--- /dev/null
+++ b/e2e/specs/mock/scenarios/tool-library-small-screen.spec.ts
@@ -0,0 +1,294 @@
+import { devices, expect, test } from '@playwright/test';
+import type { Locator, Page } from '@playwright/test';
+import { openAgentBuilder } from '../agents.helpers';
+
+const TOOL_LIBRARY = 'Tool Library';
+/** The dialog's own open animation moves it by a fraction of a pixel per frame,
+ *  so geometry is only meaningful once two consecutive reads agree. */
+const STABLE_EPSILON = 0.5;
+const EDGE_TOLERANCE = 1;
+
+type Box = { x: number; y: number; width: number; height: number };
+
+async function settledBox(locator: Locator): Promise<Box> {
+  const last: { box: Box | null } = { box: null };
+  await expect
+    .poll(
+      async () => {
+        const box = await locator.boundingBox();
+        if (!box) {
+          return false;
+        }
+        const previous = last.box;
+        last.box = box;
+        return (
+          previous !== null &&
+          Math.abs(box.x - previous.x) < STABLE_EPSILON &&
+          Math.abs(box.y - previous.y) < STABLE_EPSILON &&
+          Math.abs(box.width - previous.width) < STABLE_EPSILON &&
+          Math.abs(box.height - previous.height) < STABLE_EPSILON
+        );
+      },
+      { timeout: 15000 },
+    )
+    .toBe(true);
+  return last.box!;
+}
+
+async function openToolLibrary(page: Page): Promise<Locator> {
+  const form = await openAgentBuilder(page);
+  await form.getByRole('button', { name: 'Add tools' }).click();
+  const dialog = page.getByRole('dialog', { name: TOOL_LIBRARY });
+  await expect(dialog).toBeVisible();
+  return dialog;
+}
+
+/** The actions fade over the shared motion duration, so the resting value is
+ *  what matters, not the frame the assertion happened to land on. */
+async function expectOpacity(locator: Locator, value: string): Promise<void> {
+  await expect
+    .poll(() => locator.evaluate((element) => getComputedStyle(element).opacity), {
+      timeout: 10000,
+    })
+    .toBe(value);
+}
+
+async function blurAndMovePointer(page: Page): Promise<void> {
+  await page.evaluate(() => {
+    const active = document.activeElement;
+    if (active instanceof HTMLElement) {
+      active.blur();
+    }
+  });
+  await page.mouse.move(0, 0);
+}
+
+/** The dialog's close button is absolutely positioned over the search row, so the
+ *  field has to stop short of it at every width. */
+async function expectClearOfCloseButton(page: Page, dialog: Locator): Promise<void> {
+  const close = page.getByRole('dialog').locator('button.absolute.right-4');
+  if ((await close.count()) === 0) {
+    return;
+  }
+  const field = await dialog.getByRole('textbox', { name: 'Search tools…' }).boundingBox();
+  const button = await close.first().boundingBox();
+  expect(field).not.toBeNull();
+  expect(button).not.toBeNull();
+  const sameRow = field!.y < button!.y + button!.height && button!.y < field!.y + field!.height;
+  expect(sameRow && field!.x + field!.width > button!.x).toBe(false);
+}
+
+test.describe('tool library on a touch viewport', () => {
+  test.use({ viewport: devices['Pixel 7'].viewport, hasTouch: true });
+
+  test('@scenario:tool-library-fills-a-phone-viewport the catalog stays within a phone viewport', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    const viewport = page.viewportSize();
+    expect(viewport).not.toBeNull();
+
+    const dialogBox = await settledBox(dialog);
+    expect(dialogBox.x).toBeLessThanOrEqual(EDGE_TOLERANCE);
+    expect(Math.abs(dialogBox.width - viewport!.width)).toBeLessThanOrEqual(EDGE_TOLERANCE);
+    await expect(dialog.locator('aside')).toHaveCount(0);
+    await expect(dialog.getByRole('group', { name: TOOL_LIBRARY })).toBeVisible();
+
+    /** The regression this pins: the dialog content is a grid, and without
+     *  `min-w-0` its column sized to the chip row's 744px min-content, which
+     *  pushed every card past the right edge of a 412px screen. */
+    const cards = dialog.getByRole('list', { name: TOOL_LIBRARY }).locator(':scope > li');
+    await expect(cards.first()).toBeVisible();
+    for (let index = 0; index < (await cards.count()); index += 1) {
+      const cardBox = await cards.nth(index).boundingBox();
+      expect(cardBox).not.toBeNull();
+      expect(cardBox!.x + cardBox!.width).toBeLessThanOrEqual(viewport!.width + EDGE_TOLERANCE);
+    }
+    expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBe(viewport!.width);
+
+    /** The chip row is this layout's primary navigation and only a finger reaches
+     *  it, so every chip owes the shared 44px tap-target floor. */
+    const chips = dialog.getByRole('group', { name: TOOL_LIBRARY }).getByRole('button');
+    for (let index = 0; index < (await chips.count()); index += 1) {
+      const chipBox = await chips.nth(index).boundingBox();
+      expect(chipBox).not.toBeNull();
+      expect(chipBox!.height).toBeGreaterThanOrEqual(44);
+    }
+
+    /** The close button is absolutely positioned over this row, so the search
+     *  field owes it clearance; a responsive padding utility silently reset it. */
+    await expectClearOfCloseButton(page, dialog);
+  });
+
+  test('@scenario:tool-library-filter-chips-narrow-the-catalog filter chips narrow the catalog and expose an empty favorites state', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    const cards = dialog.getByRole('list', { name: TOOL_LIBRARY }).locator(':scope > li');
+    const allChip = dialog.getByRole('button', { name: /^All(?:\s+\d+)?$/ });
+    await expect(allChip).toHaveAttribute('aria-pressed', 'true');
+    const allCount = await cards.count();
+
+    const mcpChip = dialog.getByRole('button', { name: /^MCP servers(?:\s+\d+)?$/ });
+    const mcpCount = Number.parseInt((await mcpChip.locator('span').last().innerText()).trim(), 10);
+    expect(mcpCount).toBeGreaterThan(0);
+    await mcpChip.click();
+    await expect.poll(() => cards.count()).toBe(mcpCount);
+    expect(await cards.count()).toBeLessThan(allCount);
+
+    await dialog.getByRole('button', { name: 'Favorites', exact: true }).click();
+    await expect(
+      dialog.getByText("You haven't favorited anything yet", { exact: true }),
+    ).toBeVisible();
+    await expect(cards).toHaveCount(0);
+  });
+
+  test('@scenario:tool-card-actions-are-visible-without-hover-on-touch card actions are visible without hover on a coarse pointer', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    await blurAndMovePointer(page);
+
+    const configure = dialog.getByRole('button', { name: 'Configure', exact: true }).first();
+    const favorite = dialog.getByRole('button', { name: 'Add to favorites', exact: true }).first();
+    await expect(configure).toBeVisible();
+    await expect(favorite).toBeVisible();
+    /** The reason the actions are visible: the hide rule is gated on the absence
+     *  of a coarse pointer, not on the absence of hover. */
+    expect(await page.evaluate(() => matchMedia('(any-pointer: coarse)').matches)).toBe(true);
+    await expectOpacity(configure, '1');
+    await expectOpacity(favorite, '1');
+
+    /** The actions rest over the card's content, and on touch they never fade out,
+     *  so the card has to keep its description clear of them. */
+    const overlap = await dialog
+      .locator('ul > li')
+      .first()
+      .evaluate((card) => {
+        const cluster = card.querySelector('div.absolute')?.getBoundingClientRect();
+        const paragraphs = Array.from(card.querySelectorAll('p'));
+        const description = paragraphs[paragraphs.length - 1]?.getBoundingClientRect();
+        if (!cluster || !description) {
+          return null;
+        }
+        return description.bottom > cluster.top && description.right > cluster.left;
+      });
+    expect(overlap).toBe(false);
+  });
+
+  test('@scenario:tool-row-actions-are-visible-without-hover-on-touch selected tool row actions stay visible without hover', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const form = await openAgentBuilder(page);
+    await form.getByRole('button', { name: 'Add tools' }).click();
+    const dialog = page.getByRole('dialog', { name: TOOL_LIBRARY });
+    await expect(dialog).toBeVisible();
+    await dialog.getByRole('textbox', { name: 'Search tools…' }).fill('Calculator');
+    const calculator = dialog.getByRole('button', { name: /^Calculator/ }).first();
+    await expect(calculator).toBeVisible();
+    await calculator.click();
+    await page.keyboard.press('Escape');
+    await expect(dialog).not.toBeVisible();
+
+    const row = form.locator('li').filter({ hasText: 'Calculator' }).first();
+    await expect(row).toBeVisible();
+    const details = row.getByRole('button', { name: 'Tool details', exact: true });
+    const remove = row.getByRole('button', { name: 'Remove from agent', exact: true });
+    /** The row hides the whole action cluster, so the wrapper is what the gate
+     *  applies to; a visible button inside a transparent parent is still invisible. */
+    const actionWrapper = details.locator('xpath=..');
+    await expect(details).toBeVisible();
+    await expect(remove).toBeVisible();
+    await expectOpacity(actionWrapper, '1');
+  });
+});
+
+/** A mouse device, asserted as one: these scenarios describe what a pointer that
+ *  can hover and cannot tap sees, so they pin their own context rather than
+ *  inheriting the run's project, one of which is a touch phone. */
+test.describe('tool library on a mouse viewport', () => {
+  test.use({ viewport: { width: 1280, height: 860 }, hasTouch: false, isMobile: false });
+
+  test('@scenario:tool-card-actions-stay-hover-gated-with-a-mouse card actions remain hidden until hover on a mouse', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    await blurAndMovePointer(page);
+
+    const configure = dialog.getByRole('button', { name: 'Configure', exact: true }).first();
+    const card = configure.locator('xpath=ancestor::li[1]');
+    expect(await page.evaluate(() => matchMedia('(any-pointer: coarse)').matches)).toBe(false);
+    await expectOpacity(configure, '0');
+    await card.hover();
+    await expectOpacity(configure, '1');
+  });
+
+  test('@scenario:tool-card-action-is-revealed-by-keyboard-focus keyboard focus reveals a card action', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    await blurAndMovePointer(page);
+
+    const configure = dialog.getByRole('button', { name: 'Configure', exact: true }).first();
+    const card = configure.locator('xpath=ancestor::li[1]');
+    const cardButton = card.getByRole('button').first();
+    await cardButton.focus();
+    await cardButton.press('Tab');
+    await expect(configure).toBeFocused();
+    expect(await configure.evaluate((element) => element.matches(':focus-visible'))).toBe(true);
+    await expectOpacity(configure, '1');
+  });
+
+  test('@scenario:tool-library-keeps-its-rail-on-desktop the desktop rail contains kind entries', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    const rail = dialog.locator('aside');
+    await expect(rail).toBeVisible();
+    for (const name of ['All', 'Native', 'Tools', 'MCP servers', 'Actions']) {
+      await expect(
+        rail.getByRole('button', { name: new RegExp(`^${name}(?:\\s+\\d+)?$`) }),
+      ).toBeVisible();
+    }
+    await expect(dialog.getByRole('group', { name: TOOL_LIBRARY })).toHaveCount(0);
+    await expectClearOfCloseButton(page, dialog);
+  });
+});
+
+/** A narrow desktop window is below md as well, so it gets the chip row without
+ *  getting a finger to drag it. */
+test.describe('tool library in a narrow mouse window', () => {
+  test.use({ viewport: { width: 520, height: 900 }, hasTouch: false, isMobile: false });
+
+  test('@scenario:tool-library-chips-stay-scrollable-with-a-mouse the overflowing chip row keeps a scrollbar without touch', async ({
+    page,
+  }) => {
+    test.setTimeout(120000);
+    const dialog = await openToolLibrary(page);
+    const chips = dialog.getByRole('group', { name: TOOL_LIBRARY });
+    await expect(chips).toBeVisible();
+    expect(await page.evaluate(() => matchMedia('(any-pointer: coarse)').matches)).toBe(false);
+
+    const row = await chips.evaluate((element) => ({
+      overflows: element.scrollWidth > element.clientWidth,
+      scrollbar: element.offsetHeight - element.clientHeight,
+    }));
+    expect(row.overflows).toBe(true);
+    /** The affordance itself: with the scrollbar hidden this is 0 and a wheel
+     *  scrolls the page instead, so the trailing views cannot be reached. */
+    expect(row.scrollbar).toBeGreaterThan(0);
+
+    /** And it does scroll: the last view has to become reachable. */
+    const favorites = chips.getByRole('button', { name: 'Favorites', exact: true });
+    await favorites.scrollIntoViewIfNeeded();
+    await favorites.click();
+    await expect(favorites).toHaveAttribute('aria-pressed', 'true');
+  });
+});
diff --git a/librechat.example.yaml b/librechat.example.yaml
index c4289f737a5..3a7ca6470ef 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -1111,6 +1111,10 @@ endpoints:
 #     tokens: 2000 # Also preserve up to this many recent tokens
 
 # fileConfig:
+#   skills:
+#     # Bound parallel storage deletes after a failed archive import (default: 8).
+#     # Set to 1 for serial cleanup on storage backends that require it.
+#     importCleanupConcurrency: 8
 #   # Store best-effort text for inferred tool-routed message attachments. On each turn,
 #   # deliver it only if no available tool can read the type. Off by default; also configurable
 #   # under endpoints.default or a provider/custom endpoint name. Explicit destinations stand.
diff --git a/otel/langfuse-fanout/cmd/langfuse-fanout/main.go b/otel/langfuse-fanout/cmd/langfuse-fanout/main.go
index 25fb7464dc2..eb38dc38910 100644
--- a/otel/langfuse-fanout/cmd/langfuse-fanout/main.go
+++ b/otel/langfuse-fanout/cmd/langfuse-fanout/main.go
@@ -1284,9 +1284,20 @@ func isAzureUploadURL(value string) bool {
 
 func allowedUploadContentType(value string) bool {
 	mediaType := strings.ToLower(strings.TrimSpace(strings.Split(value, ";")[0]))
-	return mediaType == "application/octet-stream" ||
-		mediaType == "application/pdf" ||
-		strings.HasPrefix(mediaType, "image/") ||
+	switch mediaType {
+	case "text/plain", "text/html", "text/css", "text/csv", "text/markdown",
+		"text/x-python", "text/x-typescript", "application/javascript", "application/x-yaml",
+		"application/pdf", "application/msword", "application/rtf",
+		"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		"application/vnd.ms-excel",
+		"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		"application/json", "application/x-ndjson", "application/xml",
+		"application/vnd.apache.parquet", "application/zip", "application/gzip",
+		"application/x-tar", "application/x-7z-compressed", "application/octet-stream":
+		return true
+	}
+	return strings.HasPrefix(mediaType, "image/") ||
 		strings.HasPrefix(mediaType, "audio/") ||
 		strings.HasPrefix(mediaType, "video/")
 }
diff --git a/otel/langfuse-fanout/cmd/langfuse-fanout/main_test.go b/otel/langfuse-fanout/cmd/langfuse-fanout/main_test.go
index a540993d717..0830fcc6ef8 100644
--- a/otel/langfuse-fanout/cmd/langfuse-fanout/main_test.go
+++ b/otel/langfuse-fanout/cmd/langfuse-fanout/main_test.go
@@ -349,88 +349,111 @@ func TestJSONTraceProxyAddsRoutingAttributesFromPath(t *testing.T) {
 func TestMediaUploadFansOutToCentralAndTenant(t *testing.T) {
 	t.Parallel()
 
-	var mu sync.Mutex
-	uploads := map[string]string{}
-	upstream := func(name string) *httptest.Server {
-		return httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			switch {
-			case r.Method == http.MethodPost && r.URL.Path == mediaPath:
-				uploadURL := "https://" + r.Host + "/upload/" + name
-				writeJSON(w, http.StatusCreated, mediaUploadResponse{
-					MediaID:   "same-media-id",
-					UploadURL: &uploadURL,
-				})
-			case r.Method == http.MethodPut && r.URL.Path == "/upload/"+name:
-				body, _ := io.ReadAll(r.Body)
-				mu.Lock()
-				uploads[name] = string(body)
-				mu.Unlock()
-				w.WriteHeader(http.StatusOK)
-			case r.Method == http.MethodPatch && r.URL.Path == mediaPath+"/same-media-id":
-				w.WriteHeader(http.StatusNoContent)
-			default:
-				http.NotFound(w, r)
+	for _, contentType := range []string{
+		"image/png", "audio/wav", "video/mp4",
+		"text/plain", "text/plain; charset=utf-8", "text/html", "text/css", "text/csv",
+		"text/markdown", "text/x-python", "text/x-typescript",
+		"application/javascript", "application/x-yaml", "application/pdf", "application/msword",
+		"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		"application/vnd.ms-excel",
+		"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		"application/rtf", "application/json", "Application/JSON; charset=utf-8",
+		"application/x-ndjson", "application/xml", "application/vnd.apache.parquet",
+		"application/zip", "application/gzip", "application/x-tar",
+		"application/x-7z-compressed", "application/octet-stream",
+	} {
+		t.Run(contentType, func(t *testing.T) {
+			t.Parallel()
+			var mu sync.Mutex
+			uploads := map[string]string{}
+			uploadContentTypes := map[string]string{}
+			upstream := func(name string) *httptest.Server {
+				return httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					switch {
+					case r.Method == http.MethodPost && r.URL.Path == mediaPath:
+						uploadURL := "https://" + r.Host + "/upload/" + name
+						writeJSON(w, http.StatusCreated, mediaUploadResponse{
+							MediaID:   "same-media-id",
+							UploadURL: &uploadURL,
+						})
+					case r.Method == http.MethodPut && r.URL.Path == "/upload/"+name:
+						body, _ := io.ReadAll(r.Body)
+						mu.Lock()
+						uploads[name] = string(body)
+						uploadContentTypes[name] = r.Header.Get("Content-Type")
+						mu.Unlock()
+						w.WriteHeader(http.StatusOK)
+					case r.Method == http.MethodPatch && r.URL.Path == mediaPath+"/same-media-id":
+						w.WriteHeader(http.StatusNoContent)
+					default:
+						http.NotFound(w, r)
+					}
+				}))
+			}
+			central := upstream("central")
+			defer central.Close()
+			tenant := upstream("tenant")
+			defer tenant.Close()
+
+			store := newFakeUploadPlanStore()
+			createGateway := newTestGatewayWithStore(central.URL, map[string]string{"eu": tenant.URL}, store)
+			uploadGateway := newTestGatewayWithStore(central.URL, map[string]string{"eu": tenant.URL}, store)
+			createGateway.cfg.client = central.Client()
+			uploadGateway.cfg.client = central.Client()
+			createBody := fmt.Sprintf(`{"traceId":"trace","contentType":%q,"contentLength":5,"sha256Hash":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","field":"input"}`, contentType)
+			req := httptest.NewRequest(http.MethodPost, tenantPrefix+"eu"+mediaPath, strings.NewReader(createBody))
+			req.Header.Set("Authorization", "Basic tenant")
+			resp := httptest.NewRecorder()
+
+			createGateway.handle(resp, req)
+			if resp.Code != http.StatusCreated {
+				t.Fatalf("create status = %d, body = %s", resp.Code, resp.Body.String())
+			}
+			var create mediaUploadResponse
+			if err := json.NewDecoder(resp.Body).Decode(&create); err != nil {
+				t.Fatal(err)
+			}
+			if create.MediaID != "same-media-id" || create.UploadURL == nil || !strings.Contains(*create.UploadURL, mediaUploadProxyPath) {
+				t.Fatalf("unexpected create response: %#v", create)
+			}
+			uploadID := strings.TrimPrefix(newUploadURLPath(t, *create.UploadURL), mediaUploadProxyPath)
+			store.mu.Lock()
+			storedPlan := store.plans[uploadID]
+			store.mu.Unlock()
+			storedPlanJSON, err := json.Marshal(storedPlan)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(string(storedPlanJSON), "Basic ") {
+				t.Fatalf("stored upload plan leaked authorization: %s", storedPlanJSON)
 			}
-		}))
-	}
-	central := upstream("central")
-	defer central.Close()
-	tenant := upstream("tenant")
-	defer tenant.Close()
-
-	store := newFakeUploadPlanStore()
-	createGateway := newTestGatewayWithStore(central.URL, map[string]string{"eu": tenant.URL}, store)
-	uploadGateway := newTestGatewayWithStore(central.URL, map[string]string{"eu": tenant.URL}, store)
-	createGateway.cfg.client = central.Client()
-	uploadGateway.cfg.client = central.Client()
-	createBody := `{"traceId":"trace","contentType":"image/png","contentLength":5,"sha256Hash":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","field":"input"}`
-	req := httptest.NewRequest(http.MethodPost, tenantPrefix+"eu"+mediaPath, strings.NewReader(createBody))
-	req.Header.Set("Authorization", "Basic tenant")
-	resp := httptest.NewRecorder()
-
-	createGateway.handle(resp, req)
-	if resp.Code != http.StatusCreated {
-		t.Fatalf("create status = %d, body = %s", resp.Code, resp.Body.String())
-	}
-	var create mediaUploadResponse
-	if err := json.NewDecoder(resp.Body).Decode(&create); err != nil {
-		t.Fatal(err)
-	}
-	if create.MediaID != "same-media-id" || create.UploadURL == nil || !strings.Contains(*create.UploadURL, mediaUploadProxyPath) {
-		t.Fatalf("unexpected create response: %#v", create)
-	}
-	uploadID := strings.TrimPrefix(newUploadURLPath(t, *create.UploadURL), mediaUploadProxyPath)
-	store.mu.Lock()
-	storedPlan := store.plans[uploadID]
-	store.mu.Unlock()
-	storedPlanJSON, err := json.Marshal(storedPlan)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(storedPlanJSON), "Basic ") {
-		t.Fatalf("stored upload plan leaked authorization: %s", storedPlanJSON)
-	}
 
-	uploadReq := httptest.NewRequest(http.MethodPut, *create.UploadURL, strings.NewReader("hello"))
-	uploadReq.Header.Set("Content-Type", "image/png")
-	uploadResp := httptest.NewRecorder()
-	uploadGateway.handle(uploadResp, uploadReq)
-	if uploadResp.Code != http.StatusOK {
-		t.Fatalf("upload status = %d, body = %s", uploadResp.Code, uploadResp.Body.String())
-	}
+			uploadReq := httptest.NewRequest(http.MethodPut, *create.UploadURL, strings.NewReader("hello"))
+			uploadReq.Header.Set("Content-Type", contentType)
+			uploadResp := httptest.NewRecorder()
+			uploadGateway.handle(uploadResp, uploadReq)
+			if uploadResp.Code != http.StatusOK {
+				t.Fatalf("upload status = %d, body = %s", uploadResp.Code, uploadResp.Body.String())
+			}
 
-	patchReq := httptest.NewRequest(http.MethodPatch, tenantPrefix+"eu"+mediaPath+"/same-media-id", strings.NewReader(`{"uploadHttpStatus":200}`))
-	patchReq.Header.Set("Authorization", "Basic tenant")
-	patchResp := httptest.NewRecorder()
-	uploadGateway.handle(patchResp, patchReq)
-	if patchResp.Code != http.StatusNoContent {
-		t.Fatalf("patch status = %d, body = %s", patchResp.Code, patchResp.Body.String())
-	}
+			patchReq := httptest.NewRequest(http.MethodPatch, tenantPrefix+"eu"+mediaPath+"/same-media-id", strings.NewReader(`{"uploadHttpStatus":200}`))
+			patchReq.Header.Set("Authorization", "Basic tenant")
+			patchResp := httptest.NewRecorder()
+			uploadGateway.handle(patchResp, patchReq)
+			if patchResp.Code != http.StatusNoContent {
+				t.Fatalf("patch status = %d, body = %s", patchResp.Code, patchResp.Body.String())
+			}
 
-	mu.Lock()
-	defer mu.Unlock()
-	if uploads["central"] != "hello" || uploads["tenant"] != "hello" {
-		t.Fatalf("uploads = %#v", uploads)
+			mu.Lock()
+			defer mu.Unlock()
+			if uploads["central"] != "hello" || uploads["tenant"] != "hello" {
+				t.Fatalf("uploads = %#v", uploads)
+			}
+			if uploadContentTypes["central"] != contentType || uploadContentTypes["tenant"] != contentType {
+				t.Fatalf("upload content types = %#v", uploadContentTypes)
+			}
+		})
 	}
 }
 
@@ -742,6 +765,17 @@ func TestMediaUploadOversizeRestoresPlanForRetry(t *testing.T) {
 	}
 }
 
+func TestUploadContentTypeRejectsUnsupportedTypes(t *testing.T) {
+	t.Parallel()
+	for _, contentType := range []string{"", "text/x-unsupported", "application/x-unsupported", "application/jsonp", "text/plain-invalid", "multipart/form-data"} {
+		t.Run(contentType, func(t *testing.T) {
+			if allowedUploadContentType(contentType) {
+				t.Fatalf("unsupported content type accepted: %q", contentType)
+			}
+		})
+	}
+}
+
 func TestMediaUploadUnsupportedContentTypeRestoresPlanForRetry(t *testing.T) {
 	t.Parallel()
 
@@ -770,7 +804,7 @@ func TestMediaUploadUnsupportedContentTypeRestoresPlanForRetry(t *testing.T) {
 	gw.cfg.client = upstream.Client()
 
 	badReq := httptest.NewRequest(http.MethodPut, mediaUploadProxyPath+uploadID, strings.NewReader("hello"))
-	badReq.Header.Set("Content-Type", "text/html")
+	badReq.Header.Set("Content-Type", "application/x-unsupported")
 	badResp := httptest.NewRecorder()
 	gw.handle(badResp, badReq)
 	if badResp.Code != http.StatusBadGateway {
diff --git a/package-lock.json b/package-lock.json
index 5513c411c60..638785d4ded 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -64,7 +64,7 @@
         "@azure/storage-blob": "^12.30.0",
         "@google/genai": "^2.8.0",
         "@keyv/redis": "5.1.6",
-        "@librechat/agents": "^3.8.7",
+        "@librechat/agents": "^3.8.8",
         "@librechat/api": "*",
         "@librechat/data-schemas": "*",
         "@microsoft/microsoft-graph-client": "^3.0.7",
@@ -10622,9 +10622,9 @@
       }
     },
     "node_modules/@librechat/agents": {
-      "version": "3.8.7",
-      "resolved": "https://registry.npmjs.org/@librechat/agents/-/agents-3.8.7.tgz",
-      "integrity": "sha512-yIO/SnWakpKXLzaRCNJfaai0emp22cD7mO8ffzu8gDyIVTzK0jaoG1nrr0+PoVkIeK/piKb+QJEyobPecGX6fg==",
+      "version": "3.8.8",
+      "resolved": "https://registry.npmjs.org/@librechat/agents/-/agents-3.8.8.tgz",
+      "integrity": "sha512-sfvYhCRUpbK5kV/NUe1MG5xu7fgO6t81vcmejy8mDCTpM5r6IbtGeW9PlwHVVZXwnFWn5mY4K02VLCA76IHLyg==",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.115.0",
@@ -42449,7 +42449,7 @@
         "@azure/storage-blob": "^12.30.0",
         "@google/genai": "^2.8.0",
         "@keyv/redis": "5.1.6",
-        "@librechat/agents": "^3.8.7",
+        "@librechat/agents": "^3.8.8",
         "@librechat/data-schemas": "*",
         "@modelcontextprotocol/sdk": "^1.30.0",
         "@opentelemetry/api": "^1.9.0",
diff --git a/packages/api/package.json b/packages/api/package.json
index 9f155ddc419..dd7d333da14 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -120,7 +120,7 @@
     "@azure/storage-blob": "^12.30.0",
     "@google/genai": "^2.8.0",
     "@keyv/redis": "5.1.6",
-    "@librechat/agents": "^3.8.7",
+    "@librechat/agents": "^3.8.8",
     "@librechat/data-schemas": "*",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@opentelemetry/api": "^1.9.0",
diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.ts
index 91764ea1ade..36fcc14add6 100644
--- a/packages/api/src/agents/__tests__/initialize.test.ts
+++ b/packages/api/src/agents/__tests__/initialize.test.ts
@@ -2614,7 +2614,7 @@ describe('initializeAgent — execute_code capability expansion', () => {
        but never appears in the tool definitions the LLM sees. */
     expect(names).not.toContain('execute_code');
     const readFile = result.toolDefinitions?.find((d) => d.name === 'read_file');
-    expect(readFile?.description).toContain('code-execution sandbox');
+    expect(readFile?.description).toContain('code-sandbox');
     expect(readFile?.description).not.toContain('{skillName}');
     expect(readFile?.description).not.toContain('SKILL.md');
     const createFile = result.toolDefinitions?.find((d) => d.name === 'create_file');
diff --git a/packages/api/src/agents/attachments.test.ts b/packages/api/src/agents/attachments.test.ts
index 66745db1533..92610dae91b 100644
--- a/packages/api/src/agents/attachments.test.ts
+++ b/packages/api/src/agents/attachments.test.ts
@@ -1,5 +1,5 @@
 import { logger } from '@librechat/data-schemas';
-import { EModelEndpoint, FileSources } from 'librechat-data-provider';
+import { EModelEndpoint, FileContext, FileSources } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { ServerRequest } from '~/types';
 
@@ -18,7 +18,9 @@ import {
   getAgentContextAttachments,
   buildAgentContextAttachmentsByAgentId,
   isModelBoundAttachmentFile,
+  isToolOwnedAttachment,
 } from './attachments';
+import { applyTurnDelivery, resolveTurnDeliveryRouting } from './files/delivery';
 
 const makeTextFile = (file_id: string, filename: string, text: string): IMongoFile =>
   ({
@@ -670,3 +672,114 @@ describe('agent attachment helpers', () => {
     ).resolves.toEqual(new Map());
   });
 });
+
+describe('files that belong to a tool', () => {
+  const XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+  const sandboxRef = {
+    kind: 'user',
+    id: 'user-1',
+    file_id: 'sandbox-file',
+    storage_session_id: 's1',
+  };
+
+  it('keeps a code output tool-owned after priming clears its expired sandbox references', () => {
+    const output = {
+      file_id: 'rows-json',
+      type: 'application/json',
+      context: FileContext.execute_code,
+      text: '{"rows":[]}',
+      metadata: {},
+    } as unknown as IMongoFile;
+
+    expect(isToolOwnedAttachment(output)).toBe(true);
+    expect(isModelBoundAttachmentFile(output)).toBe(false);
+  });
+
+  it('still treats a route-less user upload without tool references as prompt content', () => {
+    const upload = {
+      file_id: 'legacy-upload',
+      type: 'application/pdf',
+      context: FileContext.message_attachment,
+      metadata: {},
+    } as unknown as IMongoFile;
+
+    expect(isToolOwnedAttachment(upload)).toBe(false);
+    expect(isModelBoundAttachmentFile(upload)).toBe(true);
+  });
+
+  it('admits a Run Code thread shaped like the one the history limit locked', () => {
+    /* Spreadsheets routed to tools with text stored for the fallback, one screenshot, and the
+     * code outputs of an earlier run whose expired sandbox references priming cleared. Counted
+     * as prompt attachments, the outputs and the spreadsheets' fallback text filled the per-turn
+     * count past its default of ten, so every later turn was refused. */
+    const config = {
+      fileConfig: {
+        textFallbackWithoutTools: true,
+        endpoints: {
+          default: { defaultLLMDeliveryPath: { overrides: { [XLSX]: 'none' as const } } },
+        },
+      },
+    };
+    const routing = resolveTurnDeliveryRouting({
+      agent: { provider: EModelEndpoint.bedrock, endpoint: EModelEndpoint.bedrock },
+      config,
+    });
+    const consumers = { executeCode: true, fileSearch: false };
+    const sheet = (file_id: string, extra: object = {}) =>
+      ({
+        file_id,
+        type: XLSX,
+        bytes: 200_000,
+        source: FileSources.local,
+        context: FileContext.message_attachment,
+        llmDeliveryPath: 'none',
+        text: 'x'.repeat(110_000),
+        metadata: { destinationChosen: false },
+        ...extra,
+      }) as unknown as IMongoFile;
+    const olderSheets = ['q3-actuals', 'q3-budget', 'q3-map'].map((id) =>
+      sheet(id, {
+        llmDeliveryPath: 'text',
+        metadata: { destinationChosen: false, codeEnvRef: sandboxRef },
+      }),
+    );
+    const newSheets = ['s1', 's2', 's3', 's4', 's5', 's6'].map((id) => sheet(id));
+    const screenshot = {
+      file_id: 'screenshot',
+      type: 'image/png',
+      bytes: 380_971,
+      source: FileSources.local,
+      context: FileContext.message_attachment,
+      llmDeliveryPath: 'provider',
+      metadata: { destinationChosen: false },
+    } as unknown as IMongoFile;
+    const outputs = Array.from(
+      { length: 8 },
+      (_, index) =>
+        ({
+          file_id: `output-${index}`,
+          type: 'application/json',
+          bytes: 20_000,
+          source: FileSources.local,
+          context: FileContext.execute_code,
+          text: 'y'.repeat(20_000),
+          metadata: {},
+        }) as unknown as IMongoFile,
+    );
+
+    const admitted = applyTurnDelivery([...olderSheets, screenshot, ...newSheets, ...outputs], {
+      routing,
+      consumers,
+    }).filter(isModelBoundAttachmentFile);
+
+    expect(admitted.map((file) => file.file_id)).toEqual(['screenshot']);
+    expect(() =>
+      assertAgentAttachmentLimits({
+        attachments: admitted,
+        fileConfig: config.fileConfig,
+        endpoint: EModelEndpoint.bedrock,
+        countRepeatedExtractedText: true,
+      }),
+    ).not.toThrow();
+  });
+});
diff --git a/packages/api/src/agents/attachments.ts b/packages/api/src/agents/attachments.ts
index 2606905ff04..447af3c9218 100644
--- a/packages/api/src/agents/attachments.ts
+++ b/packages/api/src/agents/attachments.ts
@@ -1,9 +1,10 @@
 import { logger } from '@librechat/data-schemas';
 import {
-  EModelEndpoint,
+  FileContext,
   FileSources,
-  getEndpointFileConfig,
+  EModelEndpoint,
   mergeFileConfig,
+  getEndpointFileConfig,
 } from 'librechat-data-provider';
 import type { IMongoFile } from '@librechat/data-schemas';
 import type { TokenCountFn } from '~/utils/text';
@@ -22,10 +23,34 @@ type AttachmentTelemetryFile = FileWithId & {
   source?: string | null;
   type?: string | null;
   text?: string | null;
+  context?: string | null;
+  embedded?: boolean | null;
   llmDeliveryPath?: string | null;
   metadata?: (IMongoFile['metadata'] & { pageCount?: number | null }) | null;
 };
 
+/**
+ * Whether a record without a delivery route belongs to a tool rather than to the prompt.
+ *
+ * A code output lives in the sandbox that wrote it, and it stays the tool's while an expired
+ * sandbox copy is re-provisioned: priming clears the dead references on the turn's copy of the
+ * record, which must not turn the output into a prompt attachment that counts toward the turn's
+ * limits. Any other record belongs to a tool once a tool has provisioned it.
+ */
+export function isToolOwnedAttachment(file: AttachmentTelemetryFile): boolean {
+  const metadata = file.metadata as
+    | (IMongoFile['metadata'] & { fileIdentifier?: unknown })
+    | null
+    | undefined;
+  return (
+    file.context === FileContext.execute_code ||
+    file.embedded === true ||
+    metadata?.codeEnvRef != null ||
+    metadata?.codeEnvRefs != null ||
+    metadata?.fileIdentifier != null
+  );
+}
+
 /** Whether a hydrated file contributes content to the model prompt itself. */
 export function isModelBoundAttachmentFile(
   file: AttachmentTelemetryFile | null | undefined,
@@ -46,16 +71,7 @@ export function isModelBoundAttachmentFile(
   if (file.llmDeliveryPath === 'provider') {
     return true;
   }
-  const metadata = file.metadata as
-    | (IMongoFile['metadata'] & { fileIdentifier?: unknown })
-    | null
-    | undefined;
-  return !(
-    (file as IMongoFile).embedded === true ||
-    metadata?.codeEnvRef != null ||
-    metadata?.codeEnvRefs != null ||
-    metadata?.fileIdentifier != null
-  );
+  return !isToolOwnedAttachment(file);
 }
 
 type AgentAttachmentLimitRequest = {
diff --git a/packages/api/src/agents/background.spec.ts b/packages/api/src/agents/background.spec.ts
index c34d8d68260..65873abc2f5 100644
--- a/packages/api/src/agents/background.spec.ts
+++ b/packages/api/src/agents/background.spec.ts
@@ -2310,7 +2310,7 @@ describe('runCheckBackgroundTask (singleton)', () => {
     );
   });
 
-  it('lets a later poll collect a receipt without inheriting an abandoned local claim', async () => {
+  it('lets a later-generation poll collect a receipt without inheriting an abandoned local claim', async () => {
     const created = backgroundTaskRegistry.create({
       userId: 'claim_user',
       conversationId: 'claim_convo',
@@ -2341,7 +2341,7 @@ describe('runCheckBackgroundTask (singleton)', () => {
       args: { background_task_id: created.task.id },
       agentId: 'agent_parent_1',
       runId: 'poll-run',
-      generationId: 'response-claim',
+      generationId: 'response-later-poll',
       claimBackgroundToolResult,
     };
 
@@ -2359,7 +2359,7 @@ describe('runCheckBackgroundTask (singleton)', () => {
     expect(laterPoll).toMatchObject({ status: 'completed', result: 'CLAIMED RESULT' });
     expect(
       backgroundTaskRegistry.get('claim_user', 'claim_convo', created.task.id)?.resultClaim,
-    ).toMatchObject({ kind: 'manual', generationId: 'response-claim' });
+    ).toMatchObject({ kind: 'manual', generationId: 'response-later-poll' });
     expect(retire).toHaveBeenCalledTimes(1);
     expect(retire).toHaveBeenCalledWith('completion claimed by same-generation manual poll', {
       onlyIfUnclaimed: true,
@@ -2369,12 +2369,63 @@ describe('runCheckBackgroundTask (singleton)', () => {
         messageId: 'response-claim',
         taskId: created.task.id,
         kind: 'manual',
-        generationId: 'response-claim',
+        generationId: 'response-later-poll',
         allowUnfinished: true,
       }),
     );
   });
 
+  it('delivers a completed result inside its originating generation before the response row finalizes', async () => {
+    const created = backgroundTaskRegistry.create({
+      userId: 'originating_user',
+      conversationId: 'originating_convo',
+      toolCallId: 'call_originating',
+      toolName: 'search_mcp_docs',
+      messageId: 'response-originating',
+    });
+    if ('atCapacity' in created) {
+      throw new Error('unexpected capacity');
+    }
+    backgroundTaskRegistry.complete('originating_user', 'originating_convo', created.task.id, {
+      content: 'ORIGINATING RESULT',
+    });
+    const retire = jest.fn(async () => true);
+    backgroundTaskRegistry.markCompletionWakeup(
+      'originating_user',
+      'originating_convo',
+      created.task.id,
+      { renew: jest.fn(async () => true), retire },
+    );
+    const claimBackgroundToolResult = jest.fn(async () => ({ status: 'not_ready' as const }));
+    const request = {
+      userId: 'originating_user',
+      conversationId: 'originating_convo',
+      args: { background_task_id: created.task.id },
+      toolCallId: 'poll-originating',
+      runId: 'originating-run',
+      generationId: 'response-originating',
+      claimBackgroundToolResult,
+    };
+
+    const result = JSON.parse(await runCheckBackgroundTask(request));
+    const replay = JSON.parse(await runCheckBackgroundTask(request));
+
+    expect(result).toMatchObject({ status: 'completed', result: 'ORIGINATING RESULT' });
+    expect(replay).toMatchObject({ status: 'completed', result: 'ORIGINATING RESULT' });
+    expect(retire).toHaveBeenCalledTimes(1);
+    expect(retire).toHaveBeenCalledWith('completion claimed by same-generation manual poll', {
+      onlyIfUnclaimed: true,
+    });
+    expect(claimBackgroundToolResult).toHaveBeenCalledTimes(2);
+    expect(
+      backgroundTaskRegistry.get('originating_user', 'originating_convo', created.task.id)
+        ?.resultClaim,
+    ).toMatchObject({
+      kind: 'manual',
+      generationId: 'response-originating',
+    });
+  });
+
   it('reclaims a dead manual delivery after its owning generation is gone', async () => {
     const claimBackgroundToolResult = jest
       .fn()
diff --git a/packages/api/src/agents/background.ts b/packages/api/src/agents/background.ts
index 70e2429e0a6..adc187943a6 100644
--- a/packages/api/src/agents/background.ts
+++ b/packages/api/src/agents/background.ts
@@ -2210,8 +2210,11 @@ export async function runCheckBackgroundTask(params: {
           if (durableClaim.status === 'not_found' || durableClaim.status === 'not_ready') {
             const localReplay =
               task.resultClaim?.kind === 'manual' && task.resultClaim.claimId === invocationId;
-            let localClaimNeedsNoDurableConfirmation =
-              localReplay && task.liveArtifactPollRequired === true;
+            const pollOwnsOriginatingGeneration =
+              params.generationId != null && params.generationId === task.messageId;
+            const localClaimAllowed =
+              pollOwnsOriginatingGeneration || task.liveArtifactPollRequired === true;
+            let localClaimNeedsNoDurableConfirmation = localReplay && localClaimAllowed;
             if (!localReplay) {
               /** Retire the still-unclaimed delivery before creating local
                * ownership. A live resolver lease wins. Once that resolver is
@@ -2259,7 +2262,7 @@ export async function runCheckBackgroundTask(params: {
                     'The task is finished and completion ownership is being settled. Retry this poll shortly.',
                 });
               }
-              if (task.liveArtifactPollRequired === true) {
+              if (localClaimAllowed) {
                 const localClaim = backgroundTaskRegistry.claimResult(
                   userId,
                   conversationId,
@@ -2285,21 +2288,21 @@ export async function runCheckBackgroundTask(params: {
                       'The task is finished and its result is being made durable. Retry this poll shortly.',
                   });
                 }
-                /** The poll is executing inside the still-unfinished dispatch
-                 * generation, so waiting for the durable row would require
-                 * that generation to end before it can obey its mandatory
-                 * live-artifact poll. The retired unclaimed wakeup plus this
-                 * local manual claim is authoritative for this owner process;
-                 * the persistence retry re-reads and copies the claim after
-                 * the generation finalizes. */
+                /** The poll is executing inside the unfinished dispatch
+                 * generation, or it must deliver a live artifact. Waiting for
+                 * the durable row would require that generation to end first.
+                 * The retired unclaimed wakeup plus this local manual claim is
+                 * authoritative for this owner process; the persistence retry
+                 * re-reads and copies the claim after finalization. */
                 localClaimNeedsNoDurableConfirmation = true;
               }
             }
             /** Ordinary polls claim the durable terminal receipt directly.
              * They never reserve a process-local claim while the receipt is
              * absent: a later poll has a different provider tool-call id and
-             * could never take over that abandoned reservation. The live-
-             * artifact exception above cannot wait for its own generation. */
+             * could never take over that abandoned reservation. A poll owned
+             * by the originating generation cannot wait for that same
+             * generation to finalize its durable response row. */
             if (!localClaimNeedsNoDurableConfirmation) {
               const reconciledClaim = await params.claimBackgroundToolResult({
                 ...durableClaimInput,
diff --git a/packages/api/src/agents/backgroundClaims.spec.ts b/packages/api/src/agents/backgroundClaims.spec.ts
new file mode 100644
index 00000000000..f0bf556e90f
--- /dev/null
+++ b/packages/api/src/agents/backgroundClaims.spec.ts
@@ -0,0 +1,82 @@
+import type { AgentTriggerDeliveryMethods, MessageMethods } from '@librechat/data-schemas';
+import { claimBackgroundToolResult } from './backgroundClaims';
+
+describe('manual background receipt arbitration', () => {
+  const input = {
+    userId: 'user',
+    conversationId: 'conversation',
+    taskId: 'task',
+    kind: 'manual' as const,
+    claimId: 'poll',
+  };
+  const receipt = { kind: 'wakeup' as const, claimId: 'delivery', claimedAt: new Date() };
+  function fixture() {
+    const methods = {
+      claimBackgroundToolResults: jest
+        .fn<
+          ReturnType<MessageMethods['claimBackgroundToolResults']>,
+          Parameters<MessageMethods['claimBackgroundToolResults']>
+        >()
+        .mockResolvedValue({
+          status: 'acquired',
+          messageId: 'recovered-parent',
+          results: [
+            {
+              taskId: 'task',
+              toolCallId: 'call',
+              toolName: 'tool',
+              status: 'completed',
+              output: 'done',
+            },
+          ],
+        }),
+      releaseBackgroundToolResultClaims: jest.fn(async () => true),
+    };
+    const lookup = jest
+      .fn<
+        ReturnType<AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim']>,
+        Parameters<AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim']>
+      >()
+      .mockResolvedValue(null);
+    return { methods, lookup };
+  }
+  it('uses the recovered parent identity when the process-local registry is gone', async () => {
+    const { methods, lookup } = fixture();
+    lookup.mockResolvedValue(receipt);
+    await expect(claimBackgroundToolResult(methods, lookup, input)).resolves.toEqual({
+      status: 'claimed',
+      claim: receipt,
+      messageId: 'recovered-parent',
+    });
+    expect(lookup).toHaveBeenCalledWith(
+      expect.objectContaining({ parentMessageId: 'recovered-parent' }),
+    );
+    expect(methods.releaseBackgroundToolResultClaims).toHaveBeenCalledWith(
+      expect.objectContaining({ messageId: 'recovered-parent', taskIds: ['task'] }),
+    );
+  });
+  it('releases a speculative message claim if receipt lookup fails', async () => {
+    const { methods, lookup } = fixture();
+    lookup.mockRejectedValue(new Error('database unavailable'));
+    await expect(claimBackgroundToolResult(methods, lookup, input)).rejects.toThrow(
+      'database unavailable',
+    );
+    expect(methods.releaseBackgroundToolResultClaims).toHaveBeenCalledTimes(1);
+  });
+  it('does not report arbitration as complete if rollback fails', async () => {
+    const { methods, lookup } = fixture();
+    lookup.mockResolvedValue(receipt);
+    methods.releaseBackgroundToolResultClaims.mockResolvedValue(false);
+    await expect(claimBackgroundToolResult(methods, lookup, input)).rejects.toThrow(
+      'could not be released',
+    );
+  });
+  it('does not claim the projection when its known receipt already has an owner', async () => {
+    const { methods, lookup } = fixture();
+    lookup.mockResolvedValue(receipt);
+    await expect(
+      claimBackgroundToolResult(methods, lookup, { ...input, messageId: 'parent' }),
+    ).resolves.toMatchObject({ status: 'claimed', messageId: 'parent' });
+    expect(methods.claimBackgroundToolResults).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/api/src/agents/backgroundClaims.ts b/packages/api/src/agents/backgroundClaims.ts
new file mode 100644
index 00000000000..6f92bca7631
--- /dev/null
+++ b/packages/api/src/agents/backgroundClaims.ts
@@ -0,0 +1,58 @@
+import type { AgentTriggerDeliveryMethods, MessageMethods } from '@librechat/data-schemas';
+import { BACKGROUND_TOOL_COMPLETION_SOURCE } from './backgroundCompletionWakeup';
+
+/** Reconciles manual polling with the independent automatic-delivery receipt,
+ * including polls reconstructed after the process-local registry was lost. */
+export async function claimBackgroundToolResult(
+  methods: Pick<MessageMethods, 'claimBackgroundToolResults' | 'releaseBackgroundToolResultClaims'>,
+  getReceiptClaim: AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim'],
+  input: Parameters<MessageMethods['claimBackgroundToolResults']>[0],
+): ReturnType<MessageMethods['claimBackgroundToolResults']> {
+  const lookup = (messageId: string) =>
+    getReceiptClaim({
+      sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+      userId: input.userId,
+      conversationId: input.conversationId,
+      parentMessageId: messageId,
+      taskId: input.taskId,
+    });
+  if (input.messageId != null) {
+    const receiptClaim = await lookup(input.messageId);
+    if (receiptClaim != null && receiptClaim.claimId !== input.claimId) {
+      return { status: 'claimed', claim: receiptClaim, messageId: input.messageId };
+    }
+  }
+  const messageClaim = await methods.claimBackgroundToolResults(input);
+  if (messageClaim.status !== 'acquired') {
+    return messageClaim;
+  }
+  const messageId = input.messageId ?? messageClaim.messageId;
+  if (messageId == null) {
+    throw new Error('The background result claim has no parent message identity');
+  }
+  const release = async () => {
+    const released = await methods.releaseBackgroundToolResultClaims({
+      userId: input.userId,
+      conversationId: input.conversationId,
+      messageId,
+      taskIds: messageClaim.results.map((result) => result.taskId),
+      kind: input.kind,
+      claimId: input.claimId,
+    });
+    if (!released) {
+      throw new Error('The background result claim could not be released');
+    }
+  };
+  let receiptClaim: Awaited<ReturnType<typeof getReceiptClaim>>;
+  try {
+    receiptClaim = await lookup(messageId);
+  } catch (error) {
+    await release();
+    throw error;
+  }
+  if (receiptClaim == null || receiptClaim.claimId === input.claimId) {
+    return messageClaim;
+  }
+  await release();
+  return { status: 'claimed', claim: receiptClaim, messageId };
+}
diff --git a/packages/api/src/agents/backgroundCompletion.ts b/packages/api/src/agents/backgroundCompletion.ts
index 08b84b0b808..8ef1d74cca5 100644
--- a/packages/api/src/agents/backgroundCompletion.ts
+++ b/packages/api/src/agents/backgroundCompletion.ts
@@ -31,6 +31,13 @@ export interface BackgroundToolWakeupRetireOptions {
 export interface BackgroundToolWakeupAdmission {
   /** Renews durable proof that the process-local executor still owns work. */
   renew: () => Promise<boolean>;
+  /** Persists terminal output on the pre-admitted delivery before the parent
+   * message projection exists. */
+  persistResult?: (result: {
+    status: 'completed' | 'error' | 'cancelled';
+    output: string;
+    settledAt: Date;
+  }) => Promise<boolean>;
   /** Retires a delivery whose terminal result can no longer be made durable.
    * Manual polling requires an atomic unclaimed-only transition: once a
    * resolver owns a lease, its prepared continuation cannot be cancelled. */
diff --git a/packages/api/src/agents/backgroundCompletionWakeup.spec.ts b/packages/api/src/agents/backgroundCompletionWakeup.spec.ts
index 19a4a9560d0..eef75fc6777 100644
--- a/packages/api/src/agents/backgroundCompletionWakeup.spec.ts
+++ b/packages/api/src/agents/backgroundCompletionWakeup.spec.ts
@@ -1,4 +1,4 @@
-import { AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1 } from '@librechat/data-schemas';
+import { AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2 } from '@librechat/data-schemas';
 import type { AgentTriggerProducerLeaseStatus } from '@librechat/data-schemas';
 import type { EnqueueBackgroundToolCompletion } from './backgroundCompletionWakeup';
 import {
@@ -91,6 +91,10 @@ function resolverMethods() {
           leaseUntil: new Date(NOW + 30_000),
         }),
       ),
+      getAgentBackgroundToolResult: jest.fn(async () => null),
+      getAgentBackgroundToolResultClaim: jest.fn(async () => null),
+      claimAgentBackgroundToolResults: jest.fn(async () => ({ status: 'not_ready' as const })),
+      releaseAgentBackgroundToolResultClaims: jest.fn(async () => true),
     },
   };
 }
@@ -111,7 +115,13 @@ describe('background tool completion wakeups', () => {
     >(async () => ({ deliveryKey: 'delivery-key-1' }));
     const retire = jest.fn(async () => true);
     const renew = jest.fn(async () => true);
-    const notify = createBackgroundToolCompletionWakeupHandler(enqueue, retire, renew);
+    const persistResult = jest.fn(async () => true);
+    const notify = createBackgroundToolCompletionWakeupHandler(
+      enqueue,
+      retire,
+      renew,
+      persistResult,
+    );
 
     const admission = await notify(registration());
     expect(admission).not.toBe(false);
@@ -134,7 +144,7 @@ describe('background tool completion wakeups', () => {
     expect(options).toEqual({
       orderingKey: 'background-tool-completion:conversation-1:task-1',
       availableAt: new Date(NOW + 250),
-      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
       producerLeaseUntil: new Date(NOW + 30_000),
     });
     if (admission !== false) {
@@ -145,6 +155,20 @@ describe('background tool completion wakeups', () => {
       'background-tool-completion',
       new Date(NOW + 30_000),
     );
+    if (admission !== false) {
+      await expect(
+        admission.persistResult?.({
+          status: 'completed',
+          output: 'done',
+          settledAt: new Date(NOW),
+        }),
+      ).resolves.toBe(true);
+    }
+    expect(persistResult).toHaveBeenCalledWith('delivery-key-1', 'background-tool-completion', {
+      status: 'completed',
+      output: 'done',
+      settledAt: new Date(NOW),
+    });
     if (admission !== false) {
       await expect(admission.retire('result unavailable')).resolves.toBe(true);
     }
@@ -180,6 +204,7 @@ describe('background tool completion wakeups', () => {
   it('retires the batch-root delivery before releasing all of its sibling claims', async () => {
     const retire = jest.fn(async () => true);
     const release = jest.fn(async () => true);
+    const releaseReceipts = jest.fn(async () => true);
     const getGenerationJob = jest.fn(async () => ({ status: 'complete' }));
     const fenceGenerationClaim = jest.fn(async () => 'fenced' as const);
     const recover = createBackgroundToolDeadClaimRecovery(
@@ -187,6 +212,7 @@ describe('background tool completion wakeups', () => {
       release,
       getGenerationJob,
       fenceGenerationClaim,
+      releaseReceipts,
     );
 
     await expect(
@@ -218,6 +244,13 @@ describe('background tool completion wakeups', () => {
       kind: 'wakeup',
       claimId: 'batch-root-delivery',
     });
+    expect(releaseReceipts).toHaveBeenCalledWith({
+      sourceId: 'background-tool-completion',
+      userId: 'user-1',
+      conversationId: 'conversation-1',
+      parentMessageId: 'response-1',
+      claimId: 'batch-root-delivery',
+    });
   });
 
   it('keeps a manual result claim while its owning generation is active', async () => {
@@ -428,6 +461,120 @@ describe('background tool completion wakeups', () => {
     );
   });
 
+  it('continues from the independent delivery receipt before the parent projection lands', async () => {
+    const { methods } = resolverMethods();
+    methods.claimBackgroundToolResults.mockResolvedValueOnce({ status: 'not_ready', results: [] });
+    methods.claimAgentBackgroundToolResults.mockResolvedValueOnce({
+      status: 'acquired',
+      results: [
+        {
+          taskId: 'task-1',
+          toolCallId: 'call-1',
+          toolName: 'slow_tool',
+          status: 'completed',
+          output: 'independently durable',
+        },
+      ],
+    } as never);
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+    });
+
+    const prepared = await resolve(await envelope(), { idempotencyKey: 'delivery-1' });
+
+    expect(prepared).toMatchObject({ status: 'ready', parentMessageId: 'response-2' });
+    expect(prepared?.status === 'ready' && prepared.input).toContain('independently durable');
+    expect(methods.claimAgentBackgroundToolResults).toHaveBeenCalledWith({
+      deliveryKey: 'delivery-1',
+      sourceId: 'background-tool-completion',
+      userId: 'user-1',
+      conversationId: 'conversation-1',
+      parentMessageId: 'response-1',
+      agentId: 'agent_parent_1',
+      claimId: 'delivery-1',
+      limit: 1,
+    });
+    expect(methods.claimBackgroundToolResults).toHaveBeenCalledWith(
+      expect.objectContaining({ taskId: 'task-1', kind: 'wakeup', claimId: 'delivery-1' }),
+    );
+  });
+
+  it('honors a manual message claim before an independent receipt', async () => {
+    const { methods } = resolverMethods();
+    methods.claimBackgroundToolResults.mockResolvedValueOnce({ status: 'claimed', results: [] });
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+    });
+
+    await expect(resolve(await envelope(), { idempotencyKey: 'delivery-1' })).resolves.toEqual({
+      status: 'settled',
+    });
+    expect(methods.claimAgentBackgroundToolResults).not.toHaveBeenCalled();
+    expect(methods.getAgentBackgroundToolResult).not.toHaveBeenCalled();
+  });
+
+  it('does not settle a resumed receipt owner while a speculative manual message claim yields', async () => {
+    const { methods } = resolverMethods();
+    methods.claimBackgroundToolResults.mockResolvedValueOnce({ status: 'claimed', results: [] });
+    methods.getAgentBackgroundToolResultClaim.mockResolvedValueOnce({
+      kind: 'wakeup',
+      claimId: 'delivery-1',
+      claimedAt: new Date(NOW),
+    } as never);
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+    });
+    await expect(resolve(await envelope(), { idempotencyKey: 'delivery-1' })).rejects.toMatchObject(
+      {
+        code: 'BACKGROUND_TOOL_CLAIM_RECONCILING',
+        deferWithoutAttempt: true,
+      },
+    );
+    expect(methods.releaseAgentBackgroundToolResultClaims).toHaveBeenCalledWith(
+      expect.objectContaining({ claimId: 'delivery-1' }),
+    );
+    expect(methods.releaseBackgroundToolResultClaims).not.toHaveBeenCalled();
+  });
+
+  it('retries after yielding to a racing manual claim so mutual yielding cannot lose output', async () => {
+    const { methods } = resolverMethods();
+    methods.claimBackgroundToolResults
+      .mockResolvedValueOnce({ status: 'not_ready' } as never)
+      .mockResolvedValueOnce({
+        status: 'claimed',
+        claim: { kind: 'manual', claimId: 'poll-1' },
+      } as never);
+    methods.claimAgentBackgroundToolResults.mockResolvedValueOnce({
+      status: 'acquired',
+      results: [
+        {
+          taskId: 'task-1',
+          toolCallId: 'call-1',
+          toolName: 'slow_tool',
+          status: 'completed',
+          output: 'durable',
+        },
+      ],
+    } as never);
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+    });
+
+    await expect(resolve(await envelope(), { idempotencyKey: 'delivery-1' })).rejects.toMatchObject(
+      {
+        code: 'BACKGROUND_TOOL_CLAIM_RECONCILING',
+        deferWithoutAttempt: true,
+      },
+    );
+    expect(methods.releaseAgentBackgroundToolResultClaims).toHaveBeenCalledWith(
+      expect.objectContaining({ claimId: 'delivery-1', parentMessageId: 'response-1' }),
+    );
+  });
+
   it('shares one bounded input budget across a full sibling batch', async () => {
     const { methods } = resolverMethods();
     const results = Array.from({ length: 8 }, (_, index) => ({
@@ -468,10 +615,61 @@ describe('background tool completion wakeups', () => {
       await prepared.releaseOnDefiniteFailure?.();
     }
     expect(releaseBackgroundToolResultClaims).toHaveBeenCalledWith(
-      expect.objectContaining({ taskIds: ['task-1', 'task-2'], claimId: 'delivery-1' }),
+      expect.objectContaining({ claimId: 'delivery-1', kind: 'wakeup' }),
+    );
+    expect(releaseBackgroundToolResultClaims).toHaveBeenCalledWith(
+      expect.not.objectContaining({ taskIds: expect.anything() }),
+    );
+  });
+
+  it('passes the configured batch size and escaped metadata budget to the atomic claim', async () => {
+    const { methods } = resolverMethods();
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+      getResultBatchSize: () => 16,
+    });
+    await resolve(await envelope(), { idempotencyKey: 'delivery-1' });
+    expect(methods.claimBackgroundToolResults).toHaveBeenCalledWith(
+      expect.objectContaining({
+        limit: 16,
+        maxMetadataChars: BACKGROUND_TOOL_WAKEUP_INPUT_MAX_CHARS - 256,
+      }),
     );
   });
 
+  it('releases projections acquired after receipt arbitration when admission fails', async () => {
+    const { methods } = resolverMethods();
+    methods.claimBackgroundToolResults.mockResolvedValueOnce({ status: 'not_ready', results: [] });
+    methods.claimAgentBackgroundToolResults.mockResolvedValueOnce({
+      status: 'acquired',
+      results: [
+        {
+          taskId: 'task-1',
+          toolCallId: 'call-1',
+          toolName: 'slow_tool',
+          status: 'completed',
+          output: 'done',
+        },
+      ],
+    } as never);
+    const resolve = createBackgroundToolCompletionWakeupResolver({
+      methods: methods as never,
+      getGenerationJob: async () => null,
+    });
+    const prepared = await resolve(await envelope(), { idempotencyKey: 'delivery-1' });
+    if (prepared?.status !== 'ready') throw new Error('Expected ready');
+    await prepared.releaseOnDefiniteFailure?.();
+    expect(methods.releaseBackgroundToolResultClaims).toHaveBeenCalledWith({
+      userId: 'user-1',
+      conversationId: 'conversation-1',
+      messageId: 'response-1',
+      kind: 'wakeup',
+      claimId: 'delivery-1',
+    });
+    expect(methods.releaseAgentBackgroundToolResultClaims).toHaveBeenCalled();
+  });
+
   it('defers without claiming while the invoking generation is active', async () => {
     const { methods } = resolverMethods();
     const resolve = createBackgroundToolCompletionWakeupResolver({
diff --git a/packages/api/src/agents/backgroundCompletionWakeup.ts b/packages/api/src/agents/backgroundCompletionWakeup.ts
index bdb2686940d..e107118bffb 100644
--- a/packages/api/src/agents/backgroundCompletionWakeup.ts
+++ b/packages/api/src/agents/backgroundCompletionWakeup.ts
@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto';
-import { isEphemeralAgentId } from 'librechat-data-provider';
-import { AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1 } from '@librechat/data-schemas';
+import { backgroundResultMetadata, isEphemeralAgentId } from 'librechat-data-provider';
+import { AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2 } from '@librechat/data-schemas';
 import type {
   AgentTriggerProducerLeaseStatus,
-  BackgroundToolResultClaim,
+  AgentTriggerDeliveryMethods,
   ConversationMethods,
   IMessage,
   MessageMethods,
@@ -51,31 +51,34 @@ export type RenewBackgroundToolCompletionProducerLease = (
   leaseUntil: Date,
 ) => Promise<boolean>;
 
+export type PersistBackgroundToolCompletionResult = (
+  deliveryKey: string,
+  sourceId: string,
+  result: {
+    status: 'completed' | 'error' | 'cancelled';
+    output: string;
+    settledAt: Date;
+  },
+) => Promise<boolean>;
+
 type WakeupMethods = Pick<ConversationMethods, 'getConvo'> &
-  Pick<MessageMethods, 'getMessages'> & {
-    claimBackgroundToolResults(params: {
-      userId: string;
-      conversationId: string;
-      messageId: string;
-      taskId: string;
-      agentId?: string;
-      kind: 'manual' | 'wakeup';
-      claimId: string;
-      limit?: number;
-    }): Promise<BackgroundToolResultClaim>;
-    releaseBackgroundToolResultClaims(params: {
-      userId: string;
-      conversationId: string;
-      messageId: string;
-      taskIds?: string[];
-      kind: 'manual' | 'wakeup';
-      claimId: string;
-    }): Promise<boolean>;
+  Pick<
+    MessageMethods,
+    'getMessages' | 'claimBackgroundToolResults' | 'releaseBackgroundToolResultClaims'
+  > & {
     getAgentTriggerDeliveryProducerLease(params: {
       deliveryKey: string;
       sourceId: string;
       now: Date;
     }): Promise<AgentTriggerProducerLeaseStatus>;
+    getAgentBackgroundToolResult?(params: { deliveryKey: string; sourceId: string }): Promise<{
+      status: 'completed' | 'error' | 'cancelled';
+      output: string;
+      settledAt: Date;
+    } | null>;
+    claimAgentBackgroundToolResults?: AgentTriggerDeliveryMethods['claimAgentBackgroundToolResults'];
+    getAgentBackgroundToolResultClaim?: AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim'];
+    releaseAgentBackgroundToolResultClaims?: AgentTriggerDeliveryMethods['releaseAgentBackgroundToolResultClaims'];
   };
 
 interface GenerationState {
@@ -90,6 +93,7 @@ interface GenerationState {
 export interface BackgroundToolCompletionWakeupResolverDeps {
   methods: WakeupMethods;
   getGenerationJob: (conversationId: string) => Promise<GenerationState | null>;
+  getResultBatchSize?: () => number | undefined;
 }
 
 function executionError(
@@ -226,13 +230,7 @@ function buildWakeupInput(
     results.length === 1
       ? 'A background tool task has finished. Continue using its durable result below.'
       : `${results.length} background tool tasks have finished. Continue using their durable results below.`;
-  const payload = results.map((result) => ({
-    background_task_id: result.taskId,
-    tool_call_id: result.toolCallId,
-    tool: result.toolName,
-    status: result.status,
-    result: '',
-  }));
+  const payload = results.map(backgroundResultMetadata);
   let remaining = Math.max(
     0,
     BACKGROUND_TOOL_WAKEUP_INPUT_MAX_CHARS - header.length - 1 - JSON.stringify(payload).length,
@@ -253,6 +251,7 @@ function buildWakeupInput(
 export function createBackgroundToolCompletionWakeupResolver({
   methods,
   getGenerationJob,
+  getResultBatchSize,
 }: BackgroundToolCompletionWakeupResolverDeps): NonNullable<
   AgentTriggerExecutionHostDeps['prepareContinue']
 > {
@@ -326,8 +325,34 @@ export function createBackgroundToolCompletionWakeupResolver({
       agentId: envelope.target.agentId,
       kind: 'wakeup',
       claimId: context.idempotencyKey,
+      limit: getResultBatchSize?.() ?? 8,
+      maxMetadataChars: BACKGROUND_TOOL_WAKEUP_INPUT_MAX_CHARS - 256,
     });
     if (claim.status === 'claimed') {
+      const receiptOwner = await methods.getAgentBackgroundToolResultClaim?.({
+        sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+        userId,
+        conversationId: envelope.target.conversationId,
+        parentMessageId: envelope.target.parentMessageId,
+        taskId: registration.taskId,
+      });
+      if (receiptOwner?.claimId === context.idempotencyKey) {
+        const released = await methods.releaseAgentBackgroundToolResultClaims?.({
+          sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+          userId,
+          conversationId: envelope.target.conversationId,
+          parentMessageId: envelope.target.parentMessageId,
+          claimId: context.idempotencyKey,
+        });
+        if (released === false)
+          throw new Error('Background receipt claim release was not confirmed');
+        throw executionError('Background result ownership is being reconciled.', {
+          code: 'BACKGROUND_TOOL_CLAIM_RECONCILING',
+          retryable: true,
+          deferWithoutAttempt: true,
+          retryAfter: '1',
+        });
+      }
       return { status: 'settled' };
     }
     if (claim.status === 'outcome_unknown') {
@@ -336,47 +361,17 @@ export function createBackgroundToolCompletionWakeupResolver({
         retryable: false,
       });
     }
-    if (claim.status !== 'acquired') {
-      let producerLease: AgentTriggerProducerLeaseStatus;
-      try {
-        producerLease = await methods.getAgentTriggerDeliveryProducerLease({
-          deliveryKey: context.idempotencyKey,
-          sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
-          now: new Date(),
-        });
-      } catch (error) {
-        throw executionError(
-          `Background tool producer liveness is temporarily unavailable: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-          { code: 'BACKGROUND_TOOL_PRODUCER_STATE_UNAVAILABLE', retryable: true },
-        );
-      }
-      if (producerLease.status === 'expired') {
-        throw executionError('The process-local background tool executor was lost.', {
-          code: 'BACKGROUND_TOOL_PRODUCER_LOST',
-          retryable: false,
-        });
-      }
-      /** A live lease proves the invocation or its durable persistence retry
-       * still has an owner. Missing remains defer-only for compatibility with
-       * completion rows admitted before producer leases existed. */
-      throw executionError('The background tool result is not durable yet.', {
-        code: 'BACKGROUND_TOOL_RESULT_NOT_READY',
-        retryable: true,
-        status: 409,
-        retryAfter: '1',
-        deferWithoutAttempt: true,
+    if (claim.status === 'acquired') {
+      const taskIds = claim.results.map((result) => result.taskId);
+      const receiptOwner = await methods.getAgentBackgroundToolResultClaim?.({
+        sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+        userId,
+        conversationId: envelope.target.conversationId,
+        parentMessageId: envelope.target.parentMessageId,
+        taskId: registration.taskId,
       });
-    }
-    const taskIds = claim.results.map((result) => result.taskId);
-    const input = buildWakeupInput(claim.results);
-    return {
-      status: 'ready',
-      parentMessageId,
-      input,
-      releaseOnDefiniteFailure: async () => {
-        await methods.releaseBackgroundToolResultClaims({
+      if (receiptOwner != null && receiptOwner.claimId !== context.idempotencyKey) {
+        const released = await methods.releaseBackgroundToolResultClaims({
           userId,
           conversationId: envelope.target.conversationId,
           messageId: envelope.target.parentMessageId,
@@ -384,8 +379,153 @@ export function createBackgroundToolCompletionWakeupResolver({
           kind: 'wakeup',
           claimId: context.idempotencyKey,
         });
-      },
-    };
+        if (!released) throw new Error('Background projection claim release was not confirmed');
+        return { status: 'settled' };
+      }
+      const input = buildWakeupInput(claim.results);
+      return {
+        status: 'ready',
+        parentMessageId,
+        input,
+        releaseOnDefiniteFailure: async () => {
+          const released = await methods.releaseBackgroundToolResultClaims({
+            userId,
+            conversationId: envelope.target.conversationId,
+            messageId: envelope.target.parentMessageId,
+            kind: 'wakeup',
+            claimId: context.idempotencyKey,
+          });
+          if (!released) throw new Error('Background projection claim release was not confirmed');
+          const receiptReleased = await methods.releaseAgentBackgroundToolResultClaims?.({
+            sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+            userId,
+            conversationId: envelope.target.conversationId,
+            parentMessageId: envelope.target.parentMessageId,
+            claimId: context.idempotencyKey,
+          });
+          if (receiptReleased === false)
+            throw new Error('Background receipt claim release was not confirmed');
+        },
+      };
+    }
+    const receiptClaim = await methods.claimAgentBackgroundToolResults?.({
+      deliveryKey: context.idempotencyKey,
+      sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+      userId,
+      conversationId: envelope.target.conversationId,
+      parentMessageId: envelope.target.parentMessageId,
+      agentId: envelope.target.agentId,
+      claimId: context.idempotencyKey,
+      limit: 1,
+    });
+    if (receiptClaim?.status === 'claimed') {
+      return { status: 'settled' };
+    }
+    if (receiptClaim?.status === 'acquired') {
+      /** Reconcile with a parent projection that may have appeared while the
+       * receipt CAS was in flight. A manual poll that already owns the message
+       * wins; otherwise stamp this same automatic owner before dispatch. */
+      const projectedClaim = await methods.claimBackgroundToolResults({
+        userId,
+        conversationId: envelope.target.conversationId,
+        messageId: envelope.target.parentMessageId,
+        taskId: registration.taskId,
+        agentId: envelope.target.agentId,
+        kind: 'wakeup',
+        claimId: context.idempotencyKey,
+        limit: 1,
+      });
+      if (projectedClaim.status === 'claimed') {
+        const released = await methods.releaseAgentBackgroundToolResultClaims?.({
+          sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+          userId,
+          conversationId: envelope.target.conversationId,
+          parentMessageId: envelope.target.parentMessageId,
+          claimId: context.idempotencyKey,
+        });
+        if (released === false)
+          throw new Error('Background receipt claim release was not confirmed');
+        throw executionError('Background result ownership is being reconciled.', {
+          code: 'BACKGROUND_TOOL_CLAIM_RECONCILING',
+          retryable: true,
+          deferWithoutAttempt: true,
+          retryAfter: '1',
+        });
+      }
+      return {
+        status: 'ready',
+        parentMessageId,
+        input: buildWakeupInput(receiptClaim.results),
+        releaseOnDefiniteFailure: async () => {
+          const projectionReleased = await methods.releaseBackgroundToolResultClaims({
+            userId,
+            conversationId: envelope.target.conversationId,
+            messageId: envelope.target.parentMessageId,
+            kind: 'wakeup',
+            claimId: context.idempotencyKey,
+          });
+          if (projectedClaim.status === 'acquired' && !projectionReleased) {
+            throw new Error('Background projection claim release was not confirmed');
+          }
+          const receiptReleased = await methods.releaseAgentBackgroundToolResultClaims?.({
+            sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+            userId,
+            conversationId: envelope.target.conversationId,
+            parentMessageId: envelope.target.parentMessageId,
+            claimId: context.idempotencyKey,
+          });
+          if (receiptReleased === false)
+            throw new Error('Background receipt claim release was not confirmed');
+        },
+      };
+    }
+    const receipt =
+      methods.claimAgentBackgroundToolResults == null
+        ? await methods.getAgentBackgroundToolResult?.({
+            deliveryKey: context.idempotencyKey,
+            sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+          })
+        : null;
+    if (receipt != null) {
+      return {
+        status: 'ready',
+        parentMessageId,
+        input: buildWakeupInput([
+          { ...registration, status: receipt.status, output: receipt.output },
+        ]),
+      };
+    }
+    let producerLease: AgentTriggerProducerLeaseStatus;
+    try {
+      producerLease = await methods.getAgentTriggerDeliveryProducerLease({
+        deliveryKey: context.idempotencyKey,
+        sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+        now: new Date(),
+      });
+    } catch (error) {
+      throw executionError(
+        `Background tool producer liveness is temporarily unavailable: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        { code: 'BACKGROUND_TOOL_PRODUCER_STATE_UNAVAILABLE', retryable: true },
+      );
+    }
+    if (producerLease.status === 'expired') {
+      throw executionError('The process-local background tool executor was lost.', {
+        code: 'BACKGROUND_TOOL_PRODUCER_LOST',
+        retryable: false,
+      });
+    }
+    /** A live lease proves the invocation or its durable persistence retry
+     * still has an owner. Missing remains defer-only for compatibility with
+     * completion rows admitted before producer leases existed. */
+    throw executionError('The background tool result is not durable yet.', {
+      code: 'BACKGROUND_TOOL_RESULT_NOT_READY',
+      retryable: true,
+      status: 409,
+      retryAfter: '1',
+      deferWithoutAttempt: true,
+    });
   };
 }
 
@@ -394,6 +534,7 @@ export function createBackgroundToolCompletionWakeupHandler(
   enqueue: EnqueueBackgroundToolCompletion,
   retire: RetireBackgroundToolCompletion,
   renewProducerLease: RenewBackgroundToolCompletionProducerLease,
+  persistResult?: PersistBackgroundToolCompletionResult,
 ): (
   registration: BackgroundToolWakeupRegistration,
 ) => Promise<BackgroundToolWakeupAdmission | false> {
@@ -437,7 +578,7 @@ export function createBackgroundToolCompletionWakeupHandler(
       availableAt: new Date(
         Math.max(Date.now(), registration.createdAt) + WAKEUP_ADMISSION_DELAY_MS,
       ),
-      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
       producerLeaseUntil: new Date(Date.now() + BACKGROUND_TOOL_PRODUCER_LEASE_MS),
     });
     return {
@@ -447,6 +588,12 @@ export function createBackgroundToolCompletionWakeupHandler(
           BACKGROUND_TOOL_COMPLETION_SOURCE,
           new Date(Date.now() + BACKGROUND_TOOL_PRODUCER_LEASE_MS),
         ),
+      ...(persistResult == null
+        ? {}
+        : {
+            persistResult: (result) =>
+              persistResult(admitted.deliveryKey, BACKGROUND_TOOL_COMPLETION_SOURCE, result),
+          }),
       retire: (reason, options) =>
         options == null
           ? retire(admitted.deliveryKey, BACKGROUND_TOOL_COMPLETION_SOURCE, reason)
@@ -469,6 +616,7 @@ export function createBackgroundToolDeadClaimRecovery(
     conversationId: string;
     claimId: string;
   }) => Promise<'fenced' | 'started' | 'unavailable'>,
+  releaseReceiptClaims?: AgentTriggerDeliveryMethods['releaseAgentBackgroundToolResultClaims'],
 ): BackgroundToolDeadClaimRecovery {
   return async ({ userId, conversationId, messageId, claimId, kind, generationId }) => {
     if (kind === 'manual') {
@@ -518,12 +666,24 @@ export function createBackgroundToolDeadClaimRecovery(
     if (await claimGenerationIsActive()) {
       return false;
     }
-    return releaseClaims({
+    const released = await releaseClaims({
       userId,
       conversationId,
       messageId,
       kind: 'wakeup',
       claimId,
     });
+    if (!released) {
+      return false;
+    }
+    return (
+      (await releaseReceiptClaims?.({
+        sourceId: BACKGROUND_TOOL_COMPLETION_SOURCE,
+        userId,
+        conversationId,
+        parentMessageId: messageId,
+        claimId,
+      })) ?? true
+    );
   };
 }
diff --git a/packages/api/src/agents/execution.spec.ts b/packages/api/src/agents/execution.spec.ts
index 376da3583ac..bc8b7bacba7 100644
--- a/packages/api/src/agents/execution.spec.ts
+++ b/packages/api/src/agents/execution.spec.ts
@@ -145,6 +145,33 @@ describe('resolveCodeExecutionContext', () => {
     expect(context.executionRouteKey).toMatch(/^stateful:[a-f0-9]{32}$/);
   });
 
+  it('derives a stable opaque worktree identity from authenticated conversation scope', () => {
+    const resolve = (conversationId: string, userId = 'user-1') =>
+      resolveCodeExecutionContext({
+        statefulSessions: true,
+        environmentId: 'my-vm',
+        environments: [
+          {
+            id: 'my-vm',
+            name: 'My VM',
+            type: 'attached',
+            baseURL: 'https://bridge.example/v1',
+            workerId: 'worker',
+            owner: 'deployment',
+          },
+        ],
+        userId,
+        conversationId,
+      }).conversationWorkspaceInstanceId;
+
+    const first = resolve('conversation-1');
+    expect(first).toMatch(/^[a-f0-9]{64}$/);
+    expect(resolve('conversation-1')).toBe(first);
+    expect(resolve('conversation-2')).not.toBe(first);
+    expect(resolve('conversation-1', 'user-2')).not.toBe(first);
+    expect(first).not.toContain('conversation-1');
+  });
+
   it('routes a deployment worker declared in pairing metadata', () => {
     const context = resolveCodeExecutionContext({
       statefulSessions: true,
@@ -408,6 +435,24 @@ describe('stateful code approval target binding', () => {
     ).toThrow('changed while this action awaited approval');
   });
 
+  it('requires new approval when the conversation worktree changes', () => {
+    const original = context();
+    original.codeWorkspace!.workspaceInstanceId = 'a'.repeat(64);
+    const expected = captureCodeExecutionApprovalBinding([
+      { id: 'a', codeExecutionContext: original },
+    ]);
+    const updated = context({
+      codeWorkspace: {
+        ...original.codeWorkspace!,
+        workspaceInstanceId: 'b'.repeat(64),
+      },
+    });
+
+    expect(() =>
+      assertCodeExecutionApprovalBinding(expected, [{ id: 'a', codeExecutionContext: updated }]),
+    ).toThrow('changed while this action awaited approval');
+  });
+
   it('captures only opaque, canonical identities for stateful targets', () => {
     const binding = captureCodeExecutionApprovalBinding([
       {
diff --git a/packages/api/src/agents/execution.ts b/packages/api/src/agents/execution.ts
index 5e55e9ff3b0..bf1768815bc 100644
--- a/packages/api/src/agents/execution.ts
+++ b/packages/api/src/agents/execution.ts
@@ -38,9 +38,14 @@ export interface CodeExecutionContext {
   bridgeWorkerId?: string;
   codeEnvironmentConfigSchema?: CodeEnvironmentUserConfigSchema;
   codeEnvironmentSettings?: CodeEnvironmentUserSettings;
+  /** Server-derived conversation identity, activated only after worker capability negotiation. */
+  conversationWorkspaceInstanceId?: string;
   /** Live, server-validated directory selection. Never derive session reuse from this field. */
   codeWorkspace?: CodeWorkspaceSelection & {
     operations: CodeWorkspaceOperation[];
+    workspaceInstanceId?: string;
+    /** Live Code API execution ceiling. Omitted by older deployments. */
+    maxCommandTimeoutMs?: number;
     instructions?: CodeWorkspaceDescriptor['instructions'];
     environment?: CodeWorkspaceDescriptor['environment'];
   };
@@ -113,6 +118,7 @@ export function captureCodeExecutionApprovalBinding(
             : {
                 environmentId: context.codeWorkspace.environmentId,
                 workspaceId: context.codeWorkspace.workspaceId,
+                workspaceInstanceId: context.codeWorkspace.workspaceInstanceId ?? null,
                 operations: [...new Set(context.codeWorkspace.operations)].sort(),
                 ...(context.codeWorkspace.environment
                   ? { definitionFingerprint: context.codeWorkspace.environment.fingerprint }
@@ -347,6 +353,13 @@ export function resolveCodeExecutionContext(params: {
     conversationId: params.conversationId,
   });
   const executionRouteKey = createCodeExecutionRouteKey('stateful', configuredEnvironment);
+  const conversationWorkspaceInstanceId =
+    configuredEnvironment?.type === 'attached' && params.conversationId
+      ? createHash('sha256')
+          .update('librechat-conversation-workspace-v1\0')
+          .update(JSON.stringify([params.userId, params.conversationId, configuredEnvironment.id]))
+          .digest('hex')
+      : undefined;
   return {
     baseUrl: getCodeExecutionBaseUrl('stateful', configuredEnvironment),
     codeSessionKey: `${Constants.EXECUTE_CODE}:${executionRouteKey}:${runtimeSessionHint}`,
@@ -359,6 +372,7 @@ export function resolveCodeExecutionContext(params: {
     bridgeWorkerId: configuredEnvironment?.workerId ?? configuredEnvironment?.pairing?.workerId,
     codeEnvironmentConfigSchema: configuredEnvironment?.configSchema,
     codeEnvironmentSettings: configuredEnvironment?.settings,
+    ...(conversationWorkspaceInstanceId ? { conversationWorkspaceInstanceId } : {}),
   };
 }
 
diff --git a/packages/api/src/agents/files/delivery.spec.ts b/packages/api/src/agents/files/delivery.spec.ts
index d36fa721d62..181501f375d 100644
--- a/packages/api/src/agents/files/delivery.spec.ts
+++ b/packages/api/src/agents/files/delivery.spec.ts
@@ -118,14 +118,23 @@ describe('applyTurnDelivery', () => {
     expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toBe(files);
   });
 
-  it('delivers text for a file the tool that would read it has yet to receive', () => {
-    /* An upload that named no destination is filed under no tool, so the enabled tool alone is
-     * not what serves it: withholding the text on that basis left it readable by nothing. */
-    expect(applyTurnDelivery([csv], { agent, config, consumers: runsCode })).toEqual([
+  it('delivers text for a file File Search has yet to receive', () => {
+    /* An upload that named no destination is filed under no tool, so an enabled search tool
+     * alone is not what serves it: withholding the text on that basis left it readable by
+     * nothing. */
+    const searchesFiles: TurnFileConsumers = { executeCode: false, fileSearch: true };
+    expect(applyTurnDelivery([csv], { agent, config, consumers: searchesFiles })).toEqual([
       { ...csv, llmDeliveryPath: 'text' },
     ]);
   });
 
+  it('leaves a file Run Code can read with Run Code before the sandbox holds it', () => {
+    /* Run Code uploads the file on its first call. Delivering the text instead would count it
+     * toward the turn's limits until that call, and a refused turn never makes it. */
+    const files = [csv];
+    expect(applyTurnDelivery(files, { agent, config, consumers: runsCode })).toBe(files);
+  });
+
   it('marks nothing where the endpoint has not enabled the fallback', () => {
     const files = [csv];
     const disabled = {
diff --git a/packages/api/src/agents/files/encode.spec.ts b/packages/api/src/agents/files/encode.spec.ts
index d999273eadb..10c29025be9 100644
--- a/packages/api/src/agents/files/encode.spec.ts
+++ b/packages/api/src/agents/files/encode.spec.ts
@@ -1,4 +1,4 @@
-import { FileSources, ImageDetail } from 'librechat-data-provider';
+import { FileContext, FileSources, ImageDetail } from 'librechat-data-provider';
 import type { TFile } from 'librechat-data-provider';
 import type { RunFileEncodingAgent, RunFileMessageEncoderDeps } from './encode';
 import type { ServerRequest } from '~/types';
@@ -172,6 +172,7 @@ describe('createRunFileMessageEncoder', () => {
       agents: {
         noReader: { provider: 'openAI', fileConsumers: { executeCode: false, fileSearch: false } },
         runsCode: { provider: 'openAI', fileConsumers: { executeCode: true, fileSearch: false } },
+        searches: { provider: 'openAI', fileConsumers: { executeCode: false, fileSearch: true } },
         unknown: { provider: 'openAI' },
       },
       fileConfig: {
@@ -184,8 +185,9 @@ describe('createRunFileMessageEncoder', () => {
       },
     });
 
-    /* A tool serves a file only once it holds it, so the child that runs code keeps the file off
-     * its prompt for the copy the sandbox has, and receives the text for the one it does not. */
+    /* Run Code uploads the file on its first call, so the child that runs code keeps it off the
+     * prompt whether or not its sandbox holds a copy yet. File search serves only what its
+     * store holds, so the searching child receives the text for a file never embedded. */
     const sandboxCsv: TFile = {
       ...csv,
       metadata: {
@@ -199,16 +201,18 @@ describe('createRunFileMessageEncoder', () => {
       },
     };
 
-    const [noReader, runsCode, unprovisioned, unknown] = await Promise.all([
+    const [noReader, runsCode, unprovisioned, searches, unknown] = await Promise.all([
       harness.encode([csv], 'noReader'),
       harness.encode([sandboxCsv], 'runsCode'),
       harness.encode([csv], 'runsCode'),
+      harness.encode([csv], 'searches'),
       harness.encode([csv], 'unknown'),
     ]);
 
     expect(JSON.stringify(noReader[0].content)).toContain('region,total');
     expect(runsCode).toEqual([]);
-    expect(JSON.stringify(unprovisioned[0].content)).toContain('region,total');
+    expect(unprovisioned).toEqual([]);
+    expect(JSON.stringify(searches[0].content)).toContain('region,total');
     expect(unknown).toEqual([]);
     expect(harness.extractText).toHaveBeenCalledWith(
       expect.objectContaining({ attachments: [{ ...csv, llmDeliveryPath: 'text' }] }),
@@ -363,6 +367,28 @@ describe('createRunFileMessageEncoder', () => {
     },
   );
 
+  it('leaves code outputs with cleared sandbox references out of the child prompt and its count budget', async () => {
+    /* Priming clears a dead reference on the turn's copy so the output is re-provisioned; the
+     * output still belongs to the sandbox, so it neither reaches the prompt nor spends the
+     * one-file budget. */
+    const harness = setup({ fileConfig: { endpoints: { openAI: { fileLimit: 1 } } } });
+    const output = (file_id: string): TFile => ({
+      ...pdf,
+      file_id,
+      filename: `${file_id}.png`,
+      type: 'image/png',
+      text: undefined,
+      llmDeliveryPath: undefined,
+      context: FileContext.execute_code,
+      metadata: {},
+    });
+
+    await expect(harness.encode([output('chart-a'), output('chart-b')], 'child')).resolves.toEqual(
+      [],
+    );
+    expect(harness.encodeImages).not.toHaveBeenCalled();
+  });
+
   it('includes permanent child context in the count budget before encoding shared files', async () => {
     const harness = setup({
       agents: {
diff --git a/packages/api/src/agents/files/encode.ts b/packages/api/src/agents/files/encode.ts
index a5312c52992..e04d6cbed86 100644
--- a/packages/api/src/agents/files/encode.ts
+++ b/packages/api/src/agents/files/encode.ts
@@ -16,6 +16,7 @@ import type { BaseMessage } from '@librechat/agents/langchain';
 import type { ServerRequest, StrategyFunctions } from '~/types';
 import type { TokenCountFn } from '~/utils/text';
 import {
+  isToolOwnedAttachment,
   isModelBoundAttachmentFile,
   assertAgentAttachmentLimits,
   AgentAttachmentPolicyError,
@@ -160,13 +161,7 @@ export function createRunFileMessageEncoder(
       }
       /* Provisioning may add tool references to native files. Only legacy records use
        * those references to decide whether their bytes belong in the prompt. */
-      if (
-        deliveryPath !== 'provider' &&
-        (file.embedded === true ||
-          file.metadata?.codeEnvRef != null ||
-          file.metadata?.codeEnvRefs != null ||
-          file.metadata?.fileIdentifier != null)
-      ) {
+      if (deliveryPath !== 'provider' && isToolOwnedAttachment(file)) {
         continue;
       }
       if (file.type.startsWith('image/')) {
diff --git a/packages/api/src/agents/handlers.background.spec.ts b/packages/api/src/agents/handlers.background.spec.ts
index dc41cb8464b..645a473cf9e 100644
--- a/packages/api/src/agents/handlers.background.spec.ts
+++ b/packages/api/src/agents/handlers.background.spec.ts
@@ -3,13 +3,19 @@ import { logger } from '@librechat/data-schemas';
 import { tool as structuredTool } from '@librechat/agents/langchain/tools';
 import type { StructuredToolInterface } from '@librechat/agents/langchain/tools';
 import type { FiltersConfig } from 'librechat-data-provider';
+import type { BackgroundToolWakeupAdmission } from './backgroundCompletion';
 import type { ToolExecuteOptions } from './handlers';
+import {
+  BACKGROUND_TASK_ABORT_GRACE_MS,
+  BACKGROUND_TASK_TIMEOUT_MS,
+  BACKGROUND_TOOL_PRODUCER_HEARTBEAT_MS,
+} from './backgroundCompletion';
 import {
   backgroundTaskRegistry,
   runCheckBackgroundTask,
   CHECK_BACKGROUND_TASK_NAME,
 } from './background';
-import { BACKGROUND_TASK_ABORT_GRACE_MS, BACKGROUND_TASK_TIMEOUT_MS } from './backgroundCompletion';
+import { BACKGROUND_TOOL_INVOCATION_CONFIG_KEY } from './invocation';
 import { ContentFilterError } from '../middleware/contentFilter';
 import { createToolExecuteHandler } from './handlers';
 
@@ -142,9 +148,13 @@ describe('createToolExecuteHandler — background tool calls', () => {
   it('pre-registers an ordinary completion before invoke and persists its terminal receipt', async () => {
     const events: string[] = [];
     const retire = jest.fn(async () => true);
+    const persistResult = jest.fn(async () => {
+      events.push('receipt');
+      return true;
+    });
     const preregister = jest.fn(async () => {
       events.push('preregister');
-      return { renew: jest.fn(async () => true), retire };
+      return { renew: jest.fn(async () => true), persistResult, retire };
     });
     const persist = jest.fn(async () => {
       events.push('persist');
@@ -183,9 +193,17 @@ describe('createToolExecuteHandler — background tool calls', () => {
     });
 
     expect(events.slice(0, 2)).toEqual(['preregister', 'invoke']);
+    expect(tool.invoke).toHaveBeenCalledWith(
+      { q: 'continuations' },
+      expect.objectContaining({
+        configurable: expect.objectContaining({
+          [BACKGROUND_TOOL_INVOCATION_CONFIG_KEY]: true,
+        }),
+      }),
+    );
     expect(JSON.parse(dispatch.content).message).toContain('host will resume you');
     await flushMicrotasks();
-    expect(events).toEqual(['preregister', 'invoke', 'persist']);
+    expect(events).toEqual(['preregister', 'invoke', 'receipt', 'persist']);
     expect(preregister).toHaveBeenCalledWith(
       expect.objectContaining({
         toolCallId: 'call-wakeup',
@@ -204,6 +222,9 @@ describe('createToolExecuteHandler — background tool calls', () => {
         }),
       }),
     );
+    expect(persistResult).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'completed', output: 'durable result' }),
+    );
     expect(retire).not.toHaveBeenCalled();
   });
 
@@ -251,6 +272,55 @@ describe('createToolExecuteHandler — background tool calls', () => {
     );
   });
 
+  it.each(['acknowledged', 'ambiguous'])(
+    'keeps delivery live for an %s receipt without a projection',
+    async (ack) => {
+      const retire = jest.fn(async () => true);
+      const persistResult = jest.fn(async () => {
+        if (ack === 'ambiguous') throw new Error('receipt committed but acknowledgement lost');
+        return true;
+      });
+      const tool = {
+        name: 'search_mcp_docs',
+        description: 'search docs',
+        schema: z.object({ q: z.string() }),
+        invoke: jest.fn(async () => ({ content: 'available before parent row' })),
+      } as unknown as StructuredToolInterface;
+      const handler = createToolExecuteHandler({
+        loadTools: async () => ({ loadedTools: [tool] }),
+        backgroundToolCompletion: {
+          preregister: jest.fn(async () => ({
+            renew: jest.fn(async () => true),
+            persistResult,
+            retire,
+          })),
+          persist: jest.fn(async () => false),
+          claim: jest.fn(async () => ({ status: 'acquired' as const, results: [] })),
+        },
+      });
+
+      await runBatch(handler, {
+        toolCalls: [
+          {
+            id: `call-independent-receipt-${ack}`,
+            name: tool.name,
+            args: { q: 'receipt', run_in_background: true },
+            stepId: 'step-independent-receipt',
+          },
+        ],
+        agentId: 'agent_parent_1',
+        configurable: buildConfig([tool.name]),
+        metadata: { thread_id: 'exec_convo', run_id: `response-independent-receipt-${ack}` },
+      });
+      await flushMicrotasks();
+
+      expect(persistResult).toHaveBeenCalledWith(
+        expect.objectContaining({ status: 'completed', output: 'available before parent row' }),
+      );
+      expect(retire).not.toHaveBeenCalled();
+    },
+  );
+
   it('keeps polling guidance when the completion adapter skips registration', async () => {
     const tool = makeSearchTool({ calls: 0 });
     const preregister = jest.fn(async () => false as const);
@@ -817,6 +887,64 @@ describe('createToolExecuteHandler — background tool calls', () => {
     }
   });
 
+  it('stops producer heartbeats after the completion lease is lost', async () => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate'] });
+    try {
+      let finishTool: ((value: { content: string }) => void) | undefined;
+      const tool = {
+        name: 'search_mcp_docs',
+        description: 'search docs',
+        schema: z.object({ q: z.string() }),
+        invoke: jest.fn(
+          () =>
+            new Promise<{ content: string }>((resolve) => {
+              finishTool = resolve;
+            }),
+        ),
+      } as unknown as StructuredToolInterface;
+      const renew = jest.fn(async () => false);
+      const handler = createToolExecuteHandler({
+        loadTools: async () => ({ loadedTools: [tool] }),
+        backgroundToolCompletion: {
+          preregister: jest.fn(async () => ({
+            renew,
+            retire: jest.fn(async () => true),
+          })),
+          persist: jest.fn(async () => true),
+          claim: jest.fn(async () => ({ status: 'acquired' as const, results: [] })),
+        },
+      });
+
+      await runBatch(handler, {
+        toolCalls: [
+          {
+            id: 'call-lost-producer-lease',
+            name: tool.name,
+            args: { q: 'lease', run_in_background: true },
+            stepId: 'step-lost-producer-lease',
+          },
+        ],
+        agentId: 'agent_parent_1',
+        configurable: buildConfig([tool.name]),
+        metadata: { thread_id: 'exec_convo', run_id: 'response-lost-producer-lease' },
+      });
+
+      jest.advanceTimersByTime(BACKGROUND_TOOL_PRODUCER_HEARTBEAT_MS);
+      await flushMicrotasks();
+      expect(renew).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(BACKGROUND_TOOL_PRODUCER_HEARTBEAT_MS * 6);
+      await flushMicrotasks();
+      expect(renew).toHaveBeenCalledTimes(1);
+
+      finishTool?.({ content: 'settled after lease loss' });
+      await flushMicrotasks();
+      await flushMicrotasks();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
   it('persists an Event Actor launch before invoking and terminal evidence before wakeup', async () => {
     const events: string[] = [];
     let finishTool: ((value: { content: string }) => void) | undefined;
@@ -2499,6 +2627,84 @@ describe('createToolExecuteHandler — backgrounded code execution', () => {
     expect(poll[0].artifact).toEqual(CODE_ARTIFACT);
   });
 
+  it('does not publish an output-only receipt when generated files miss their message anchor', async () => {
+    const state: CodeToolState = { calls: 0 };
+    const retire = jest.fn(async () => true);
+    const persistResult = jest.fn(async () => true);
+    const handler = createToolExecuteHandler({
+      loadTools: async () => ({ loadedTools: [makeCodeTool(state)] }),
+      persistBackgroundCodeResult: async () => ({
+        deliveryReady: false,
+        attachments: [{ filename: 'plot.png' }],
+      }),
+      backgroundToolCompletion: {
+        preregister: jest.fn(async () => ({
+          renew: jest.fn(async () => true),
+          persistResult,
+          retire,
+        })),
+        persist: jest.fn(async () => true),
+        claim: jest.fn(async () => ({ status: 'acquired' as const, results: [] })),
+      },
+    });
+
+    await runBatch(handler, {
+      toolCalls: [codeCall({ id: 'call_code_missing_anchor' })],
+      agentId: 'a',
+      configurable: buildConfig(['execute_code']),
+      metadata: { thread_id: 'exec_convo_code_missing_anchor', run_id: 'msg-missing-anchor' },
+    });
+    await flushMicrotasks();
+    await flushMicrotasks();
+
+    expect(persistResult).not.toHaveBeenCalled();
+    expect(retire).toHaveBeenCalledWith('background code result was not persisted', undefined);
+  });
+
+  it('uses the configured durable completion result size', async () => {
+    const persistResult: jest.MockedFunction<
+      NonNullable<BackgroundToolWakeupAdmission['persistResult']>
+    > = jest.fn(
+      async (_result: Parameters<NonNullable<BackgroundToolWakeupAdmission['persistResult']>>[0]) =>
+        true,
+    );
+    const tool = {
+      name: 'execute_code',
+      description: 'run code',
+      schema: z.object({ lang: z.string(), code: z.string() }),
+      invoke: jest.fn(async () => ({ content: '0123456789'.repeat(10), artifact: CODE_ARTIFACT })),
+    } as unknown as StructuredToolInterface;
+    const handler = createToolExecuteHandler({
+      loadTools: async () => ({ loadedTools: [tool] }),
+      backgroundCompletionResultMaxChars: 32,
+      persistBackgroundCodeResult: async () => ({ deliveryReady: true, attachments: [] }),
+      backgroundToolCompletion: {
+        preregister: jest.fn(async () => ({
+          renew: jest.fn(async () => true),
+          persistResult,
+          retire: jest.fn(async () => true),
+        })),
+        persist: jest.fn(async () => true),
+        claim: jest.fn(async () => ({ status: 'acquired' as const, results: [] })),
+      },
+    });
+
+    await runBatch(handler, {
+      toolCalls: [codeCall({ id: 'call-sized-receipt' })],
+      agentId: 'agent_parent_1',
+      configurable: buildConfig([tool.name]),
+      metadata: { thread_id: 'exec_convo', run_id: 'response-sized-receipt' },
+    });
+    await flushMicrotasks();
+    await flushMicrotasks();
+    await flushMicrotasks();
+
+    expect(persistResult).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'completed', output: expect.any(String) }),
+    );
+    expect(persistResult.mock.calls[0][0].output).toHaveLength(32);
+  });
+
   it('makes a completion-time generated-file policy rejection terminal across polls', async () => {
     const protectedValue = 'PROTECTED-GENERATED-FILE-BYTES';
     const blockedArtifact = {
@@ -2525,12 +2731,17 @@ describe('createToolExecuteHandler — backgrounded code execution', () => {
     });
     const toolEndCallback = jest.fn();
     const retire = jest.fn(async () => true);
+    const persistResult = jest.fn(async () => true);
     const handler = createToolExecuteHandler({
       loadTools: async () => ({ loadedTools: [codeTool] }),
       toolEndCallback,
       persistBackgroundCodeResult,
       backgroundToolCompletion: {
-        preregister: jest.fn(async () => ({ renew: jest.fn(async () => true), retire })),
+        preregister: jest.fn(async () => ({
+          renew: jest.fn(async () => true),
+          retire,
+          persistResult,
+        })),
         persist: jest.fn(async () => true),
         claim: jest.fn(async () => ({ status: 'acquired' as const, results: [] })),
       },
@@ -2550,7 +2761,10 @@ describe('createToolExecuteHandler — backgrounded code execution', () => {
     const taskId = JSON.parse(dispatch[0].content).background_task_id;
     await flushMicrotasks();
     await flushMicrotasks();
-    expect(retire).toHaveBeenCalledWith('background code result persistence failed', undefined);
+    expect(persistResult).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'error', output: MODEL_BOUND_FILE_CONTENT_BLOCK }),
+    );
+    expect(retire).not.toHaveBeenCalled();
     await flushMicrotasks();
 
     for (const pollId of ['call_policy_poll_1', 'call_policy_poll_2']) {
diff --git a/packages/api/src/agents/handlers.spec.ts b/packages/api/src/agents/handlers.spec.ts
index daa6eebabf1..bf71ed678c6 100644
--- a/packages/api/src/agents/handlers.spec.ts
+++ b/packages/api/src/agents/handlers.spec.ts
@@ -2913,6 +2913,49 @@ describe('createToolExecuteHandler', () => {
       expect(grantSkillOwner).toHaveBeenCalledWith({ req, skillId: SKILL_ID });
     });
 
+    it('retries dependent cleanup when create_file cannot grant ownership', async () => {
+      const createSkill = jest.fn(async () => ({
+        skill: { _id: SKILL_ID, name: 'permission-failure', body: '# Test', version: 1 },
+      }));
+      const deleteSkill = jest
+        .fn()
+        .mockResolvedValueOnce({
+          deleted: true,
+          skillAbsent: true,
+          cleanupComplete: false,
+          failedCleanupSteps: ['permissions'],
+        })
+        .mockResolvedValueOnce({
+          deleted: false,
+          skillAbsent: true,
+          cleanupComplete: true,
+          failedCleanupSteps: [],
+        });
+      const handler = makeAuthoringHandler({
+        getSkillByName: jest.fn(async () => null),
+        createSkill: createSkill as unknown as ToolExecuteOptions['createSkill'],
+        grantSkillOwner: jest.fn(async () => {
+          throw new Error('permission unavailable');
+        }),
+        deleteSkill,
+      });
+
+      const [result] = await invokeHandler(handler, [
+        {
+          id: 'call_permission_failure',
+          name: 'create_file',
+          args: {
+            path: 'skills/permission-failure/SKILL.md',
+            content:
+              '---\nname: permission-failure\ndescription: Permission rollback test\n---\n# Test\n',
+          },
+        },
+      ]);
+
+      expect(result.status).toBe('error');
+      expect(deleteSkill).toHaveBeenCalledTimes(2);
+    });
+
     it('rejects case-colliding recognized frontmatter keys in create_file', async () => {
       const createSkill = jest.fn();
       const handler = makeAuthoringHandler({
@@ -4539,6 +4582,14 @@ describe('createToolExecuteHandler', () => {
             executionProfile: 'stateful',
             statefulSessions: true,
             environmentType: 'attached',
+            environmentId: 'personal-machine',
+            codeWorkspace: {
+              environmentId: 'personal-machine',
+              workspaceId: 'project-a',
+              workspaceInstanceId: 'a'.repeat(64),
+              operations: TEST_ATTACHED_WORKSPACE_OPERATIONS,
+            },
+            codeEnvironmentConfigSchema: { limits: { maxQueueWaitMs: 0 } },
             bridgeWorkerId: 'user-worker',
           },
         },
@@ -4568,6 +4619,8 @@ describe('createToolExecuteHandler', () => {
         content: 'export const ok = 1;',
         overwrite: false,
         workspace_id: 'project-a',
+        workspace_instance_id: 'a'.repeat(64),
+        maxQueueWaitMs: 0,
         codeApiBaseUrl: 'https://code.example.com',
         executionProfile: 'stateful',
         bridgeWorkerId: 'user-worker',
@@ -4654,6 +4707,7 @@ describe('createToolExecuteHandler', () => {
             executionProfile: 'stateful',
             statefulSessions: true,
             environmentType: 'attached',
+            codeEnvironmentConfigSchema: { limits: { maxQueueWaitMs: 0 } },
             bridgeWorkerId: 'user-worker',
           },
         },
@@ -4688,6 +4742,7 @@ describe('createToolExecuteHandler', () => {
           { oldText: 'false', newText: 'true' },
         ],
         workspace_id: 'project-a',
+        maxQueueWaitMs: 0,
         codeApiBaseUrl: 'https://code.example.com',
         executionProfile: 'stateful',
         bridgeWorkerId: 'user-worker',
@@ -4760,78 +4815,105 @@ describe('createToolExecuteHandler', () => {
       expect(editWorkspaceFile).not.toHaveBeenCalled();
     });
 
-    it('commits inspected attached edits with the preview revision fence', async () => {
-      const previewWorkspaceEdit = jest.fn(async () => ({
-        protocolVersion: 1 as const,
-        operation: 'preview_edit' as const,
-        workspaceId: 'primary',
-        path: 'src/app.ts',
-        content: 'const state = "ready";',
-        hasUtf8Bom: false,
-        baseSha256: 'b'.repeat(64),
-        replacements: 1,
-        bytesWritten: 22,
-      }));
-      const editWorkspaceFile = jest.fn(async () => ({
-        protocolVersion: 1 as const,
-        operation: 'edit_file' as const,
-        workspaceId: 'primary',
-        path: 'src/app.ts',
-        replacements: 1,
-        bytesWritten: 22,
-      }));
-      const protectedReq = {
-        user: { id: 'user-1' },
-        config: {
-          filters: {
-            files: {
-              pii: {
-                fields: ['content'],
-                starterPatterns: [],
-                customPatterns: [
-                  {
-                    id: 'blocked-placeholder',
-                    label: 'blocked placeholder',
-                    regex: 'NEVER-MATCH-THIS',
-                  },
-                ],
+    it.each([
+      { budget: 1200, elapsed: 0, remaining: 1200 },
+      { budget: 1200, elapsed: 400, remaining: 800 },
+      { budget: 1200, elapsed: 1200, remaining: null },
+      { budget: 1200, elapsed: 1500, remaining: null },
+      { budget: 0, elapsed: 400, remaining: 0 },
+    ])(
+      'shares a protected edit retry horizon ($budget ms, preview $elapsed ms)',
+      async ({ budget, elapsed, remaining }) => {
+        let nowMs = Date.now();
+        jest.spyOn(Date, 'now').mockImplementation(() => nowMs);
+        const previewWorkspaceEdit = jest.fn(async () => {
+          nowMs += elapsed;
+          return {
+            protocolVersion: 1 as const,
+            operation: 'preview_edit' as const,
+            workspaceId: 'primary',
+            path: 'src/app.ts',
+            content: 'const state = "ready";',
+            hasUtf8Bom: false,
+            baseSha256: 'b'.repeat(64),
+            replacements: 1,
+            bytesWritten: 22,
+          };
+        });
+        const editWorkspaceFile = jest.fn(async () => ({
+          protocolVersion: 1 as const,
+          operation: 'edit_file' as const,
+          workspaceId: 'primary',
+          path: 'src/app.ts',
+          replacements: 1,
+          bytesWritten: 22,
+        }));
+        const protectedReq = {
+          user: { id: 'user-1' },
+          config: {
+            filters: {
+              files: {
+                pii: {
+                  fields: ['content'],
+                  starterPatterns: [],
+                  customPatterns: [
+                    {
+                      id: 'blocked-placeholder',
+                      label: 'blocked placeholder',
+                      regex: 'NEVER-MATCH-THIS',
+                    },
+                  ],
+                },
               },
             },
           },
-        },
-      } as never;
-      const handler = makeSandboxAuthoringHandler(
-        { previewWorkspaceEdit, editWorkspaceFile },
-        {
-          req: protectedReq,
-          codeExecutionContext: {
-            baseUrl: 'https://code.example.com',
-            codeSessionKey: 'attached-session',
-            executionProfile: 'stateful',
-            statefulSessions: true,
-            environmentType: 'attached',
-            bridgeWorkerId: 'user-worker',
+        } as never;
+        const handler = makeSandboxAuthoringHandler(
+          { previewWorkspaceEdit, editWorkspaceFile },
+          {
+            req: protectedReq,
+            codeExecutionContext: {
+              baseUrl: 'https://code.example.com',
+              codeSessionKey: 'attached-session',
+              executionProfile: 'stateful',
+              statefulSessions: true,
+              environmentType: 'attached',
+              codeEnvironmentConfigSchema: { limits: { maxQueueWaitMs: budget } },
+              bridgeWorkerId: 'user-worker',
+            },
           },
-        },
-      );
+        );
 
-      const [result] = await invokeHandler(handler, [
-        {
-          id: 'call_edit_workspace_inspected',
-          name: 'edit_file',
-          args: {
-            path: 'workspace/src/app.ts',
-            old_text: 'draft',
-            new_text: 'ready',
+        const [result] = await invokeHandler(handler, [
+          {
+            id: 'call_edit_workspace_inspected',
+            name: 'edit_file',
+            args: {
+              path: 'workspace/src/app.ts',
+              old_text: 'draft',
+              new_text: 'ready',
+            },
           },
-        },
-      ]);
+        ]);
 
-      expect(result.status).toBe('success');
-      expect(editWorkspaceFile).toHaveBeenCalledWith(
-        expect.objectContaining({ expected_base_sha256: 'b'.repeat(64) }),
-      );
-    });
+        expect(previewWorkspaceEdit).toHaveBeenCalledWith(
+          expect.objectContaining({ maxQueueWaitMs: budget }),
+        );
+        if (remaining == null) {
+          expect(result.status).toBe('error');
+          expect(result.errorMessage).toContain('The file was not modified');
+          expect(editWorkspaceFile).not.toHaveBeenCalled();
+          return;
+        }
+        expect(result.status).toBe('success');
+        expect(editWorkspaceFile).toHaveBeenCalledWith(
+          expect.objectContaining({
+            expected_base_sha256: 'b'.repeat(64),
+            maxQueueWaitMs: remaining,
+          }),
+        );
+      },
+    );
 
     it('contains a file-artifact policy rejection to its call without rejecting the batch', async () => {
       const detectorLabel = 'generated-file bearer token';
@@ -5516,6 +5598,14 @@ describe('createToolExecuteHandler', () => {
           codeSessionKey: 'execute_code:stateful:attached',
           executionProfile: 'stateful',
           environmentType: 'attached',
+          environmentId: 'personal-machine',
+          codeWorkspace: {
+            environmentId: 'personal-machine',
+            workspaceId: 'project-a',
+            workspaceInstanceId: 'b'.repeat(64),
+            operations: TEST_ATTACHED_WORKSPACE_OPERATIONS,
+          },
+          codeEnvironmentConfigSchema: { limits: { maxQueueWaitMs: 0 } },
           bridgeWorkerId: 'personal-worker-1',
           statefulSessions: true,
         },
@@ -5534,6 +5624,8 @@ describe('createToolExecuteHandler', () => {
       expect(readWorkspaceFile).toHaveBeenCalledWith({
         file_path: 'src/app.ts',
         workspace_id: 'project-a',
+        workspace_instance_id: 'b'.repeat(64),
+        maxQueueWaitMs: 0,
         start_line: 1,
         max_lines: 200,
         codeApiBaseUrl: 'https://code.example.com/v1',
@@ -5840,6 +5932,7 @@ describe('createToolExecuteHandler', () => {
       expect(searchWorkspace).toHaveBeenCalledWith({
         query: 'needle',
         workspace_id: 'project-a',
+        maxQueueWaitMs: 300000,
         path: 'src',
         max_results: 20,
         codeApiBaseUrl: 'https://code.example.com/v1',
@@ -5992,6 +6085,7 @@ describe('createToolExecuteHandler', () => {
 
       expect(listWorkspaceFiles).toHaveBeenCalledWith({
         workspace_id: 'project-a',
+        maxQueueWaitMs: 300000,
         path: 'src',
         after_path: 'src/app.ts',
         max_results: 20,
diff --git a/packages/api/src/agents/handlers.ts b/packages/api/src/agents/handlers.ts
index 4c4a836781f..5d39bf4068a 100644
--- a/packages/api/src/agents/handlers.ts
+++ b/packages/api/src/agents/handlers.ts
@@ -3,6 +3,7 @@ import { Types } from 'mongoose';
 import { GraphEvents, Constants, ToolEndHandler } from '@librechat/agents';
 import { logger, normalizeSkillFrontmatterKeys } from '@librechat/data-schemas';
 import {
+  AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT,
   hasActivePiiFields,
   hasActivePiiPatterns,
   hasToolCallErrorPrefix,
@@ -22,8 +23,12 @@ import type {
   StreamEventData,
   ToolEndCallback as SdkToolEndCallback,
 } from '@librechat/agents';
+import type {
+  BackgroundToolResultClaim,
+  DeleteSkillResult,
+  ValidationIssue,
+} from '@librechat/data-schemas';
 import type { CodeEnvRef, CodeWorkspaceOperation, PtcToolCallEvent } from 'librechat-data-provider';
-import type { BackgroundToolResultClaim, ValidationIssue } from '@librechat/data-schemas';
 import type { StructuredToolInterface } from '@librechat/agents/langchain/tools';
 import type { CodeEnvFile, CodeSessionContext } from '@librechat/agents';
 import type {
@@ -116,10 +121,13 @@ import {
 } from './intent';
 import { buildSkillPrimeMessage, isSkillFilePath, SKILL_FILE_PREFIX } from './skills';
 import { resolveCallerCapabilityProjectionSnapshot } from './callerCapabilities';
+import { resolveAttachedWorkspaceQueueWaitMs } from '~/code/command';
+import { BACKGROUND_TOOL_INVOCATION_CONFIG_KEY } from './invocation';
 import { mergeCodeFilesIntoContext } from './codeFilesSession';
 import { toolValidationFeedback } from './validationFeedback';
 import { createSkillContentDigest } from './compatibility';
 import { isMissingSandboxPathError } from '~/files/code';
+import { deleteSkillWithRetry } from '~/skills/cleanup';
 import { resolveDownloadPath } from '~/storage/path';
 import { parseFrontmatter } from '../skills/import';
 import { cleanCodeToolOutput } from './cleanup';
@@ -264,6 +272,8 @@ export interface ToolExecuteOptions {
   runFiles?: Pick<RunFileSession, 'isActive' | 'prepareTools' | 'withCodeExecution'>;
   /** Trusted deployment gate for cooperative ordinary-tool cancellation. */
   ordinaryToolCancellation?: boolean;
+  /** Deployment-configured cap for terminal output copied into durable receipts. */
+  backgroundCompletionResultMaxChars?: number;
   /** Callback to process tool artifacts (code output files, file citations, etc.) */
   toolEndCallback?: ToolEndCallback;
   /** Durable internal-completion adapter, present only for an Event Actor invocation. */
@@ -453,7 +463,7 @@ export interface ToolExecuteOptions {
     skillId: Types.ObjectId | string;
   }) => Promise<void>;
   /** Deletes a freshly-created skill if owner-permission setup fails. */
-  deleteSkill?: (id: string) => Promise<{ deleted: boolean }>;
+  deleteSkill?: (id: string) => Promise<DeleteSkillResult>;
   /** Saves or replaces a bundled skill file in configured storage and metadata. */
   saveSkillFileContent?: (params: {
     req: ServerRequest;
@@ -533,6 +543,7 @@ export interface ToolExecuteOptions {
   readWorkspaceFile?: (params: {
     file_path: string;
     workspace_id: string;
+    workspace_instance_id?: string;
     start_line: number;
     max_lines: number;
     codeApiBaseUrl: string;
@@ -540,11 +551,13 @@ export interface ToolExecuteOptions {
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspaceReadResult>;
   /** Searches literal text within an attached worker's logical workspace. */
   searchWorkspace?: (params: {
     query: string;
     workspace_id: string;
+    workspace_instance_id?: string;
     path?: string;
     max_results: number;
     codeApiBaseUrl: string;
@@ -552,10 +565,12 @@ export interface ToolExecuteOptions {
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspaceSearchResult>;
   /** Lists relative file paths within an attached worker's logical workspace. */
   listWorkspaceFiles?: (params: {
     workspace_id: string;
+    workspace_instance_id?: string;
     path?: string;
     after_path?: string;
     max_results: number;
@@ -564,6 +579,7 @@ export interface ToolExecuteOptions {
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspaceListResult>;
   /** Writes a UTF-8 file within an attached worker's logical workspace. */
   writeWorkspaceFile?: (params: {
@@ -571,22 +587,26 @@ export interface ToolExecuteOptions {
     content: string;
     overwrite: boolean;
     workspace_id: string;
+    workspace_instance_id?: string;
     codeApiBaseUrl: string;
     executionProfile: CodeExecutionContext['executionProfile'];
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspaceWriteResult>;
   /** Previews exact replacements without mutating an attached worker workspace. */
   previewWorkspaceEdit?: (params: {
     file_path: string;
     edits: Array<{ oldText: string; newText: string }>;
     workspace_id: string;
+    workspace_instance_id?: string;
     codeApiBaseUrl: string;
     executionProfile: CodeExecutionContext['executionProfile'];
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspacePreviewEditResult>;
   /** Applies exact replacements atomically within an attached worker workspace. */
   editWorkspaceFile?: (params: {
@@ -594,11 +614,13 @@ export interface ToolExecuteOptions {
     edits: Array<{ oldText: string; newText: string }>;
     expected_base_sha256?: string;
     workspace_id: string;
+    workspace_instance_id?: string;
     codeApiBaseUrl: string;
     executionProfile: CodeExecutionContext['executionProfile'];
     bridgeWorkerId?: string;
     req?: ServerRequest;
     signal?: AbortSignal;
+    maxQueueWaitMs?: number;
   }) => Promise<WorkspaceEditResult>;
   /**
    * Reads a code-execution sandbox file by shelling `cat` through the
@@ -2418,9 +2440,15 @@ async function handleWorkspaceFileRead(
     const result = await readWorkspaceFile({
       file_path: filePath,
       workspace_id: workspaceId,
+      ...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
+        ? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
+        : {}),
       start_line: startLine,
       max_lines: maxLines,
       codeApiBaseUrl: codeExecutionContext.baseUrl,
+      maxQueueWaitMs: resolveAttachedWorkspaceQueueWaitMs(
+        codeExecutionContext.codeEnvironmentConfigSchema,
+      ),
       executionProfile: codeExecutionContext.executionProfile,
       ...(codeExecutionContext.bridgeWorkerId
         ? { bridgeWorkerId: codeExecutionContext.bridgeWorkerId }
@@ -2520,9 +2548,15 @@ async function handleWorkspaceSearchCall(
     const result = await options.searchWorkspace({
       query: args.query,
       workspace_id: workspaceId,
+      ...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
+        ? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
+        : {}),
       ...(typeof args.path === 'string' && args.path.length > 0 ? { path: args.path } : {}),
       max_results: Number(maxResults),
       codeApiBaseUrl: codeExecutionContext.baseUrl,
+      maxQueueWaitMs: resolveAttachedWorkspaceQueueWaitMs(
+        codeExecutionContext.codeEnvironmentConfigSchema,
+      ),
       executionProfile: codeExecutionContext.executionProfile,
       ...(codeExecutionContext.bridgeWorkerId
         ? { bridgeWorkerId: codeExecutionContext.bridgeWorkerId }
@@ -2604,12 +2638,18 @@ async function handleWorkspaceListCall(
   try {
     const result = await options.listWorkspaceFiles({
       workspace_id: workspaceId,
+      ...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
+        ? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
+        : {}),
       ...(typeof args.path === 'string' && args.path.length > 0 ? { path: args.path } : {}),
       ...(typeof args.after_path === 'string' && args.after_path.length > 0
         ? { after_path: args.after_path }
         : {}),
       max_results: Number(maxResults),
       codeApiBaseUrl: codeExecutionContext.baseUrl,
+      maxQueueWaitMs: resolveAttachedWorkspaceQueueWaitMs(
+        codeExecutionContext.codeEnvironmentConfigSchema,
+      ),
       executionProfile: codeExecutionContext.executionProfile,
       ...(codeExecutionContext.bridgeWorkerId
         ? { bridgeWorkerId: codeExecutionContext.bridgeWorkerId }
@@ -3571,11 +3611,20 @@ async function writeSkillMd({
       await options.grantSkillOwner({ req, skillId: result.skill._id });
     } catch (error) {
       if (options.deleteSkill) {
-        await options.deleteSkill(result.skill._id.toString()).catch((rollbackError: unknown) => {
-          logger.error('[create_file] Failed to roll back skill after permission error', {
-            rollbackError,
+        await deleteSkillWithRetry(options.deleteSkill, result.skill._id.toString())
+          .then((deletion) => {
+            if (!deletion.cleanupComplete) {
+              logger.error('[create_file] Skill rollback left dependent cleanup incomplete', {
+                skillId: result.skill._id.toString(),
+                failedCleanupSteps: deletion.failedCleanupSteps,
+              });
+            }
+          })
+          .catch((rollbackError: unknown) => {
+            logger.error('[create_file] Failed to roll back skill after permission error', {
+              rollbackError,
+            });
           });
-        });
       }
       throw error;
     }
@@ -3759,15 +3808,23 @@ function attachedWorkspaceMutationParams(
   signal: AbortSignal | undefined,
 ): {
   workspace_id: string;
+  workspace_instance_id?: string;
   codeApiBaseUrl: string;
   executionProfile: CodeExecutionContext['executionProfile'];
   bridgeWorkerId?: string;
   req?: ServerRequest;
   signal?: AbortSignal;
+  maxQueueWaitMs: number;
 } {
   return {
     workspace_id: workspaceId,
+    ...(codeExecutionContext.codeWorkspace?.workspaceInstanceId
+      ? { workspace_instance_id: codeExecutionContext.codeWorkspace.workspaceInstanceId }
+      : {}),
     codeApiBaseUrl: codeExecutionContext.baseUrl,
+    maxQueueWaitMs: resolveAttachedWorkspaceQueueWaitMs(
+      codeExecutionContext.codeEnvironmentConfigSchema,
+    ),
     executionProfile: codeExecutionContext.executionProfile,
     ...(codeExecutionContext.bridgeWorkerId
       ? { bridgeWorkerId: codeExecutionContext.bridgeWorkerId }
@@ -3884,6 +3941,13 @@ async function handleAttachedWorkspaceEditFileCall({
       oldText: edit.old_text,
       newText: edit.new_text,
     }));
+    const workspaceParams = attachedWorkspaceMutationParams(
+      codeExecutionContext,
+      workspaceId,
+      req,
+      signal,
+    );
+    const queueDeadlineAt = Date.now() + workspaceParams.maxQueueWaitMs;
     let expectedBaseSha256: string | undefined;
     if (hasActiveFileFieldPolicy(req?.config?.filters, ['content', 'extracted_text'])) {
       if (!options.previewWorkspaceEdit) {
@@ -3900,7 +3964,7 @@ async function handleAttachedWorkspaceEditFileCall({
         preview = await options.previewWorkspaceEdit({
           file_path: path.filePath,
           edits: workspaceEdits,
-          ...attachedWorkspaceMutationParams(codeExecutionContext, workspaceId, req, signal),
+          ...workspaceParams,
         });
       } catch (error) {
         if (signal?.aborted === true && isAbortError(error)) throw error;
@@ -3913,12 +3977,24 @@ async function handleAttachedWorkspaceEditFileCall({
       const filteredContent = filteredFileResult(tc, req, path.filePath, preview.content);
       if (filteredContent != null) return filteredContent;
       expectedBaseSha256 = preview.baseSha256;
+      /** Zero disables retries, not the two operations required for a protected
+       * edit. Positive horizons must not restart after a successful preview. */
+      if (workspaceParams.maxQueueWaitMs > 0) {
+        const remainingMs = queueDeadlineAt - Date.now();
+        if (remainingMs <= 0) {
+          return errorResult(
+            tc,
+            'The workspace retry budget expired after preview. The file was not modified.',
+          );
+        }
+        workspaceParams.maxQueueWaitMs = remainingMs;
+      }
     }
     const result = await options.editWorkspaceFile({
       file_path: path.filePath,
       edits: workspaceEdits,
       ...(expectedBaseSha256 ? { expected_base_sha256: expectedBaseSha256 } : {}),
-      ...attachedWorkspaceMutationParams(codeExecutionContext, workspaceId, req, signal),
+      ...workspaceParams,
     });
     return successResult(
       tc,
@@ -5263,6 +5339,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
     subagentTasks,
     runFiles,
     ordinaryToolCancellation = false,
+    backgroundCompletionResultMaxChars = AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT,
     provisionFiles,
   } = options;
 
@@ -5720,6 +5797,9 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                       ...(params.status === 'cancelled' ? { cancelled: true } : {}),
                       settledAt: new Date(current?.updatedAt ?? Date.now()),
                       ...(completionPreregistered ? { completionWakeup: true } : {}),
+                      ...(completionAdmission?.persistResult != null
+                        ? { completionReceipt: true }
+                        : {}),
                       ...(current?.resultClaim != null
                         ? {
                             resultClaim: {
@@ -5740,10 +5820,40 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                     task.id,
                   );
                   const backgroundTask = resolveBackgroundTask();
+                  let durableReceiptReady = false;
+                  let durableReceiptAmbiguous = false;
+                  const persistDurableReceipt = async (receipt: {
+                    status: 'completed' | 'error' | 'cancelled';
+                    output?: string;
+                  }): Promise<boolean> => {
+                    if (completionAdmission?.persistResult == null) {
+                      return false;
+                    }
+                    try {
+                      return await completionAdmission.persistResult({
+                        status: receipt.status,
+                        output: truncateMiddle(
+                          receipt.output ?? '',
+                          backgroundCompletionResultMaxChars,
+                        ),
+                        settledAt: backgroundTask.settledAt,
+                      });
+                    } catch (receiptError) {
+                      durableReceiptAmbiguous = true;
+                      logger.warn(
+                        `[background] Failed to persist independent result receipt for task ${task.id}:`,
+                        receiptError,
+                      );
+                      return false;
+                    }
+                  };
                   const retireFailedPersistence = async (
                     reason: string,
                     certainty: 'definite' | 'ambiguous',
                   ): Promise<void> => {
+                    if (durableReceiptAmbiguous) {
+                      return;
+                    }
                     if (completionAdmission == null) {
                       backgroundTaskRegistry.markCompletionPersistenceFailed(
                         backgroundUserId,
@@ -5798,6 +5908,10 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                     }
                   };
                   if (!harvestEnabled || !persistBackgroundCodeResult) {
+                    durableReceiptReady = await persistDurableReceipt({
+                      status: params.status,
+                      output: params.output ?? localTask?.result,
+                    });
                     if (
                       backgroundToolCompletion == null ||
                       detachedReservation?.status === 'reserved'
@@ -5816,17 +5930,19 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                         backgroundTask,
                         resolveBackgroundTask,
                       });
-                      if (!deliveryReady) {
+                      if (!deliveryReady && !durableReceiptReady) {
                         await retireFailedPersistence(
                           'background tool result was not persisted',
                           'definite',
                         );
                       }
                     } catch (persistError) {
-                      await retireFailedPersistence(
-                        'background tool result persistence failed',
-                        isContentFilterError(persistError) ? 'definite' : 'ambiguous',
-                      );
+                      if (!durableReceiptReady) {
+                        await retireFailedPersistence(
+                          'background tool result persistence failed',
+                          isContentFilterError(persistError) ? 'definite' : 'ambiguous',
+                        );
+                      }
                       logger.warn(
                         `[background] Failed to persist result for task ${task.id}:`,
                         persistError,
@@ -5868,7 +5984,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                         task.id,
                         params.artifact,
                       );
-                      if (completionPreregistered) {
+                      if (completionPreregistered && !durableReceiptReady) {
                         await retireFailedPersistence(
                           'background code result had no durable message anchor',
                           'definite',
@@ -5876,6 +5992,12 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                       }
                       return;
                     }
+                    if (persisted.deliveryReady !== false) {
+                      durableReceiptReady = await persistDurableReceipt({
+                        status: params.status,
+                        output: params.output ?? localTask?.result,
+                      });
+                    }
                     if (persisted.deliveryReady === false) {
                       await retireFailedPersistence(
                         'background code result was not persisted',
@@ -5889,26 +6011,38 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                       persisted.attachments,
                     );
                   } catch (persistError) {
-                    if (completionPreregistered) {
-                      await retireFailedPersistence(
-                        'background code result persistence failed',
-                        isContentFilterError(persistError) ? 'definite' : 'ambiguous',
-                      );
-                    }
                     if (isContentFilterError(persistError)) {
+                      const blockedMessage =
+                        persistError instanceof ContentFilterError
+                          ? modelBoundContentFilterErrorMessage(persistError.body)
+                          : persistError.body.message;
                       backgroundTaskRegistry.blockArtifact(
                         backgroundUserId,
                         backgroundConversationId,
                         task.id,
-                        persistError instanceof ContentFilterError
-                          ? modelBoundContentFilterErrorMessage(persistError.body)
-                          : persistError.body.message,
+                        blockedMessage,
                       );
+                      durableReceiptReady = await persistDurableReceipt({
+                        status: 'error',
+                        output: blockedMessage,
+                      });
+                      if (completionPreregistered && !durableReceiptReady) {
+                        await retireFailedPersistence(
+                          'background code result was blocked by content policy',
+                          'definite',
+                        );
+                      }
                       logger.warn(
                         `[background] Generated code output for task ${task.id} was blocked by content policy.`,
                       );
                       return;
                     }
+                    if (completionPreregistered && !durableReceiptReady) {
+                      await retireFailedPersistence(
+                        'background code result persistence failed',
+                        'ambiguous',
+                      );
+                    }
                     logger.warn(
                       `[background] Failed to persist code result for task ${task.id}:`,
                       persistError,
@@ -5957,6 +6091,7 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                       signal: backgroundAbortController.signal,
                       configurable: {
                         ...mergedConfigurable,
+                        [BACKGROUND_TOOL_INVOCATION_CONFIG_KEY]: true,
                         ...(detachedReservation?.status === 'reserved'
                           ? {
                               eventActorDetachedAction: {
@@ -6028,6 +6163,10 @@ export function createToolExecuteHandler(options: ToolExecuteOptions): EventHand
                           .renew()
                           .then((renewed) => {
                             if (!renewed) {
+                              producerHeartbeatStopped = true;
+                              if (producerHeartbeat != null) {
+                                clearInterval(producerHeartbeat);
+                              }
                               logger.warn(
                                 `[background] Completion producer lease was not renewed for task ${task.id}.`,
                               );
diff --git a/packages/api/src/agents/harvest.ts b/packages/api/src/agents/harvest.ts
index 55eb828bb2e..84738597ad5 100644
--- a/packages/api/src/agents/harvest.ts
+++ b/packages/api/src/agents/harvest.ts
@@ -40,6 +40,8 @@ export interface BackgroundToolResultState {
   settledAt: Date;
   /** This exact task owns a pre-registered automatic continuation delivery. */
   completionWakeup?: true;
+  /** Independent receipts retain task-local delivery ownership. */
+  completionReceipt?: true;
   resultClaim?: {
     kind: 'manual' | 'wakeup';
     claimId: string;
diff --git a/packages/api/src/agents/index.ts b/packages/api/src/agents/index.ts
index 56090134f13..cfca8b0cfc4 100644
--- a/packages/api/src/agents/index.ts
+++ b/packages/api/src/agents/index.ts
@@ -25,6 +25,7 @@ export * from './handlers';
 export * from './guard';
 export * from './harvest';
 export * from './backgroundCompletion';
+export * from './backgroundClaims';
 export * from './backgroundCompletionWakeup';
 export * from './initialize';
 export * from './legacy';
diff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.ts
index 94f1a15bd3e..79ae24e74a2 100644
--- a/packages/api/src/agents/initialize.ts
+++ b/packages/api/src/agents/initialize.ts
@@ -1993,6 +1993,7 @@ export async function initializeAgent(
     trustedCodeExecutionContext.environmentType === 'attached'
       ? resolveAttachedWorkspaceCommandTimeoutMax(
           trustedCodeExecutionContext.codeEnvironmentConfigSchema,
+          trustedCodeExecutionContext.codeWorkspace?.maxCommandTimeoutMs,
         )
       : undefined;
   if (
diff --git a/packages/api/src/agents/invocation.ts b/packages/api/src/agents/invocation.ts
new file mode 100644
index 00000000000..e5c355d2f92
--- /dev/null
+++ b/packages/api/src/agents/invocation.ts
@@ -0,0 +1,2 @@
+/** Host-only marker added when an ordinary tool is executing as a detached background task. */
+export const BACKGROUND_TOOL_INVOCATION_CONFIG_KEY = '__librechatBackgroundToolInvocation';
diff --git a/packages/api/src/agents/tools.spec.ts b/packages/api/src/agents/tools.spec.ts
index d21683a668d..96bfa32cdb9 100644
--- a/packages/api/src/agents/tools.spec.ts
+++ b/packages/api/src/agents/tools.spec.ts
@@ -494,13 +494,17 @@ describe('registerCodeExecutionTools', () => {
       });
 
       const readFile = result.toolDefinitions.find((d) => d.name === 'read_file');
-      expect(readFile?.description).toContain('code-execution sandbox');
+      expect(readFile?.description).toContain('code-sandbox');
       expect(readFile?.description).toContain('/mnt/data/');
       expect(readFile?.description).toContain('Do not run ls/find');
-      expect(readFile?.description).toContain('/tmp is per-call scratch');
-      expect(readFile?.description).toContain('truncate around 256KB');
-      expect(readFile?.description).toContain('images (png, jpeg, gif, webp)');
-      expect(readFile?.description).toContain('true filesystem discovery');
+      expect(readFile?.description).toContain('only retained files under /mnt/data');
+      expect(readFile?.description).toContain('$HOME');
+      expect(readFile?.description).toContain('/tmp');
+      expect(readFile?.description).toContain('global installs');
+      expect(readFile?.description).toContain('background processes are call-local');
+      expect(readFile?.description).toContain('truncates around 256KB');
+      expect(readFile?.description).toContain('png, jpeg, gif, and webp images');
+      expect(readFile?.description).toContain('filesystem discovery');
       expect(readFile?.description).not.toContain('{skillName}');
       expect(readFile?.description).not.toContain('SKILL.md');
       expect(JSON.stringify(readFile?.parameters)).not.toContain('{skillName}');
@@ -526,6 +530,10 @@ describe('registerCodeExecutionTools', () => {
       );
       expect(readFile?.description).toContain('workspace/');
       expect(readFile?.description).toContain('attached');
+      expect(readFile?.description).toContain(
+        'Only the registered workspace persists for attached commands',
+      );
+      expect(readFile?.description).toContain('operator-managed');
       expect(readFile?.parameters).toMatchObject({
         properties: {
           start_line: { type: 'integer' },
@@ -701,11 +709,21 @@ describe('registerCodeExecutionTools', () => {
         includeSkillFileInstructions: false,
         enableToolOutputReferences: false,
       });
+      const attachedWithoutRefs = registerCodeExecutionTools({
+        toolRegistry: makeRegistry(),
+        toolDefinitions: [],
+        includeBash: true,
+        includeSkillFileInstructions: false,
+        enableToolOutputReferences: false,
+        workspaceTools: true,
+        workspaceOperations: new Set(CODE_WORKSPACE_OPERATIONS),
+      });
 
       expect(
         maxToolDescriptionLength([
           ...skillAwareWithRefs.toolDefinitions,
           ...codeOnlyWithoutRefs.toolDefinitions,
+          ...attachedWithoutRefs.toolDefinitions,
         ]),
       ).toBeLessThanOrEqual(TOOL_DESCRIPTION_ADVISORY_MAX_LENGTH);
     });
diff --git a/packages/api/src/agents/tools.ts b/packages/api/src/agents/tools.ts
index 08f4091d29e..3b4827eae7e 100644
--- a/packages/api/src/agents/tools.ts
+++ b/packages/api/src/agents/tools.ts
@@ -478,11 +478,13 @@ const READ_FILE_DEF: LCTool = Object.freeze({
   responseFormat: ReadFileToolDefinition.responseFormat,
 }) as LCTool;
 
-const CODE_READ_FILE_DESCRIPTION = `Read a known file from the code-execution sandbox. Text files return line-numbered content (large files truncate around 256KB); images (png, jpeg, gif, webp) return as visual content you can see.
+const CODE_READ_FILE_DESCRIPTION = `Read a known code-sandbox file. Text is line-numbered and truncates around 256KB; png, jpeg, gif, and webp images return as visual content.
 
-Use for text, CSV, JSON, Markdown, logs, small source files, and images at paths returned by tool output, just written, or under /mnt/data/. Do not run ls/find just to rediscover known paths. Use bash_tool for other binary files, large files, transforms, metadata, or true filesystem discovery. /tmp is per-call scratch and unavailable later.`;
+Use paths returned by tool output, just written, or under /mnt/data/. Do not run ls/find to rediscover known paths. Use bash_tool for binary or large files, transforms, metadata, and filesystem discovery.
 
-const ATTACHED_WORKSPACE_READ_FILE_INSTRUCTIONS = `For an attached environment, use "workspace/{relativePath}" to read a file from the workspace directory registered on the worker. Use a canonical relative path without empty, ".", or ".." segments. It may be an existing project, a Git repository, or an empty directory; Git is not required. The worker's host path stays private. Use start_line and max_lines for bounded pagination.`;
+For managed execution, only retained files under /mnt/data reach later calls. $HOME, /tmp, $TMPDIR, shell/environment state, cwd, global installs, and background processes are call-local.`;
+
+const ATTACHED_WORKSPACE_READ_FILE_INSTRUCTIONS = `For an attached environment, read registered files as "workspace/{relativePath}". Use a canonical relative path without empty, ".", or ".." segments; the worker's host path stays private. Only the registered workspace persists for attached commands. Project dependencies stored there persist, while $HOME and global/system packages are operator-managed. Use start_line and max_lines for bounded pagination.`;
 
 const CODE_READ_FILE_PARAMETERS: LCTool['parameters'] = Object.freeze({
   type: 'object',
diff --git a/packages/api/src/agents/triggers/engine.spec.ts b/packages/api/src/agents/triggers/engine.spec.ts
index 91f24aa8f5c..e00a600654b 100644
--- a/packages/api/src/agents/triggers/engine.spec.ts
+++ b/packages/api/src/agents/triggers/engine.spec.ts
@@ -589,6 +589,32 @@ describe('createAgentTriggerDeliveryEngine', () => {
     expect(store.dead).toHaveBeenCalledWith(expect.objectContaining({ claimToken: 'claim-1' }));
   });
 
+  it.each([false, true])(
+    'offers configured receipt recovery when already exhausted is %s',
+    async (exhausted) => {
+      const store = storeWith({
+        claimNext: jest.fn(async () => delivery({ attempts: exhausted ? 1 : 0 })),
+      });
+      const engine = createAgentTriggerDeliveryEngine(
+        {
+          store,
+          now: () => START,
+          dispatch: async () => {
+            throw new Error('database unavailable');
+          },
+        },
+        { concurrency: 1, maxAttempts: 1, retryCapMs: 123_000 },
+      );
+      await engine.runTick();
+      expect(store.dead).toHaveBeenCalledWith(
+        expect.objectContaining({
+          receiptRetryAt: new Date(START.getTime() + 123_000),
+          error: expect.objectContaining({ retryable: true }),
+        }),
+      );
+    },
+  );
+
   it('bounds a persisted last failure before exhausting its source', async () => {
     const oversized = 'x'.repeat(3_000);
     const store = storeWith({
diff --git a/packages/api/src/agents/triggers/engine.ts b/packages/api/src/agents/triggers/engine.ts
index 164854a0e7c..8fd6592a3b8 100644
--- a/packages/api/src/agents/triggers/engine.ts
+++ b/packages/api/src/agents/triggers/engine.ts
@@ -183,6 +183,7 @@ export interface AgentTriggerDeliveryStore {
     attempt: number;
     error: AgentTriggerDeliveryFailure;
     settledAt: Date;
+    receiptRetryAt?: Date;
   }) => Promise<boolean>;
 }
 
@@ -409,6 +410,9 @@ export function createAgentTriggerDeliveryEngine(
         attempt: delivery.attempts,
         error: recorded,
         settledAt: now(),
+        ...(recorded.retryable && {
+          receiptRetryAt: new Date(now().getTime() + retryCapMs),
+        }),
       });
       if (deadLettered) {
         logger.error('[agent-triggers] delivery dead-lettered after exhausting retries', {
@@ -532,6 +536,9 @@ export function createAgentTriggerDeliveryEngine(
             attempt,
             error: recorded,
             settledAt: attemptedAt,
+            ...(recorded.retryable && {
+              receiptRetryAt: new Date(attemptedAt.getTime() + retryCapMs),
+            }),
           });
           if (deadLettered) {
             logger.error('[agent-triggers] delivery dead-lettered', {
diff --git a/packages/api/src/agents/triggers/service.delivery.spec.ts b/packages/api/src/agents/triggers/service.delivery.spec.ts
index bd3977598b4..f3b6b4c1034 100644
--- a/packages/api/src/agents/triggers/service.delivery.spec.ts
+++ b/packages/api/src/agents/triggers/service.delivery.spec.ts
@@ -1,4 +1,5 @@
 import {
+  AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
   AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
@@ -180,6 +181,7 @@ describe('durable agent trigger service', () => {
     expect(methods.claimNextAgentTriggerDelivery).toHaveBeenCalledWith(
       expect.objectContaining({
         workerCapabilities: [
+          AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
           AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
           AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
           AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
@@ -218,6 +220,7 @@ describe('durable agent trigger service', () => {
     expect(methods.claimNextAgentTriggerDelivery).toHaveBeenCalledWith(
       expect.objectContaining({
         workerCapabilities: [
+          AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
           AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
           AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
         ],
diff --git a/packages/api/src/agents/triggers/service.ts b/packages/api/src/agents/triggers/service.ts
index 029312caee2..18f7b32c690 100644
--- a/packages/api/src/agents/triggers/service.ts
+++ b/packages/api/src/agents/triggers/service.ts
@@ -1,4 +1,5 @@
 import {
+  AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
   AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
@@ -39,6 +40,7 @@ const DEFAULT_PURGE_RECOVERY_INTERVAL_MS = 30_000;
 const DEFAULT_PURGE_RECOVERY_LIMIT = 25;
 
 export interface AgentTriggerServiceOptions {
+  completionResultBatchSize?: number;
   address?: BoundAddress | string | null;
 }
 
@@ -112,6 +114,9 @@ export interface AgentTriggerDeliveryPersistence {
   completeAgentTriggerDelivery: AgentTriggerDeliveryStore['complete'];
   retireAgentTriggerDelivery: AgentTriggerDeliveryMethods['retireAgentTriggerDelivery'];
   renewAgentTriggerDeliveryProducerLease: AgentTriggerDeliveryMethods['renewAgentTriggerDeliveryProducerLease'];
+  persistAgentBackgroundToolResult?: AgentTriggerDeliveryMethods['persistAgentBackgroundToolResult'];
+  getAgentBackgroundToolResultClaim?: AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim'];
+  releaseAgentBackgroundToolResultClaims?: AgentTriggerDeliveryMethods['releaseAgentBackgroundToolResultClaims'];
   retryAgentTriggerDelivery: AgentTriggerDeliveryStore['retry'];
   deadLetterAgentTriggerDelivery: AgentTriggerDeliveryStore['dead'];
   getAgentTriggerDelivery: (deliveryKey: string) => Promise<AgentTriggerStoredRecord | null>;
@@ -168,6 +173,20 @@ export interface AgentTriggerService {
     options?: { onlyIfUnclaimed?: boolean; onlyIfDead?: boolean },
   ) => Promise<boolean>;
   renewProducerLease: (deliveryKey: string, sourceId: string, leaseUntil: Date) => Promise<boolean>;
+  persistBackgroundToolResult: (input: {
+    deliveryKey: string;
+    sourceId: string;
+    result: {
+      status: 'completed' | 'error' | 'cancelled';
+      output: string;
+      settledAt: Date;
+    };
+  }) => Promise<boolean>;
+  getBackgroundToolResultClaim: (
+    input: Parameters<AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim']>[0],
+  ) => ReturnType<AgentTriggerDeliveryMethods['getAgentBackgroundToolResultClaim']>;
+  getBackgroundCompletionResultBatchSize: () => number;
+  releaseBackgroundToolResultClaims: AgentTriggerDeliveryMethods['releaseAgentBackgroundToolResultClaims'];
   drainUser: (userId: string) => Promise<void>;
   prepareUserPurge: (userId: string, fenceStartedAt: Date, tenantId?: string) => Promise<void>;
   cancelUserPurge: (userId: string, fenceStartedAt: Date) => Promise<boolean>;
@@ -183,6 +202,7 @@ function createDeliveryStore(
       methods.claimNextAgentTriggerDelivery({
         ...input,
         workerCapabilities: [
+          AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
           AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
           AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
           ...(supportsDetachedActionCompletion()
@@ -254,6 +274,7 @@ export function createAgentTriggerService(deps: AgentTriggerServiceDeps = {}): A
     throw new TypeError('purgeRecoveryLimit must be a positive integer');
   }
   let boundOrigin: string | undefined;
+  let backgroundCompletionResultBatchSize = 8;
   let deliveryEngine: AgentTriggerDeliveryEngine | undefined;
   let initializePromise: Promise<void> | undefined;
   let purgeRecoveryPromise: Promise<void> | undefined;
@@ -467,6 +488,7 @@ export function createAgentTriggerService(deps: AgentTriggerServiceDeps = {}): A
 
   return {
     initialize: (options = {}) => {
+      backgroundCompletionResultBatchSize = options.completionResultBatchSize ?? 8;
       boundOrigin = selfOriginFromAddress(options.address) ?? boundOrigin;
       if (deps.methods == null || deliveryReady) {
         return Promise.resolve();
@@ -600,6 +622,22 @@ export function createAgentTriggerService(deps: AgentTriggerServiceDeps = {}): A
           leaseUntil,
         }),
       ),
+    persistBackgroundToolResult: (input) =>
+      runAsSystem(async () => {
+        const persist = requireMethods().persistAgentBackgroundToolResult;
+        return persist == null ? false : persist(input);
+      }),
+    getBackgroundToolResultClaim: (input) =>
+      runAsSystem(async () => {
+        const getClaim = requireMethods().getAgentBackgroundToolResultClaim;
+        return getClaim == null ? null : getClaim(input);
+      }),
+    getBackgroundCompletionResultBatchSize: () => backgroundCompletionResultBatchSize,
+    releaseBackgroundToolResultClaims: (input) =>
+      runAsSystem(async () => {
+        const release = requireMethods().releaseAgentBackgroundToolResultClaims;
+        return release == null ? false : release(input);
+      }),
     drainUser,
     prepareUserPurge: (userId, fenceStartedAt, tenantId) =>
       runAsSystem(async () =>
diff --git a/packages/api/src/code/bridge.spec.ts b/packages/api/src/code/bridge.spec.ts
index db1af81812d..778129d1e4c 100644
--- a/packages/api/src/code/bridge.spec.ts
+++ b/packages/api/src/code/bridge.spec.ts
@@ -84,6 +84,7 @@ describe('getCodeBridgeWorkerStatus', () => {
           online: true,
           ready: true,
           leaseExpiresInMs: 45_000,
+          maxCommandTimeoutMs: 120_000,
           capabilities: {
             statefulWorkspace: true,
             sandboxProfile: 'native-srt',
@@ -92,7 +93,11 @@ describe('getCodeBridgeWorkerStatus', () => {
               protocolVersion: 1,
               operations: ['read_file', 'execute_command'],
               workspaces: [
-                { id: 'project-a', name: 'Project A' },
+                {
+                  id: 'project-a',
+                  name: 'Project A',
+                  workspaceInstances: ['git_worktree'],
+                },
                 { id: 'docs', operations: ['read_file'] },
               ],
             },
@@ -114,11 +119,16 @@ describe('getCodeBridgeWorkerStatus', () => {
       status: 'ready',
       statefulWorkspace: true,
       leaseExpiresInMs: 45_000,
+      maxCommandTimeoutMs: 120_000,
       sandboxProfile: 'native-srt',
       runtimes: ['bash'],
       operations: ['read_file', 'execute_command'],
       workspaces: [
-        { id: 'project-a', name: 'Project A' },
+        {
+          id: 'project-a',
+          name: 'Project A',
+          workspaceInstances: ['git_worktree'],
+        },
         { id: 'docs', operations: ['read_file'] },
       ],
     });
@@ -172,6 +182,8 @@ describe('getCodeBridgeWorkerStatus', () => {
     { online: true, ready: false },
     { online: false, ready: false, leaseExpiresInMs: 5_000 },
     { online: true, ready: true, leaseExpiresInMs: 60_001 },
+    { online: true, ready: true, maxCommandTimeoutMs: 0 },
+    { online: true, ready: true, maxCommandTimeoutMs: 300_001 },
     {
       online: true,
       ready: true,
@@ -192,6 +204,21 @@ describe('getCodeBridgeWorkerStatus', () => {
         },
       },
     },
+    {
+      online: true,
+      ready: true,
+      leaseExpiresInMs: 5_000,
+      capabilities: {
+        statefulWorkspace: true,
+        sandboxProfile: 'native-srt',
+        runtimes: ['bash'],
+        workspaceTools: {
+          protocolVersion: 1,
+          operations: ['read_file'],
+          workspaces: [{ id: 'project-a', workspaceInstances: ['container'] }],
+        },
+      },
+    },
     {
       online: true,
       ready: true,
diff --git a/packages/api/src/code/bridge.ts b/packages/api/src/code/bridge.ts
index b44701804ad..99b732335e6 100644
--- a/packages/api/src/code/bridge.ts
+++ b/packages/api/src/code/bridge.ts
@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import {
+  CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS,
   CODE_WORKSPACE_ID_PATTERN,
   CODE_WORKSPACE_MAX_COUNT,
   CODE_WORKSPACE_OPERATIONS,
@@ -38,6 +39,7 @@ export type CodeBridgeWorkerStatus = {
   operations?: CodeWorkspaceOperation[];
   workspaces?: CodeWorkspaceDescriptor[];
   programmaticLanguages?: ['bash'];
+  maxCommandTimeoutMs?: number;
 };
 
 export type CodeBridgeFetch = (
@@ -192,6 +194,7 @@ function validWorkspaceCapabilities(value: unknown): value is {
           key !== 'id' &&
           key !== 'name' &&
           key !== 'operations' &&
+          key !== 'workspaceInstances' &&
           key !== 'environment' &&
           key !== 'instructions',
       ) ||
@@ -203,6 +206,10 @@ function validWorkspaceCapabilities(value: unknown): value is {
           workspace.instructions.length > 1 ||
           !workspace.instructions.every(isRepositoryInstructionDescriptor))) ||
       (workspace.environment !== undefined && !isCodeWorkspaceEnvironment(workspace.environment)) ||
+      (workspace.workspaceInstances !== undefined &&
+        (!Array.isArray(workspace.workspaceInstances) ||
+          workspace.workspaceInstances.length !== 1 ||
+          workspace.workspaceInstances[0] !== 'git_worktree')) ||
       (workspace.name !== undefined &&
         (typeof workspace.name !== 'string' ||
           workspace.name.trim().length === 0 ||
@@ -292,6 +299,7 @@ export async function getCodeBridgeWorkerStatus({
       online?: unknown;
       ready?: unknown;
       leaseExpiresInMs?: unknown;
+      maxCommandTimeoutMs?: unknown;
       capabilities?: {
         statefulWorkspace?: unknown;
         sandboxProfile?: unknown;
@@ -306,6 +314,12 @@ export async function getCodeBridgeWorkerStatus({
         Number.isSafeInteger(status.leaseExpiresInMs) &&
         status.leaseExpiresInMs > 0 &&
         status.leaseExpiresInMs <= 60_000);
+    const validCommandTimeout =
+      status.maxCommandTimeoutMs == null ||
+      (typeof status.maxCommandTimeoutMs === 'number' &&
+        Number.isSafeInteger(status.maxCommandTimeoutMs) &&
+        status.maxCommandTimeoutMs >= 1 &&
+        status.maxCommandTimeoutMs <= CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS);
     const validCapabilities =
       capabilities == null || validStatusString(capabilities.sandboxProfile);
     const validRuntimes = capabilities == null || validStatusStringArray(capabilities.runtimes);
@@ -322,6 +336,7 @@ export async function getCodeBridgeWorkerStatus({
       (status.online && (status.leaseExpiresInMs == null || capabilities == null)) ||
       (!status.online && (status.leaseExpiresInMs != null || capabilities != null)) ||
       !validLease ||
+      !validCommandTimeout ||
       !validCapabilities ||
       !validRuntimes ||
       !validWorkspaceTools ||
@@ -366,6 +381,9 @@ export async function getCodeBridgeWorkerStatus({
       ...(typeof status.leaseExpiresInMs !== 'number'
         ? {}
         : { leaseExpiresInMs: status.leaseExpiresInMs }),
+      ...(typeof status.maxCommandTimeoutMs !== 'number'
+        ? {}
+        : { maxCommandTimeoutMs: status.maxCommandTimeoutMs }),
       ...(typeof capabilities?.sandboxProfile !== 'string'
         ? {}
         : { sandboxProfile: capabilities.sandboxProfile }),
diff --git a/packages/api/src/code/capabilities.spec.ts b/packages/api/src/code/capabilities.spec.ts
index a473389ca23..746d68b8d1f 100644
--- a/packages/api/src/code/capabilities.spec.ts
+++ b/packages/api/src/code/capabilities.spec.ts
@@ -351,7 +351,11 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
     delete process.env.TEST_CODE_CAPABILITY_TOKEN;
   });
 
-  function workspaceStatus(workspaces: unknown[], statefulWorkspace: boolean = true): Response {
+  function workspaceStatus(
+    workspaces: unknown[],
+    statefulWorkspace: boolean = true,
+    maxCommandTimeoutMs?: number,
+  ): Response {
     return new Response(
       JSON.stringify({
         protocolVersion: 1,
@@ -359,6 +363,7 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
         online: true,
         ready: true,
         leaseExpiresInMs: 45_000,
+        maxCommandTimeoutMs,
         capabilities: {
           statefulWorkspace,
           sandboxProfile: 'native-srt',
@@ -375,10 +380,14 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
 
   it('binds the exact advertised workspace and its operation ceiling', async () => {
     jest.spyOn(globalThis, 'fetch').mockResolvedValue(
-      workspaceStatus([
-        { id: 'project-a', name: 'Project A' },
-        { id: 'docs', operations: ['read_file', 'list_files'] },
-      ]),
+      workspaceStatus(
+        [
+          { id: 'project-a', name: 'Project A' },
+          { id: 'docs', operations: ['read_file', 'list_files'] },
+        ],
+        true,
+        120_000,
+      ),
     );
 
     await expect(
@@ -397,6 +406,7 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
         environmentId: 'personal',
         workspaceId: 'docs',
         operations: ['read_file', 'list_files'],
+        maxCommandTimeoutMs: 120_000,
       },
     });
   });
@@ -423,6 +433,34 @@ describe('resolveCodeExecutionWorkspaceContext', () => {
     expect(resolved.codeWorkspace?.environment).toEqual(environment);
   });
 
+  it('activates a server-derived instance only when the worker advertises worktree support', async () => {
+    const workspaceInstanceId = 'c'.repeat(64);
+    jest
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValue(
+        workspaceStatus([
+          { id: 'worktree', workspaceInstances: ['git_worktree'] },
+          { id: 'legacy' },
+        ]),
+      );
+
+    const supported = await resolveCodeExecutionWorkspaceContext({
+      context: { ...context, conversationWorkspaceInstanceId: workspaceInstanceId },
+      requestedSelections: [{ environmentId: 'personal', workspaceId: 'worktree' }],
+      environments,
+      getAppConfig,
+    });
+    const legacy = await resolveCodeExecutionWorkspaceContext({
+      context: { ...context, conversationWorkspaceInstanceId: workspaceInstanceId },
+      requestedSelections: [{ environmentId: 'personal', workspaceId: 'legacy' }],
+      environments,
+      getAppConfig,
+    });
+
+    expect(supported.codeWorkspace?.workspaceInstanceId).toBe(workspaceInstanceId);
+    expect(legacy.codeWorkspace).not.toHaveProperty('workspaceInstanceId');
+  });
+
   it('admits native workspace tools without enabling programmatic runtime execution', async () => {
     jest
       .spyOn(globalThis, 'fetch')
diff --git a/packages/api/src/code/capabilities.ts b/packages/api/src/code/capabilities.ts
index 4f76a2797e4..85b8f7ed72a 100644
--- a/packages/api/src/code/capabilities.ts
+++ b/packages/api/src/code/capabilities.ts
@@ -178,6 +178,13 @@ export async function resolveCodeExecutionWorkspaceContext({
     codeWorkspace: {
       ...selection,
       operations: [...(workspace.operations ?? status.operations)],
+      ...(context.conversationWorkspaceInstanceId &&
+      workspace.workspaceInstances?.includes('git_worktree')
+        ? { workspaceInstanceId: context.conversationWorkspaceInstanceId }
+        : {}),
+      ...(status.maxCommandTimeoutMs == null
+        ? {}
+        : { maxCommandTimeoutMs: status.maxCommandTimeoutMs }),
       ...(workspace.instructions ? { instructions: workspace.instructions } : {}),
       ...(workspace.environment ? { environment: workspace.environment } : {}),
     },
diff --git a/packages/api/src/code/command.spec.ts b/packages/api/src/code/command.spec.ts
index f936ddbf599..0cd2dd12f8f 100644
--- a/packages/api/src/code/command.spec.ts
+++ b/packages/api/src/code/command.spec.ts
@@ -3,12 +3,41 @@ import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import type { CodeBridgeFetch } from './bridge';
 import {
+  ATTACHED_WORKSPACE_BASH_DESCRIPTION,
   ATTACHED_WORKSPACE_BASH_SCHEMA,
   buildAttachedWorkspaceBashSchema,
   createAttachedWorkspaceBashTool,
   createGitIdentityProgrammaticBashTool,
   resolveAttachedWorkspaceCommandTimeoutMax,
+  resolveAttachedWorkspaceProgrammaticTimeout,
+  resolveAttachedWorkspaceQueueWaitMs,
 } from './command';
+import { BACKGROUND_TOOL_INVOCATION_CONFIG_KEY } from '~/agents/invocation';
+
+describe('attached workspace Bash contract', () => {
+  test('distinguishes durable workspace files from per-call and operator-managed state', () => {
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain(
+      'Only registered-workspace files persist',
+    );
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain('Install project dependencies there');
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain('$HOME');
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain('/tmp, $TMPDIR');
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain('global/system packages');
+    expect(ATTACHED_WORKSPACE_BASH_DESCRIPTION).toContain('background processes do not survive');
+  });
+
+  test('keeps the command parameter persistence warning next to generated commands', () => {
+    expect(ATTACHED_WORKSPACE_BASH_SCHEMA).toMatchObject({
+      properties: {
+        command: {
+          description: expect.stringContaining(
+            'Only files written inside the workspace persist between calls',
+          ),
+        },
+      },
+    });
+  });
+});
 
 describe('programmatic Bash Git identity', () => {
   test('applies authorship before the SDK sends a programmatic script', async () => {
@@ -47,15 +76,20 @@ describe('programmatic Bash Git identity', () => {
     }
   });
 
-  test('pins a selected project on the real SDK no-tools route', async () => {
-    const received: { url?: string; workspace?: string | string[]; code: string }[] = [];
+  test('pins the selected project and conversation instance on the real SDK no-tools route', async () => {
+    const received: {
+      url?: string;
+      workspace?: string | string[];
+      code: string;
+      workspace_instance_id?: string;
+    }[] = [];
     const server = createServer(async (req, res) => {
       let body = '';
       for await (const chunk of req) body += chunk;
       received.push({
         url: req.url,
         workspace: req.headers['x-librechat-code-workspace-id'],
-        code: JSON.parse(body).code,
+        ...JSON.parse(body),
       });
       res.setHeader('Content-Type', 'application/json');
       res.end(JSON.stringify({ status: 'completed', stdout: 'done', stderr: '', files: [] }));
@@ -63,11 +97,13 @@ describe('programmatic Bash Git identity', () => {
     server.listen(0, '127.0.0.1');
     await once(server, 'listening');
     const { port } = server.address() as AddressInfo;
+    const workspaceInstanceId = 'a'.repeat(64);
     try {
       const bashTool = createGitIdentityProgrammaticBashTool(
         {
           baseUrl: `http://127.0.0.1:${port}/v1`,
           workspaceId: 'project-a',
+          workspaceInstanceId,
           authHeaders: () => ({}),
         },
         { name: 'Lia', email: 'lia@example.com' },
@@ -79,7 +115,11 @@ describe('programmatic Bash Git identity', () => {
         invocationConfig,
       );
       expect(received).toHaveLength(1);
-      expect(received[0]).toMatchObject({ url: '/v1/exec/programmatic', workspace: 'project-a' });
+      expect(received[0]).toMatchObject({
+        url: '/v1/exec/programmatic',
+        workspace: 'project-a',
+        workspace_instance_id: workspaceInstanceId,
+      });
       expect(received[0].code).toContain("GIT_AUTHOR_NAME='Lia'");
       expect(bashTool.description).toContain('selected persistent workspace');
     } finally {
@@ -87,6 +127,22 @@ describe('programmatic Bash Git identity', () => {
       await once(server, 'close');
     }
   });
+
+  test('preserves the foreground timeout while bounding an explicit admin override', () => {
+    expect(resolveAttachedWorkspaceProgrammaticTimeout(undefined, 90_000)).toBe(30_000);
+    expect(
+      resolveAttachedWorkspaceProgrammaticTimeout(
+        { limits: { maxCommandTimeoutMs: 120_000 } },
+        90_000,
+      ),
+    ).toBe(90_000);
+    expect(
+      resolveAttachedWorkspaceProgrammaticTimeout(
+        { limits: { maxCommandTimeoutMs: 60_000 } },
+        90_000,
+      ),
+    ).toBe(60_000);
+  });
 });
 
 function commandResponse(overrides: Record<string, unknown> = {}): Response {
@@ -107,6 +163,26 @@ function commandResponse(overrides: Record<string, unknown> = {}): Response {
 }
 
 describe('createAttachedWorkspaceBashTool', () => {
+  test('dispatches commands to the resolved conversation workspace instance', async () => {
+    const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
+    const workspaceInstanceId = 'e'.repeat(64);
+    const bashTool = createAttachedWorkspaceBashTool({
+      baseUrl: 'https://code.example.com/v1/',
+      authHeaders: () => ({}),
+      workspaceId: 'project-a',
+      workspaceInstanceId,
+      fetchImpl,
+    });
+
+    await bashTool.invoke({ command: 'pwd' });
+
+    const [, options] = (fetchImpl as jest.Mock).mock.calls[0];
+    expect(JSON.parse(options.body)).toMatchObject({
+      workspaceId: 'project-a',
+      workspaceInstanceId,
+    });
+  });
+
   test('dispatches only advertised named actions with the resolved definition fingerprint', async () => {
     const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
     const bashTool = createAttachedWorkspaceBashTool({
@@ -263,6 +339,52 @@ describe('createAttachedWorkspaceBashTool', () => {
       properties: { timeoutMs: { type: 'integer', minimum: 1, maximum: 120_000 } },
     });
     expect(resolveAttachedWorkspaceCommandTimeoutMax()).toBe(30_000);
+    expect(resolveAttachedWorkspaceCommandTimeoutMax(undefined, 90_000)).toBe(90_000);
+    expect(
+      resolveAttachedWorkspaceCommandTimeoutMax(
+        { limits: { maxCommandTimeoutMs: 120_000 } },
+        90_000,
+      ),
+    ).toBe(90_000);
+    expect(
+      resolveAttachedWorkspaceCommandTimeoutMax(
+        { limits: { maxCommandTimeoutMs: 60_000 } },
+        90_000,
+      ),
+    ).toBe(60_000);
+  });
+
+  test('uses the negotiated ceiling only for omitted detached background timeouts', async () => {
+    const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());
+    const bashTool = createAttachedWorkspaceBashTool({
+      baseUrl: 'https://code.example.com/v1',
+      authHeaders: () => ({}),
+      workspaceId: 'project-a',
+      maxTimeoutMs: 90_000,
+      fetchImpl,
+    });
+
+    await bashTool.invoke(
+      { command: 'npm test' },
+      { configurable: { [BACKGROUND_TOOL_INVOCATION_CONFIG_KEY]: true } },
+    );
+    await bashTool.invoke({ command: 'npm test' });
+
+    const backgroundRequest = JSON.parse(String((fetchImpl as jest.Mock).mock.calls[0][1]?.body));
+    const foregroundRequest = JSON.parse(String((fetchImpl as jest.Mock).mock.calls[1][1]?.body));
+    expect(backgroundRequest).toMatchObject({ timeoutMs: 90_000 });
+    expect(foregroundRequest).toMatchObject({ timeoutMs: 30_000 });
+  });
+
+  test('resolves the administrator-configured admission budget', () => {
+    expect(resolveAttachedWorkspaceQueueWaitMs()).toBe(5 * 60_000);
+    expect(resolveAttachedWorkspaceQueueWaitMs({ limits: { maxQueueWaitMs: 30_000 } })).toBe(
+      30_000,
+    );
+    expect(resolveAttachedWorkspaceQueueWaitMs({ limits: { maxQueueWaitMs: 0 } })).toBe(0);
+    expect(resolveAttachedWorkspaceQueueWaitMs({ limits: { maxQueueWaitMs: 10 * 60_000 } })).toBe(
+      5 * 60_000,
+    );
   });
 
   test('lowers the omitted timeout when the deployment ceiling is below 30 seconds', async () => {
diff --git a/packages/api/src/code/command.ts b/packages/api/src/code/command.ts
index e32da5a2951..e3ea3b3fd2d 100644
--- a/packages/api/src/code/command.ts
+++ b/packages/api/src/code/command.ts
@@ -19,18 +19,20 @@ import {
   executeWorkspaceTool,
   WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,
   WORKSPACE_COMMAND_MAX_TIMEOUT_MS,
+  WORKSPACE_QUEUE_MAX_WAIT_MS,
 } from './workspace';
+import { BACKGROUND_TOOL_INVOCATION_CONFIG_KEY } from '~/agents/invocation';
 
 const DEFAULT_OUTPUT_BYTES = 256 * 1024;
 
-export const ATTACHED_WORKSPACE_BASH_DESCRIPTION = `Runs bash commands inside the selected attached environment and returns stdout/stderr. The workspace may be an existing project, a Git repository, or an empty directory; Git is not required.
+export const ATTACHED_WORKSPACE_BASH_DESCRIPTION = `Runs bash commands inside the selected attached environment and returns stdout/stderr. Its workspace may be an existing project, Git repository, or empty directory.
 
 Session behavior:
-- This tool starts a new command. It does not inspect an existing background task. Use check_background_task with background_task_id when that tool is available to inspect an existing task; do not send a task ID to bash_tool.
-- Files in the registered workspace persist between calls.
-- Each call runs in a fresh sandboxed process; shell variables, the working directory, temporary files, and background processes do not survive the call.
-- Network access follows the sandbox policy configured on the worker and may be unavailable.
-- Commands and file access remain confined by the worker's runtime policy.
+- This starts a new command, not an existing background task. Inspect a background_task_id with check_background_task when available; never send it to bash_tool.
+- Only registered-workspace files persist between calls. Install project dependencies there.
+- Every call is a fresh process. Shell and exported variables, cwd, /tmp, $TMPDIR, and background processes do not survive.
+- $HOME, global/system packages, and machine services are operator-managed. Do not change or rely on them as session storage.
+- Network access follows the sandbox policy configured on the worker and may be unavailable. File access follows the same worker policy.
 - Input code is already displayed to the user; do not repeat it unless asked.
 - Explicitly print every result the user should see.
 - Never use this tool to execute malicious commands.`;
@@ -42,7 +44,7 @@ const attachedCommandSchema: NonNullable<LCTool['parameters']> = {
   ...bashSchema.properties?.command,
   type: 'string',
   description:
-    'The bash command or script to execute from the attached workspace root. Files written in the workspace persist between calls, but each call starts a fresh process.',
+    'The bash command or script to execute from the attached workspace root. Only files written inside the workspace persist between calls. Each call starts a fresh process; $HOME, temporary files, shell state, global installs, and background processes are not durable.',
 };
 
 /** `maxLength` is valid JSON Schema, but the SDK's schema type omits it. */
@@ -73,7 +75,7 @@ function buildAttachedTimeoutSchema(maxTimeoutMs: number): BoundedTimeoutSchema
     type: 'integer',
     minimum: 1,
     maximum: maxTimeoutMs,
-    description: `Optional execution timeout in milliseconds, from 1 through ${maxTimeoutMs}. Defaults to ${defaultTimeoutMs}. Waiting for an available worker does not consume this execution budget.`,
+    description: `Optional execution timeout in milliseconds, from 1 through ${maxTimeoutMs}. Defaults to ${defaultTimeoutMs} for foreground calls and ${maxTimeoutMs} for detached background calls. Waiting for an available worker does not consume this execution budget.`,
   };
 }
 
@@ -86,11 +88,56 @@ function normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs: number): numb
 
 export function resolveAttachedWorkspaceCommandTimeoutMax(
   configSchema?: CodeEnvironmentUserConfigSchema,
+  upstreamMaxTimeoutMs?: number,
 ): number {
   const configured = configSchema?.limits?.maxCommandTimeoutMs;
-  return configured == null
-    ? WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS
-    : normalizeAttachedWorkspaceCommandTimeoutMax(configured);
+  const upstream =
+    upstreamMaxTimeoutMs == null
+      ? WORKSPACE_COMMAND_MAX_TIMEOUT_MS
+      : normalizeAttachedWorkspaceCommandTimeoutMax(upstreamMaxTimeoutMs);
+  let requested = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS;
+  if (configured != null) {
+    requested = normalizeAttachedWorkspaceCommandTimeoutMax(configured);
+  } else if (upstreamMaxTimeoutMs != null) {
+    requested = upstream;
+  }
+  return Math.min(requested, upstream);
+}
+
+/**
+ * Programmatic calls do not currently carry the detached-invocation marker.
+ * Preserve their historical foreground default while still enforcing both an
+ * explicit administrator override and the live upstream ceiling.
+ */
+export function resolveAttachedWorkspaceProgrammaticTimeout(
+  configSchema?: CodeEnvironmentUserConfigSchema,
+  upstreamMaxTimeoutMs?: number,
+): number {
+  const configured = configSchema?.limits?.maxCommandTimeoutMs;
+  const requested =
+    configured == null
+      ? WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS
+      : normalizeAttachedWorkspaceCommandTimeoutMax(configured);
+  const upstream =
+    upstreamMaxTimeoutMs == null
+      ? WORKSPACE_COMMAND_MAX_TIMEOUT_MS
+      : normalizeAttachedWorkspaceCommandTimeoutMax(upstreamMaxTimeoutMs);
+  return Math.min(requested, upstream);
+}
+
+/**
+ * Client retry horizon for one capacity-blocked invocation. `0` surfaces the
+ * first capacity expiry without retrying; an in-flight server admission window
+ * and execution retain their own budgets.
+ */
+export function resolveAttachedWorkspaceQueueWaitMs(
+  configSchema?: CodeEnvironmentUserConfigSchema,
+): number {
+  const configured = configSchema?.limits?.maxQueueWaitMs;
+  if (configured == null || !Number.isSafeInteger(configured) || configured < 0) {
+    return WORKSPACE_QUEUE_MAX_WAIT_MS;
+  }
+  return Math.min(WORKSPACE_QUEUE_MAX_WAIT_MS, configured);
 }
 
 export function buildAttachedWorkspaceBashSchema(
@@ -182,23 +229,25 @@ export function createContextProgrammaticBashTool(
   identity?: AgentGitIdentity | null,
 ): DynamicStructuredTool {
   const attached = context?.environmentType === 'attached';
-  return createGitIdentityProgrammaticBashTool(
-    {
-      authHeaders,
-      baseUrl: context?.baseUrl,
-      executionProfile: context?.executionProfile,
-      runtimeSessionHint: context?.runtimeSessionHint,
-      ...(attached
-        ? {
-            workspaceId: context.codeWorkspace?.workspaceId,
-            runTimeoutMs: resolveAttachedWorkspaceCommandTimeoutMax(
-              context.codeEnvironmentConfigSchema,
-            ),
-          }
-        : {}),
-    },
-    attached ? identity : undefined,
-  );
+  const options: Parameters<typeof createBashProgrammaticToolCallingTool>[0] & {
+    workspaceInstanceId?: string;
+  } = {
+    authHeaders,
+    baseUrl: context?.baseUrl,
+    executionProfile: context?.executionProfile,
+    runtimeSessionHint: context?.runtimeSessionHint,
+    ...(attached
+      ? {
+          workspaceId: context.codeWorkspace?.workspaceId,
+          workspaceInstanceId: context.codeWorkspace?.workspaceInstanceId,
+          runTimeoutMs: resolveAttachedWorkspaceProgrammaticTimeout(
+            context.codeEnvironmentConfigSchema,
+            context.codeWorkspace?.maxCommandTimeoutMs,
+          ),
+        }
+      : {}),
+  };
+  return createGitIdentityProgrammaticBashTool(options, attached ? identity : undefined);
 }
 
 /** Apply authorship before the SDK prepares the script and its replay requests. */
@@ -232,18 +281,23 @@ export function createAttachedWorkspaceBashTool({
   baseUrl,
   authHeaders,
   workspaceId,
+  workspaceInstanceId,
   environment,
   gitIdentity,
   maxTimeoutMs = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,
+  maxQueueWaitMs,
   fetchImpl,
 }: {
   baseUrl: string;
   authHeaders: () => Promise<Record<string, string>> | Record<string, string>;
   workspaceId: string;
+  workspaceInstanceId?: string;
   environment?: CodeWorkspaceDescriptor['environment'];
   gitIdentity?: AgentGitIdentity | null;
-  /** Deployment ceiling already intersected with the protocol hard cap. */
+  /** Effective admin/upstream ceiling already intersected with the protocol hard cap. */
   maxTimeoutMs?: number;
+  /** Deployment admission budget; omitted keeps the built-in default. */
+  maxQueueWaitMs?: number;
   fetchImpl?: CodeBridgeFetch;
 }): DynamicStructuredTool {
   const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);
@@ -286,7 +340,10 @@ export function createAttachedWorkspaceBashTool({
         action ??
         commandWithGitIdentity(commandWithArguments(rawInput.command!, rawInput.args), gitIdentity);
       const timeoutMs =
-        rawInput.timeoutMs ?? Math.min(WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS, effectiveMaxTimeoutMs);
+        rawInput.timeoutMs ??
+        (config?.configurable?.[BACKGROUND_TOOL_INVOCATION_CONFIG_KEY] === true
+          ? effectiveMaxTimeoutMs
+          : Math.min(WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS, effectiveMaxTimeoutMs));
       const signal = config?.signal;
       const trace = {
         runId: config?.metadata?.run_id,
@@ -301,11 +358,13 @@ export function createAttachedWorkspaceBashTool({
       try {
         const result = await executeWorkspaceTool({
           baseURL: baseUrl,
-          authHeaders: await authHeaders(),
+          /** Passed as a supplier: a queued call outlives its minted token. */
+          authHeaders,
           request: {
             protocolVersion: 1,
             operation: 'execute_command',
             workspaceId,
+            ...(workspaceInstanceId ? { workspaceInstanceId } : {}),
             command,
             ...(action && environment
               ? { environmentAction: { name: action, fingerprint: environment.fingerprint } }
@@ -316,6 +375,7 @@ export function createAttachedWorkspaceBashTool({
           },
           signal,
           fetchImpl,
+          ...(maxQueueWaitMs == null ? {} : { maxQueueWaitMs }),
         });
         if (result.operation !== 'execute_command') {
           throw new Error('Attached workspace returned an unexpected command result.');
diff --git a/packages/api/src/code/decision.spec.ts b/packages/api/src/code/decision.spec.ts
index cd3a96e5d10..42d29df8f8d 100644
--- a/packages/api/src/code/decision.spec.ts
+++ b/packages/api/src/code/decision.spec.ts
@@ -42,6 +42,27 @@ describe('resolveConversationCodeEnvironmentDecision', () => {
     ).toEqual({ mode: 'without_attached' });
   });
 
+  /* A chat started by an agent that never ran code stores neither field. Sealing that state made
+   * switching it to a coding agent reject the first workspace its owner picked. */
+  it('lets a saved conversation that never decided establish a decision', () => {
+    expect(
+      resolveConversationCodeEnvironmentDecision({
+        conversationId: 'conversation-1',
+        requestedMode: 'attached',
+        requestedSelections: [selection],
+        conversation: { conversationId: 'conversation-1' },
+      }),
+    ).toEqual({ mode: 'attached', codeWorkspaces: [selection] });
+    expect(
+      resolveConversationCodeEnvironmentDecision({
+        conversationId: 'conversation-1',
+        requestedMode: 'attached',
+        requestedSelections: [selection],
+        conversation: { conversationId: 'conversation-1', codeWorkspaces: [] },
+      }),
+    ).toEqual({ mode: 'attached', codeWorkspaces: [selection] });
+  });
+
   it('allows an identical retry of a persisted decision', () => {
     expect(
       resolveConversationCodeEnvironmentDecision({
@@ -253,6 +274,18 @@ describe('resolvePersistableCodeEnvironmentDecision', () => {
     ).toEqual({ codeEnvironmentMode: 'without_attached' });
   });
 
+  it('records the whole decision a saved conversation establishes for the first time', () => {
+    /* Selections included: an `attached` mode stored without them fails the next turn's
+     * validation, which requires a non-empty selection set. */
+    expect(
+      resolvePersistableCodeEnvironmentDecision({
+        conversationId: 'conversation-1',
+        decision: { mode: 'attached', codeWorkspaces: [mac] },
+        conversation: { conversationId: 'conversation-1' },
+      }),
+    ).toEqual({ codeEnvironmentMode: 'attached', codeWorkspaces: [mac] });
+  });
+
   it('never writes a run-start decision over a stored one that a move replaced', () => {
     expect(
       resolvePersistableCodeEnvironmentDecision({
diff --git a/packages/api/src/code/decision.ts b/packages/api/src/code/decision.ts
index f120032620b..8c3880b4969 100644
--- a/packages/api/src/code/decision.ts
+++ b/packages/api/src/code/decision.ts
@@ -49,7 +49,17 @@ function validateDecision(mode: unknown, selections: unknown): ConversationCodeE
   return { mode, codeWorkspaces: canonicalSelections(selections) };
 }
 
-/** A stored conversation always carries a decision; legacy rows infer it from their selections. */
+/**
+ * Whether the conversation already recorded a decision. A chat whose turns never involved a
+ * code-capable agent stores neither field, so it has nothing to seal: switching one to a coding
+ * agent still gets to decide. Sealing that state instead would report `without_attached` for a
+ * choice its owner never made, and reject the selection they go on to make.
+ */
+function holdsDecision(conversation: StoredConversationDecision): boolean {
+  return conversation.codeEnvironmentMode != null || (conversation.codeWorkspaces?.length ?? 0) > 0;
+}
+
+/** Reads the decision a conversation holds; legacy rows infer it from their selections. */
 function readPersistedDecision(
   conversation: StoredConversationDecision,
 ): ConversationCodeEnvironmentDecision {
@@ -71,7 +81,11 @@ export function resolveConversationCodeEnvironmentDecision({
   requestedSelections?: unknown;
   conversation?: StoredConversationDecision | null;
 }): ConversationCodeEnvironmentDecision {
-  if (conversation != null && conversation.conversationId === conversationId) {
+  if (
+    conversation != null &&
+    conversation.conversationId === conversationId &&
+    holdsDecision(conversation)
+  ) {
     const persisted = readPersistedDecision(conversation);
     if (requestedMode !== undefined && requestedMode !== persisted.mode) {
       throw new CodeWorkspaceSelectionError('locked');
@@ -191,6 +205,11 @@ export function resolvePersistableCodeEnvironmentDecision({
   if (conversation == null || conversation.conversationId !== conversationId) {
     return candidate;
   }
+  /* A saved chat that held no decision records the one this run establishes, selections included:
+   * writing the mode alone would leave `attached` without the selections the next turn validates. */
+  if (!holdsDecision(conversation)) {
+    return candidate;
+  }
   if (conversation.codeEnvironmentMode != null || candidate.codeEnvironmentMode == null) {
     return {};
   }
diff --git a/packages/api/src/code/instructions.spec.ts b/packages/api/src/code/instructions.spec.ts
index 9a26bf9391b..f5b92a0e5e9 100644
--- a/packages/api/src/code/instructions.spec.ts
+++ b/packages/api/src/code/instructions.spec.ts
@@ -103,6 +103,38 @@ describe('repository instruction loading', () => {
     expect(await load({ ...input, mode: 'defer' })).toContain('unless they conflict');
   });
 
+  it('reads and caches instructions within the resolved conversation worktree', async () => {
+    const load = createRepositoryInstructionLoader();
+    let requestBody: string | undefined;
+    const fetchImpl = jest.fn(
+      async (_input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+        requestBody = init?.body as string | undefined;
+        return response();
+      },
+    );
+    const workspaceInstanceId = 'f'.repeat(64);
+    const scopedContext = {
+      ...context,
+      codeWorkspace: { ...context.codeWorkspace!, workspaceInstanceId },
+    };
+    const input = {
+      enabled: true,
+      context: scopedContext,
+      principalId: 'alice',
+      fetchImpl,
+      authHeaders: async () => ({}),
+      assertContent: jest.fn(),
+    };
+
+    await load(input);
+    await load(input);
+
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(requestBody!)).toMatchObject({
+      workspaceInstanceId,
+    });
+  });
+
   it('omits changed, missing and unauthorized instruction snapshots', async () => {
     const load = createRepositoryInstructionLoader();
     const input = {
diff --git a/packages/api/src/code/instructions.ts b/packages/api/src/code/instructions.ts
index e34027eaf62..74db097616a 100644
--- a/packages/api/src/code/instructions.ts
+++ b/packages/api/src/code/instructions.ts
@@ -82,6 +82,7 @@ export function createRepositoryInstructionLoader() {
       context.baseUrl,
       context.bridgeWorkerId,
       workspace.workspaceId,
+      workspace.workspaceInstanceId ?? null,
       descriptor.path,
       descriptor.sha256,
     ]);
@@ -103,6 +104,9 @@ export function createRepositoryInstructionLoader() {
             protocolVersion: 1,
             operation: 'read_file',
             workspaceId: workspace.workspaceId,
+            ...(workspace.workspaceInstanceId
+              ? { workspaceInstanceId: workspace.workspaceInstanceId }
+              : {}),
             path: descriptor.path,
             instructionSha256: descriptor.sha256,
           },
diff --git a/packages/api/src/code/workspace.spec.ts b/packages/api/src/code/workspace.spec.ts
index c19c2efd1f9..84b02735a73 100644
--- a/packages/api/src/code/workspace.spec.ts
+++ b/packages/api/src/code/workspace.spec.ts
@@ -3,6 +3,57 @@ import type { CodeBridgeFetch } from './bridge';
 import { executeWorkspaceTool, WorkspaceToolHttpError } from './workspace';
 
 describe('workspace admission feedback', () => {
+  test('forwards a valid conversation workspace instance unchanged', async () => {
+    const workspaceInstanceId = 'd'.repeat(64);
+    const fetchImpl = jest.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          protocolVersion: 1,
+          operation: 'write_file',
+          workspaceId: 'primary',
+          path: 'notes.txt',
+          created: true,
+          bytesWritten: 5,
+        }),
+        { status: 200, headers: { 'Content-Type': 'application/json' } },
+      ),
+    );
+
+    await executeWorkspaceTool({
+      baseURL: 'https://code.example/v1',
+      authHeaders: {},
+      fetchImpl,
+      request: {
+        protocolVersion: 1,
+        operation: 'write_file',
+        workspaceId: 'primary',
+        workspaceInstanceId,
+        path: 'notes.txt',
+        content: 'ready',
+      },
+    });
+
+    expect(JSON.parse(fetchImpl.mock.calls[0][1].body)).toMatchObject({ workspaceInstanceId });
+  });
+
+  test('rejects malformed workspace instance identifiers before transport', async () => {
+    const fetchImpl = jest.fn();
+    await expect(
+      executeWorkspaceTool({
+        baseURL: 'https://code.example/v1',
+        authHeaders: {},
+        fetchImpl,
+        request: {
+          protocolVersion: 1,
+          operation: 'list_files',
+          workspaceId: 'primary',
+          workspaceInstanceId: 'conversation-1',
+        },
+      }),
+    ).rejects.toBeInstanceOf(WorkspaceToolHttpError);
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
   test('identifies definite pre-execution expiry without retrying the operation', async () => {
     const fetchImpl = jest.fn().mockResolvedValue(
       new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
@@ -15,6 +66,7 @@ describe('workspace admission feedback', () => {
         baseURL: 'https://code.example/v1',
         authHeaders: {},
         fetchImpl,
+        maxQueueWaitMs: 0,
         request: {
           protocolVersion: 1,
           operation: 'execute_command',
@@ -26,6 +78,261 @@ describe('workspace admission feedback', () => {
     expect(fetchImpl).toHaveBeenCalledTimes(1);
   });
 
+  test('keeps one tool call queued when capacity expires before admission', async () => {
+    const unavailable = () =>
+      new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
+        status: 503,
+        headers: { 'Retry-After': '0' },
+      });
+    const fetchImpl = jest
+      .fn()
+      .mockResolvedValueOnce(unavailable())
+      .mockResolvedValueOnce(unavailable())
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            protocolVersion: 1,
+            operation: 'edit_file',
+            workspaceId: 'primary',
+            path: 'src/app.ts',
+            replacements: 1,
+            bytesWritten: 24,
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      );
+
+    await expect(
+      executeWorkspaceTool({
+        baseURL: 'https://code.example/v1',
+        authHeaders: {},
+        fetchImpl,
+        request: {
+          protocolVersion: 1,
+          operation: 'edit_file',
+          workspaceId: 'primary',
+          path: 'src/app.ts',
+          edits: [{ oldText: 'const old = true;', newText: 'const ready = true;' }],
+        },
+      }),
+    ).resolves.toMatchObject({ operation: 'edit_file', replacements: 1 });
+
+    expect(fetchImpl).toHaveBeenCalledTimes(3);
+    expect(fetchImpl.mock.calls.map((call) => call[1]?.body)).toEqual([
+      fetchImpl.mock.calls[0][1]?.body,
+      fetchImpl.mock.calls[0][1]?.body,
+      fetchImpl.mock.calls[0][1]?.body,
+    ]);
+  });
+
+  test('mints fresh credentials for every admission attempt', async () => {
+    let minted = 0;
+    const authHeaders = jest.fn(async () => ({ Authorization: `Bearer token-${++minted}` }));
+    const fetchImpl = jest
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
+          status: 503,
+          headers: { 'Retry-After': '0' },
+        }),
+      )
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            protocolVersion: 1,
+            operation: 'edit_file',
+            workspaceId: 'primary',
+            path: 'src/app.ts',
+            replacements: 1,
+            bytesWritten: 24,
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      );
+
+    await expect(
+      executeWorkspaceTool({
+        baseURL: 'https://code.example/v1',
+        authHeaders,
+        fetchImpl,
+        request: {
+          protocolVersion: 1,
+          operation: 'edit_file',
+          workspaceId: 'primary',
+          path: 'src/app.ts',
+          edits: [{ oldText: 'const old = true;', newText: 'const ready = true;' }],
+        },
+      }),
+    ).resolves.toMatchObject({ operation: 'edit_file' });
+
+    // A token minted before the first capacity window expires within the
+    // admission budget, so reusing it would fail the retry with a 401.
+    expect(authHeaders).toHaveBeenCalledTimes(2);
+    expect(
+      fetchImpl.mock.calls.map(
+        (call) => (call[1]?.headers as Record<string, string>).Authorization,
+      ),
+    ).toEqual(['Bearer token-1', 'Bearer token-2']);
+  });
+
+  test('never opens another admission window once the queue budget is spent', async () => {
+    jest.useFakeTimers();
+    try {
+      const fetchImpl = jest.fn().mockResolvedValue(
+        new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
+          status: 503,
+          headers: { 'Retry-After': '1' },
+        }),
+      );
+
+      const result = executeWorkspaceTool({
+        baseURL: 'https://code.example/v1',
+        authHeaders: {},
+        fetchImpl,
+        maxQueueWaitMs: 150,
+        request: {
+          protocolVersion: 1,
+          operation: 'edit_file',
+          workspaceId: 'primary',
+          path: 'src/app.ts',
+          edits: [{ oldText: 'const old = true;', newText: 'const ready = true;' }],
+        },
+      }).catch((error: Error) => error);
+
+      await jest.advanceTimersByTimeAsync(150);
+      expect(await result).toMatchObject({
+        message: expect.stringContaining('The operation was not started'),
+      });
+
+      // The clamped wait lands on the deadline: a further dispatch could still be
+      // admitted and run a long command after the budget expired.
+      expect(fetchImpl).toHaveBeenCalledTimes(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  test.each([true, false])(
+    'does not dispatch when cancelled before or during credential refresh (%s)',
+    async (beforeRefresh) => {
+      const controller = new AbortController();
+      const reason = new DOMException('Stopped', 'AbortError');
+      const authHeaders = jest.fn(async () => {
+        controller.abort(reason);
+        return {};
+      });
+      const fetchImpl = jest.fn();
+      if (beforeRefresh) controller.abort(reason);
+      await expect(
+        executeWorkspaceTool({
+          baseURL: 'https://code.example/v1',
+          authHeaders,
+          fetchImpl,
+          signal: controller.signal,
+          request: {
+            protocolVersion: 1,
+            operation: 'read_file',
+            workspaceId: 'primary',
+            path: 'src/app.ts',
+          },
+        }),
+      ).rejects.toBe(reason);
+      expect(fetchImpl).not.toHaveBeenCalled();
+      expect(authHeaders).toHaveBeenCalledTimes(beforeRefresh ? 0 : 1);
+    },
+  );
+
+  test('does not dispatch a retry if credential refresh spends the remaining queue budget', async () => {
+    const now = jest.spyOn(Date, 'now').mockReturnValue(1000);
+    const authHeaders = jest
+      .fn()
+      .mockResolvedValueOnce({})
+      .mockImplementationOnce(async () => {
+        now.mockReturnValue(2000);
+        return {};
+      });
+    const fetchImpl = jest.fn().mockResolvedValueOnce(
+      new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
+        status: 503,
+        headers: { 'Retry-After': '0' },
+      }),
+    );
+    try {
+      await expect(
+        executeWorkspaceTool({
+          baseURL: 'https://code.example/v1',
+          authHeaders,
+          fetchImpl,
+          maxQueueWaitMs: 1000,
+          request: {
+            protocolVersion: 1,
+            operation: 'read_file',
+            workspaceId: 'primary',
+            path: 'src/app.ts',
+          },
+        }),
+      ).rejects.toThrow('The operation was not started');
+      expect(authHeaders).toHaveBeenCalledTimes(2);
+      expect(fetchImpl).toHaveBeenCalledTimes(1);
+    } finally {
+      now.mockRestore();
+    }
+  });
+
+  test('stops waiting for capacity when the chat is cancelled', async () => {
+    const controller = new AbortController();
+    const reason = new DOMException('Stopped', 'AbortError');
+    const fetchImpl = jest.fn().mockResolvedValue(
+      new Response(JSON.stringify({ code: 'WORKSPACE_QUEUE_TIMEOUT' }), {
+        status: 503,
+        headers: { 'Retry-After': '1' },
+      }),
+    );
+    const request = executeWorkspaceTool({
+      baseURL: 'https://code.example/v1',
+      authHeaders: {},
+      fetchImpl,
+      signal: controller.signal,
+      request: {
+        protocolVersion: 1,
+        operation: 'read_file',
+        workspaceId: 'primary',
+        path: 'src/app.ts',
+      },
+    });
+    while (fetchImpl.mock.calls.length === 0) await Promise.resolve();
+    controller.abort(reason);
+
+    await expect(request).rejects.toBe(reason);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  test('never retries an ambiguous capacity-looking failure', async () => {
+    const fetchImpl = jest.fn().mockResolvedValue(
+      new Response('<html>Gateway unavailable</html>', {
+        status: 503,
+        headers: { 'Retry-After': '0' },
+      }),
+    );
+
+    await expect(
+      executeWorkspaceTool({
+        baseURL: 'https://code.example/v1',
+        authHeaders: {},
+        fetchImpl,
+        request: {
+          protocolVersion: 1,
+          operation: 'edit_file',
+          workspaceId: 'primary',
+          path: 'src/app.ts',
+          edits: [{ oldText: 'const old = true;', newText: 'const ready = true;' }],
+        },
+      }),
+    ).rejects.toMatchObject({ upstreamStatus: 503 });
+
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
   test.each([
     [504, '{"code":"ASSIGNMENT_EXPIRED"}', false],
     [503, '<html>Gateway unavailable</html>', false],
@@ -42,6 +349,51 @@ describe('workspace admission feedback', () => {
 });
 
 describe('executeWorkspaceTool', () => {
+  test.each([0, 100])(
+    'preserves admitted command execution beyond a %i ms retry horizon',
+    async (maxQueueWaitMs) => {
+      const now = jest.spyOn(Date, 'now').mockReturnValue(1000);
+      const timeout = jest.spyOn(AbortSignal, 'timeout');
+      const fetchImpl = jest.fn(async (...[_url, init]: Parameters<CodeBridgeFetch>) => {
+        // The endpoint does not report admission separately. A successful command
+        // may finish after the client retry horizon without being cancelled.
+        now.mockReturnValue(2000);
+        expect(init?.signal?.aborted).toBe(false);
+        return new Response(
+          JSON.stringify({
+            protocolVersion: 1,
+            operation: 'execute_command',
+            workspaceId: 'primary',
+            stdout: 'ready',
+            stderr: '',
+            exitCode: 0,
+            timedOut: false,
+            truncated: false,
+          }),
+          { status: 200 },
+        );
+      });
+      await expect(
+        executeWorkspaceTool({
+          baseURL: 'https://code.example/v1',
+          authHeaders: {},
+          maxQueueWaitMs,
+          fetchImpl,
+          request: {
+            protocolVersion: 1,
+            operation: 'execute_command',
+            workspaceId: 'primary',
+            command: 'echo ready',
+            timeoutMs: 300000,
+          },
+        }),
+      ).resolves.toMatchObject({ stdout: 'ready', exitCode: 0 });
+      expect(timeout).toHaveBeenCalledTimes(1);
+      expect(timeout).toHaveBeenCalledWith(340000);
+      expect(fetchImpl).toHaveBeenCalledTimes(1);
+    },
+  );
+
   test.each<[WorkspaceToolRequest, number]>([
     [
       { protocolVersion: 1, operation: 'read_file', workspaceId: 'primary', path: 'README.md' },
diff --git a/packages/api/src/code/workspace.ts b/packages/api/src/code/workspace.ts
index d043fde185d..3de4d8ab5ff 100644
--- a/packages/api/src/code/workspace.ts
+++ b/packages/api/src/code/workspace.ts
@@ -1,3 +1,4 @@
+import { CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS } from 'librechat-data-provider';
 import type { CodeBridgeFetch } from './bridge';
 
 const WORKSPACE_TOOL_TIMEOUT_MS = 30_000;
@@ -20,6 +21,9 @@ const MAX_COMMAND_SIGNAL_LENGTH = 32;
 const WORKSPACE_COMMAND_TRANSPORT_GRACE_MS = 5_000;
 /** Matches Code API's bounded admission wait and command settlement allowance. */
 const WORKSPACE_QUEUE_TIMEOUT_MS = 30_000;
+/** Compatibility export; the deployment schema owns the default and hard cap. */
+export const WORKSPACE_QUEUE_MAX_WAIT_MS: number = CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS;
+const WORKSPACE_QUEUE_RETRY_DELAY_MS = 1_000;
 const WORKSPACE_COMMAND_SETTLEMENT_GRACE_MS = 5_000;
 const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 const MAX_ERROR_BODY_BYTES = 4096;
@@ -95,6 +99,7 @@ export interface WorkspaceReadRequest {
   protocolVersion: 1;
   operation: 'read_file';
   workspaceId: string;
+  workspaceInstanceId?: string;
   path: string;
   startLine?: number;
   maxLines?: number;
@@ -105,6 +110,7 @@ export interface WorkspaceSearchRequest {
   protocolVersion: 1;
   operation: 'search_text';
   workspaceId: string;
+  workspaceInstanceId?: string;
   query: string;
   path?: string;
   maxResults?: number;
@@ -114,6 +120,7 @@ export interface WorkspaceListRequest {
   protocolVersion: 1;
   operation: 'list_files';
   workspaceId: string;
+  workspaceInstanceId?: string;
   path?: string;
   maxResults?: number;
   afterPath?: string;
@@ -123,6 +130,7 @@ export interface WorkspaceExecuteCommandRequest {
   protocolVersion: 1;
   operation: 'execute_command';
   workspaceId: string;
+  workspaceInstanceId?: string;
   command: string;
   cwd?: string;
   timeoutMs?: number;
@@ -134,6 +142,7 @@ export interface WorkspaceWriteRequest {
   protocolVersion: 1;
   operation: 'write_file';
   workspaceId: string;
+  workspaceInstanceId?: string;
   path: string;
   content: string;
   overwrite?: boolean;
@@ -148,6 +157,7 @@ export interface WorkspaceEditRequest {
   protocolVersion: 1;
   operation: 'edit_file';
   workspaceId: string;
+  workspaceInstanceId?: string;
   path: string;
   edits: WorkspaceTextEdit[];
   expectedBaseSha256?: string;
@@ -157,6 +167,7 @@ export interface WorkspacePreviewEditRequest {
   protocolVersion: 1;
   operation: 'preview_edit';
   workspaceId: string;
+  workspaceInstanceId?: string;
   path: string;
   edits: WorkspaceTextEdit[];
 }
@@ -282,6 +293,30 @@ function isWorkspaceAdmissionTimeout(status?: number, body?: string, truncated =
   }
 }
 
+function waitForWorkspaceAdmission(delayMs: number, signal?: AbortSignal): Promise<void> {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => signal?.removeEventListener('abort', abort);
+    const finish = () => {
+      cleanup();
+      resolve();
+    };
+    const abort = () => {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(finish, delayMs);
+    signal?.addEventListener('abort', abort, { once: true });
+    if (signal?.aborted === true) abort();
+  });
+}
+
+function workspaceAdmissionRetryDelay(value: string | null): number {
+  if (value == null || !/^\d+$/.test(value)) return WORKSPACE_QUEUE_RETRY_DELAY_MS;
+  return Math.max(100, Math.min(Number(value) * 1_000, WORKSPACE_QUEUE_TIMEOUT_MS));
+}
+
 /** Keep a received HTTP status even if reading its diagnostic body fails or stalls. */
 async function readErrorBody(
   response: Response,
@@ -458,7 +493,9 @@ async function readBoundedJson(response: Response, signal?: AbortSignal): Promis
 function isValidRequest(request: WorkspaceToolRequest): boolean {
   if (
     request.protocolVersion !== 1 ||
-    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(request.workspaceId)
+    !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(request.workspaceId) ||
+    (request.workspaceInstanceId !== undefined &&
+      !/^[a-f0-9]{64}$/.test(request.workspaceInstanceId))
   ) {
     return false;
   }
@@ -703,62 +740,110 @@ function getWorkspaceToolTimeoutMs(request: WorkspaceToolRequest): number {
   return WORKSPACE_QUEUE_TIMEOUT_MS + executionBudgetMs + WORKSPACE_COMMAND_TRANSPORT_GRACE_MS;
 }
 
+/**
+ * Credentials for one admission attempt. A supplier is minted per attempt, so a
+ * call that stays queued past the Code API token TTL presents a fresh token
+ * instead of failing permanently with 401 while capacity is still pending.
+ */
+export type WorkspaceToolAuthHeaders =
+  | Record<string, string>
+  | (() => Promise<Record<string, string>> | Record<string, string>);
+
 export async function executeWorkspaceTool({
   baseURL,
   authHeaders,
   request,
   signal,
   fetchImpl = fetch,
+  maxQueueWaitMs = WORKSPACE_QUEUE_MAX_WAIT_MS,
 }: {
   baseURL: string;
-  authHeaders: Record<string, string>;
+  authHeaders: WorkspaceToolAuthHeaders;
   request: WorkspaceToolRequest;
   signal?: AbortSignal;
   fetchImpl?: CodeBridgeFetch;
+  maxQueueWaitMs?: number;
 }): Promise<WorkspaceToolResult> {
-  if (!isValidRequest(request)) {
+  if (
+    !isValidRequest(request) ||
+    !Number.isSafeInteger(maxQueueWaitMs) ||
+    maxQueueWaitMs < 0 ||
+    maxQueueWaitMs > WORKSPACE_QUEUE_MAX_WAIT_MS
+  ) {
     throw new WorkspaceToolHttpError('invalid');
   }
-  try {
-    const timeoutSignal = AbortSignal.timeout(getWorkspaceToolTimeoutMs(request));
-    const requestSignal =
-      signal != null && typeof AbortSignal.any === 'function'
-        ? AbortSignal.any([signal, timeoutSignal])
-        : timeoutSignal;
-    const response = await fetchImpl(
-      `${baseURL.trim().replace(/\/+$/, '')}/workspace-tools/execute`,
-      {
-        method: 'POST',
-        headers: {
-          ...authHeaders,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(request),
-        redirect: 'error',
-        signal: requestSignal,
-      },
-    );
-    if (!response.ok) {
-      const { body, truncated } = await readErrorBody(response, requestSignal);
+  const queueDeadlineAt = Date.now() + maxQueueWaitMs;
+  const body = JSON.stringify(request);
+  let lastAdmissionRejection: WorkspaceToolHttpError | undefined;
+  while (true) {
+    try {
       signal?.throwIfAborted();
-      throw new WorkspaceToolHttpError('rejected', response.status, body, truncated);
-    }
-    const result = await readBoundedJson(response, requestSignal);
-    if (!isValidResult(request, result)) {
-      throw new WorkspaceToolHttpError('invalid');
-    }
-    return result;
-  } catch (error) {
-    if (error instanceof WorkspaceToolHttpError) throw error;
-    if (
-      signal?.aborted === true &&
-      (error === signal.reason || (isRecord(error) && error.name === 'AbortError'))
-    ) {
-      throw error;
-    }
-    if (error instanceof Error && error.name === 'TimeoutError') {
-      throw new WorkspaceToolHttpError('timeout');
+      /** The endpoint replies only after execution settles. Capping this by the
+       * retry horizon would also abort already-admitted commands, with an unknown
+       * mutation outcome. Server admission and execution retain separate budgets. */
+      const timeoutSignal = AbortSignal.timeout(getWorkspaceToolTimeoutMs(request));
+      const requestSignal =
+        signal != null && typeof AbortSignal.any === 'function'
+          ? AbortSignal.any([signal, timeoutSignal])
+          : timeoutSignal;
+      const attemptHeaders = typeof authHeaders === 'function' ? await authHeaders() : authHeaders;
+      requestSignal.throwIfAborted();
+      if (lastAdmissionRejection && Date.now() >= queueDeadlineAt) {
+        throw lastAdmissionRejection;
+      }
+      const response = await fetchImpl(
+        `${baseURL.trim().replace(/\/+$/, '')}/workspace-tools/execute`,
+        {
+          method: 'POST',
+          headers: {
+            ...attemptHeaders,
+            'Content-Type': 'application/json',
+          },
+          body,
+          redirect: 'error',
+          signal: requestSignal,
+        },
+      );
+      if (!response.ok) {
+        const { body, truncated } = await readErrorBody(response, requestSignal);
+        signal?.throwIfAborted();
+        const rejection = new WorkspaceToolHttpError('rejected', response.status, body, truncated);
+        if (
+          !isWorkspaceAdmissionTimeout(response.status, body, truncated) ||
+          Date.now() >= queueDeadlineAt
+        ) {
+          throw rejection;
+        }
+        const delayMs = Math.min(
+          workspaceAdmissionRetryDelay(response.headers.get('Retry-After')),
+          queueDeadlineAt - Date.now(),
+        );
+        lastAdmissionRejection = rejection;
+        await waitForWorkspaceAdmission(delayMs, signal);
+        /** A clamped delay can land exactly on the deadline: the budget is spent,
+         * so never open another admission window that could still be admitted. */
+        if (Date.now() >= queueDeadlineAt) {
+          throw rejection;
+        }
+        continue;
+      }
+      const result = await readBoundedJson(response, requestSignal);
+      if (!isValidResult(request, result)) {
+        throw new WorkspaceToolHttpError('invalid');
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof WorkspaceToolHttpError) throw error;
+      if (
+        signal?.aborted === true &&
+        (error === signal.reason || (isRecord(error) && error.name === 'AbortError'))
+      ) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === 'TimeoutError') {
+        throw new WorkspaceToolHttpError('timeout');
+      }
+      throw new WorkspaceToolHttpError('failed');
     }
-    throw new WorkspaceToolHttpError('failed');
   }
 }
diff --git a/packages/api/src/conversations/index.ts b/packages/api/src/conversations/index.ts
index 80329340be5..35c0db3f921 100644
--- a/packages/api/src/conversations/index.ts
+++ b/packages/api/src/conversations/index.ts
@@ -2,3 +2,4 @@ export * from './archive';
 export * from './chatgpt';
 export * from './import';
 export * from './lineage';
+export * from './save';
diff --git a/packages/api/src/conversations/save.spec.ts b/packages/api/src/conversations/save.spec.ts
new file mode 100644
index 00000000000..e39a71d2e73
--- /dev/null
+++ b/packages/api/src/conversations/save.spec.ts
@@ -0,0 +1,210 @@
+import mongoose from 'mongoose';
+import { randomUUID } from 'crypto';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { createMethods, createModels } from '@librechat/data-schemas';
+import type { ConversationMethods, MessageMethods } from '@librechat/data-schemas';
+import type { TurnConversationRequest } from './save';
+import {
+  runAfterSeed,
+  saveTurnConversation,
+  seedTurnConversation,
+  getConversationWriteContext,
+} from './save';
+
+type Store = Pick<ConversationMethods, 'getConvo' | 'saveConvo'> &
+  Pick<MessageMethods, 'saveMessage'>;
+
+let mongoServer: MongoMemoryServer;
+let store: Store;
+
+const endpointOptions = { model: 'claude-sonnet', agent_id: 'agent_persisted' };
+
+function createRequest(userId: string): TurnConversationRequest {
+  return {
+    user: { id: userId },
+    body: {},
+    conversationCreatedAt: '2026-09-19T12:00:00.000Z',
+  };
+}
+
+function seedFields(req: TurnConversationRequest, conversationId: string) {
+  return {
+    req,
+    conversationId,
+    endpoint: 'agents',
+    endpointType: undefined,
+    endpointOptions,
+    agentId: 'agent_persisted',
+    context: 'save.spec seed',
+  };
+}
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  await mongoose.connect(mongoServer.getUri());
+  createModels(mongoose);
+  const methods = createMethods(mongoose);
+  store = {
+    getConvo: methods.getConvo,
+    saveConvo: methods.saveConvo,
+    saveMessage: methods.saveMessage,
+  };
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+  await mongoServer.stop();
+});
+
+beforeEach(async () => {
+  await mongoose.models.Conversation.deleteMany({});
+  await mongoose.models.Message.deleteMany({});
+  jest.restoreAllMocks();
+});
+
+describe('seedTurnConversation', () => {
+  it('creates the row a deferred first message has not written yet', async () => {
+    const userId = new mongoose.Types.ObjectId().toString();
+    const conversationId = randomUUID();
+    const req = createRequest(userId);
+    const messageFind = jest.spyOn(mongoose.models.Message, 'find');
+
+    await seedTurnConversation(store, seedFields(req, conversationId));
+
+    const row = await store.getConvo(userId, conversationId);
+    expect(row).toMatchObject({
+      conversationId,
+      endpoint: 'agents',
+      model: 'claude-sonnet',
+      agent_id: 'agent_persisted',
+      messages: [],
+    });
+    expect(row?.createdAt?.toISOString()).toBe('2026-09-19T12:00:00.000Z');
+    /** The seed knows the row holds no messages, so it never reads the message list. */
+    expect(messageFind).not.toHaveBeenCalled();
+    expect(req.resolvedConversation).toMatchObject({ conversationId });
+  });
+
+  it('lets the deferred message save reuse the seeded row and append its message', async () => {
+    const userId = new mongoose.Types.ObjectId().toString();
+    const conversationId = randomUUID();
+    const req = createRequest(userId);
+    await seedTurnConversation(store, seedFields(req, conversationId));
+    const getConvo = jest.spyOn(store, 'getConvo');
+
+    const ctx = getConversationWriteContext(req);
+    const saved = await store.saveMessage(ctx, {
+      messageId: randomUUID(),
+      conversationId,
+      text: 'Summarize the attached sheet',
+      isCreatedByUser: true,
+      user: userId,
+    });
+    const { initialized } = await saveTurnConversation(store, {
+      ...seedFields(req, conversationId),
+      context: 'save.spec message',
+      ctx,
+      savedMessageId: saved?._id,
+    });
+
+    expect(initialized).toBe(true);
+    expect(getConvo).not.toHaveBeenCalled();
+    const row = await store.getConvo(userId, conversationId);
+    expect(row?.messages?.map(String)).toEqual([String(saved?._id)]);
+    expect(row).toMatchObject({ model: 'claude-sonnet', agent_id: 'agent_persisted' });
+  });
+
+  it('leaves an existing conversation to the message save', async () => {
+    const userId = new mongoose.Types.ObjectId().toString();
+    const conversationId = randomUUID();
+    await store.saveConvo(
+      { userId },
+      { conversationId, endpoint: 'openAI', model: 'gpt-4o', title: 'Existing chat' },
+    );
+    const before = await store.getConvo(userId, conversationId);
+    const saveConvo = jest.spyOn(store, 'saveConvo');
+
+    await seedTurnConversation(store, seedFields(createRequest(userId), conversationId));
+
+    expect(saveConvo).not.toHaveBeenCalled();
+    const after = await store.getConvo(userId, conversationId);
+    expect(after).toMatchObject({ endpoint: 'openAI', model: 'gpt-4o', title: 'Existing chat' });
+    expect(after?.updatedAt).toEqual(before?.updatedAt);
+  });
+
+  it('never creates a subagent thread row, which only its parent run may create', async () => {
+    const userId = new mongoose.Types.ObjectId().toString();
+    const conversationId = randomUUID();
+    const req = {
+      ...createRequest(userId),
+      _agentEventBindingParentConversationId: randomUUID(),
+    };
+
+    await seedTurnConversation(store, seedFields(req, conversationId));
+
+    await expect(store.getConvo(userId, conversationId)).resolves.toBeNull();
+  });
+
+  it('stamps a temporary chat with its retention', async () => {
+    const userId = new mongoose.Types.ObjectId().toString();
+    const conversationId = randomUUID();
+    const req = { ...createRequest(userId), body: { isTemporary: true } };
+
+    await seedTurnConversation(store, seedFields(req, conversationId));
+
+    const row = await store.getConvo(userId, conversationId);
+    expect(row?.isTemporary).toBe(true);
+    expect(row?.expiredAt).toBeInstanceOf(Date);
+  });
+
+  it('settles instead of rejecting when the lookup fails, so the message still saves', async () => {
+    const failingStore = {
+      ...store,
+      getConvo: jest.fn().mockRejectedValue(new Error('database unavailable')),
+    };
+
+    await expect(
+      seedTurnConversation(
+        failingStore,
+        seedFields(createRequest(new mongoose.Types.ObjectId().toString()), randomUUID()),
+      ),
+    ).resolves.toBeUndefined();
+  });
+
+  it('does nothing for a request without a user', async () => {
+    const saveConvo = jest.spyOn(store, 'saveConvo');
+
+    await seedTurnConversation(store, seedFields({ body: {} }, randomUUID()));
+
+    expect(saveConvo).not.toHaveBeenCalled();
+  });
+});
+
+describe('runAfterSeed', () => {
+  it('holds the write while the seed is in flight', async () => {
+    let finishSeed: () => void = () => undefined;
+    const seed = new Promise<void>((resolve) => {
+      finishSeed = resolve;
+    });
+    const write = jest.fn().mockResolvedValue('written');
+
+    const pending = runAfterSeed(seed, write)();
+    expect(write).not.toHaveBeenCalled();
+
+    finishSeed();
+    await expect(pending).resolves.toBe('written');
+    expect(write).toHaveBeenCalledTimes(1);
+  });
+
+  it('starts the write synchronously once the seed has landed', async () => {
+    const seed = Promise.resolve();
+    const write = jest.fn().mockResolvedValue('written');
+    const start = runAfterSeed(seed, write);
+    await seed;
+    await Promise.resolve();
+
+    void start();
+
+    expect(write).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/api/src/conversations/save.ts b/packages/api/src/conversations/save.ts
new file mode 100644
index 00000000000..ab355fbed0f
--- /dev/null
+++ b/packages/api/src/conversations/save.ts
@@ -0,0 +1,221 @@
+import { logger } from '@librechat/data-schemas';
+import { excludedKeys, isAgentsEndpoint, isEphemeralAgentId } from 'librechat-data-provider';
+import type { AppConfig, ConversationMethods, IConversation } from '@librechat/data-schemas';
+import type { TConversation } from 'librechat-data-provider';
+
+type SaveConvo = ConversationMethods['saveConvo'];
+type SaveConvoOptions = NonNullable<Parameters<SaveConvo>[2]>;
+type SavedMessageId = NonNullable<SaveConvoOptions['appendMessageIds']>[number];
+type ConversationStore = Pick<ConversationMethods, 'getConvo' | 'saveConvo'>;
+
+/** Retention context a message or conversation write runs under. */
+export type ConversationWriteContext = Parameters<SaveConvo>[0];
+
+/** The request state a turn's conversation writes read and update. */
+export interface TurnConversationRequest {
+  user?: { id?: string };
+  body?: { isTemporary?: boolean };
+  config?: { interfaceConfig?: AppConfig['interfaceConfig'] };
+  /** Server-captured creation time, stamped only when a write inserts the row. */
+  conversationCreatedAt?: string;
+  /** `null` once looked up and absent; unset until something has read it. */
+  resolvedConversation?: Partial<IConversation> | null;
+  _agentEventBindingRetention?: { isTemporary?: boolean; expiredAt?: Date };
+  /** Set for subagent threads, whose rows only their parent run may create. */
+  _agentEventBindingParentConversationId?: string;
+}
+
+/** The conversation fields a turn writes, shared by its seed and its message saves. */
+export interface TurnConversationFields {
+  req?: TurnConversationRequest;
+  conversationId: string;
+  endpoint?: string | null;
+  endpointType?: string | null;
+  endpointOptions?: Partial<TConversation>;
+  /** The agent running the turn, recorded as the conversation's initial agent when persisted. */
+  agentId?: string;
+  /** Logged by `saveConvo` to name the write. */
+  context: string;
+}
+
+export interface TurnConversationWrite extends TurnConversationFields {
+  ctx: ConversationWriteContext;
+  /** Whether an earlier write in this request already initialized the conversation. */
+  initialized?: boolean;
+  /** The message this write just saved, appended to the conversation's message list. */
+  savedMessageId?: SavedMessageId;
+}
+
+export interface TurnConversationResult {
+  conversation: Awaited<ReturnType<SaveConvo>>;
+  /** Whether the conversation was already stored, so later writes in the turn skip that work. */
+  initialized: boolean;
+}
+
+function hasResolvedConversation(req?: TurnConversationRequest): boolean {
+  return req != null && Object.prototype.hasOwnProperty.call(req, 'resolvedConversation');
+}
+
+/** Whether `retentionMode: all` still needs the stored conversation to stamp a write. */
+export function needsRetentionConversation(req?: TurnConversationRequest): boolean {
+  const interfaceConfig = req?.config?.interfaceConfig;
+  return (
+    interfaceConfig?.retentionMode === 'all' &&
+    interfaceConfig.generalChatRetention !== undefined &&
+    !hasResolvedConversation(req)
+  );
+}
+
+/** Builds the retention context a message or conversation write runs under. */
+export function getConversationWriteContext(
+  req?: TurnConversationRequest,
+): ConversationWriteContext {
+  const resolved = hasResolvedConversation(req) ? req?.resolvedConversation : null;
+  return {
+    userId: req?.user?.id ?? '',
+    isTemporary:
+      req?._agentEventBindingRetention?.isTemporary ??
+      resolved?.isTemporary ??
+      req?.body?.isTemporary,
+    expiredAt: req?._agentEventBindingRetention?.expiredAt ?? resolved?.expiredAt ?? undefined,
+    interfaceConfig: req?.config?.interfaceConfig,
+  };
+}
+
+function isAgentOwned(write: TurnConversationFields): boolean {
+  const agentId = write.endpointOptions?.agent_id;
+  return (
+    isAgentsEndpoint(write.endpoint) &&
+    agentId != null &&
+    agentId !== '' &&
+    !isEphemeralAgentId(agentId)
+  );
+}
+
+/** Keys the stored row carries that this turn's options no longer set. */
+function getUnsetFields(
+  existing: Partial<IConversation>,
+  endpointOptions: Partial<TConversation>,
+  agentOwned: boolean,
+): Record<string, number> {
+  const kept = new Set(['spec', 'iconURL']);
+  if (agentOwned) {
+    kept.add('model');
+  }
+  const unsetFields: Record<string, number> = {};
+  for (const key of Object.keys(existing)) {
+    if (excludedKeys.has(key) && !kept.has(key)) {
+      continue;
+    }
+    if (endpointOptions[key as keyof TConversation] === undefined) {
+      unsetFields[key] = 1;
+    }
+  }
+  return unsetFields;
+}
+
+function getCreatedAtOnInsert(req?: TurnConversationRequest): Date | undefined {
+  if (req?.conversationCreatedAt == null) {
+    return undefined;
+  }
+  const createdAt = new Date(req.conversationCreatedAt);
+  return Number.isNaN(createdAt.getTime()) ? undefined : createdAt;
+}
+
+async function loadExistingConversation(
+  deps: ConversationStore,
+  write: TurnConversationWrite,
+): Promise<Partial<IConversation> | null> {
+  if (write.initialized === true) {
+    return null;
+  }
+  if (hasResolvedConversation(write.req)) {
+    return write.req?.resolvedConversation ?? null;
+  }
+  return deps.getConvo(write.ctx.userId, write.conversationId);
+}
+
+async function writeConversation(
+  deps: ConversationStore,
+  write: TurnConversationWrite,
+  existing: Partial<IConversation> | null,
+  appendMessageIds: SavedMessageId[] | undefined,
+): Promise<TurnConversationResult> {
+  const { req, ctx, conversationId, endpoint, endpointType, endpointOptions = {} } = write;
+  const agentOwned = isAgentOwned(write);
+  const conversation = await deps.saveConvo(
+    ctx,
+    {
+      endpoint,
+      endpointType,
+      ...endpointOptions,
+      conversationId: endpointOptions.conversationId ?? conversationId,
+    },
+    {
+      context: write.context,
+      unsetFields: existing != null ? getUnsetFields(existing, endpointOptions, agentOwned) : {},
+      noUpsert: req?._agentEventBindingParentConversationId != null,
+      initialAgentId: agentOwned ? (write.agentId ?? null) : null,
+      createdAtOnInsert:
+        write.initialized !== true && existing == null ? getCreatedAtOnInsert(req) : undefined,
+      ...(appendMessageIds != null ? { appendMessageIds } : {}),
+    },
+  );
+  if (req != null && conversation != null && 'conversationId' in conversation) {
+    req.resolvedConversation = conversation;
+  }
+  return { conversation, initialized: existing != null };
+}
+
+/** Writes the conversation row for a turn's message save. */
+export async function saveTurnConversation(
+  deps: ConversationStore,
+  write: TurnConversationWrite,
+): Promise<TurnConversationResult> {
+  const existing = await loadExistingConversation(deps, write);
+  const appendMessageIds = write.savedMessageId != null ? [write.savedMessageId] : undefined;
+  return writeConversation(deps, write, existing, appendMessageIds);
+}
+
+/**
+ * Creates a new conversation's row ahead of a deferred first message, without the message, so
+ * the conversation lists return a running chat. An existing row is left to the message save.
+ * Settles once the write has finished and never rejects.
+ */
+export async function seedTurnConversation(
+  deps: ConversationStore,
+  fields: TurnConversationFields,
+): Promise<void> {
+  const { req } = fields;
+  const userId = req?.user?.id;
+  if (req == null || userId == null || userId === '') {
+    return;
+  }
+  try {
+    if (!hasResolvedConversation(req)) {
+      req.resolvedConversation = await deps.getConvo(userId, fields.conversationId);
+    }
+    const write: TurnConversationWrite = { ...fields, ctx: getConversationWriteContext(req) };
+    const existing = await loadExistingConversation(deps, write);
+    if (existing != null) {
+      return;
+    }
+    /** An empty append set tells `saveConvo` the row holds no messages yet, sparing the read. */
+    await writeConversation(deps, write, null, []);
+  } catch (error) {
+    logger.error('[seedTurnConversation] Failed to seed the conversation', error);
+  }
+}
+
+/**
+ * Orders a deferred write behind a seed of the same row. While the seed is in flight the write
+ * waits for it; once the seed has landed the write starts synchronously, which a Stop relies on.
+ * `seed` must not reject.
+ */
+export function runAfterSeed<T>(seed: Promise<void>, write: () => Promise<T>): () => Promise<T> {
+  let seeding = true;
+  void seed.finally(() => {
+    seeding = false;
+  });
+  return () => (seeding ? seed.then(write) : write());
+}
diff --git a/packages/api/src/files/deletion.spec.ts b/packages/api/src/files/deletion.spec.ts
index 409c1d2f824..86bbebdea0c 100644
--- a/packages/api/src/files/deletion.spec.ts
+++ b/packages/api/src/files/deletion.spec.ts
@@ -1,4 +1,10 @@
-import { buildDeleteFilesResponse, PARTIAL_FILE_DELETION_MESSAGE } from './deletion';
+import type { AgentResourceFileInput } from './deletion';
+import {
+  buildDeleteFilesResponse,
+  deleteAgentResourceFiles,
+  partitionAgentResourceFiles,
+  PARTIAL_FILE_DELETION_MESSAGE,
+} from './deletion';
 
 describe('delete files response', () => {
   it('reports the caller’s success message when nothing failed', () => {
@@ -32,3 +38,242 @@ describe('delete files response', () => {
     });
   });
 });
+
+type TestFile = { file_id: string; filename: string };
+
+const input = (file_id: string, owner: string | null): AgentResourceFileInput<TestFile> => ({
+  file_id,
+  owner,
+  file: { file_id, filename: `${file_id}.txt` },
+});
+
+describe('partition agent resource files', () => {
+  const userId = 'user-1';
+  const owned = input('owned', userId);
+  const foreign = input('foreign', 'user-2');
+
+  it('makes an attached file the caller owns a candidate for the delete pass', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['owned'],
+        attachedFileIds: ['owned'],
+        files: [owned],
+        toolResource: 'file_search',
+        userId,
+      }),
+    ).toEqual({ ownedFiles: [owned], unlinkOnlyFiles: [] });
+  });
+
+  it('only unlinks an attached file owned by someone else', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['foreign'],
+        attachedFileIds: ['foreign'],
+        files: [foreign],
+        toolResource: 'file_search',
+        userId,
+      }),
+    ).toEqual({
+      ownedFiles: [],
+      unlinkOnlyFiles: [{ tool_resource: 'file_search', file_id: 'foreign' }],
+    });
+  });
+
+  it('only unlinks an attached file whose metadata record is gone', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['missing'],
+        attachedFileIds: ['missing'],
+        files: [],
+        toolResource: 'file_search',
+        userId,
+      }),
+    ).toEqual({
+      ownedFiles: [],
+      unlinkOnlyFiles: [{ tool_resource: 'file_search', file_id: 'missing' }],
+    });
+  });
+
+  it('does not treat an ownerless record as the caller’s', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['orphan'],
+        attachedFileIds: ['orphan'],
+        files: [input('orphan', null)],
+        toolResource: 'file_search',
+        userId,
+      }),
+    ).toEqual({
+      ownedFiles: [],
+      unlinkOnlyFiles: [{ tool_resource: 'file_search', file_id: 'orphan' }],
+    });
+  });
+
+  it('ignores files the tool resource does not hold', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['owned', 'elsewhere'],
+        attachedFileIds: ['owned'],
+        files: [owned, input('elsewhere', userId)],
+        toolResource: 'file_search',
+        userId,
+      }),
+    ).toEqual({ ownedFiles: [owned], unlinkOnlyFiles: [] });
+  });
+
+  it('splits a mixed request and counts each file once', () => {
+    expect(
+      partitionAgentResourceFiles({
+        requestedFileIds: ['owned', 'foreign', 'owned'],
+        attachedFileIds: ['owned', 'foreign'],
+        files: [owned, foreign],
+        toolResource: 'ocr',
+        userId,
+      }),
+    ).toEqual({
+      ownedFiles: [owned],
+      unlinkOnlyFiles: [{ tool_resource: 'ocr', file_id: 'foreign' }],
+    });
+  });
+});
+
+describe('delete agent resource files', () => {
+  const userId = 'user-1';
+
+  const makeDeps = (sharedFileIds: string[] = [], calls: string[] = []) => ({
+    getSharedResourceFileIds: jest.fn().mockResolvedValue(sharedFileIds),
+    removeAgentResourceFiles: jest.fn().mockImplementation(() => {
+      calls.push('unlink');
+      return Promise.resolve(undefined);
+    }),
+    deleteFiles: jest.fn().mockImplementation((files: TestFile[]) => {
+      calls.push('destroy');
+      return Promise.resolve({
+        deletedFileIds: files.map((file) => file.file_id),
+        failedFileIds: [],
+      });
+    }),
+  });
+
+  const run = (
+    files: Array<AgentResourceFileInput<TestFile>>,
+    deps: ReturnType<typeof makeDeps>,
+    attachedFileIds?: string[],
+  ) =>
+    deleteAgentResourceFiles(
+      {
+        agentId: 'agent_1',
+        agentObjectId: '65f000000000000000000001',
+        toolResource: 'file_search',
+        requestedFileIds: files.map((file) => file.file_id),
+        attachedFileIds: attachedFileIds ?? files.map((file) => file.file_id),
+        files,
+        userId,
+      },
+      deps,
+    );
+
+  it('destroys a file this agent was the last to reference', async () => {
+    const deps = makeDeps();
+    const result = await run([input('owned', userId)], deps);
+
+    expect(deps.deleteFiles).toHaveBeenCalledWith([{ file_id: 'owned', filename: 'owned.txt' }]);
+    expect(deps.removeAgentResourceFiles).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      outcome: { deletedFileIds: ['owned'], failedFileIds: [] },
+      unlinkedFileIds: [],
+      destroyedFileIds: ['owned'],
+    });
+  });
+
+  it('excludes the agent by a globally unique identity, not its logical id', async () => {
+    const deps = makeDeps();
+    await run([input('owned', userId)], deps);
+
+    expect(deps.getSharedResourceFileIds).toHaveBeenCalledWith({
+      file_ids: ['owned'],
+      excludeAgentObjectId: '65f000000000000000000001',
+      excludeToolResource: 'file_search',
+    });
+  });
+
+  it('keeps a file another agent still references, unlinking it here only', async () => {
+    const deps = makeDeps(['shared']);
+    const result = await run([input('shared', userId)], deps);
+
+    expect(deps.deleteFiles).not.toHaveBeenCalled();
+    expect(deps.removeAgentResourceFiles).toHaveBeenCalledWith({
+      agent_id: 'agent_1',
+      files: [{ tool_resource: 'file_search', file_id: 'shared' }],
+    });
+    expect(result).toEqual({
+      outcome: null,
+      unlinkedFileIds: ['shared'],
+      destroyedFileIds: [],
+    });
+  });
+
+  it('destroys the last-reference file and unlinks the shared one in the same request', async () => {
+    const deps = makeDeps(['shared']);
+    const result = await run([input('shared', userId), input('owned', userId)], deps);
+
+    expect(deps.deleteFiles).toHaveBeenCalledWith([{ file_id: 'owned', filename: 'owned.txt' }]);
+    expect(deps.removeAgentResourceFiles).toHaveBeenCalledWith({
+      agent_id: 'agent_1',
+      files: [{ tool_resource: 'file_search', file_id: 'shared' }],
+    });
+    expect(result.unlinkedFileIds).toEqual(['shared']);
+    expect(result.destroyedFileIds).toEqual(['owned']);
+  });
+
+  it('unlinks a file the caller does not own without asking to destroy it', async () => {
+    const deps = makeDeps();
+    const result = await run([input('foreign', 'user-2')], deps);
+
+    expect(deps.getSharedResourceFileIds).not.toHaveBeenCalled();
+    expect(deps.deleteFiles).not.toHaveBeenCalled();
+    expect(deps.removeAgentResourceFiles).toHaveBeenCalledWith({
+      agent_id: 'agent_1',
+      files: [{ tool_resource: 'file_search', file_id: 'foreign' }],
+    });
+    expect(result.outcome).toBeNull();
+  });
+
+  it('touches nothing when the tool resource holds none of the requested files', async () => {
+    const deps = makeDeps();
+    const result = await run([input('owned', userId)], deps, []);
+
+    expect(deps.getSharedResourceFileIds).not.toHaveBeenCalled();
+    expect(deps.removeAgentResourceFiles).not.toHaveBeenCalled();
+    expect(deps.deleteFiles).not.toHaveBeenCalled();
+    expect(result).toEqual({ outcome: null, unlinkedFileIds: [], destroyedFileIds: [] });
+  });
+
+  it('destroys before removing any reference, so a failed destroy leaves the file attached', async () => {
+    const calls: string[] = [];
+    const deps = makeDeps(['shared'], calls);
+    await run([input('shared', userId), input('owned', userId)], deps);
+
+    expect(calls).toEqual(['destroy', 'unlink']);
+  });
+
+  it('reports what the delete pass deleted rather than what it was handed', async () => {
+    const deps = makeDeps();
+    deps.deleteFiles.mockResolvedValue({
+      deletedFileIds: ['owned'],
+      failedFileIds: ['other-owned'],
+    });
+    const result = await run([input('owned', userId), input('other-owned', userId)], deps);
+
+    expect(result.destroyedFileIds).toEqual(['owned']);
+  });
+
+  it('passes a partial delete outcome back to the caller', async () => {
+    const deps = makeDeps();
+    deps.deleteFiles.mockResolvedValue({ deletedFileIds: [], failedFileIds: ['owned'] });
+    const result = await run([input('owned', userId)], deps);
+
+    expect(result.outcome).toEqual({ deletedFileIds: [], failedFileIds: ['owned'] });
+    expect(deps.removeAgentResourceFiles).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/api/src/files/deletion.ts b/packages/api/src/files/deletion.ts
index 92f176a23fb..c320814063a 100644
--- a/packages/api/src/files/deletion.ts
+++ b/packages/api/src/files/deletion.ts
@@ -6,6 +6,52 @@ export type FileDeletionOutcome = {
   failedFileIds?: string[];
 };
 
+/** The `{ tool_resource, file_id }` pair an agent resource unlink takes. */
+export type AgentResourceFileRef = {
+  tool_resource: string;
+  file_id: string;
+};
+
+/**
+ * One requested file, as this module needs to see it: an id, an owner already normalized to a
+ * plain string by the caller, and the opaque record the delete pass will be handed. Ownership
+ * arrives as a string so no storage type crosses into this package.
+ */
+export type AgentResourceFileInput<TFile> = {
+  file_id: string;
+  owner: string | null;
+  file: TFile;
+};
+
+export type AgentResourceDeletion<TFile> = {
+  /** Attached files the caller owns: candidates for storage, vector and metadata deletion. */
+  ownedFiles: Array<AgentResourceFileInput<TFile>>;
+  /** Attached files owned by someone else, or with no metadata left: unlink the association only. */
+  unlinkOnlyFiles: AgentResourceFileRef[];
+};
+
+export type AgentResourceDeletionDeps<TFile> = {
+  /** Which of these ids another agent still references; a shared file is never destroyed. */
+  getSharedResourceFileIds: (params: {
+    file_ids: string[];
+    excludeAgentObjectId: string;
+    excludeToolResource: string;
+  }) => Promise<string[]>;
+  removeAgentResourceFiles: (params: {
+    agent_id: string;
+    files: AgentResourceFileRef[];
+  }) => Promise<unknown>;
+  /** The full delete pass, injected: storage, vectors, metadata, and the unlink of what it deleted. */
+  deleteFiles: (files: TFile[]) => Promise<FileDeletionOutcome>;
+};
+
+export type AgentResourceDeletionResult = {
+  /** `null` when nothing was destroyed, so the caller answers with the unlink message. */
+  outcome: FileDeletionOutcome | null;
+  unlinkedFileIds: string[];
+  destroyedFileIds: string[];
+};
+
 export const PARTIAL_FILE_DELETION_MESSAGE = 'Some files could not be deleted';
 
 /**
@@ -25,3 +71,129 @@ export const buildDeleteFilesResponse = (
     failedFileIds,
   };
 };
+
+/**
+ * Splits the files a delete request names for one agent tool resource into the ones whose storage
+ * and embeddings may go with the unlink, and the ones only the association can be removed for.
+ *
+ * A file the caller owns is theirs to destroy, so it becomes a candidate for the full delete pass;
+ * a file that belongs to another user, or that no longer has a metadata record, keeps its bytes and
+ * its chunks and loses only its link to the agent. A file the request names but the tool resource
+ * does not hold appears in neither list.
+ */
+export const partitionAgentResourceFiles = <TFile>({
+  requestedFileIds,
+  attachedFileIds,
+  files,
+  toolResource,
+  userId,
+}: {
+  requestedFileIds: string[];
+  attachedFileIds: string[];
+  files: Array<AgentResourceFileInput<TFile>>;
+  toolResource: string;
+  userId: string;
+}): AgentResourceDeletion<TFile> => {
+  const attached = new Set(attachedFileIds);
+  const inputsById = new Map(files.map((input) => [input.file_id, input]));
+  const seen = new Set<string>();
+  const ownedFiles: Array<AgentResourceFileInput<TFile>> = [];
+  const unlinkOnlyFiles: AgentResourceFileRef[] = [];
+
+  for (const fileId of requestedFileIds) {
+    if (!attached.has(fileId) || seen.has(fileId)) {
+      continue;
+    }
+    seen.add(fileId);
+    const input = inputsById.get(fileId);
+    if (input != null && input.owner === userId) {
+      ownedFiles.push(input);
+      continue;
+    }
+    unlinkOnlyFiles.push({ tool_resource: toolResource, file_id: fileId });
+  }
+
+  return { ownedFiles, unlinkOnlyFiles };
+};
+
+/**
+ * Removes files from one agent tool resource, destroying only what this agent was the last holder
+ * of.
+ *
+ * Three outcomes, decided per file. A file the caller does not own is unlinked and left whole. A
+ * file the caller owns that any other `(agent, tool_resource)` pair still references is unlinked here
+ * and left whole too:
+ * duplicating an agent copies `file_ids` rather than the files behind them, so destroying the bytes
+ * would empty the other agent's knowledge without touching its configuration. Only a file the
+ * caller owns and this agent was the last to reference goes through the delete pass, which removes
+ * the storage, the vector chunks and the metadata, and unlinks exactly what it managed to delete.
+ */
+export const deleteAgentResourceFiles = async <TFile>(
+  {
+    agentId,
+    agentObjectId,
+    toolResource,
+    requestedFileIds,
+    attachedFileIds,
+    files,
+    userId,
+  }: {
+    agentId: string;
+    /** The agent's globally unique `_id`; `id` alone repeats across tenants. */
+    agentObjectId: string;
+    toolResource: string;
+    requestedFileIds: string[];
+    attachedFileIds: string[];
+    files: Array<AgentResourceFileInput<TFile>>;
+    userId: string;
+  },
+  deps: AgentResourceDeletionDeps<TFile>,
+): Promise<AgentResourceDeletionResult> => {
+  const { ownedFiles, unlinkOnlyFiles } = partitionAgentResourceFiles({
+    requestedFileIds,
+    attachedFileIds,
+    files,
+    toolResource,
+    userId,
+  });
+
+  const sharedFileIds =
+    ownedFiles.length === 0
+      ? new Set<string>()
+      : new Set(
+          await deps.getSharedResourceFileIds({
+            file_ids: ownedFiles.map((input) => input.file_id),
+            excludeAgentObjectId: agentObjectId,
+            excludeToolResource: toolResource,
+          }),
+        );
+
+  const destroyable: Array<AgentResourceFileInput<TFile>> = [];
+  const unlinkOnly = [...unlinkOnlyFiles];
+  for (const input of ownedFiles) {
+    if (sharedFileIds.has(input.file_id)) {
+      unlinkOnly.push({ tool_resource: toolResource, file_id: input.file_id });
+      continue;
+    }
+    destroyable.push(input);
+  }
+
+  /* The destroy runs before any reference is removed, and the delete pass strips the references of
+     the files it actually deleted. A reference removed ahead of a destroy that then fails is what
+     strands a file: it leaves the agent panel while its storage, chunks or metadata remain, and
+     neither this route nor the client's retry queue can name it again. */
+  const outcome =
+    destroyable.length === 0
+      ? null
+      : await deps.deleteFiles(destroyable.map((input) => input.file));
+
+  if (unlinkOnly.length > 0) {
+    await deps.removeAgentResourceFiles({ agent_id: agentId, files: unlinkOnly });
+  }
+
+  return {
+    outcome,
+    unlinkedFileIds: unlinkOnly.map((ref) => ref.file_id),
+    destroyedFileIds: outcome?.deletedFileIds ?? [],
+  };
+};
diff --git a/packages/api/src/files/encode/document.spec.ts b/packages/api/src/files/encode/document.spec.ts
index 295bafe7692..f58d591ed67 100644
--- a/packages/api/src/files/encode/document.spec.ts
+++ b/packages/api/src/files/encode/document.spec.ts
@@ -909,6 +909,53 @@ describe('encodeAndFormatDocuments - fileConfig integration', () => {
       expect(mockedGetFileStream).not.toHaveBeenCalled();
     });
 
+    it('should send textual documents as text parts to Claude through an OpenAI-compatible gateway', async () => {
+      const req = createMockRequest(30) as ServerRequest;
+      const file = createMockDocFile(1, 'text/plain', 'notes.txt');
+      mockedGetFileStream.mockResolvedValue({
+        file,
+        content: Buffer.from('hello from test').toString('base64'),
+        metadata: file,
+      });
+
+      const result = await encodeAndFormatDocuments(
+        req,
+        [file],
+        { provider: Providers.OPENAI, model: 'claude-auto-latest' },
+        mockStrategyFunctions,
+      );
+
+      expect(result.documents).toEqual([
+        { type: 'text', text: 'File: "notes.txt"\n\nhello from test' },
+      ]);
+      expect(result.files).toHaveLength(1);
+    });
+
+    it('should keep textual documents as file parts for non-Claude OpenAI models', async () => {
+      const req = createMockRequest(30) as ServerRequest;
+      const file = createMockDocFile(1, 'text/html', 'page.html');
+      const mockContent = Buffer.from('<p>hi</p>').toString('base64');
+      mockedGetFileStream.mockResolvedValue({
+        file,
+        content: mockContent,
+        metadata: file,
+      });
+
+      const result = await encodeAndFormatDocuments(
+        req,
+        [file],
+        { provider: Providers.OPENAI, model: 'gemini-auto-latest' },
+        mockStrategyFunctions,
+      );
+
+      expect(result.documents).toEqual([
+        {
+          type: 'file',
+          file: { filename: 'page.html', file_data: `data:text/html;base64,${mockContent}` },
+        },
+      ]);
+    });
+
     it('should retain XLSX support for non-Claude OpenAI models', async () => {
       const req = createMockRequest(30) as ServerRequest;
       const file = createMockDocFile(
diff --git a/packages/api/src/files/encode/document.ts b/packages/api/src/files/encode/document.ts
index 4ad0780ca64..57ef72db9a3 100644
--- a/packages/api/src/files/encode/document.ts
+++ b/packages/api/src/files/encode/document.ts
@@ -47,6 +47,17 @@ function getAnthropicDocumentSource(
   return null;
 }
 
+/**
+ * Whether the model behind this provider is Claude, which accepts only PDFs as base64
+ * documents. OpenAI-compatible gateways report an OpenAI-like provider for Claude models.
+ */
+function usesAnthropicDocumentCapabilities(provider: Providers, model?: string): boolean {
+  return (
+    provider === Providers.ANTHROPIC ||
+    (isOpenAILikeProvider(provider) && (model?.toLowerCase().includes('claude') ?? false))
+  );
+}
+
 /**
  * Formats a base64-encoded document into the appropriate provider-specific block.
  * Returns `null` when the provider has no matching handler.
@@ -57,6 +68,7 @@ function formatDocumentBlock(
   content: string,
   filename: string | undefined,
   useResponsesApi: boolean | undefined,
+  model?: string,
 ): DocumentBlock | null {
   if (provider === Providers.ANTHROPIC) {
     const source = getAnthropicDocumentSource(mimeType, content);
@@ -87,6 +99,19 @@ function formatDocumentBlock(
 
   const resolvedFilename = filename ?? 'document';
 
+  /* A gateway translates an OpenAI `file` part into a base64 document with the file's own
+   * media type, which Claude rejects for anything but PDF. Send textual files as text. */
+  if (
+    !useResponsesApi &&
+    isAnthropicTextDocumentType(mimeType) &&
+    usesAnthropicDocumentCapabilities(provider, model)
+  ) {
+    return {
+      type: 'text',
+      text: `File: "${resolvedFilename}"\n\n${Buffer.from(content, 'base64').toString('utf8')}`,
+    };
+  }
+
   if (useResponsesApi) {
     return {
       type: 'input_file',
@@ -123,11 +148,7 @@ function filterProviderDocumentFiles(
     return files.filter((file) => isBedrockDocumentType(file.type));
   }
 
-  const usesAnthropicDocumentCapabilities =
-    provider === Providers.ANTHROPIC ||
-    (isOpenAILikeProvider(provider) && model?.toLowerCase().includes('claude'));
-
-  if (!usesAnthropicDocumentCapabilities) {
+  if (!usesAnthropicDocumentCapabilities(provider, model)) {
     return files;
   }
 
@@ -283,6 +304,7 @@ export async function encodeAndFormatDocuments(
         content,
         file.filename,
         useResponsesApi,
+        model,
       );
       if (block) {
         result.documents.push(block);
@@ -302,6 +324,7 @@ export async function encodeAndFormatDocuments(
         content,
         file.filename,
         useResponsesApi,
+        model,
       );
       if (block) {
         result.documents.push(block);
diff --git a/packages/api/src/langfuse/prompt.spec.ts b/packages/api/src/langfuse/prompt.spec.ts
new file mode 100644
index 00000000000..28169d9a5fe
--- /dev/null
+++ b/packages/api/src/langfuse/prompt.spec.ts
@@ -0,0 +1,132 @@
+import { toTracePrompt, toTraceReply } from './prompt';
+
+const system = { role: 'system', content: 'S'.repeat(400) };
+const turn = (index: number) => [
+  { role: 'user', content: `question ${index}` },
+  {
+    role: 'assistant',
+    content: '',
+    tool_calls: [{ id: `call-${index}`, name: 'web_search', args: { query: `q${index}` } }],
+  },
+  { role: 'web_search', content: `result ${index}`, additional_kwargs: {} },
+];
+const conversation = (turns: number) => ({
+  messages: [system, ...Array.from({ length: turns }, (_, index) => turn(index)).flat()],
+  tools: [{ type: 'function', name: 'web_search' }, { function: { name: 'read_file' } }, {}],
+});
+
+describe('toTracePrompt', () => {
+  it('reads the conversation Langfuse stores as JSON text, in the application roles', () => {
+    const prompt = toTracePrompt(JSON.stringify(conversation(1)), 10_000);
+
+    expect(prompt).toEqual({
+      total: 4,
+      omitted: 0,
+      tools: ['web_search', 'read_file'],
+      messages: [
+        { role: 'system', text: { value: 'S'.repeat(400), truncated: false } },
+        { role: 'user', text: { value: 'question 0', truncated: false } },
+        {
+          role: 'assistant',
+          toolCalls: [{ name: 'web_search', args: { value: '{"query":"q0"}', truncated: false } }],
+        },
+        { role: 'tool', toolName: 'web_search', text: { value: 'result 0', truncated: false } },
+      ],
+    });
+  });
+
+  it('keeps the system message and the newest messages when the conversation outgrows the budget', () => {
+    const prompt = toTracePrompt(conversation(40), 200);
+
+    expect(prompt?.total).toBe(121);
+    expect(prompt?.messages[0]).toEqual({
+      role: 'system',
+      text: { value: 'S'.repeat(50), truncated: true },
+    });
+    expect(prompt?.messages[(prompt?.messages.length ?? 0) - 1]).toEqual({
+      role: 'tool',
+      toolName: 'web_search',
+      text: { value: 'result 39', truncated: false },
+    });
+    expect(prompt?.omitted).toBe(121 - (prompt?.messages.length ?? 0));
+    expect(prompt?.omitted).toBeGreaterThan(100);
+    const spent = (prompt?.messages ?? []).reduce(
+      (total, message) => total + (message.text?.value.length ?? 0),
+      0,
+    );
+    expect(spent).toBeLessThanOrEqual(200);
+  });
+
+  it('bounds one long message alone so it cannot hide the messages before it', () => {
+    const prompt = toTracePrompt(
+      [
+        { role: 'user', content: 'first' },
+        { role: 'assistant', content: 'A'.repeat(1000) },
+      ],
+      400,
+    );
+
+    expect(prompt?.messages).toEqual([
+      { role: 'user', text: { value: 'first', truncated: false } },
+      { role: 'assistant', text: { value: 'A'.repeat(100), truncated: true } },
+    ]);
+  });
+
+  it('joins text parts and names the parts that are not text', () => {
+    const prompt = toTracePrompt(
+      [
+        {
+          type: 'human',
+          content: [
+            { type: 'text', text: 'Look at this' },
+            { type: 'image_url', image_url: { url: 'data:image/png;base64,AAAA' } },
+            { type: 'text', text: 'and this.' },
+          ],
+        },
+      ],
+      1000,
+    );
+
+    expect(prompt?.messages).toEqual([
+      {
+        role: 'user',
+        text: { value: 'Look at this\nand this.', truncated: false },
+        attachments: ['image_url'],
+      },
+    ]);
+  });
+
+  it('returns nothing for input that is not a conversation', () => {
+    expect(toTracePrompt('plain text prompt', 100)).toBeUndefined();
+    expect(toTracePrompt('{"messages":', 100)).toBeUndefined();
+    expect(toTracePrompt({ question: 'hi' }, 100)).toBeUndefined();
+    expect(toTracePrompt([], 100)).toBeUndefined();
+    expect(toTracePrompt([1, 'two', null], 100)).toBeUndefined();
+    expect(toTracePrompt(undefined, 100)).toBeUndefined();
+  });
+});
+
+describe('toTraceReply', () => {
+  it('reads the message a model call wrote, with the tools it asked for', () => {
+    expect(
+      toTraceReply(
+        JSON.stringify({
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Let me check.', index: 0 }],
+          tool_calls: [{ type: 'function', function: { name: 'read_file', arguments: '{"p":1}' } }],
+        }),
+        1000,
+      ),
+    ).toEqual({
+      role: 'assistant',
+      text: { value: 'Let me check.', truncated: false },
+      toolCalls: [{ name: 'read_file', args: { value: '{"p":1}', truncated: false } }],
+    });
+  });
+
+  it('returns nothing for output that is not an assistant message', () => {
+    expect(toTraceReply('short', 100)).toBeUndefined();
+    expect(toTraceReply({ role: 'user', content: 'hi' }, 100)).toBeUndefined();
+    expect(toTraceReply({ role: 'assistant', content: '' }, 100)).toBeUndefined();
+  });
+});
diff --git a/packages/api/src/langfuse/prompt.ts b/packages/api/src/langfuse/prompt.ts
new file mode 100644
index 00000000000..0b8ee1675c3
--- /dev/null
+++ b/packages/api/src/langfuse/prompt.ts
@@ -0,0 +1,224 @@
+import type {
+  TTracePrompt,
+  TTraceMessage,
+  TTraceContent,
+  TTraceToolCall,
+  TTraceMessageRole,
+} from 'librechat-data-provider';
+
+/** Shares of the content budget: the system message may not crowd out the turns the call answered. */
+const SYSTEM_SHARE = 0.25;
+const MESSAGE_SHARE = 0.25;
+const MAX_TOOL_CALLS = 64;
+const MAX_TOOL_NAMES = 128;
+const MAX_ATTACHMENTS = 16;
+const NAME_MAX_LENGTH = 256;
+
+const ROLES: Record<string, TTraceMessageRole> = {
+  system: 'system',
+  developer: 'system',
+  user: 'user',
+  human: 'user',
+  assistant: 'assistant',
+  ai: 'assistant',
+  tool: 'tool',
+  function: 'tool',
+};
+
+type Json = string | number | boolean | null | Json[] | { [key: string]: Json };
+type JsonObject = { [key: string]: Json };
+
+function isObject(value: Json | undefined): value is JsonObject {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** Langfuse returns a generation's input and output as JSON text; an SDK may also hand back the value. */
+function parse(value: unknown): Json | undefined {
+  if (typeof value !== 'string') {
+    return value as Json | undefined;
+  }
+  const trimmed = value.trimStart();
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(value) as Json;
+  } catch {
+    return undefined;
+  }
+}
+
+function bounded(text: string, maxLength: number): TTraceContent | undefined {
+  if (text === '') {
+    return undefined;
+  }
+  return text.length > maxLength
+    ? { value: text.slice(0, maxLength), truncated: true }
+    : { value: text, truncated: false };
+}
+
+function name(value: Json | undefined): string | undefined {
+  return typeof value === 'string' && value !== '' ? value.slice(0, NAME_MAX_LENGTH) : undefined;
+}
+
+/** A message's text and the types of its parts that are not text. */
+function contentOf(content: Json | undefined): { text: string; attachments: string[] } {
+  if (typeof content === 'string') {
+    return { text: content, attachments: [] };
+  }
+  if (!Array.isArray(content)) {
+    return { text: '', attachments: [] };
+  }
+  const texts: string[] = [];
+  const attachments: string[] = [];
+  for (const part of content) {
+    if (typeof part === 'string') {
+      texts.push(part);
+      continue;
+    }
+    if (!isObject(part)) {
+      continue;
+    }
+    if (typeof part.text === 'string') {
+      texts.push(part.text);
+      continue;
+    }
+    const type = name(part.type);
+    if (type != null && attachments.length < MAX_ATTACHMENTS) {
+      attachments.push(type);
+    }
+  }
+  return { text: texts.join('\n'), attachments };
+}
+
+function toolCallsOf(calls: Json | undefined, maxLength: number): TTraceToolCall[] {
+  if (!Array.isArray(calls)) {
+    return [];
+  }
+  const result: TTraceToolCall[] = [];
+  for (const call of calls) {
+    if (result.length === MAX_TOOL_CALLS || !isObject(call)) {
+      continue;
+    }
+    const fn = isObject(call.function) ? call.function : undefined;
+    const callName = name(call.name) ?? name(fn?.name);
+    if (callName == null) {
+      continue;
+    }
+    const rawArgs = call.args ?? fn?.arguments;
+    const args =
+      rawArgs == null
+        ? undefined
+        : bounded(typeof rawArgs === 'string' ? rawArgs : JSON.stringify(rawArgs), maxLength);
+    result.push({ name: callName, ...(args ? { args } : {}) });
+  }
+  return result;
+}
+
+/**
+ * One message in the application's terms. A tool's answer is recorded under the
+ * tool's own name as its role, so a role that is none of the known ones is a
+ * tool message from that tool.
+ */
+function toMessage(value: Json, maxLength: number): TTraceMessage | undefined {
+  if (!isObject(value)) {
+    return undefined;
+  }
+  const rawRole = name(value.role) ?? name(value.type);
+  if (rawRole == null) {
+    return undefined;
+  }
+  const known = ROLES[rawRole.toLowerCase()];
+  const role = known ?? 'tool';
+  const { text, attachments } = contentOf(value.content);
+  const content = bounded(text, maxLength);
+  const toolCalls = role === 'assistant' ? toolCallsOf(value.tool_calls, maxLength) : [];
+  const toolName =
+    role === 'tool' ? (name(value.name) ?? (known == null ? rawRole : undefined)) : undefined;
+  return {
+    role,
+    ...(content ? { text: content } : {}),
+    ...(toolName != null ? { toolName } : {}),
+    ...(toolCalls.length > 0 ? { toolCalls } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+  };
+}
+
+function costOf(message: TTraceMessage): number {
+  let cost = message.text?.value.length ?? 0;
+  for (const call of message.toolCalls ?? []) {
+    cost += call.name.length + (call.args?.value.length ?? 0);
+  }
+  return cost;
+}
+
+function messagesOf(parsed: Json | undefined): Json | undefined {
+  return isObject(parsed) ? parsed.messages : undefined;
+}
+
+/**
+ * Reads a model call's input as a conversation within `maxLength` characters.
+ * Cutting the raw input at its front keeps only the start of the system message
+ * of a long conversation, so the budget goes to the system message first (a
+ * share of it) and then to the newest messages backwards, each bounded alone.
+ */
+export function toTracePrompt(input: unknown, maxLength: number): TTracePrompt | undefined {
+  const parsed = parse(input);
+  const list = Array.isArray(parsed) ? parsed : messagesOf(parsed);
+  if (!Array.isArray(list) || list.length === 0) {
+    return undefined;
+  }
+  const perMessage = Math.max(1, Math.floor(maxLength * MESSAGE_SHARE));
+  const first = toMessage(list[0], Math.max(1, Math.floor(maxLength * SYSTEM_SHARE)));
+  const system = first?.role === 'system' ? first : undefined;
+  const oldest = system ? 1 : 0;
+  let remaining = maxLength - (system ? costOf(system) : 0);
+  const newest: TTraceMessage[] = [];
+  let index = list.length - 1;
+  for (; index >= oldest && remaining > 0; index--) {
+    const message = toMessage(list[index], Math.min(perMessage, remaining));
+    if (message == null) {
+      continue;
+    }
+    remaining -= costOf(message);
+    newest.push(message);
+  }
+  const messages = [...(system ? [system] : []), ...newest.reverse()];
+  if (messages.length === 0) {
+    return undefined;
+  }
+  const tools = isObject(parsed) && Array.isArray(parsed.tools) ? toolNamesOf(parsed.tools) : [];
+  return {
+    messages,
+    total: list.length,
+    omitted: index - oldest + 1,
+    ...(tools.length > 0 ? { tools } : {}),
+  };
+}
+
+function toolNamesOf(tools: Json[]): string[] {
+  const names: string[] = [];
+  for (const tool of tools) {
+    if (names.length === MAX_TOOL_NAMES || !isObject(tool)) {
+      continue;
+    }
+    const fn = isObject(tool.function) ? tool.function : undefined;
+    const toolName = name(tool.name) ?? name(fn?.name);
+    if (toolName != null) {
+      names.push(toolName);
+    }
+  }
+  return names;
+}
+
+/** Reads a model call's output as the message it wrote, when it is one. */
+export function toTraceReply(output: unknown, maxLength: number): TTraceMessage | undefined {
+  const parsed = parse(output);
+  if (!isObject(parsed)) {
+    return undefined;
+  }
+  const message = toMessage(parsed, maxLength);
+  return message?.role === 'assistant' && (message.text != null || message.toolCalls != null)
+    ? message
+    : undefined;
+}
diff --git a/packages/api/src/langfuse/reader.spec.ts b/packages/api/src/langfuse/reader.spec.ts
index 18006fc0540..1236aa7eca2 100644
--- a/packages/api/src/langfuse/reader.spec.ts
+++ b/packages/api/src/langfuse/reader.spec.ts
@@ -1021,6 +1021,7 @@ describe('createLangfuseTraceReader', () => {
           messageId: 'response-1',
           parentId: null,
           kind: 'agent',
+          role: 'run',
           name: 'AgentGraph',
           startTime: '2026-09-12T11:30:00.000Z',
           endTime: '2026-09-12T11:30:05.000Z',
@@ -1032,6 +1033,7 @@ describe('createLangfuseTraceReader', () => {
           messageId: 'response-1',
           parentId: 'obs-root',
           kind: 'generation',
+          role: 'model',
           name: 'llm',
           model: 'claude-haiku-4-5',
           startTime: '2026-09-12T11:30:00.000Z',
@@ -1064,6 +1066,7 @@ describe('createLangfuseTraceReader', () => {
           messageId: 'response-1',
           parentId: 'obs-root',
           kind: 'span',
+          role: 'tools',
           name: 'tool-dispatch',
           startTime: '2026-09-12T11:30:00.000Z',
           endTime: '2026-09-12T11:30:05.000Z',
@@ -1373,6 +1376,48 @@ describe('createLangfuseTraceReader', () => {
       });
     });
 
+    it('reads a model call as a conversation, and only a model call', async () => {
+      const io = {
+        input:
+          '{"messages":[{"role":"system","content":"Be brief."},{"role":"user","content":"hello"}]}',
+        output: '{"role":"assistant","content":[{"type":"text","text":"Hi."}]}',
+      };
+      const settings = resolveTraceViewerConfig({ enabled: true, showInputOutput: true });
+      const { reader } = setup({
+        responses: [
+          jsonResponse({ data: [observation({ id: 'obs-llm', type: 'GENERATION', ...io })] }),
+          jsonResponse({ data: [observation(io)] }),
+        ],
+      });
+
+      const modelCall = await reader.getRecord({
+        ...createQuery({ settings }),
+        recordId: 'obs-llm',
+        messageId: 'response-1',
+      });
+      const wrapper = await reader.getRecord({
+        ...createQuery({ settings }),
+        recordId: 'obs-root',
+        messageId: 'response-1',
+      });
+
+      expect(modelCall?.prompt).toEqual({
+        total: 2,
+        omitted: 0,
+        messages: [
+          { role: 'system', text: { value: 'Be brief.', truncated: false } },
+          { role: 'user', text: { value: 'hello', truncated: false } },
+        ],
+      });
+      expect(modelCall?.reply).toEqual({
+        role: 'assistant',
+        text: { value: 'Hi.', truncated: false },
+      });
+      expect(modelCall?.input?.value).toBe(io.input);
+      expect(wrapper?.prompt).toBeUndefined();
+      expect(wrapper?.reply).toBeUndefined();
+    });
+
     it('keeps literal strings that spell an empty object or null', async () => {
       const { reader } = setup({
         responses: [
diff --git a/packages/api/src/langfuse/reader.ts b/packages/api/src/langfuse/reader.ts
index 422781d8fef..fac7bd47960 100644
--- a/packages/api/src/langfuse/reader.ts
+++ b/packages/api/src/langfuse/reader.ts
@@ -16,11 +16,13 @@ import type {
 import type { LangfuseScoreDestination } from './destinations';
 import type { TraceQuery, TraceReader } from '~/traces/types';
 import { exportsInternalTraceUserId } from './identity';
+import { toTracePrompt, toTraceReply } from './prompt';
 import { getScoreDestinations } from './destinations';
 import { TraceReadError } from '~/traces/types';
 import { mergeHeaders } from '~/utils/headers';
 import { redirectPolicyFor } from './utils';
 import { traceIdForMessage } from './trace';
+import { resolveTraceRole } from './roles';
 
 const OBSERVATIONS_PATH = '/api/public/v2/observations';
 const MAX_PAGE_SIZE = 1000;
@@ -184,12 +186,14 @@ function toRecord(
   const model = (observation.model ?? observation.providedModelName)?.trim();
   const usage = toUsage(observation.usageDetails);
   const cost = toCost(observation);
+  const kind = KIND_BY_TYPE[type] ?? 'span';
   return {
     id: observation.id,
     traceId: observation.traceId,
     messageId,
     parentId: observation.parentObservationId || null,
-    kind: KIND_BY_TYPE[type] ?? 'span',
+    kind,
+    ...resolveTraceRole(kind, name),
     name: clamp(name, NAME_MAX_LENGTH),
     startTime: new Date(observation.startTime).toISOString(),
     status,
@@ -1088,9 +1092,14 @@ export function createLangfuseTraceReader({
       const input = toContent(observation.input, maxLength);
       const output = toContent(observation.output, maxLength);
       const metadata = toContent(observation.metadata, maxLength);
+      const isModelCall = record.kind === 'generation';
+      const prompt = isModelCall ? toTracePrompt(observation.input, maxLength) : undefined;
+      const reply = isModelCall ? toTraceReply(observation.output, maxLength) : undefined;
       return {
         record,
         contentAvailable: true,
+        ...(prompt ? { prompt } : {}),
+        ...(reply ? { reply } : {}),
         ...(input ? { input } : {}),
         ...(output ? { output } : {}),
         ...(metadata ? { metadata } : {}),
diff --git a/packages/api/src/langfuse/roles.spec.ts b/packages/api/src/langfuse/roles.spec.ts
new file mode 100644
index 00000000000..183dcb1e701
--- /dev/null
+++ b/packages/api/src/langfuse/roles.spec.ts
@@ -0,0 +1,37 @@
+import { resolveTraceRole } from './roles';
+
+describe('resolveTraceRole', () => {
+  it('names the run, its saved agent and the wrappers around a model call', () => {
+    expect(resolveTraceRole('agent', 'AgentGraph')).toEqual({ role: 'run' });
+    expect(resolveTraceRole('agent', 'MultiAgentGraph')).toEqual({ role: 'run' });
+    expect(resolveTraceRole('span', 'agent_ZwXQuP527oibHg8S2qNV3')).toEqual({
+      role: 'agent',
+      agentId: 'agent_ZwXQuP527oibHg8S2qNV3',
+    });
+    expect(resolveTraceRole('agent', 'agent')).toEqual({ role: 'plumbing' });
+    expect(resolveTraceRole('span', 'AgentModelCall')).toEqual({ role: 'plumbing' });
+    expect(resolveTraceRole('span', 'prompt')).toEqual({ role: 'plumbing' });
+    expect(resolveTraceRole('span', 'tool-dispatch')).toEqual({ role: 'tools' });
+  });
+
+  it('tells the model calls that wrote activity labels from the ones that answered', () => {
+    expect(resolveTraceRole('generation', 'StepLabel')).toEqual({ role: 'stepLabel' });
+    expect(resolveTraceRole('generation', 'ReasoningLabel')).toEqual({ role: 'reasoningLabel' });
+    expect(resolveTraceRole('generation', 'MultiStepLabelGeneration')).toEqual({
+      role: 'phaseLabel',
+    });
+    expect(resolveTraceRole('span', 'MultiStepLabel')).toEqual({ role: 'plumbing' });
+    expect(resolveTraceRole('generation', 'llm')).toEqual({ role: 'model' });
+    expect(resolveTraceRole('generation', 'ChatOpenAI')).toEqual({});
+    expect(resolveTraceRole('span', 'llm')).toEqual({});
+  });
+
+  it('gives no role to a name a deployment or a tool chose', () => {
+    expect(resolveTraceRole('tool', 'tool-dispatch')).toEqual({});
+    expect(resolveTraceRole('tool', 'agent_lookup')).toEqual({});
+    expect(resolveTraceRole('generation', 'agent_ZwXQuP527oibHg8S2qNV3')).toEqual({});
+    expect(resolveTraceRole('generation', 'AgentGraph')).toEqual({});
+    expect(resolveTraceRole('span', 'StepLabel')).toEqual({});
+    expect(resolveTraceRole('span', 'My Research Agent')).toEqual({});
+  });
+});
diff --git a/packages/api/src/langfuse/roles.ts b/packages/api/src/langfuse/roles.ts
new file mode 100644
index 00000000000..6a61a1aaa15
--- /dev/null
+++ b/packages/api/src/langfuse/roles.ts
@@ -0,0 +1,59 @@
+import {
+  ACTIVITY_LABEL_RUN_NAME,
+  ACTIVITY_PHASE_RUN_NAME,
+  STANDARD_GRAPH_RUN_NAME,
+  REASONING_LABEL_RUN_NAME,
+  AGENT_MODEL_CALL_RUN_NAME,
+  MULTI_AGENT_GRAPH_RUN_NAME,
+  ACTIVITY_PHASE_LABEL_RUN_NAME,
+} from '@librechat/agents';
+import type { TTraceRecord, TTraceRecordRole } from 'librechat-data-provider';
+
+/** Span names the agents SDK assigns while shaping a trace for export, which it does not export. */
+const AGENT_NODE_NAME = 'agent';
+const PROMPT_NAME = 'prompt';
+const MODEL_CALL_NAME = 'llm';
+const TOOL_DISPATCH_NAME = 'tool-dispatch';
+/** The SDK names an agent's workflow node with the saved agent's bare id. */
+const SAVED_AGENT_ID = /^agent_[A-Za-z0-9_-]+$/;
+
+const ROLE_BY_NAME: Record<string, TTraceRecordRole> = {
+  [STANDARD_GRAPH_RUN_NAME]: 'run',
+  [MULTI_AGENT_GRAPH_RUN_NAME]: 'run',
+  [AGENT_NODE_NAME]: 'plumbing',
+  [AGENT_MODEL_CALL_RUN_NAME]: 'plumbing',
+  [PROMPT_NAME]: 'plumbing',
+  [ACTIVITY_PHASE_RUN_NAME]: 'plumbing',
+  [MODEL_CALL_NAME]: 'model',
+  [TOOL_DISPATCH_NAME]: 'tools',
+  [ACTIVITY_LABEL_RUN_NAME]: 'stepLabel',
+  [REASONING_LABEL_RUN_NAME]: 'reasoningLabel',
+  [ACTIVITY_PHASE_LABEL_RUN_NAME]: 'phaseLabel',
+};
+
+/** A tool or a model call may carry any name a deployment gave it, so only the SDK's own spans have a role. */
+const NAMED_BY_SDK: ReadonlySet<TTraceRecord['kind']> = new Set(['agent', 'span', 'generation']);
+const MODEL_CALL_ROLES: ReadonlySet<TTraceRecordRole> = new Set([
+  'model',
+  'stepLabel',
+  'reasoningLabel',
+  'phaseLabel',
+]);
+
+/** What a record did in the run, read from the names the agents SDK gives the spans it exports. */
+export function resolveTraceRole(
+  kind: TTraceRecord['kind'],
+  name: string,
+): Pick<TTraceRecord, 'role' | 'agentId'> {
+  if (!NAMED_BY_SDK.has(kind)) {
+    return {};
+  }
+  if (kind !== 'generation' && SAVED_AGENT_ID.test(name)) {
+    return { role: 'agent', agentId: name };
+  }
+  const role = ROLE_BY_NAME[name];
+  if (role == null || (kind === 'generation') !== MODEL_CALL_ROLES.has(role)) {
+    return {};
+  }
+  return { role };
+}
diff --git a/packages/api/src/mcp/MCPConnectionFactory.ts b/packages/api/src/mcp/MCPConnectionFactory.ts
index 07fa1b41145..1b8be2a2dd3 100644
--- a/packages/api/src/mcp/MCPConnectionFactory.ts
+++ b/packages/api/src/mcp/MCPConnectionFactory.ts
@@ -1553,6 +1553,34 @@ export class MCPConnectionFactory {
     return true;
   }
 
+  /**
+   * Whether the server rejected the tokens a silent refresh issued during this connection attempt,
+   * and they are still the stored credential. A provider can keep refreshing a grant its resource
+   * server no longer accepts, so refreshing again would repeat the rejection on every connect
+   * attempt and never ask the user to authorize. Tokens another request stored since then are not
+   * a rejected renewal; the refresh path adopts them.
+   */
+  private async isRejectedRenewal(
+    renewed: MCPOAuthTokens,
+    rejectedCredentialSetId: string | null,
+  ): Promise<boolean> {
+    if (!this.tokenMethods?.findToken) {
+      return false;
+    }
+    if ((renewed.credential_set_id ?? null) !== rejectedCredentialSetId) {
+      return false;
+    }
+    return this.runWithCapturedTenant(() =>
+      MCPTokenStorage.isCurrentAccessToken({
+        userId: this.userId!,
+        serverName: this.serverName,
+        accessToken: renewed.access_token,
+        credentialSetId: renewed.credential_set_id,
+        findToken: this.tokenMethods!.findToken!,
+      }),
+    );
+  }
+
   private getOAuthReplayExpiresAt(createdAt?: number): number | undefined {
     if (!createdAt) {
       return undefined;
@@ -1662,6 +1690,8 @@ export class MCPConnectionFactory {
     const isRequestRecovery = eventName === 'oauthReauthenticationRequired';
     let recoveryPhase: OAuthRecoveryPhase = 'silent-refresh';
     let eventHandling: Promise<void> | null = null;
+    /** Tokens a silent refresh issued while this connection was being established. */
+    let renewedTokens: MCPOAuthTokens | null = null;
 
     const handleOAuthEvent = async (data: OAuthRequiredEvent) => {
       logger.info(`${this.logPrefix} oauthRequired event received`);
@@ -1704,7 +1734,15 @@ export class MCPConnectionFactory {
 
       if (!isRequestRecovery || recoveryPhase === 'silent-refresh') {
         recoveryPhase = 'interactive';
-        if (!data.skipSilentRefresh && this.shouldAttemptSilentTokenRefresh(data)) {
+        if (
+          !isRequestRecovery &&
+          renewedTokens != null &&
+          (await this.isRejectedRenewal(renewedTokens, rejectedCredentialSetId))
+        ) {
+          logger.info(
+            `${this.logPrefix} Server rejected the tokens a silent refresh just issued; starting interactive OAuth`,
+          );
+        } else if (!data.skipSilentRefresh && this.shouldAttemptSilentTokenRefresh(data)) {
           let refreshedTokens: MCPOAuthTokens | null;
           try {
             refreshedTokens = await this.attemptSilentTokenRefresh(rejectedCredentialSetId);
@@ -1727,6 +1765,9 @@ export class MCPConnectionFactory {
             return;
           }
           if (refreshedTokens) {
+            if (!isRequestRecovery) {
+              renewedTokens = refreshedTokens;
+            }
             connection.setOAuthTokens(refreshedTokens);
             connection.emit('oauthHandled', 'silent-refresh' satisfies t.OAuthHandledSource);
             return;
diff --git a/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts b/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
index 95e17af2132..07aff464b52 100644
--- a/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPConnectionFactory.oauthSdk.integration.test.ts
@@ -495,6 +495,53 @@ describe('MCPConnectionFactory OAuth against real SDK Streamable HTTP server', (
     }
   });
 
+  it('starts OAuth once the resource rejects the tokens a refresh issued while connecting', async () => {
+    server = await createOAuthMCPServer({
+      issueRefreshTokens: true,
+      requireResourceParameter: true,
+      tokenScopes: ['read'],
+      scopesSupported: ['read'],
+      rejectRefreshTokens: 10,
+    });
+    const initialTokens = await issueTokens(server);
+    await storeTokens(tokenStore, server, initialTokens);
+    server.issuedTokens.delete(initialTokens.access_token);
+
+    const oauthStart = jest.fn(async (_authorizationUrl: string): Promise<void> => undefined);
+    await expect(
+      MCPConnectionFactory.create(
+        {
+          serverName: SERVER_NAME,
+          serverConfig: {
+            type: 'streamable-http',
+            url: server.url,
+            initTimeout: 15000,
+          },
+        },
+        {
+          useOAuth: true,
+          user: { id: USER_ID } as IUser,
+          flowManager: createFlowManager(),
+          tokenMethods: {
+            findToken: tokenStore.findToken,
+            createToken: tokenStore.createToken,
+            updateToken: tokenStore.updateToken,
+            deleteTokens: tokenStore.deleteTokens,
+          },
+          returnOnOAuth: true,
+          oauthStart,
+        },
+      ),
+    ).rejects.toThrow();
+
+    expect(
+      server.tokenRequests.filter((request) => request.grantType === 'refresh_token'),
+    ).toHaveLength(1);
+    expect(oauthStart).toHaveBeenCalledTimes(1);
+    const authorizationUrl = new URL(oauthStart.mock.calls[0][0]);
+    expect(authorizationUrl.searchParams.get('resource')).toBe(server.resourceUrl);
+  });
+
   it('does not silently refresh an SDK insufficient_scope challenge before starting OAuth', async () => {
     server = await createOAuthMCPServer({
       issueRefreshTokens: true,
diff --git a/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts b/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
index 674ac4f6164..787270c1dd8 100644
--- a/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
+++ b/packages/api/src/mcp/__tests__/MCPConnectionFactory.test.ts
@@ -2156,6 +2156,117 @@ describe('MCPConnectionFactory', () => {
       expect(oauthOptions.oauthStart).not.toHaveBeenCalled();
     });
 
+    describe('when the server rejects the tokens a silent refresh issued', () => {
+      const renewedTokens: MCPOAuthTokens = {
+        access_token: 'renewed-access',
+        refresh_token: 'refresh123',
+        token_type: 'Bearer',
+        obtained_at: Date.now(),
+        credential_set_id: 'grant-1',
+      };
+      const challenge = {
+        serverUrl: 'https://api.example.com',
+        rejectedCredentialSetId: 'grant-1',
+      };
+
+      async function captureEstablishmentHandler(oauthStart: jest.Mock) {
+        let oauthRequiredHandler: ((data: Record<string, unknown>) => Promise<void>) | undefined;
+        mockConnectionInstance.on.mockImplementation((event, handler) => {
+          if (event === 'oauthRequired') {
+            oauthRequiredHandler = handler as (data: Record<string, unknown>) => Promise<void>;
+          }
+          return mockConnectionInstance;
+        });
+        mockConnectionInstance.isConnected.mockResolvedValue(false);
+        mockMCPOAuthHandler.generateFlowId.mockReturnValue('flow123');
+        mockMCPTokenStorage.forceRefreshTokens.mockResolvedValue(renewedTokens);
+        mockMCPOAuthHandler.initiateOAuthFlow.mockResolvedValue({
+          authorizationUrl: 'https://auth.example.com',
+          flowId: 'flow123',
+          flowMetadata: {
+            serverName: 'test-server',
+            userId: 'user123',
+            serverUrl: 'https://api.example.com',
+            state: 'random-state',
+          },
+        });
+        mockFlowManager.getFlowState.mockResolvedValue(null);
+        mockFlowManager.createFlow.mockReturnValue(new Promise(() => {}));
+
+        try {
+          await MCPConnectionFactory.create(
+            {
+              serverName: 'test-server',
+              serverConfig: {
+                ...mockServerConfig,
+                url: 'https://api.example.com',
+                type: 'sse' as const,
+              } as t.SSEOptions,
+            },
+            {
+              useOAuth: true,
+              user: mockUser,
+              flowManager: mockFlowManager,
+              returnOnOAuth: true,
+              oauthStart,
+              tokenMethods: {
+                findToken: jest.fn(),
+                createToken: jest.fn(),
+                updateToken: jest.fn(),
+                deleteTokens: jest.fn(),
+              },
+            },
+          );
+        } catch {
+          // Expected: the mocked connection never reports connected
+        }
+        return oauthRequiredHandler!;
+      }
+
+      it('starts interactive OAuth instead of refreshing the rejected renewal again', async () => {
+        const oauthStart = jest.fn();
+        const handler = await captureEstablishmentHandler(oauthStart);
+
+        await handler(challenge);
+        await handler(challenge);
+
+        expect(mockMCPTokenStorage.forceRefreshTokens).toHaveBeenCalledTimes(1);
+        expect(mockMCPTokenStorage.isCurrentAccessToken).toHaveBeenCalledWith(
+          expect.objectContaining({ accessToken: 'renewed-access', credentialSetId: 'grant-1' }),
+        );
+        expect(mockConnectionInstance.emit).toHaveBeenCalledWith('oauthHandled', 'silent-refresh');
+        expect(oauthStart).toHaveBeenCalledWith('https://auth.example.com');
+        expect(mockConnectionInstance.emit).toHaveBeenCalledWith(
+          'oauthFailed',
+          expect.objectContaining({ message: 'OAuth flow initiated - return early' }),
+        );
+      });
+
+      it('refreshes again when another request replaced the renewal', async () => {
+        const oauthStart = jest.fn();
+        const handler = await captureEstablishmentHandler(oauthStart);
+        mockMCPTokenStorage.isCurrentAccessToken.mockResolvedValue(false);
+
+        await handler(challenge);
+        await handler(challenge);
+
+        expect(mockMCPTokenStorage.forceRefreshTokens).toHaveBeenCalledTimes(2);
+        expect(mockMCPOAuthHandler.initiateOAuthFlow).not.toHaveBeenCalled();
+        expect(oauthStart).not.toHaveBeenCalled();
+      });
+
+      it('refreshes a credential set the renewal did not issue', async () => {
+        const oauthStart = jest.fn();
+        const handler = await captureEstablishmentHandler(oauthStart);
+
+        await handler(challenge);
+        await handler({ ...challenge, rejectedCredentialSetId: 'grant-2' });
+
+        expect(mockMCPTokenStorage.forceRefreshTokens).toHaveBeenCalledTimes(2);
+        expect(oauthStart).not.toHaveBeenCalled();
+      });
+    });
+
     it('should fall back to interactive OAuth when silent refresh throws unexpectedly', async () => {
       const sseConfig = {
         ...mockServerConfig,
diff --git a/packages/api/src/skills/__tests__/import.test.ts b/packages/api/src/skills/__tests__/import.test.ts
index 54de9be3971..33eeb7b6c12 100644
--- a/packages/api/src/skills/__tests__/import.test.ts
+++ b/packages/api/src/skills/__tests__/import.test.ts
@@ -22,6 +22,13 @@ interface ImportSummary {
   errors: Array<{ path: string; status: 'ok' | 'error'; error?: string }>;
 }
 
+interface ImportFailure {
+  error: string;
+  message: string;
+  failedFiles: Array<{ path: string; reason: string; limitMb?: number }>;
+  skillId?: string;
+}
+
 function mockAppConfig(filters: FiltersConfig): NonNullable<ImportRequest['config']> {
   return {
     config: {},
@@ -57,9 +64,15 @@ function mockImportDeps(limits?: ImportSkillDeps['limits']): ImportSkillDeps {
     limits,
     createSkill: jest.fn(async () => ({ skill }) as unknown as CreateSkillResult),
     getSkillById: jest.fn(async () => skill),
-    deleteSkill: jest.fn(async () => ({ deleted: true })),
+    deleteSkill: jest.fn(async () => ({
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: true,
+      failedCleanupSteps: [],
+    })),
     upsertSkillFile: jest.fn(async () => skillFile),
     saveBuffer: jest.fn(async () => ({ filepath: '/tmp/imported-file', source: 'local' })),
+    deleteFile: jest.fn(async () => undefined),
     grantPermission: jest.fn(async () => undefined),
   };
 }
@@ -119,6 +132,10 @@ function importSummary(body: unknown): ImportSummary {
   return (body as { _importSummary: ImportSummary })._importSummary;
 }
 
+function importFailure(body: unknown): ImportFailure {
+  return body as ImportFailure;
+}
+
 async function zipWithAdditionalFiles(fileCount: number, fileBytes: number): Promise<Buffer> {
   const zip = new JSZip();
   zip.file(
@@ -459,6 +476,23 @@ describe('createImportHandler', () => {
     );
   });
 
+  it('reports zero failed files when every archive entry persists', async () => {
+    const deps = mockImportDeps();
+    const handler = createImportHandler(deps);
+    const buffer = await zipWithAdditionalFiles(2, 128);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(201);
+    const summary = importSummary(res.body);
+    expect(summary.filesProcessed).toBe(2);
+    expect(summary.filesSucceeded).toBe(2);
+    expect(summary.filesFailed).toBe(0);
+    expect(summary.errors).toEqual([]);
+    expect(deps.deleteSkill).not.toHaveBeenCalled();
+  });
+
   it('counts rejected oversized zip entries toward the cumulative decompressed limit', async () => {
     const kib = 1024;
     const deps = mockImportDeps({
@@ -473,14 +507,443 @@ describe('createImportHandler', () => {
 
     await handler(mockZipRequest(buffer), res);
 
-    expect(res.status).toHaveBeenCalledWith(201);
-    const summary = importSummary(res.body);
-    expect(summary.filesProcessed).toBe(3);
-    expect(summary.filesSucceeded).toBe(0);
-    expect(summary.filesFailed).toBe(3);
-    expect(summary.errors).toHaveLength(3);
+    expect(res.status).toHaveBeenCalledWith(422);
+    const failure = importFailure(res.body);
+    expect(failure.error).toBe('skill_import_incomplete');
+    /** All four bundled files are reported, including the one the scan never
+     *  reached once the cumulative budget was exhausted. */
+    expect(failure.failedFiles).toHaveLength(4);
+    expect(failure.failedFiles.map((entry) => entry.path)).toEqual([
+      'files/0.txt',
+      'files/1.txt',
+      'files/2.txt',
+      'files/3.txt',
+    ]);
+    expect(failure.message).toContain('4 of 4');
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports unprocessed archive entries once the decompression budget is exhausted', async () => {
+    const kib = 1024;
+    const deps = mockImportDeps({
+      maxZipBytes: 1024 * kib,
+      maxEntries: 10,
+      maxSingleFileBytes: 8 * kib,
+      maxDecompressedBytes: 12 * kib,
+    });
+    const handler = createImportHandler(deps);
+    /** The first entry fits the per-file limit and consumes most of the budget,
+     *  so the second exhausts it and the third is never attempted. */
+    const buffer = await zipWithAdditionalFiles(3, 7 * kib);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(422);
+    const failure = importFailure(res.body);
+    expect(failure.failedFiles).toEqual([
+      { path: 'files/1.txt', reason: 'archive_too_large', limitMb: 0.01 },
+      { path: 'files/2.txt', reason: 'archive_too_large', limitMb: 0.01 },
+    ]);
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(1);
   });
 
+  it('reports a size-limit rejection as a code with the limit, not a server message', async () => {
+    const kib = 1024;
+    const deps = mockImportDeps({
+      maxZipBytes: 1024 * kib,
+      maxEntries: 10,
+      maxSingleFileBytes: 1024 * kib,
+      maxDecompressedBytes: 4096 * kib,
+    });
+    const handler = createImportHandler(deps);
+    const buffer = await zipWithAdditionalFiles(1, 1025 * kib);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(422);
+    const failure = importFailure(res.body);
+    expect(failure.failedFiles).toEqual([
+      { path: 'files/0.txt', reason: 'file_too_large', limitMb: 1 },
+    ]);
+  });
+
+  it('leaves stored blobs in place and reports 500 when the skill cannot be deleted', async () => {
+    const deps = mockImportDeps();
+    deps.deleteSkill = jest.fn(async () => {
+      throw new Error('replica set stepped down');
+    }) as ImportSkillDeps['deleteSkill'];
+    deps.deleteFile = jest.fn(async () => undefined);
+    const upsert = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(new Error('write conflict'));
+    deps.upsertSkillFile = upsert as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const buffer = await zipWithAdditionalFiles(2, 64);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    const failure = importFailure(res.body);
+    expect(failure.error).toBe('skill_import_rollback_failed');
+    expect(failure.skillId).toBeDefined();
+    expect(failure.failedFiles).toEqual([{ path: 'files/1.txt', reason: 'persistence_failed' }]);
+    /** Only the inline cleanup for the row that failed runs. The blob whose row
+     *  survived stays, because SkillFile rows may still reference it and a
+     *  visible skill with missing files is worse than unreferenced storage. */
+    expect(deps.deleteFile).toHaveBeenCalledTimes(1);
+    expect(deps.deleteFile).not.toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ filepath: '/tmp/imported-0' }),
+    );
+  });
+
+  it('retries an orphan blob after SkillFile cleanup remains incomplete', async () => {
+    const deps = mockImportDeps();
+    deps.deleteSkill = jest.fn(async () => ({
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: false,
+      failedCleanupSteps: ['skill_files'],
+    })) as ImportSkillDeps['deleteSkill'];
+    deps.deleteFile = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('storage unavailable'))
+      .mockResolvedValueOnce(undefined) as ImportSkillDeps['deleteFile'];
+    deps.upsertSkillFile = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new Error('write conflict'),
+      ) as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(await zipWithAdditionalFiles(1, 64)), res);
+
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(2);
+    expect(deps.deleteFile).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(importFailure(res.body).error).toBe('skill_import_cleanup_incomplete');
+  });
+
+  it('retries dependent cleanup after owner permission setup fails', async () => {
+    const deps = mockImportDeps();
+    deps.grantPermission = jest.fn(async () => {
+      throw new Error('permission unavailable');
+    });
+    deps.deleteSkill = jest
+      .fn()
+      .mockResolvedValueOnce({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['permissions'],
+      })
+      .mockResolvedValueOnce({
+        deleted: false,
+        skillAbsent: true,
+        cleanupComplete: true,
+        failedCleanupSteps: [],
+      }) as ImportSkillDeps['deleteSkill'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(
+      mockMarkdownRequest(
+        '---\nname: permission-failure\ndescription: Permission rollback test\n---\n# Test',
+      ),
+      res,
+    );
+
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(500);
+  });
+
+  it('retries idempotent database cleanup before deleting stored blobs', async () => {
+    const deps = mockImportDeps();
+    deps.deleteSkill = jest
+      .fn()
+      .mockResolvedValueOnce({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['skill_files'],
+      })
+      .mockResolvedValueOnce({
+        deleted: false,
+        skillAbsent: true,
+        cleanupComplete: true,
+        failedCleanupSteps: [],
+      }) as ImportSkillDeps['deleteSkill'];
+    deps.deleteFile = jest.fn(async () => undefined);
+    deps.upsertSkillFile = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(
+        new Error('write conflict'),
+      ) as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(await zipWithAdditionalFiles(2, 64)), res);
+
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(422);
+    expect(importFailure(res.body).error).toBe('skill_import_incomplete');
+  });
+
+  it('reports incomplete cleanup when a persisted blob cannot be deleted', async () => {
+    const deps = mockImportDeps();
+    deps.deleteFile = jest.fn(async (_req, file) => {
+      if (file.filepath === '/tmp/imported-file') {
+        throw new Error('storage unavailable');
+      }
+    });
+    deps.upsertSkillFile = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(
+        new Error('write conflict'),
+      ) as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(await zipWithAdditionalFiles(2, 64)), res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(importFailure(res.body).error).toBe('skill_import_cleanup_incomplete');
+  });
+
+  it('deletes unreferenced blobs while reporting incomplete non-file cleanup', async () => {
+    const deps = mockImportDeps();
+    deps.deleteSkill = jest.fn(async () => ({
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: false,
+      failedCleanupSteps: ['permissions'],
+    })) as ImportSkillDeps['deleteSkill'];
+    deps.deleteFile = jest.fn(async () => undefined);
+    deps.upsertSkillFile = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(
+        new Error('write conflict'),
+      ) as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(await zipWithAdditionalFiles(2, 64)), res);
+
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(2);
+    expect(deps.deleteFile).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(importFailure(res.body).error).toBe('skill_import_cleanup_incomplete');
+  });
+
+  it('preserves successful cleanup steps across alternating rollback failures', async () => {
+    const deps = mockImportDeps();
+    deps.deleteSkill = jest
+      .fn()
+      .mockResolvedValueOnce({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['permissions'],
+      })
+      .mockResolvedValueOnce({
+        deleted: false,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['skill_files'],
+      }) as ImportSkillDeps['deleteSkill'];
+    deps.deleteFile = jest.fn(async () => undefined);
+    deps.upsertSkillFile = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(
+        new Error('write conflict'),
+      ) as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(await zipWithAdditionalFiles(2, 64)), res);
+
+    expect(deps.deleteFile).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(422);
+    expect(importFailure(res.body).error).toBe('skill_import_incomplete');
+  });
+
+  it('rolls back the skill and its stored blobs when one archive file fails', async () => {
+    const deps = mockImportDeps();
+    let savedFiles = 0;
+    deps.saveBuffer = jest.fn(async () => ({
+      filepath: `/tmp/imported-${savedFiles++}`,
+      source: 'local',
+      storageKey: `key-${savedFiles}`,
+      storageRegion: 'us-east-1',
+    })) as ImportSkillDeps['saveBuffer'];
+    deps.deleteFile = jest.fn(async () => undefined);
+    const upsert = jest
+      .fn()
+      .mockResolvedValueOnce({ _id: new Types.ObjectId() })
+      .mockRejectedValueOnce(new Error('write conflict'));
+    deps.upsertSkillFile = upsert as unknown as ImportSkillDeps['upsertSkillFile'];
+    const handler = createImportHandler(deps);
+    const buffer = await zipWithAdditionalFiles(2, 64);
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(422);
+    const failure = importFailure(res.body);
+    expect(failure.error).toBe('skill_import_incomplete');
+    expect(failure.failedFiles).toEqual([{ path: 'files/1.txt', reason: 'persistence_failed' }]);
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(1);
+    /** The blob whose row failed is cleaned up inline; the rollback removes the
+     *  one that did persist, so both writes are undone. */
+    expect(deps.deleteFile).toHaveBeenCalledTimes(2);
+    expect(deps.deleteFile).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ filepath: '/tmp/imported-0' }),
+    );
+    expect(res.body).not.toHaveProperty('_importSummary');
+  });
+
+  it('rolls back an archive whose entry path is unsafe instead of importing it partially', async () => {
+    const deps = mockImportDeps();
+    deps.deleteFile = jest.fn(async () => undefined);
+    const handler = createImportHandler(deps);
+    const zip = new JSZip();
+    zip.file(
+      'SKILL.md',
+      [
+        '---',
+        'name: tiny-limit-skill',
+        'description: A skill used by import handler tests.',
+        '---',
+        '# Test skill',
+      ].join('\n'),
+    );
+    zip.file('queries.sql', 'select 1;');
+    zip.file('references/region mapping.md', '# regions');
+    const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
+    const res = mockResponse();
+
+    await handler(mockZipRequest(buffer), res);
+
+    expect(res.status).toHaveBeenCalledWith(422);
+    const failure = importFailure(res.body);
+    expect(failure.failedFiles).toEqual([
+      { path: 'references/region mapping.md', reason: 'invalid_path' },
+    ]);
+    expect(deps.deleteSkill).toHaveBeenCalledTimes(1);
+    expect(deps.deleteFile).toHaveBeenCalledTimes(1);
+  });
+
+  describe.each([false, true])('persisted path validation with preflight=%s', (preflight) => {
+    const config = preflight
+      ? mockAppConfig({
+          files: {
+            pii: {
+              fields: ['content'],
+              starterPatterns: [],
+              customPatterns: [{ id: 'private_token', label: 'private token', regex: 'PRIVATE' }],
+            },
+          },
+        })
+      : undefined;
+
+    it.each(['references/' + 'a'.repeat(486) + '.txt', 'SKILL.md/resource.txt'])(
+      'rejects %s before writing storage',
+      async (relativePath) => {
+        const deps = mockImportDeps();
+        const zip = await JSZip.loadAsync(await zipWithAdditionalFiles(0, 0));
+        zip.file(`bundle/${relativePath}`, 'safe content');
+        const markdown = await zip.file('SKILL.md')!.async('string');
+        zip.remove('SKILL.md');
+        zip.file('bundle/SKILL.md', markdown);
+        const res = mockResponse();
+
+        await createImportHandler(deps)(
+          mockZipRequest(await zip.generateAsync({ type: 'nodebuffer' }), config),
+          res,
+        );
+
+        expect(res.statusCode).toBe(422);
+        expect(importFailure(res.body).failedFiles).toEqual([
+          { path: relativePath, reason: 'invalid_path' },
+        ]);
+        expect(deps.saveBuffer).not.toHaveBeenCalled();
+        expect(deps.upsertSkillFile).not.toHaveBeenCalled();
+      },
+    );
+
+    it('accepts a persisted path at the 500-character boundary', async () => {
+      const deps = mockImportDeps();
+      const zip = await JSZip.loadAsync(await zipWithAdditionalFiles(0, 0));
+      const relativePath = 'references/' + 'a'.repeat(485) + '.txt';
+      zip.file(relativePath, 'safe content');
+      const res = mockResponse();
+
+      await createImportHandler(deps)(
+        mockZipRequest(await zip.generateAsync({ type: 'nodebuffer' }), config),
+        res,
+      );
+
+      expect(relativePath).toHaveLength(500);
+      expect(res.statusCode).toBe(201);
+      expect(deps.upsertSkillFile).toHaveBeenCalledWith(expect.objectContaining({ relativePath }));
+    });
+  });
+
+  it.each([1, 3, undefined])(
+    'awaits every blob cleanup with concurrency=%s even when deletions fail',
+    async (concurrency) => {
+      const deps = mockImportDeps();
+      const zip = await JSZip.loadAsync(await zipWithAdditionalFiles(20, 64));
+      zip.file('invalid path.txt', 'trigger rollback after the successful writes');
+      let active = 0;
+      let peak = 0;
+      let started = 0;
+      let finished = 0;
+      const failures: number[] = [];
+      deps.deleteFile = jest.fn(async () => {
+        const index = started++;
+        active++;
+        peak = Math.max(peak, active);
+        try {
+          await new Promise<void>((resolve) => setImmediate(resolve));
+          if (index === 0 || index === 19) {
+            failures.push(index);
+            throw new Error('storage unavailable');
+          }
+        } finally {
+          active--;
+          finished++;
+        }
+      });
+      const config = mockAppConfig({});
+      config.fileConfig = { skills: { importCleanupConcurrency: concurrency } };
+      const res = mockResponse();
+
+      await createImportHandler(deps)(
+        mockZipRequest(await zip.generateAsync({ type: 'nodebuffer' }), config),
+        res,
+      );
+
+      expect(peak).toBe(concurrency ?? 8);
+      expect(finished).toBe(20);
+      expect(active).toBe(0);
+      expect(failures).toEqual([0, 19]);
+      expect(deps.deleteFile).toHaveBeenCalledTimes(20);
+      expect(res.statusCode).toBe(500);
+      expect(importFailure(res.body).error).toBe('skill_import_cleanup_incomplete');
+    },
+  );
+
   it('bounds SKILL.md inflation even when archive headers understate its size', async () => {
     const kib = 1024;
     const deps = mockImportDeps({
diff --git a/packages/api/src/skills/cleanup.spec.ts b/packages/api/src/skills/cleanup.spec.ts
new file mode 100644
index 00000000000..b974a241d73
--- /dev/null
+++ b/packages/api/src/skills/cleanup.spec.ts
@@ -0,0 +1,48 @@
+import type { DeleteSkillResult } from '@librechat/data-schemas';
+import { deleteSkillWithRetry, mergeDeleteSkillResults } from './cleanup';
+
+function incomplete(...failedCleanupSteps: DeleteSkillResult['failedCleanupSteps']) {
+  return {
+    deleted: true,
+    skillAbsent: true,
+    cleanupComplete: false,
+    failedCleanupSteps,
+  } satisfies DeleteSkillResult;
+}
+
+describe('mergeDeleteSkillResults', () => {
+  it('keeps steps settled when alternating retries fail independently', () => {
+    expect(mergeDeleteSkillResults(incomplete('permissions'), incomplete('skill_files'))).toEqual({
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: true,
+      failedCleanupSteps: [],
+    });
+  });
+
+  it('retains a step that failed in every attempt', () => {
+    expect(
+      mergeDeleteSkillResults(incomplete('permissions', 'skill_files'), incomplete('permissions')),
+    ).toEqual({
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: false,
+      failedCleanupSteps: ['permissions'],
+    });
+  });
+});
+
+describe('deleteSkillWithRetry', () => {
+  it('retries and preserves settled cleanup steps', async () => {
+    const deleteSkill = jest
+      .fn()
+      .mockResolvedValueOnce(incomplete('permissions'))
+      .mockResolvedValueOnce(incomplete('skill_files'));
+
+    await expect(deleteSkillWithRetry(deleteSkill, 'skill-id')).resolves.toMatchObject({
+      cleanupComplete: true,
+      failedCleanupSteps: [],
+    });
+    expect(deleteSkill).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/packages/api/src/skills/cleanup.ts b/packages/api/src/skills/cleanup.ts
new file mode 100644
index 00000000000..d0b6a35d33b
--- /dev/null
+++ b/packages/api/src/skills/cleanup.ts
@@ -0,0 +1,39 @@
+import type { DeleteSkillCleanupStep, DeleteSkillResult } from '@librechat/data-schemas';
+
+const CLEANUP_STEPS: DeleteSkillCleanupStep[] = ['agent_allowlists', 'skill_files', 'permissions'];
+
+/**
+ * Cleanup is monotonic across idempotent deletion attempts. Once any attempt
+ * confirms a step succeeded, a later transient failure cannot make that work
+ * incomplete again. Only steps that failed in every confirming attempt remain
+ * unsettled.
+ */
+export function mergeDeleteSkillResults(
+  current: DeleteSkillResult,
+  next: DeleteSkillResult,
+): DeleteSkillResult {
+  const confirmingAttempts = [current, next].filter((result) => result.skillAbsent);
+  const failedCleanupSteps = CLEANUP_STEPS.filter((step) =>
+    confirmingAttempts.every((result) => result.failedCleanupSteps.includes(step)),
+  );
+  const skillAbsent = confirmingAttempts.length > 0;
+
+  return {
+    deleted: current.deleted || next.deleted,
+    skillAbsent,
+    cleanupComplete: skillAbsent && failedCleanupSteps.length === 0,
+    failedCleanupSteps,
+  };
+}
+
+/** Retry an idempotent cascade once when the skill row is already gone. */
+export async function deleteSkillWithRetry(
+  deleteSkill: (id: string) => Promise<DeleteSkillResult>,
+  id: string,
+): Promise<DeleteSkillResult> {
+  const result = await deleteSkill(id);
+  if (!result.skillAbsent || result.cleanupComplete) {
+    return result;
+  }
+  return mergeDeleteSkillResults(result, await deleteSkill(id));
+}
diff --git a/packages/api/src/skills/handlers.spec.ts b/packages/api/src/skills/handlers.spec.ts
new file mode 100644
index 00000000000..ab991206fdb
--- /dev/null
+++ b/packages/api/src/skills/handlers.spec.ts
@@ -0,0 +1,150 @@
+import { Types } from 'mongoose';
+import type { DeleteSkillResult, ISkillFile } from '@librechat/data-schemas';
+import type { Response } from 'express';
+import type { SkillsHandlersDeps } from './handlers';
+import type { ServerRequest } from '~/types';
+import { createSkillsHandlers } from './handlers';
+
+function mockResponse(): Response {
+  const res = {} as Response;
+  res.status = jest.fn(() => res) as Response['status'];
+  res.json = jest.fn(() => res) as Response['json'];
+  return res;
+}
+
+describe('skill delete handler', () => {
+  it('retries dependent cleanup before the deleted skill becomes unreachable', async () => {
+    const id = new Types.ObjectId().toString();
+    const deleteBlob = jest.fn(async () => undefined);
+    const incomplete: DeleteSkillResult = {
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: false,
+      failedCleanupSteps: ['skill_files'],
+    };
+    const complete: DeleteSkillResult = {
+      deleted: false,
+      skillAbsent: true,
+      cleanupComplete: true,
+      failedCleanupSteps: [],
+    };
+    const deleteSkill = jest.fn().mockResolvedValueOnce(incomplete).mockResolvedValueOnce(complete);
+    const file = {
+      relativePath: 'references/query.sql',
+      filepath: '/uploads/query.sql',
+      source: 'local',
+    } as ISkillFile & { _id: Types.ObjectId };
+    const handlers = createSkillsHandlers({
+      deleteSkill,
+      listSkillFiles: jest.fn(async () => [file]),
+      getStrategyFunctions: jest.fn(() => ({ deleteFile: deleteBlob })),
+      isValidObjectIdString: jest.fn(() => true),
+    } as unknown as SkillsHandlersDeps);
+    const req = { params: { id } } as unknown as ServerRequest;
+    const res = mockResponse();
+
+    await handlers.delete(req, res);
+
+    expect(deleteSkill).toHaveBeenCalledTimes(2);
+    expect(deleteBlob).toHaveBeenCalledTimes(1);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ id, deleted: true, cleanupComplete: true });
+  });
+
+  it('returns an evictable response when only non-file cleanup remains incomplete', async () => {
+    const id = new Types.ObjectId().toString();
+    const incomplete: DeleteSkillResult = {
+      deleted: true,
+      skillAbsent: true,
+      cleanupComplete: false,
+      failedCleanupSteps: ['permissions'],
+    };
+    const deleteSkill = jest.fn(async () => incomplete);
+    const handlers = createSkillsHandlers({
+      deleteSkill,
+      listSkillFiles: jest.fn(async () => []),
+      getStrategyFunctions: jest.fn(),
+      isValidObjectIdString: jest.fn(() => true),
+    } as unknown as SkillsHandlersDeps);
+    const req = { params: { id } } as unknown as ServerRequest;
+    const res = mockResponse();
+
+    await handlers.delete(req, res);
+
+    expect(deleteSkill).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ id, deleted: true, cleanupComplete: false });
+  });
+
+  it('awaits blob cleanup and reports a partial deletion when storage rejects it', async () => {
+    const id = new Types.ObjectId().toString();
+    const deleteBlob = jest.fn(async () => {
+      throw new Error('storage unavailable');
+    });
+    const handlers = createSkillsHandlers({
+      deleteSkill: jest.fn(async () => ({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: true,
+        failedCleanupSteps: [],
+      })),
+      listSkillFiles: jest.fn(async () => [
+        {
+          relativePath: 'references/query.sql',
+          filepath: '/uploads/query.sql',
+          source: 'local',
+        } as ISkillFile & { _id: Types.ObjectId },
+      ]),
+      getStrategyFunctions: jest.fn(() => ({ deleteFile: deleteBlob })),
+      isValidObjectIdString: jest.fn(() => true),
+    } as unknown as SkillsHandlersDeps);
+    const req = { params: { id } } as unknown as ServerRequest;
+    const res = mockResponse();
+
+    await handlers.delete(req, res);
+
+    expect(deleteBlob).toHaveBeenCalledTimes(1);
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ id, deleted: true, cleanupComplete: false });
+  });
+});
+
+describe('skill create handler', () => {
+  it('retries dependent cleanup after owner permission setup fails', async () => {
+    const skillId = new Types.ObjectId();
+    const deleteSkill = jest
+      .fn()
+      .mockResolvedValueOnce({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['permissions'],
+      })
+      .mockResolvedValueOnce({
+        deleted: false,
+        skillAbsent: true,
+        cleanupComplete: true,
+        failedCleanupSteps: [],
+      });
+    const handlers = createSkillsHandlers({
+      createSkill: jest.fn(async () => ({
+        skill: { _id: skillId, name: 'permission-failure' },
+        warnings: [],
+      })),
+      grantPermission: jest.fn(async () => {
+        throw new Error('permission unavailable');
+      }),
+      deleteSkill,
+    } as unknown as SkillsHandlersDeps);
+    const req = {
+      body: { name: 'permission-failure', description: 'Rollback test', body: '# Test' },
+      user: { id: 'user-1', _id: new Types.ObjectId(), name: 'Test User' },
+    } as unknown as ServerRequest;
+    const res = mockResponse();
+
+    await handlers.create(req, res);
+
+    expect(deleteSkill).toHaveBeenCalledTimes(2);
+    expect(res.status).toHaveBeenCalledWith(500);
+  });
+});
diff --git a/packages/api/src/skills/handlers.ts b/packages/api/src/skills/handlers.ts
index 7a75d0d1996..7c53c674932 100644
--- a/packages/api/src/skills/handlers.ts
+++ b/packages/api/src/skills/handlers.ts
@@ -29,11 +29,13 @@ import type {
   ListSkillsByAccessParams,
   UpdateSkillResult,
   ValidationIssue,
+  DeleteSkillResult,
 } from '@librechat/data-schemas';
 import type { Response } from 'express';
 import type { Types } from 'mongoose';
 import type { ServerRequest, StrategyFunctions } from '~/types';
 import { extractSkillContent, inspectContentWithTraversal } from '~/protection';
+import { deleteSkillWithRetry, mergeDeleteSkillResults } from './cleanup';
 import { contentFilterBlockResponse } from '~/middleware/contentFilter';
 import { getDeploymentSkillIds } from './deployment';
 import { resolveDownloadPath } from '~/storage/path';
@@ -62,7 +64,7 @@ export interface SkillsHandlersDeps {
     expectedVersion: number;
     update: UpdateSkillInput;
   }) => Promise<UpdateSkillResult>;
-  deleteSkill: (id: string) => Promise<{ deleted: boolean }>;
+  deleteSkill: (id: string) => Promise<DeleteSkillResult>;
   listSkillFiles: (
     skillId: string | Types.ObjectId,
   ) => Promise<Array<ISkillFile & { _id: Types.ObjectId }>>;
@@ -471,7 +473,12 @@ export function createSkillsHandlers(deps: SkillsHandlersDeps): {
           permissionError,
         );
         try {
-          await deleteSkill(skill._id.toString());
+          const deletion = await deleteSkillWithRetry(deleteSkill, skill._id.toString());
+          if (!deletion.cleanupComplete) {
+            logger.error(
+              `[POST /skills] Compensating delete incomplete for orphaned skill ${skill._id.toString()}: ${deletion.failedCleanupSteps.join(', ')}`,
+            );
+          }
         } catch (rollbackError) {
           logger.error(
             `[POST /skills] Compensating delete failed for orphaned skill ${skill._id.toString()}:`,
@@ -596,28 +603,60 @@ export function createSkillsHandlers(deps: SkillsHandlersDeps): {
       // Collect file records before deletion so we can clean up storage blobs
       const files = await listSkillFiles(id);
 
-      const result = await deleteSkill(id);
-      if (!result.deleted) {
-        return res.status(404).json({ error: 'Skill not found' });
+      let result = await deleteSkill(id);
+      if (result.skillAbsent && !result.cleanupComplete) {
+        try {
+          result = mergeDeleteSkillResults(result, await deleteSkill(id));
+        } catch (error) {
+          logger.error(`[deleteSkill] Cleanup retry failed for ${id}:`, error);
+        }
       }
-
-      // Fire-and-forget blob cleanup for each file
-      for (const file of files) {
-        const { deleteFile: deleteBlob } = getStrategyFunctions(file.source);
-        if (deleteBlob) {
-          deleteBlob(req, {
+      /** Once SkillFile cleanup succeeds, the records loaded above are the
+       * only remaining references to their blobs. Use them even if an
+       * independent allowlist or permission cleanup step needs a retry. */
+      let blobCleanupComplete = true;
+      if (!result.failedCleanupSteps.includes('skill_files')) {
+        const blobDeletions = files.map(async (file) => {
+          const { deleteFile: deleteBlob } = getStrategyFunctions(file.source);
+          if (!deleteBlob) {
+            throw new Error(`No delete strategy for ${file.source}`);
+          }
+          await deleteBlob(req, {
             filepath: file.filepath,
             storageKey: file.storageKey,
             storageRegion: file.storageRegion,
             user: file.author?.toString?.(),
             tenantId: file.tenantId?.toString?.(),
-          }).catch((e) =>
-            logger.error(`[deleteSkill] Blob cleanup failed for ${file.relativePath}:`, e),
-          );
+          });
+        });
+        const blobResults = await Promise.allSettled(blobDeletions);
+        for (const [index, blobResult] of blobResults.entries()) {
+          if (blobResult.status === 'rejected') {
+            blobCleanupComplete = false;
+            logger.error(
+              `[deleteSkill] Blob cleanup failed for ${files[index].relativePath}:`,
+              blobResult.reason,
+            );
+          }
+        }
+      }
+
+      const cleanupComplete = result.cleanupComplete && blobCleanupComplete;
+      if (!cleanupComplete) {
+        if (result.skillAbsent) {
+          /** The client must evict the now-missing skill even though dependent
+           * cleanup still needs repair. A 2xx response reaches the mutation's
+           * cache reconciliation path; the flag preserves the warning. */
+          const response: TDeleteSkillResponse = { id, deleted: true, cleanupComplete: false };
+          return res.status(200).json(response);
         }
+        return res.status(500).json({ error: 'Skill deletion cleanup did not finish' });
+      }
+      if (!result.deleted && files.length === 0) {
+        return res.status(404).json({ error: 'Skill not found' });
       }
 
-      const response: TDeleteSkillResponse = { id, deleted: true };
+      const response: TDeleteSkillResponse = { id, deleted: true, cleanupComplete };
       return res.status(200).json(response);
     } catch (error) {
       logger.error('[DELETE /skills/:id] Error deleting skill', error);
diff --git a/packages/api/src/skills/import.ts b/packages/api/src/skills/import.ts
index 480b7d9539a..8d454b4feff 100644
--- a/packages/api/src/skills/import.ts
+++ b/packages/api/src/skills/import.ts
@@ -1,9 +1,10 @@
 import path from 'path';
 import JSZip from 'jszip';
 import crypto from 'crypto';
-import { logger } from '@librechat/data-schemas';
+import { logger, validateRelativePath } from '@librechat/data-schemas';
 import {
   ResourceType,
+  DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY,
   AccessRoleIds,
   PrincipalType,
   hasActivePiiFields,
@@ -15,8 +16,10 @@ import type {
   ISkillFile,
   CreateSkillInput,
   CreateSkillResult,
+  DeleteSkillResult,
   UpsertSkillFileInput,
 } from '@librechat/data-schemas';
+import type { SkillImportFailureReason, TSkillImportFailedResponse } from 'librechat-data-provider';
 import type { Request, Response } from 'express';
 import type { Types } from 'mongoose';
 import type {
@@ -37,10 +40,11 @@ import {
   contentFilterUninspectableResponse,
   getBlockedUninspectableSkillFileField,
 } from '~/protection';
+import { deleteSkillWithRetry, mergeDeleteSkillResults } from './cleanup';
 import { contentFilterBlockResponse } from '~/middleware/contentFilter';
 import { resolveRequestTenantId } from '~/middleware/tenant';
+import { createConcurrencyLimiter } from '~/utils/promise';
 import { DEFAULT_SKILL_IMPORT_LIMITS } from './limits';
-import { isSafeSkillFilePath } from './path';
 import { parseSkillMarkdown } from './parse';
 import { isBinaryBuffer } from './binary';
 
@@ -130,7 +134,7 @@ export interface ImportSkillDeps {
   limits?: Partial<ImportLimits> | ((req: ServerRequest) => Partial<ImportLimits> | undefined);
   createSkill: (data: CreateSkillInput) => Promise<CreateSkillResult>;
   getSkillById: (id: string | Types.ObjectId) => Promise<(ISkill & { _id: Types.ObjectId }) | null>;
-  deleteSkill: (id: string) => Promise<{ deleted: boolean }>;
+  deleteSkill: (id: string) => Promise<DeleteSkillResult>;
   upsertSkillFile: (row: UpsertSkillFileInput) => Promise<ISkillFile & { _id: Types.ObjectId }>;
   saveBuffer: (
     req: Request,
@@ -365,7 +369,12 @@ async function grantOwnership(
   } catch (error) {
     logger.error(`[importSkill] Failed to grant SKILL_OWNER for ${skillId}, rolling back:`, error);
     try {
-      await deps.deleteSkill(skillId.toString());
+      const deletion = await deleteSkillWithRetry(deps.deleteSkill, skillId.toString());
+      if (!deletion.cleanupComplete) {
+        logger.error(
+          `[importSkill] Compensating delete incomplete for ${skillId}: ${deletion.failedCleanupSteps.join(', ')}`,
+        );
+      }
     } catch (rollbackError) {
       logger.error(`[importSkill] Compensating delete failed for ${skillId}:`, rollbackError);
     }
@@ -468,9 +477,30 @@ async function handleMarkdown(
 type ImportFileResult = {
   path: string;
   status: 'ok' | 'error';
+  /** Stable code the client localizes; set on every failure. */
+  reason?: SkillImportFailureReason;
+  /** Limit in MB, when `reason` names a size limit. */
+  limitMb?: number;
+  /**
+   * Human-readable detail for the server log only. Storage and database
+   * messages can name buckets, hosts and driver internals, so this never
+   * reaches the client — `reason` does.
+   */
   error?: string;
 };
 
+/**
+ * Limits are reported to the user in MB. Two decimals, and never 0 for a
+ * positive limit: a deployment configured in kilobytes would otherwise render
+ * as "exceeds the 0 MB limit".
+ */
+function bytesToMb(bytes: number): number {
+  if (bytes <= 0) {
+    return 0;
+  }
+  return Math.max(0.01, Math.round((bytes / (1024 * 1024)) * 100) / 100);
+}
+
 interface ArchiveFileDescriptor {
   readonly entryPath: string;
   readonly relativePath: string;
@@ -526,6 +556,42 @@ async function readZipEntry(
   };
 }
 
+/**
+ * Record every archive entry the scan never reached.
+ *
+ * The decompression budget stops the loop mid-archive, and an import that
+ * reported only the entries it happened to read would tell the user they had
+ * seen the whole failure set: they would fix those paths, retry, and meet the
+ * next batch. `startIndex` is the entry the loop stopped on, inclusive.
+ */
+function pushUnprocessedEntries(
+  results: ImportFileResult[],
+  entries: readonly [string, JSZip.JSZipObject][],
+  startIndex: number,
+  prefix: string,
+  limitMb: number,
+): void {
+  for (let index = startIndex; index < entries.length; index++) {
+    const [entryPath, zipEntry] = entries[index];
+    if (zipEntry.dir) {
+      continue;
+    }
+    const normalized = entryPath.replace(/\\/g, '/');
+    const relativePath =
+      prefix && normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+    if (relativePath.toUpperCase() === SKILL_MD.toUpperCase()) {
+      continue;
+    }
+    results.push({
+      path: relativePath || normalized,
+      status: 'error',
+      reason: 'archive_too_large',
+      limitMb,
+      error: 'Not processed: cumulative decompressed size exceeded limit',
+    });
+  }
+}
+
 async function scanArchiveFiles(
   zip: JSZip,
   prefix: string,
@@ -539,7 +605,11 @@ async function scanArchiveFiles(
   let totalDecompressed = initialDecompressedBytes;
   let cumulativeLimitExceeded = false;
 
-  for (const [entryPath, zipEntry] of Object.entries(zip.files)) {
+  const entries = Object.entries(zip.files);
+  const budgetMb = bytesToMb(maxDecompressedBytes);
+
+  for (let index = 0; index < entries.length; index++) {
+    const [entryPath, zipEntry] = entries[index];
     if (zipEntry.dir) {
       continue;
     }
@@ -552,8 +622,13 @@ async function scanArchiveFiles(
     if (callbacks.onName?.(relativePath || normalized) === true) {
       return { files, results, blocked: true, cumulativeLimitExceeded };
     }
-    if (!relativePath || !isSafeSkillFilePath(relativePath)) {
-      results.push({ path: normalized, status: 'error', error: 'Invalid path' });
+    if (validateRelativePath(relativePath).length > 0) {
+      results.push({
+        path: relativePath,
+        status: 'error',
+        reason: 'invalid_path',
+        error: 'Invalid path',
+      });
       continue;
     }
 
@@ -562,26 +637,25 @@ async function scanArchiveFiles(
       const effectiveLimit = Math.min(limits.maxSingleFileBytes, cumulativeLimit);
       if (effectiveLimit <= 0) {
         cumulativeLimitExceeded = true;
-        results.push({
-          path: relativePath,
-          status: 'error',
-          error: 'Cumulative decompressed size exceeds limit',
-        });
+        pushUnprocessedEntries(results, entries, index, prefix, budgetMb);
         break;
       }
 
       const { buffer, bytesRead } = await readZipEntry(zipEntry, effectiveLimit);
       totalDecompressed += bytesRead;
       if (buffer == null) {
-        const reason =
-          bytesRead > limits.maxSingleFileBytes
-            ? `File too large (max ${limits.maxSingleFileBytes / 1024 / 1024}MB)`
-            : 'Cumulative decompressed size exceeds limit';
-        results.push({ path: relativePath, status: 'error', error: reason });
         if (bytesRead > cumulativeLimit) {
           cumulativeLimitExceeded = true;
+          pushUnprocessedEntries(results, entries, index, prefix, budgetMb);
           break;
         }
+        results.push({
+          path: relativePath,
+          status: 'error',
+          reason: 'file_too_large',
+          limitMb: bytesToMb(limits.maxSingleFileBytes),
+          error: `File too large (max ${limits.maxSingleFileBytes / 1024 / 1024}MB)`,
+        });
         continue;
       }
 
@@ -603,6 +677,7 @@ async function scanArchiveFiles(
       results.push({
         path: relativePath,
         status: 'error',
+        reason: 'persistence_failed',
         error: (error as Error).message,
       });
     }
@@ -633,11 +708,28 @@ function preflightArchiveNames(
   return false;
 }
 
+/** A blob that reached storage, kept so a failed import can delete it again. */
+interface PersistedArchiveBlob {
+  readonly relativePath: string;
+  readonly filepath: string;
+  readonly source: string;
+  readonly storageKey?: string;
+  readonly storageRegion?: string;
+  /** Whether a SkillFile row can still reference this blob. */
+  readonly rowPersisted: boolean;
+}
+
 interface ArchivePersistenceContext {
   readonly userId: string;
   readonly skillId: Types.ObjectId;
   readonly authorId: Types.ObjectId;
   readonly tenantId?: string;
+  /**
+   * Blobs written so far, in archive order. An import that loses any bundled
+   * file is rolled back whole (`rollbackArchiveImport`), and the storage writes
+   * are the only part of that no database cascade can undo.
+   */
+  readonly persisted: PersistedArchiveBlob[];
 }
 
 async function persistArchiveFile(
@@ -657,6 +749,14 @@ async function persistArchiveFile(
     isImage: file.mimeType.startsWith('image/'),
     tenantId: context.tenantId,
   });
+  const persistedBlob: PersistedArchiveBlob = {
+    relativePath: file.relativePath,
+    filepath,
+    source,
+    storageKey,
+    storageRegion,
+    rowPersisted: false,
+  };
 
   try {
     await deps.upsertSkillFile({
@@ -675,6 +775,7 @@ async function persistArchiveFile(
       tenantId: context.tenantId,
     });
   } catch (dbError) {
+    let blobRemoved = false;
     if (deps.deleteFile) {
       await deps
         .deleteFile(req, {
@@ -685,12 +786,143 @@ async function persistArchiveFile(
           user: context.authorId,
           tenantId: context.tenantId,
         })
+        .then(() => {
+          blobRemoved = true;
+        })
         .catch((error) =>
           logger.error(`[importSkill] Orphan cleanup failed for ${file.relativePath}:`, error),
         );
     }
+    if (!blobRemoved) {
+      context.persisted.push(persistedBlob);
+    }
     throw dbError;
   }
+
+  context.persisted.push({ ...persistedBlob, rowPersisted: true });
+}
+
+async function cleanupArchiveBlobs(
+  req: ServerRequest,
+  deps: ImportSkillDeps,
+  context: ArchivePersistenceContext,
+  blobs: PersistedArchiveBlob[],
+): Promise<boolean> {
+  const { deleteFile } = deps;
+  if (blobs.length === 0) {
+    return true;
+  }
+  if (deleteFile == null) {
+    return false;
+  }
+
+  const limit = createConcurrencyLimiter(
+    req.config?.fileConfig?.skills?.importCleanupConcurrency ??
+      DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY,
+  );
+  const results = await Promise.allSettled(
+    blobs.map((blob) =>
+      limit(() =>
+        deleteFile(req, {
+          filepath: blob.filepath,
+          storageKey: blob.storageKey,
+          storageRegion: blob.storageRegion,
+          source: blob.source,
+          user: context.authorId,
+          tenantId: context.tenantId,
+        }),
+      ),
+    ),
+  );
+  let complete = true;
+  for (const [index, result] of results.entries()) {
+    if (result.status === 'rejected') {
+      complete = false;
+      logger.error(
+        `[importSkill] Rollback blob cleanup failed for ${blobs[index].relativePath}:`,
+        result.reason,
+      );
+    }
+  }
+  return complete;
+}
+
+/**
+ * Undo an archive import that could not persist every bundled file.
+ *
+ * `deleteSkill` cascades to the SkillFile rows, the agent allowlists and the
+ * ACL grant, so only the storage blobs written by `persistArchiveFile` need
+ * explicit cleanup.
+ *
+ * Order matters: the blobs are deleted only once the cascade has confirmed the
+ * skill is gone. If the delete throws or finds nothing, the SkillFile rows may
+ * still reference those blobs, and deleting them anyway would leave a visible,
+ * shareable skill whose files 404 — a worse version of the bug this rollback
+ * exists to prevent. Unreferenced storage is reclaimable; a broken skill is
+ * not, so the blobs stay and the caller reports the rollback as incomplete.
+ */
+async function rollbackArchiveImport(
+  req: ServerRequest,
+  deps: ImportSkillDeps,
+  context: ArchivePersistenceContext,
+): Promise<{ skillRemoved: boolean; cleanupComplete: boolean }> {
+  const skillId = context.skillId.toString();
+  let deletion: DeleteSkillResult;
+  try {
+    deletion = await deps.deleteSkill(skillId);
+  } catch (error) {
+    logger.error(`[importSkill] Rollback delete failed for skill ${skillId}:`, error);
+    logger.error(
+      `[importSkill] Rollback incomplete for skill ${skillId}: retaining row-backed files because the skill row was not removed`,
+    );
+    await cleanupArchiveBlobs(
+      req,
+      deps,
+      context,
+      context.persisted.filter((blob) => !blob.rowPersisted),
+    );
+    return { skillRemoved: false, cleanupComplete: false };
+  }
+
+  if (deletion.skillAbsent && !deletion.cleanupComplete) {
+    try {
+      deletion = mergeDeleteSkillResults(deletion, await deps.deleteSkill(skillId));
+    } catch (error) {
+      logger.error(`[importSkill] Rollback cleanup retry failed for skill ${skillId}:`, error);
+    }
+  }
+
+  if (!deletion.skillAbsent) {
+    logger.error(`[importSkill] Rollback could not confirm removal of skill ${skillId}`);
+    await cleanupArchiveBlobs(
+      req,
+      deps,
+      context,
+      context.persisted.filter((blob) => !blob.rowPersisted),
+    );
+    return { skillRemoved: false, cleanupComplete: false };
+  }
+  const databaseCleanupComplete = deletion.cleanupComplete;
+  if (!deletion.cleanupComplete) {
+    logger.error(
+      `[importSkill] Rollback database cleanup incomplete for skill ${skillId}: ${deletion.failedCleanupSteps.join(', ')}`,
+    );
+    /** If SkillFile cleanup failed, those rows can still reference the stored
+     * blobs, so retain them for the idempotent database retry. When only an
+     * independent cleanup step failed, the captured records are now the last
+     * blob references and must be consumed before returning the 500. */
+  }
+
+  const skillFileCleanupIncomplete = deletion.failedCleanupSteps.includes('skill_files');
+  const blobsToDelete = skillFileCleanupIncomplete
+    ? context.persisted.filter((blob) => !blob.rowPersisted)
+    : context.persisted;
+
+  const blobCleanupComplete = await cleanupArchiveBlobs(req, deps, context, blobsToDelete);
+  return {
+    skillRemoved: true,
+    cleanupComplete: databaseCleanupComplete && blobCleanupComplete,
+  };
 }
 
 async function persistPreflightedArchiveFiles(
@@ -704,8 +936,10 @@ async function persistPreflightedArchiveFiles(
 ): Promise<ImportFileResult[]> {
   const results: ImportFileResult[] = [];
   let totalDecompressed = initialDecompressedBytes;
+  const budgetMb = bytesToMb(limits.maxDecompressedBytes);
 
-  for (const file of files) {
+  for (let index = 0; index < files.length; index++) {
+    const file = files[index];
     try {
       const zipEntry = zip.file(file.entryPath);
       if (zipEntry == null) {
@@ -714,11 +948,18 @@ async function persistPreflightedArchiveFiles(
       const cumulativeLimit = limits.maxDecompressedBytes - totalDecompressed;
       const effectiveLimit = Math.min(limits.maxSingleFileBytes, cumulativeLimit);
       if (effectiveLimit <= 0) {
-        results.push({
-          path: file.relativePath,
-          status: 'error',
-          error: 'Cumulative decompressed size exceeds limit',
-        });
+        /** Same reasoning as `pushUnprocessedEntries`: the remaining files were
+         *  never attempted, and omitting them would understate the failure set
+         *  the user has to fix before a retry can succeed. */
+        for (const skipped of files.slice(index)) {
+          results.push({
+            path: skipped.relativePath,
+            status: 'error',
+            reason: 'archive_too_large',
+            limitMb: budgetMb,
+            error: 'Not processed: cumulative decompressed size exceeded limit',
+          });
+        }
         break;
       }
       const { buffer, bytesRead } = await readZipEntry(zipEntry, effectiveLimit);
@@ -727,6 +968,7 @@ async function persistPreflightedArchiveFiles(
         results.push({
           path: file.relativePath,
           status: 'error',
+          reason: 'archive_entry_changed',
           error: 'Archive entry changed after content inspection',
         });
         continue;
@@ -741,6 +983,7 @@ async function persistPreflightedArchiveFiles(
       results.push({
         path: file.relativePath,
         status: 'error',
+        reason: 'persistence_failed',
         error: (error as Error).message,
       });
     }
@@ -782,6 +1025,9 @@ async function handleZip(
   let skillMdPath: string | null = null;
   let prefix = '';
   for (const p of entries) {
+    if (zip.files[p].dir) {
+      continue;
+    }
     const normalized = p.replace(/\\/g, '/');
     const segments = normalized.split('/').filter(Boolean);
     const basename = segments[segments.length - 1];
@@ -955,6 +1201,7 @@ async function handleZip(
     skillId: skill._id,
     authorId,
     tenantId,
+    persisted: [],
   };
   let fileResults: ImportFileResult[];
   if (preflight == null) {
@@ -995,9 +1242,56 @@ async function handleZip(
     }
   }
 
-  logger.info(
-    `[importSkill] Imported skill "${inferredName}" with ${successCount} files (${errors.length} errors)`,
-  );
+  /**
+   * A skill whose bundled files did not all persist is broken in a way the
+   * uploader cannot see: it lists, shares and attaches normally while an agent
+   * that follows `SKILL.md` cannot find the resources it names. Import is
+   * therefore atomic — any failed file rolls the whole skill back and the
+   * response says which paths failed and why.
+   */
+  if (errors.length > 0) {
+    logger.warn(
+      `[importSkill] Rolling back skill "${inferredName}" (${skill._id.toString()}): ${errors.length} of ${fileResults.length} files failed`,
+    );
+    const { skillRemoved, cleanupComplete } = await rollbackArchiveImport(
+      req,
+      deps,
+      persistenceContext,
+    );
+    /** Reasons are codes, not prose: the client localizes them, and the
+     *  underlying storage and database messages stay in the server log where
+     *  they cannot leak infrastructure detail to the uploader. */
+    const failedFiles = errors.map((entry) => ({
+      path: entry.path,
+      reason: entry.reason ?? 'persistence_failed',
+      ...(entry.limitMb == null ? {} : { limitMb: entry.limitMb }),
+    }));
+    if (!skillRemoved) {
+      const rollbackFailure: TSkillImportFailedResponse = {
+        error: 'skill_import_rollback_failed',
+        message: `Import failed for ${errors.length} of ${fileResults.length} files and the partially created skill could not be removed automatically.`,
+        failedFiles,
+        skillId: skill._id.toString(),
+      };
+      return res.status(500).json(rollbackFailure);
+    }
+    if (!cleanupComplete) {
+      const cleanupFailure: TSkillImportFailedResponse = {
+        error: 'skill_import_cleanup_incomplete',
+        message: `Import failed for ${errors.length} of ${fileResults.length} files. The skill was removed, but automatic cleanup did not finish.`,
+        failedFiles,
+      };
+      return res.status(500).json(cleanupFailure);
+    }
+    const failure: TSkillImportFailedResponse = {
+      error: 'skill_import_incomplete',
+      message: `Import canceled: ${errors.length} of ${fileResults.length} files in the archive could not be imported.`,
+      failedFiles,
+    };
+    return res.status(422).json(failure);
+  }
+
+  logger.info(`[importSkill] Imported skill "${inferredName}" with ${successCount} files`);
 
   // Re-read the skill to get the current version/fileCount (bumped by each upsertSkillFile)
   const refreshed = (await deps.getSkillById(skill._id)) ?? skill;
@@ -1007,7 +1301,7 @@ async function handleZip(
     _importSummary: {
       filesProcessed: fileResults.length,
       filesSucceeded: successCount,
-      filesFailed: errors.length,
+      filesFailed: 0,
       errors,
     },
   });
diff --git a/packages/api/src/skills/sync/github.spec.ts b/packages/api/src/skills/sync/github.spec.ts
index fc6b5951eb2..f7b2e62edee 100644
--- a/packages/api/src/skills/sync/github.spec.ts
+++ b/packages/api/src/skills/sync/github.spec.ts
@@ -11,6 +11,7 @@ import type {
   UpdateSkillInput,
   UpdateSkillResult,
   UpsertSkillFileInput,
+  DeleteSkillResult,
 } from '@librechat/data-schemas';
 import type { RepoTreeEntry, GitRepoAdapter } from './adapters/types';
 import type { GitHubSkillSyncDeps } from './github';
@@ -40,6 +41,26 @@ function blob(content: string) {
   };
 }
 
+function completeSkillDeletion(deleted: boolean): DeleteSkillResult {
+  return {
+    deleted,
+    skillAbsent: true,
+    cleanupComplete: true,
+    failedCleanupSteps: [],
+  };
+}
+
+function incompleteSkillDeletion(
+  failedCleanupSteps: DeleteSkillResult['failedCleanupSteps'],
+): DeleteSkillResult {
+  return {
+    deleted: true,
+    skillAbsent: true,
+    cleanupComplete: false,
+    failedCleanupSteps,
+  };
+}
+
 function githubFetch(
   skillMarkdown = '---\nname: research\ndescription: Research things\nalways-apply: true\n---\nBody',
 ): typeof fetch {
@@ -306,7 +327,7 @@ function createDeps(
       } as ISkillFile & { _id: Types.ObjectId };
     }),
     deleteSkillFile: jest.fn(async () => ({ deleted: true })),
-    deleteSkill: jest.fn(async () => ({ deleted: true })),
+    deleteSkill: jest.fn(async () => completeSkillDeletion(true)),
     saveBuffer: jest.fn(async () => ({ filepath: '/uploads/file-id__run.sh', source: 'local' })),
     deleteFile: jest.fn(async () => undefined),
     grantPermission: jest.fn(async () => undefined),
@@ -1599,7 +1620,7 @@ describe('createGitHubSkillSyncRunner', () => {
     );
     const deleteSkill = jest.fn(async (id: string) => {
       deletedIds.add(id);
-      return { deleted: true };
+      return completeSkillDeletion(true);
     });
     const updateSkill = jest.fn(
       async ({
@@ -1751,7 +1772,9 @@ describe('createGitHubSkillSyncRunner', () => {
     const staleSkill = makeExisting('librechat-skills:skills/removed', staleId, 'renamed');
     const syncedSkill = makeExisting('librechat-skills:skills/research', existingId, 'research');
     const createdIds: string[] = [];
-    const deleteSkill = jest.fn(async (id: string) => ({ deleted: createdIds.includes(id) }));
+    const deleteSkill = jest.fn(async (id: string) =>
+      completeSkillDeletion(createdIds.includes(id)),
+    );
     const deps = createDeps({
       fetchFn,
       findSkillBySourceIdentity: jest.fn(async ({ upstreamId }) =>
@@ -1824,7 +1847,7 @@ describe('createGitHubSkillSyncRunner', () => {
       return { skill: restoredSkill, warnings: [] };
     });
     const deleteSkill = jest.fn(async (id: string) => {
-      return { deleted: persistedSkills.delete(id) };
+      return completeSkillDeletion(persistedSkills.delete(id));
     });
     const deps = createDeps({
       fetchFn: githubFetch('---\nname: renamed\ndescription: Renamed skill\n---\nBody'),
@@ -1868,60 +1891,85 @@ describe('createGitHubSkillSyncRunner', () => {
     );
   });
 
-  it('fails the source when stale mirror deletion can leave partial persisted state', async () => {
-    const staleId = new Types.ObjectId();
-    const existingId = new Types.ObjectId();
-    const author = makeSourceAuthorId();
-    const makeExisting = (
-      upstreamId: string,
-      _id: Types.ObjectId,
-      name: string,
-    ): ISkill & { _id: Types.ObjectId } => {
-      const skill = makeSkill({
-        name,
-        description: `${name} skill`,
+  it.each([
+    { failedStep: 'skill_files' as const, expectedBlobDeletes: 0 },
+    { failedStep: 'permissions' as const, expectedBlobDeletes: 1 },
+  ])(
+    'fails the source and safely handles blobs when stale deletion leaves $failedStep incomplete',
+    async ({ failedStep, expectedBlobDeletes }) => {
+      const staleId = new Types.ObjectId();
+      const existingId = new Types.ObjectId();
+      const author = makeSourceAuthorId();
+      const makeExisting = (
+        upstreamId: string,
+        _id: Types.ObjectId,
+        name: string,
+      ): ISkill & { _id: Types.ObjectId } => {
+        const skill = makeSkill({
+          name,
+          description: `${name} skill`,
+          author,
+          authorName: 'GitHub Sync',
+          source: 'github',
+          sourceMetadata: { provider: 'github', sourceId: 'librechat-skills', upstreamId },
+        });
+        skill._id = _id;
+        return skill;
+      };
+      const staleSkill = makeExisting('librechat-skills:skills/removed', staleId, 'renamed');
+      const syncedSkill = makeExisting('librechat-skills:skills/research', existingId, 'research');
+      const deleteSkill = jest.fn(async (id: string) => {
+        if (id === staleId.toString()) {
+          return incompleteSkillDeletion([failedStep]);
+        }
+        return completeSkillDeletion(true);
+      });
+      const staleFile = {
+        _id: new Types.ObjectId(),
+        skillId: staleId,
+        relativePath: 'references/stale.md',
+        filepath: '/uploads/stale.md',
+        source: 'local',
         author,
-        authorName: 'GitHub Sync',
-        source: 'github',
-        sourceMetadata: { provider: 'github', sourceId: 'librechat-skills', upstreamId },
+      } as ISkillFile & { _id: Types.ObjectId };
+      const deleteFile = jest.fn(
+        async (_file: Parameters<NonNullable<GitHubSkillSyncDeps['deleteFile']>>[0]) => undefined,
+      );
+      const deps = createDeps({
+        fetchFn: githubFetch('---\nname: renamed\ndescription: Renamed skill\n---\nBody'),
+        findSkillBySourceIdentity: jest.fn(async ({ upstreamId }) =>
+          upstreamId === 'librechat-skills:skills/research' ? syncedSkill : null,
+        ),
+        getSkillById: jest.fn(async (id) =>
+          id.toString() === existingId.toString() ? syncedSkill : null,
+        ),
+        listSkillsBySource: jest.fn(async () => [staleSkill, syncedSkill]),
+        listSkillFiles: jest.fn(async (id) =>
+          id.toString() === staleId.toString() ? [staleFile] : [],
+        ),
+        deleteFile,
+        deleteSkill,
+        updateSkill: jest.fn(),
       });
-      skill._id = _id;
-      return skill;
-    };
-    const staleSkill = makeExisting('librechat-skills:skills/removed', staleId, 'renamed');
-    const syncedSkill = makeExisting('librechat-skills:skills/research', existingId, 'research');
-    const deleteSkill = jest.fn(async (id: string) => {
-      if (id === staleId.toString()) {
-        throw new Error('skill file deletion unavailable');
-      }
-      return { deleted: true };
-    });
-    const deps = createDeps({
-      fetchFn: githubFetch('---\nname: renamed\ndescription: Renamed skill\n---\nBody'),
-      findSkillBySourceIdentity: jest.fn(async ({ upstreamId }) =>
-        upstreamId === 'librechat-skills:skills/research' ? syncedSkill : null,
-      ),
-      getSkillById: jest.fn(async (id) =>
-        id.toString() === existingId.toString() ? syncedSkill : null,
-      ),
-      listSkillsBySource: jest.fn(async () => [staleSkill, syncedSkill]),
-      deleteSkill,
-      updateSkill: jest.fn(),
-    });
-    const runner = createGitHubSkillSyncRunner(deps);
-    const result = await runner.runOnce();
+      const runner = createGitHubSkillSyncRunner(deps);
+      const result = await runner.runOnce();
 
-    expect(result.status).toBe('failed');
-    expect(deleteSkill).toHaveBeenCalledWith(staleId.toString());
-    expect(deps.updateSkill).not.toHaveBeenCalled();
-    expect(deps.upsertStatus).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        status: 'failed',
-        errorCode: 'SYNC_ROLLBACK_FAILED',
-        errorMessage: 'Stale mirror deletion failed: skill file deletion unavailable',
-      }),
-    );
-  });
+      expect(result.status).toBe('failed');
+      expect(deleteSkill).toHaveBeenCalledWith(staleId.toString());
+      const staleBlobCalls = deleteFile.mock.calls.filter(
+        ([file]) => file.filepath === staleFile.filepath,
+      );
+      expect(staleBlobCalls).toHaveLength(expectedBlobDeletes);
+      expect(deps.updateSkill).not.toHaveBeenCalled();
+      expect(deps.upsertStatus).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          status: 'failed',
+          errorCode: 'SYNC_ROLLBACK_FAILED',
+          errorMessage: `Stale mirror deletion failed: Skill cleanup did not finish: ${failedStep}`,
+        }),
+      );
+    },
+  );
 
   it("does not mirror-delete another tenant's skills from an ambient source run", async () => {
     const ambientStaleId = new Types.ObjectId();
@@ -2476,7 +2524,7 @@ describe('createGitHubSkillSyncRunner', () => {
     expect(deps.deleteSkill).not.toHaveBeenCalled();
   });
 
-  it('fails the source when a skill rollback leaves a half-written mirror', async () => {
+  it('fails the source when skill rollback reports incomplete cleanup', async () => {
     /* A clean rollback is just a skipped skill. A failed one leaves the mirror
        inconsistent, which must not be reported as a partial success next to
        the skills that did publish. */
@@ -2484,9 +2532,7 @@ describe('createGitHubSkillSyncRunner', () => {
       saveBuffer: jest.fn(async () => {
         throw new Error('storage unavailable');
       }),
-      deleteSkill: jest.fn(async () => {
-        throw new Error('rollback unavailable');
-      }),
+      deleteSkill: jest.fn(async () => incompleteSkillDeletion(['permissions'])),
     });
     const runner = createGitHubSkillSyncRunner(deps);
     const result = await runner.runOnce();
@@ -2506,7 +2552,7 @@ describe('createGitHubSkillSyncRunner', () => {
     const deleteFile = jest.fn(async () => {
       throw new Error('storage cleanup unavailable');
     });
-    const deleteSkill = jest.fn(async () => ({ deleted: true }));
+    const deleteSkill = jest.fn(async () => completeSkillDeletion(true));
     const deps = createDeps({
       listSkillFiles: jest.fn(async () => storedFiles),
       upsertSkillFile: jest.fn(async (input: UpsertSkillFileInput) => {
@@ -2700,7 +2746,7 @@ describe('createGitHubSkillSyncRunner', () => {
       },
     }) as ISkill & { _id: Types.ObjectId };
     let createdSkill: (ISkill & { _id: Types.ObjectId }) | undefined;
-    const deleteSkill = jest.fn(async () => ({ deleted: true }));
+    const deleteSkill = jest.fn(async () => completeSkillDeletion(true));
     const deps = createDeps({
       fetchFn: githubFetch(
         '---\nname: renamed-research\ndescription: Renamed research skill\n---\nBody',
diff --git a/packages/api/src/skills/sync/github.ts b/packages/api/src/skills/sync/github.ts
index e48ad2f30ef..aadc502f38b 100644
--- a/packages/api/src/skills/sync/github.ts
+++ b/packages/api/src/skills/sync/github.ts
@@ -23,6 +23,7 @@ import type {
   SkillSyncProvider,
   SkillSyncCredentialSummary,
   SkillSyncStatusInput,
+  DeleteSkillResult,
 } from '@librechat/data-schemas';
 import type { SkillSyncConfig, SkillSyncGitHubSourceConfig } from 'librechat-data-provider';
 import type {
@@ -206,7 +207,7 @@ export type GitHubSkillSyncDeps = {
     skillId: string | Types.ObjectId,
     relativePath: string,
   ) => Promise<{ deleted: boolean }>;
-  deleteSkill: (id: string) => Promise<{ deleted: boolean }>;
+  deleteSkill: (id: string) => Promise<DeleteSkillResult>;
   saveBuffer: (params: {
     userId: string;
     buffer: Buffer;
@@ -1072,7 +1073,20 @@ async function deleteSyncedSkillForRestore(
   skill: ISkill & { _id: Types.ObjectId },
 ): Promise<{ deletedFileCount: number; deletedSkill: DeletedSyncedSkillJournal }> {
   const files = await deps.listSkillFiles(skill._id);
-  await deps.deleteSkill(skill._id.toString());
+  const deletion = await deps.deleteSkill(skill._id.toString());
+  if (!deletion.cleanupComplete) {
+    if (!deletion.failedCleanupSteps.includes('skill_files')) {
+      await cleanupStoredFiles({
+        deps,
+        files: files.map(toStoredFileRefFromSkillFile),
+        logMessage: '[GitHubSkillSync] Failed to clean up partially deleted stale skill file:',
+        throwOnError: true,
+      });
+    }
+    throw new Error(
+      `Skill cleanup did not finish: ${deletion.failedCleanupSteps.join(', ') || 'unknown step'}`,
+    );
+  }
   return {
     deletedFileCount: files.length,
     deletedSkill: { skill, files },
@@ -1396,16 +1410,23 @@ async function deleteSyncedSkill(
   skill: ISkill & { _id: Types.ObjectId },
 ): Promise<number> {
   const files = await deps.listSkillFiles(skill._id);
+  const deletion = await deps.deleteSkill(skill._id.toString());
   let deletedFiles = 0;
   const cleanupErrors: unknown[] = [];
-  for (const file of files) {
-    await cleanupFile(deps, file).catch((cleanupError) => {
-      cleanupErrors.push(cleanupError);
-      logger.error('[GitHubSkillSync] Failed to clean up mirrored skill file:', cleanupError);
-    });
-    deletedFiles++;
+  if (!deletion.failedCleanupSteps.includes('skill_files')) {
+    for (const file of files) {
+      await cleanupFile(deps, file).catch((cleanupError) => {
+        cleanupErrors.push(cleanupError);
+        logger.error('[GitHubSkillSync] Failed to clean up mirrored skill file:', cleanupError);
+      });
+      deletedFiles++;
+    }
+  }
+  if (!deletion.cleanupComplete) {
+    throw new Error(
+      `Skill cleanup did not finish: ${deletion.failedCleanupSteps.join(', ') || 'unknown step'}`,
+    );
   }
-  await deps.deleteSkill(skill._id.toString());
   if (cleanupErrors.length > 0) {
     throw cleanupErrors[0];
   }
diff --git a/packages/api/src/storage/cloudfront/__tests__/crud.test.ts b/packages/api/src/storage/cloudfront/__tests__/crud.test.ts
index cde16c73e08..8b24bc6f75f 100644
--- a/packages/api/src/storage/cloudfront/__tests__/crud.test.ts
+++ b/packages/api/src/storage/cloudfront/__tests__/crud.test.ts
@@ -1,4 +1,5 @@
 import { Readable } from 'stream';
+import { finished } from 'stream/promises';
 import type { TFile } from 'librechat-data-provider';
 import type { CloudFrontFullConfig } from '~/cdn/cloudfront';
 import type { ServerRequest } from '~/types';
@@ -10,17 +11,20 @@ const mockSaveURLToS3WithMetadata = jest.fn();
 const mockUploadFileToS3 = jest.fn();
 const mockDeleteFileFromS3 = jest.fn();
 const mockGetS3FileStream = jest.fn();
+const mockParseS3Key = jest.fn();
 const mockExtractKeyFromS3Url = jest.fn<string, [string]>();
 const mockResolveStoredS3Key = jest.fn<string, [TFile]>();
 const mockCloudFrontSend = jest.fn();
 const mockGetSignedUrl = jest.fn<string, [object]>();
 const mockLogger = { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() };
+const originalFetch = global.fetch;
 
 jest.mock('~/cdn/cloudfront', () => ({
   getCloudFrontConfig: mockGetCloudFrontConfig,
 }));
 
 jest.mock('~/storage/s3/crud', () => ({
+  parseS3Key: mockParseS3Key,
   getS3Key: mockGetS3Key,
   saveBufferToS3: mockSaveBufferToS3,
   saveURLToS3WithMetadata: mockSaveURLToS3WithMetadata,
@@ -62,6 +66,10 @@ function makeConfig(overrides: Partial<CloudFrontFullConfig> = {}): CloudFrontFu
 }
 
 describe('CloudFront CRUD', () => {
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
   beforeEach(() => {
     jest.clearAllMocks();
     mockGetS3Key.mockImplementation(
@@ -610,9 +618,137 @@ describe('CloudFront CRUD', () => {
   });
 
   describe('getCloudFrontFileStream', () => {
-    it('delegates to getS3FileStream', async () => {
+    const remoteKey = 'i/r/eu-west-1/images/u/f.webp';
+    const responseFor = (body: Readable) =>
+      new Response(Readable.toWeb(body) as unknown as BodyInit);
+
+    beforeEach(() => {
+      mockExtractKeyFromS3Url.mockReturnValue(remoteKey);
+      mockParseS3Key.mockReturnValue({ storageRegion: 'eu-west-1' });
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('forwards a body error to the returned stream', async () => {
+      const body = new Readable({ read() {} });
+      jest.spyOn(global, 'fetch').mockResolvedValue(responseFor(body));
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream({} as ServerRequest, remoteKey);
+      const result = finished(stream);
+      body.destroy(new Error('terminated'));
+      await expect(result).rejects.toThrow('terminated');
+    });
+
+    it('forwards caller cancellation after headers and cancels the body', async () => {
+      const body = new Readable({ read() {} });
+      const controller = new AbortController();
+      jest.spyOn(global, 'fetch').mockResolvedValue(responseFor(body));
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream({} as ServerRequest, remoteKey, {
+        signal: controller.signal,
+      });
+      const result = finished(stream);
+      controller.abort();
+      await expect(result).rejects.toMatchObject({ name: 'AbortError' });
+      expect(body.destroyed).toBe(true);
+    });
+
+    it('cancels the body when the returned stream is destroyed', async () => {
+      const body = new Readable({ read() {} });
+      jest.spyOn(global, 'fetch').mockResolvedValue(responseFor(body));
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream({} as ServerRequest, remoteKey);
+      const result = finished(stream);
+      stream.destroy();
+      await expect(result).rejects.toThrow('Premature close');
+      expect(body.destroyed).toBe(true);
+    });
+
+    it('cancels the body when the streamed byte limit is exceeded', async () => {
+      const limits = await import('~/storage/url');
+      jest.spyOn(limits, 'getRemoteFileFetchMaxBytes').mockReturnValue(3);
+      const body = new Readable({ read() {} });
+      jest.spyOn(global, 'fetch').mockResolvedValue(responseFor(body));
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream({} as ServerRequest, remoteKey);
+      const result = finished(stream);
+      stream.resume();
+      body.push('large');
+      await expect(result).rejects.toThrow('Remote file response too large');
+      expect(body.destroyed).toBe(true);
+    });
+
+    it('preserves caller cancellation before headers and clears the timeout', async () => {
+      jest.useFakeTimers();
+      jest.spyOn(global, 'fetch').mockImplementation(
+        (_url, init) =>
+          new Promise((_resolve, reject) => {
+            init?.signal?.addEventListener('abort', () => reject(init.signal?.reason), {
+              once: true,
+            });
+          }),
+      );
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const controller = new AbortController();
+      const result = getCloudFrontFileStream({} as ServerRequest, remoteKey, {
+        signal: controller.signal,
+      });
+      controller.abort();
+      await expect(result).rejects.toMatchObject({ name: 'AbortError' });
+      expect(jest.getTimerCount()).toBe(0);
+    });
+
+    it.each([false, true])(
+      'times out response headers with caller signal=%s',
+      async (withSignal) => {
+        jest.useFakeTimers();
+        jest.spyOn(global, 'fetch').mockImplementation(
+          (_url, init) =>
+            new Promise((_resolve, reject) => {
+              init?.signal?.addEventListener('abort', () => reject(init.signal?.reason), {
+                once: true,
+              });
+            }),
+        );
+        const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+        const { getRemoteFileFetchTimeoutMs } = await import('~/storage/url');
+        const controller = new AbortController();
+        const result = getCloudFrontFileStream(
+          {} as ServerRequest,
+          remoteKey,
+          withSignal ? { signal: controller.signal } : undefined,
+        );
+        await Promise.all([
+          expect(result).rejects.toMatchObject({ name: 'AbortError' }),
+          jest.advanceTimersByTimeAsync(getRemoteFileFetchTimeoutMs()),
+        ]);
+        expect(controller.signal.aborted).toBe(false);
+        expect(jest.getTimerCount()).toBe(0);
+      },
+    );
+
+    it('clears the header timeout while the body is still streaming', async () => {
+      jest.useFakeTimers();
+      const body = new Readable({ read() {} });
+      jest.spyOn(global, 'fetch').mockResolvedValue(responseFor(body));
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream({} as ServerRequest, remoteKey);
+      expect(jest.getTimerCount()).toBe(0);
+      jest.useRealTimers();
+      const result = finished(stream);
+      stream.resume();
+      body.push('remote');
+      body.push(null);
+      await result;
+    });
+
+    it('reads a local-region key directly from S3', async () => {
       const readable = new Readable();
       mockGetS3FileStream.mockResolvedValue(readable);
+      mockExtractKeyFromS3Url.mockReturnValue('r/us-east-1/images/u/f.webp');
+      mockParseS3Key.mockReturnValue({ storageRegion: 'us-east-1' });
 
       const mockReq = { user: { id: 'u' } } as ServerRequest;
       const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
@@ -623,11 +759,85 @@ describe('CloudFront CRUD', () => {
 
       expect(mockGetS3FileStream).toHaveBeenCalledWith(
         mockReq,
-        'https://d123.cloudfront.net/images/u/f.webp',
+        'r/us-east-1/images/u/f.webp',
         undefined,
       );
       expect(result).toBe(readable);
     });
+
+    it('reads a cross-region key through CloudFront', async () => {
+      mockGetCloudFrontConfig.mockReturnValue(
+        makeConfig({ privateKey: 'pk-secret', keyPairId: 'K123' }),
+      );
+      mockExtractKeyFromS3Url.mockReturnValue('i/r/eu-west-1/images/u/f.webp');
+      mockParseS3Key.mockReturnValue({ storageRegion: 'eu-west-1' });
+      mockGetSignedUrl.mockReturnValue(
+        'https://d123.cloudfront.net/i/r/eu-west-1/images/u/f.webp?Policy=abc',
+      );
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        headers: { get: () => '6' },
+        body: Readable.toWeb(Readable.from('remote')),
+      }) as unknown as typeof fetch;
+
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      const stream = await getCloudFrontFileStream(
+        { user: { id: 'u' } } as ServerRequest,
+        'i/r/eu-west-1/images/u/f.webp',
+      );
+      const chunks: Buffer[] = [];
+      for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+      }
+
+      expect(Buffer.concat(chunks).toString()).toBe('remote');
+      expect(mockGetS3FileStream).not.toHaveBeenCalled();
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://d123.cloudfront.net/i/r/eu-west-1/images/u/f.webp?Policy=abc',
+        expect.objectContaining({ signal: expect.any(Object) }),
+      );
+    });
+
+    it('preserves a cross-region CloudFront 404 for missing-attachment handling', async () => {
+      mockExtractKeyFromS3Url.mockReturnValue('i/r/eu-west-1/images/u/missing.webp');
+      mockParseS3Key.mockReturnValue({ storageRegion: 'eu-west-1' });
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        body: { cancel },
+      }) as unknown as typeof fetch;
+
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      await expect(
+        getCloudFrontFileStream(
+          { user: { id: 'u' } } as ServerRequest,
+          'i/r/eu-west-1/images/u/missing.webp',
+        ),
+      ).rejects.toMatchObject({ status: 404 });
+      expect(cancel).toHaveBeenCalled();
+    });
+
+    it('cancels an oversized cross-region response', async () => {
+      mockExtractKeyFromS3Url.mockReturnValue('i/r/eu-west-1/images/u/large.webp');
+      mockParseS3Key.mockReturnValue({ storageRegion: 'eu-west-1' });
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        headers: { get: () => String(513 * 1024 * 1024) },
+        body: { cancel },
+      }) as unknown as typeof fetch;
+
+      const { getCloudFrontFileStream } = await import('~/storage/cloudfront/crud');
+      await expect(
+        getCloudFrontFileStream(
+          { user: { id: 'u' } } as ServerRequest,
+          'i/r/eu-west-1/images/u/large.webp',
+        ),
+      ).rejects.toThrow('Remote file response too large');
+      expect(cancel).toHaveBeenCalled();
+    });
   });
 
   describe('getCloudFrontDownloadURL', () => {
diff --git a/packages/api/src/storage/cloudfront/crud.ts b/packages/api/src/storage/cloudfront/crud.ts
index 21801728cf9..764c4e34ee7 100644
--- a/packages/api/src/storage/cloudfront/crud.ts
+++ b/packages/api/src/storage/cloudfront/crud.ts
@@ -1,9 +1,9 @@
 import crypto from 'crypto';
+import { Readable, pipeline } from 'stream';
 import { logger } from '@librechat/data-schemas';
 import { getSignedUrl } from '@aws-sdk/cloudfront-signer';
 import { CloudFrontClient, CreateInvalidationCommand } from '@aws-sdk/client-cloudfront';
 import type { TFile } from 'librechat-data-provider';
-import type { Readable } from 'stream';
 import type {
   SaveBufferParams,
   GetURLParams,
@@ -15,7 +15,9 @@ import type {
 } from '~/storage/types';
 import type { ServerRequest } from '~/types';
 import {
+  parseS3Key,
   getS3Key,
+  extractKeyFromS3Url,
   saveBufferToS3,
   saveURLToS3WithMetadata,
   uploadFileToS3,
@@ -23,6 +25,12 @@ import {
   getS3FileStream,
   resolveStoredS3Key,
 } from '~/storage/s3/crud';
+import {
+  getRemoteFileFetchMaxBytes,
+  getRemoteFileFetchTimeoutMs,
+  assertRemoteFileContentLength,
+  createRemoteFileByteLimitTransform,
+} from '~/storage/url';
 import { AVATAR_BASE_PATH, DEFAULT_BASE_PATH as defaultBasePath } from '~/storage/constants';
 import { sanitizeContentDispositionFilename } from '~/storage/validation';
 import { getCloudFrontConfig } from '~/cdn/cloudfront';
@@ -267,13 +275,65 @@ export async function deleteFileFromCloudFront(req: ServerRequest, file: TFile):
   }
 }
 
-/** Get file stream from S3 storage. */
+/** Get a file stream from its owning regional origin. */
 export async function getCloudFrontFileStream(
   req: ServerRequest,
   filePath: string,
   options?: { signal?: AbortSignal },
 ): Promise<Readable> {
-  return getS3FileStream(req, filePath, options);
+  const key = extractKeyFromS3Url(filePath);
+  const storageRegion = parseS3Key(key)?.storageRegion;
+  const localStorageRegion = getCloudFrontConfig()?.storageRegion ?? s3Config.AWS_REGION;
+
+  if (!storageRegion || storageRegion === localStorageRegion) {
+    return getS3FileStream(req, key, options);
+  }
+
+  const maxBytes = getRemoteFileFetchMaxBytes();
+  const unsignedUrl = buildCloudFrontUrl(key);
+  const config = getCloudFrontConfig();
+  const url = config?.privateKey && config.keyPairId ? signUrl(unsignedUrl) : unsignedUrl;
+  const controller = new AbortController();
+  const signal = options?.signal
+    ? AbortSignal.any([options.signal, controller.signal])
+    : controller.signal;
+  const timeout = setTimeout(() => controller.abort(), getRemoteFileFetchTimeoutMs());
+  let response: Response;
+  try {
+    response = await fetch(url, { signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => undefined);
+    const error = new Error(
+      `[getCloudFrontFileStream] CloudFront returned ${response.status} ${response.statusText}`,
+    ) as Error & { status: number };
+    error.status = response.status;
+    throw error;
+  }
+  if (!response.body) {
+    throw new Error('[getCloudFrontFileStream] CloudFront response body is empty');
+  }
+
+  try {
+    assertRemoteFileContentLength(response.headers, maxBytes);
+  } catch (error) {
+    await response.body.cancel().catch(() => undefined);
+    throw error;
+  }
+  const stream = createRemoteFileByteLimitTransform(maxBytes);
+  pipeline(
+    Readable.fromWeb(response.body as unknown as Parameters<typeof Readable.fromWeb>[0], {
+      signal,
+    }),
+    stream,
+    () => {
+      /** Pipeline forwards failures to the returned stream and closes both ends. */
+    },
+  );
+  return stream;
 }
 
 /** Get a signed CloudFront URL for an authorized file download. */
diff --git a/packages/api/src/stream/GenerationJobManager.ts b/packages/api/src/stream/GenerationJobManager.ts
index 7c65136c227..a547193cc00 100644
--- a/packages/api/src/stream/GenerationJobManager.ts
+++ b/packages/api/src/stream/GenerationJobManager.ts
@@ -6734,10 +6734,13 @@ class GenerationJobManagerClass {
      * One decision drives both durable-log and publish batching: the append and
      * the sequence allocation for an event must stay tightly coupled in time, or
      * the resume frontier (chunk-log snapshot → sequence-counter sync) misreads
-     * a window's tail as already-delivered or as duplicates.
+     * a window's tail as already-delivered or as duplicates. Before first-subscriber
+     * admission, each append is awaited for snapshot safety; batching that path
+     * would add a full window of producer latency to every delta.
      */
     const coalescableDelta =
       this._deltaCoalescingEnabled &&
+      (runtime.hasSubscriber || runtime.everHadSubscriber) &&
       !runtime.startupTelemetry &&
       options?.durable !== true &&
       options?.deliveredSteer == null &&
diff --git a/packages/api/src/stream/__tests__/deltaCoalescing.spec.ts b/packages/api/src/stream/__tests__/deltaCoalescing.spec.ts
index 42ebfde2b74..c2822d3f5e2 100644
--- a/packages/api/src/stream/__tests__/deltaCoalescing.spec.ts
+++ b/packages/api/src/stream/__tests__/deltaCoalescing.spec.ts
@@ -4,6 +4,7 @@ import { InMemoryEventTransport } from '~/stream/implementations/InMemoryEventTr
 import { registerChunkPublicationCapability } from '~/stream/internal/chunkPublication';
 import { InMemoryJobStore } from '~/stream/implementations/InMemoryJobStore';
 import { GenerationJobManagerClass } from '~/stream/GenerationJobManager';
+import { resolveCoalesceWindowMs } from '~/stream/internal/coalescing';
 
 jest.spyOn(console, 'log').mockImplementation();
 
@@ -37,6 +38,7 @@ describe('delta coalescing manager gating and backpressure', () => {
   async function createManager(options: {
     windowMs: string | undefined;
     advertise: boolean;
+    isRedis?: boolean;
   }): Promise<{
     manager: GenerationJobManagerClass;
     publishCalls: Array<unknown[]>;
@@ -64,7 +66,7 @@ describe('delta coalescing manager gating and backpressure', () => {
     });
 
     const manager = new GenerationJobManagerClass();
-    manager.configure({ jobStore, eventTransport, isRedis: true });
+    manager.configure({ jobStore, eventTransport, isRedis: options.isRedis ?? true });
     manager.initialize();
     return {
       manager,
@@ -83,6 +85,7 @@ describe('delta coalescing manager gating and backpressure', () => {
       advertise: false,
     });
     await manager.createJob('gate-off', 'user-1', 'gate-off');
+    await manager.subscribe('gate-off', jest.fn());
 
     const emission = manager.emitChunk('gate-off', DELTA_EVENT);
     await new Promise((resolve) => setImmediate(resolve));
@@ -105,27 +108,62 @@ describe('delta coalescing manager gating and backpressure', () => {
     await manager.destroy();
   });
 
-  it('sends coalesce hints and stops awaiting receipts when both services advertise support', async () => {
+  it.each([undefined, '25'])(
+    'sends coalesce hints without awaiting receipts with capable Redis services and window %s',
+    async (windowMs) => {
+      const { manager, publishCalls, settleAll } = await createManager({
+        windowMs,
+        advertise: true,
+      });
+      await manager.createJob('gate-on', 'user-1', 'gate-on');
+      await manager.subscribe('gate-on', jest.fn());
+
+      await manager.emitChunk('gate-on', DELTA_EVENT);
+      expect(publishCalls).toHaveLength(1);
+      expect(publishCalls[0][3]).toEqual({ coalesce: true });
+
+      settleAll(0);
+      await manager.destroy();
+    },
+  );
+
+  it('does not batch the awaited append path before first subscriber admission', async () => {
     const { manager, publishCalls, settleAll } = await createManager({
-      windowMs: '25',
+      windowMs: undefined,
       advertise: true,
     });
-    await manager.createJob('gate-on', 'user-1', 'gate-on');
-
-    await manager.emitChunk('gate-on', DELTA_EVENT);
-    expect(publishCalls).toHaveLength(1);
-    expect(publishCalls[0][3]).toEqual({ coalesce: true });
+    await manager.createJob('before-admission', 'user-1', 'before-admission');
 
+    const emission = manager.emitChunk('before-admission', DELTA_EVENT);
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(publishCalls[0]).toHaveLength(3);
     settleAll(0);
+    await emission;
     await manager.destroy();
   });
 
-  it('keeps the awaited path when the window is unset even with capable services', async () => {
+  it('continues batching after an admitted subscriber disconnects', async () => {
     const { manager, publishCalls, settleAll } = await createManager({
       windowMs: undefined,
       advertise: true,
     });
+    await manager.createJob('after-admission', 'user-1', 'after-admission');
+    const subscription = await manager.subscribe('after-admission', jest.fn());
+    subscription?.unsubscribe();
+
+    await manager.emitChunk('after-admission', DELTA_EVENT);
+    expect(publishCalls[0][3]).toEqual({ coalesce: true });
+    settleAll(0);
+    await manager.destroy();
+  });
+
+  it('keeps the awaited path with an explicit zero even with capable services', async () => {
+    const { manager, publishCalls, settleAll } = await createManager({
+      windowMs: '0',
+      advertise: true,
+    });
     await manager.createJob('window-off', 'user-1', 'window-off');
+    await manager.subscribe('window-off', jest.fn());
 
     const emission = manager.emitChunk('window-off', DELTA_EVENT);
     await new Promise((resolve) => setImmediate(resolve));
@@ -136,12 +174,52 @@ describe('delta coalescing manager gating and backpressure', () => {
     await manager.destroy();
   });
 
+  it('keeps attached in-memory streams on the awaited path with the default window', async () => {
+    const { manager, publishCalls, settleAll } = await createManager({
+      windowMs: undefined,
+      advertise: true,
+      isRedis: false,
+    });
+    await manager.createJob('memory-default', 'user-1', 'memory-default');
+    const subscription = await manager.subscribe('memory-default', jest.fn());
+
+    const emission = manager.emitChunk('memory-default', DELTA_EVENT);
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(publishCalls[0]).toHaveLength(3);
+    settleAll(0);
+    await emission;
+    subscription?.unsubscribe();
+    await manager.destroy();
+  });
+
+  it.each([
+    [undefined, 25],
+    ['0', 0],
+    ['', 0],
+    ['invalid', 0],
+    ['NaN', 0],
+    ['Infinity', 0],
+    ['-1', 0],
+    ['0.5', 0],
+    ['25', 25],
+    ['50.9', 50],
+    ['2000', 1000],
+  ])('resolves window %s to %s ms', (value, expected) => {
+    if (value === undefined) {
+      delete process.env.STREAM_DELTA_COALESCE_MS;
+    } else {
+      process.env.STREAM_DELTA_COALESCE_MS = value;
+    }
+    expect(resolveCoalesceWindowMs()).toBe(expected);
+  });
+
   it('applies backpressure once outstanding coalesced receipts hit the cap', async () => {
     const { manager, publishCalls, settleAll } = await createManager({
       windowMs: '25',
       advertise: true,
     });
     await manager.createJob('backpressure', 'user-1', 'backpressure');
+    await manager.subscribe('backpressure', jest.fn());
 
     /** The cap is 256: every emission below it resolves without awaiting the
      * (deliberately unsettled) publication receipts. */
diff --git a/packages/api/src/stream/__tests__/deltaCoalescing.stream_integration.spec.ts b/packages/api/src/stream/__tests__/deltaCoalescing.stream_integration.spec.ts
index 5db02086cc8..0359de0697e 100644
--- a/packages/api/src/stream/__tests__/deltaCoalescing.stream_integration.spec.ts
+++ b/packages/api/src/stream/__tests__/deltaCoalescing.stream_integration.spec.ts
@@ -1,4 +1,4 @@
-/* eslint jest/no-standalone-expect: ["error", { "additionalTestBlockFunctions": ["testRedis"] }] */
+/* eslint jest/no-standalone-expect: ["error", { "additionalTestBlockFunctions": ["testRedis", "testRedis.each"] }] */
 import type { Redis, Cluster } from 'ioredis';
 import type { emitChunkWithReceipt as EmitChunkWithReceipt } from '~/stream/internal/chunkPublication';
 import type { ServerSentEvent } from '~/types';
@@ -11,12 +11,12 @@ jest.spyOn(console, 'log').mockImplementation();
  * Integration tests for streaming-delta coalescing (STREAM_DELTA_COALESCE_MS > 0).
  *
  * Coalescing batches eligible delta publications (and their durable appends) into
- * one windowed frame while preserving per-event sequences, barrier ordering,
+ * one Redis request with legacy frames while preserving per-event sequences, barrier ordering,
  * terminal flushing, and the generation fence.
  *
  * Run with: USE_REDIS=true npx jest deltaCoalescing.stream_integration
  */
-describe('Delta coalescing integration', () => {
+describe.each([undefined, '25'])('Delta coalescing integration (window %s)', (windowMs) => {
   let originalEnv: NodeJS.ProcessEnv;
   let ioredisClient: Redis | Cluster | null = null;
   const testPrefix = 'DeltaCoalescing-Integration-Test';
@@ -28,7 +28,11 @@ describe('Delta coalescing integration', () => {
     process.env.USE_REDIS = process.env.USE_REDIS ?? 'true';
     process.env.REDIS_URI = process.env.REDIS_URI ?? 'redis://127.0.0.1:6379';
     process.env.REDIS_KEY_PREFIX = testPrefix;
-    process.env.STREAM_DELTA_COALESCE_MS = '25';
+    if (windowMs === undefined) {
+      delete process.env.STREAM_DELTA_COALESCE_MS;
+    } else {
+      process.env.STREAM_DELTA_COALESCE_MS = windowMs;
+    }
 
     jest.resetModules();
     const redisModule = await import('~/cache/redisClients');
@@ -98,7 +102,7 @@ describe('Delta coalescing integration', () => {
   }
 
   testRedis(
-    'delivers a coalesced window as individually sequenced chunks in order',
+    'publishes a window in one EVAL as legacy chunks readable without batch support',
     async () => {
       const { RedisEventTransport, emitChunkWithReceipt } = await importFreshTransportModules();
       const subscriber = (ioredisClient as Redis).duplicate();
@@ -107,10 +111,15 @@ describe('Delta coalescing integration', () => {
 
       const received: unknown[] = [];
       const rawSubscriber = (ioredisClient as Redis).duplicate();
-      const rawFrames: Array<{ type: string; count?: number }> = [];
+      const rawFrames: Array<{ type: string; seq: number; data: { data: { i: number } } }> = [];
+      const legacyReceived: number[] = [];
       rawSubscriber.on('message', (_channel: string, message: string) => {
-        const parsed = JSON.parse(message) as { type: string; events?: unknown[] };
-        rawFrames.push({ type: parsed.type, count: parsed.events?.length });
+        const parsed = JSON.parse(message) as (typeof rawFrames)[number];
+        rawFrames.push(parsed);
+        /** A pre-batching subscriber only recognizes the individual chunk envelope. */
+        if (parsed.type === 'chunk') {
+          legacyReceived.push(parsed.data.data.i);
+        }
       });
       await rawSubscriber.subscribe(`stream:{${streamId}}:events`);
 
@@ -119,6 +128,7 @@ describe('Delta coalescing integration', () => {
       });
       await subscription.ready;
 
+      const evalSpy = jest.spyOn(ioredisClient!, 'eval');
       const receipts = await Promise.all(
         Array.from({ length: 5 }, (_, i) =>
           emitChunkWithReceipt(
@@ -131,7 +141,10 @@ describe('Delta coalescing integration', () => {
         ),
       );
 
-      await waitFor(() => received.length === 5);
+      await waitFor(() => received.length === 5 && rawFrames.length === 5);
+      expect(evalSpy).toHaveBeenCalledTimes(1);
+      evalSpy.mockRestore();
+      expect(legacyReceived).toEqual([0, 1, 2, 3, 4]);
       expect(received.map((event) => (event as { data: { i: number } }).data.i)).toEqual([
         0, 1, 2, 3, 4,
       ]);
@@ -140,9 +153,8 @@ describe('Delta coalescing integration', () => {
       for (let i = 1; i < sequences.length; i++) {
         expect(sequences[i]).toBe(sequences[0] + i);
       }
-      const batchFrames = rawFrames.filter((frame) => frame.type === 'chunk_batch');
-      expect(batchFrames).toHaveLength(1);
-      expect(batchFrames[0].count).toBe(5);
+      expect(rawFrames.map((frame) => frame.type)).toEqual(Array(5).fill('chunk'));
+      expect(rawFrames.map((frame) => frame.seq)).toEqual(sequences);
 
       subscription.unsubscribe();
       transport.destroy();
@@ -151,6 +163,170 @@ describe('Delta coalescing integration', () => {
     15000,
   );
 
+  testRedis.each([
+    { name: 'below byte cap, untagged', offset: -1, tagged: false, count: 2, character: 'x' },
+    { name: 'at byte cap, untagged', offset: 0, tagged: false, count: 2, character: 'x' },
+    { name: 'above byte cap, untagged', offset: 1, tagged: false, count: 2, character: 'x' },
+    { name: 'below byte cap, tagged', offset: -1, tagged: true, count: 2, character: 'x' },
+    { name: 'at byte cap, tagged', offset: 0, tagged: true, count: 2, character: 'x' },
+    { name: 'above byte cap, tagged', offset: 1, tagged: true, count: 2, character: 'x' },
+    { name: 'below byte cap, non-ASCII', offset: -1, tagged: true, count: 2, character: '雪' },
+    { name: 'at event cap', offset: -1000, tagged: true, count: 64, character: 'x' },
+  ])(
+    'aligns append and publication flushes $name',
+    async ({ offset, tagged, count, character }) => {
+      const { RedisEventTransport, emitChunkWithReceipt } = await importFreshTransportModules();
+      const { RedisJobStore } = await import('../implementations/RedisJobStore');
+      const { MAX_COALESCED_BYTES, MAX_COALESCED_EVENTS } = await import('../internal/coalescing');
+      const store = new RedisJobStore(ioredisClient!);
+      const transport = new RedisEventTransport(
+        ioredisClient!,
+        (ioredisClient as Redis).duplicate(),
+      );
+      const reader = (ioredisClient as Redis).duplicate();
+      const streamId = `coalesce-boundary-${Date.now()}`;
+      const job = await store.createJob(streamId, 'user-1', streamId);
+      await reader.ping();
+      const generationId = tagged ? job.createdAt : undefined;
+      const eventWithText = (text: string) => ({ event: 'on_message_delta', data: { text } });
+      const targetSize = MAX_COALESCED_BYTES + offset;
+      const emptySize = JSON.stringify(eventWithText('')).length;
+      const baseSize = Math.floor(targetSize / count);
+      const events = Array.from({ length: count }, (_, index) =>
+        eventWithText(
+          character.repeat(
+            (index === count - 1 ? targetSize - baseSize * (count - 1) : baseSize) - emptySize,
+          ),
+        ),
+      );
+      expect(events.reduce((size, event) => size + JSON.stringify(event).length, 0)).toBe(
+        targetSize,
+      );
+      const immediate = targetSize >= MAX_COALESCED_BYTES || count >= MAX_COALESCED_EVENTS;
+      const evalSpy = jest.spyOn(ioredisClient!, 'eval');
+      const appends: Array<Promise<boolean>> = [];
+      const publications: Array<ReturnType<typeof emitChunkWithReceipt>> = [];
+
+      /** Freeze only timers: real Redis I/O continues, while scheduler speed cannot
+       * conceal one coalescer flushing before the other's window expires. */
+      jest.useFakeTimers({
+        doNotFake: [
+          'Date',
+          'hrtime',
+          'nextTick',
+          'performance',
+          'queueMicrotask',
+          'setImmediate',
+          'clearImmediate',
+        ],
+      });
+      try {
+        for (const event of events) {
+          appends.push(
+            store.appendChunk(streamId, event, generationId, undefined, { coalesce: true }),
+          );
+          publications.push(
+            emitChunkWithReceipt(transport, streamId, event, generationId, { coalesce: true }),
+          );
+        }
+        /** Append script has eight keys; publication has three. Both must issue on
+         * the same boundary, with durable append first, or neither may issue yet. */
+        expect(evalSpy.mock.calls.map((call) => call[1])).toEqual(immediate ? [8, 3] : []);
+        if (!immediate) {
+          expect(await reader.xlen(`stream:{${streamId}}:chunks`)).toBe(0);
+          expect(await reader.get(`stream:{${streamId}}:seq`)).toBeNull();
+          await jest.advanceTimersByTimeAsync(25);
+        }
+        expect(await Promise.all(appends)).toEqual(Array(count).fill(true));
+        expect(await Promise.all(publications)).toEqual(Array.from({ length: count }, (_, i) => i));
+        expect(evalSpy.mock.calls.map((call) => call[1])).toEqual([8, 3]);
+
+        /** A different connection reads only durable Redis state, never the owner's
+         * local pending buffer. Its log and publication frontier must agree. */
+        const entries = await reader.xrange(`stream:{${streamId}}:chunks`, '-', '+');
+        expect(
+          entries.map(([, fields]) => JSON.parse(fields[fields.indexOf('event') + 1])),
+        ).toEqual(events);
+        expect(await reader.get(`stream:{${streamId}}:seq`)).toBe(String(count));
+        await jest.advanceTimersByTimeAsync(25);
+        expect(evalSpy).toHaveBeenCalledTimes(2);
+      } finally {
+        evalSpy.mockRestore();
+        transport.destroy();
+        await store.destroy();
+        reader.disconnect();
+        jest.useRealTimers();
+      }
+    },
+  );
+
+  testRedis('preserves JSON payloads and generation tags in coalesced legacy frames', async () => {
+    const { RedisEventTransport, emitChunkWithReceipt } = await importFreshTransportModules();
+    const { RedisJobStore } = await import('../implementations/RedisJobStore');
+    const store = new RedisJobStore(ioredisClient!);
+    const streamId = `coalesce-json-${Date.now()}`;
+    const job = await store.createJob(streamId, 'user-1', streamId);
+    const rawSubscriber = (ioredisClient as Redis).duplicate();
+    const transport = new RedisEventTransport(ioredisClient!, (ioredisClient as Redis).duplicate());
+    const frames: Array<{ type: string; seq: number; data?: object | null; generationId: number }> =
+      [];
+    rawSubscriber.on('message', (_channel: string, message: string) => {
+      frames.push(JSON.parse(message) as (typeof frames)[number]);
+    });
+    await rawSubscriber.subscribe(`stream:{${streamId}}:events`);
+    const payloads = [
+      { arrays: [[], [null, []]], precise: 1.2345678901234567, text: '雪 "quoted" \n' },
+      null,
+      undefined,
+    ];
+    const receipts = await Promise.all(
+      payloads.map((payload) =>
+        emitChunkWithReceipt(transport, streamId, payload, job.createdAt, { coalesce: true }),
+      ),
+    );
+    await waitFor(() => frames.length === payloads.length);
+    expect(frames).toEqual(
+      payloads.map((data, index) => ({
+        type: 'chunk',
+        seq: receipts[index],
+        generationId: job.createdAt,
+        ...(data !== undefined && { data }),
+      })),
+    );
+    expect(frames[2]).not.toHaveProperty('data');
+    rawSubscriber.disconnect();
+    transport.destroy();
+    await store.destroy();
+  });
+
+  testRedis('still receives chunk_batch frames from existing opt-in producers', async () => {
+    const { RedisEventTransport } = await importFreshTransportModules();
+    const transport = new RedisEventTransport(ioredisClient!, (ioredisClient as Redis).duplicate());
+    const streamId = `coalesce-older-producer-${Date.now()}`;
+    const received: unknown[] = [];
+    let done = false;
+    const subscription = transport.subscribe(streamId, {
+      onChunk: (event) => received.push(event),
+      onDone: () => {
+        done = true;
+      },
+    });
+    await subscription.ready;
+    const events = [{ delta: 'first' }, { delta: 'second' }];
+    await ioredisClient!.publish(
+      `stream:{${streamId}}:events`,
+      JSON.stringify({ type: 'chunk_batch', baseSeq: 0, events }),
+    );
+    await ioredisClient!.publish(
+      `stream:{${streamId}}:events`,
+      JSON.stringify({ type: 'done', seq: 2, data: { final: true } }),
+    );
+    await waitFor(() => done);
+    expect(received).toEqual(events);
+    subscription.unsubscribe();
+    transport.destroy();
+  });
+
   testRedis(
     'a non-coalescable publication is a barrier that preserves emission order',
     async () => {
diff --git a/packages/api/src/stream/__tests__/helpers/publisher.ts b/packages/api/src/stream/__tests__/helpers/publisher.ts
index 9c2c65efabe..58e676d1434 100644
--- a/packages/api/src/stream/__tests__/helpers/publisher.ts
+++ b/packages/api/src/stream/__tests__/helpers/publisher.ts
@@ -76,13 +76,20 @@ export function createMockPublisher(): MockPublisher {
       _expectedGenerationId: string,
       _allowRetainedEpoch: string,
       _generationEpochGraceTtl: string,
+      _requireActiveJob: string,
+      sequenceCount = '1',
+      ...chunkSuffixes: string[]
     ) => {
       if (_numKeys === 1) {
         const frontier = await publisher.get(seqKey);
         await publisher.publish(jobKey, _generationEpochKey);
         return frontier ?? '0';
       }
+      const count = Number(sequenceCount);
       const val = (await publisher.incr(seqKey)) as number;
+      for (let i = 1; i < count; i++) {
+        await publisher.incr(seqKey);
+      }
       let ttl = Number(ttlSeconds);
       const seqTtl = (await publisher.ttl(seqKey)) as number;
       if (seqTtl < Math.floor(ttl / 2)) {
@@ -93,7 +100,13 @@ export function createMockPublisher(): MockPublisher {
         await publisher.expire(seqKey, ttl);
       }
       const seq = val - 1;
-      await publisher.publish(channel, `${prefix}${seq}${suffix}`);
+      if (chunkSuffixes.length > 0) {
+        for (let i = 0; i < count; i++) {
+          await publisher.publish(channel, `${prefix}${seq + i}${chunkSuffixes[i]}`);
+        }
+      } else {
+        await publisher.publish(channel, `${prefix}${seq}${suffix}`);
+      }
       return seq;
     },
   );
diff --git a/packages/api/src/stream/implementations/RedisEventTransport.ts b/packages/api/src/stream/implementations/RedisEventTransport.ts
index 274c089fd5c..58544475768 100644
--- a/packages/api/src/stream/implementations/RedisEventTransport.ts
+++ b/packages/api/src/stream/implementations/RedisEventTransport.ts
@@ -80,7 +80,7 @@ interface PubSubMessage {
 
 /**
  * Producer-side buffer of coalescable chunk publications for one stream.
- * Payloads are pre-serialized at enqueue so a flush only joins strings, and
+ * Payload suffixes are pre-serialized at enqueue so a flush only passes strings, and
  * each resolver settles its caller's receipt with `baseSeq + index`.
  */
 interface PendingChunkBatch {
@@ -147,12 +147,13 @@ interface PreemptRegistration {
  *     allowRetainedEpoch ("0" | "1"),
  *     generationEpochGraceTtl,
  *     requireActiveJob ("0" | "1"),
- *     sequenceCount
+ *     sequenceCount,
+ *     ...chunkSuffixes (optional, one per event for a coalesced publication)
  *   ]
  *   RETURNS: the 0-indexed first seq assigned to this frame, or -1 when the generation
- *   guard fails. A single-event frame passes count 1 and splices the seq; a coalesced
- *   frame passes its event count, reserves that many consecutive sequences in one INCRBY,
- *   and splices the base — event i in the frame owns base + i.
+ *   guard fails. A single frame splices its seq into prefix/suffix. A coalesced
+ *   publication reserves consecutive sequences in one INCRBY and publishes one
+ *   legacy chunk frame per suffix, keeping pre-batching subscribers compatible.
  *
  * During a rolling deployment, a job created by the previous version can expire without
  * leaving a generation marker. A tagged terminal event may claim that absent marker only
@@ -187,7 +188,13 @@ const PUBLISH_SEQ_LUA =
   'redis.call("EXPIRE", KEYS[1], ttl) ' +
   'end ' +
   'local seq = val - count ' +
+  'if #ARGV > 9 then ' +
+  'for i = 1, count do ' +
+  'redis.call("PUBLISH", ARGV[1], ARGV[2] .. string.format("%d", seq + i - 1) .. ARGV[9 + i]) ' +
+  'end ' +
+  'else ' +
   'redis.call("PUBLISH", ARGV[1], ARGV[2] .. string.format("%d", seq) .. ARGV[3]) ' +
+  'end ' +
   'return seq';
 
 /** A normal generation guard correctly rejects events from an old epoch once
@@ -470,6 +477,7 @@ export class RedisEventTransport implements IEventTransport {
     expectedGenerationId?: number,
     allowRetainedEpoch = false,
     requireActiveJob = false,
+    chunkSuffixes: string[] = [],
   ): Promise<number> {
     const seq = await this.publisher.eval(
       PUBLISH_SEQ_LUA,
@@ -486,6 +494,7 @@ export class RedisEventTransport implements IEventTransport {
       String(GENERATION_EPOCH_GRACE_TTL_SECONDS),
       requireActiveJob ? '1' : '0',
       String(count),
+      ...chunkSuffixes,
     );
     return seq as number;
   }
@@ -548,9 +557,19 @@ export class RedisEventTransport implements IEventTransport {
     }
 
     const batch = pending;
-    const encoded = JSON.stringify(event);
-    batch.events.push(encoded);
-    batch.bytes += encoded.length;
+    const payload = JSON.stringify(event);
+    const [, envelopeSuffix] = RedisEventTransport.buildPayloadParts({
+      type: EventTypes.CHUNK,
+      ...(generationId != null && { generationId }),
+    });
+    batch.events.push(
+      payload === undefined ? envelopeSuffix : `,"data":${payload}${envelopeSuffix}`,
+    );
+    /** Match RedisJobStore's raw JSON length, excluding the publication envelope.
+     * Counting its wrapper would flush publications before their durable appends
+     * near the byte cap, letting a remote resume skip not-yet-durable events.
+     * Reuse the serialized payload so size accounting adds no second traversal. */
+    batch.bytes += payload?.length ?? 0;
     const receipt = new Promise<number | false | undefined>((resolve) => {
       batch.resolvers.push(resolve);
     });
@@ -566,12 +585,12 @@ export class RedisEventTransport implements IEventTransport {
   }
 
   /**
-   * Publish the stream's pending coalesced chunks as one CHUNK_BATCH frame.
+   * Publish the pending window in one EVAL using legacy CHUNK frames.
    *
-   * One INCRBY reserves a consecutive sequence per buffered event, so subscribers
-   * unpack the frame into individually sequenced chunks and the reorder buffer is
-   * none the wiser. The events array is spliced from pre-serialized payloads for
-   * the same reason single frames are: no server-side re-encoding.
+   * One INCRBY reserves consecutive sequences and Lua publishes each serialized
+   * suffix with its own sequence. This saves round trips and repeated guard/TTL
+   * work without requiring older subscribers to understand CHUNK_BATCH. Payloads
+   * are spliced, not decoded/re-encoded by Lua, preserving JSON semantics.
    */
   private flushCoalescedChunks(streamId: string): Promise<void> {
     const pending = this.pendingBatches.get(streamId);
@@ -585,19 +604,17 @@ export class RedisEventTransport implements IEventTransport {
     }
 
     const { generationId, events, resolvers } = pending;
-    const prefix = `{"type":${JSON.stringify(EventTypes.CHUNK_BATCH)},"baseSeq":`;
-    const suffix =
-      (generationId != null ? `,"generationId":${generationId}` : '') +
-      `,"events":[${events.join(',')}]}`;
+    const prefix = `{"type":${JSON.stringify(EventTypes.CHUNK)},"seq":`;
 
     return this.evalPublishSequenced(
       streamId,
       prefix,
-      suffix,
+      '',
       events.length,
       generationId,
       false,
       generationId != null,
+      events,
     ).then(
       (baseSeq) => {
         if (baseSeq === -1) {
diff --git a/packages/api/src/stream/internal/coalescing.ts b/packages/api/src/stream/internal/coalescing.ts
index 5440566688a..8114ffa002a 100644
--- a/packages/api/src/stream/internal/coalescing.ts
+++ b/packages/api/src/stream/internal/coalescing.ts
@@ -2,6 +2,8 @@
 const MAX_COALESCE_WINDOW_MS = 1000;
 /** Coalesced-batch safety caps: a full buffer flushes immediately, ahead of the window. */
 export const MAX_COALESCED_EVENTS = 64;
+/** Shared raw-event JSON string-length budget, excluding transport envelopes.
+ * Keep both coalescers on the same accounting basis, including for non-ASCII JSON. */
 export const MAX_COALESCED_BYTES = 128 * 1024;
 
 /**
@@ -14,10 +16,10 @@ export const MAX_COALESCED_BYTES = 128 * 1024;
  * resume frontier assumes an event is never visible in the durable chunk log
  * meaningfully earlier than its sequence lands on the shared counter, so
  * batching one side without the other reopens that race for the full window
- * instead of a same-tick skew. 0 (the default) disables coalescing.
+ * instead of a same-tick skew. Unset uses 25ms; explicit 0 disables coalescing.
  */
 export function resolveCoalesceWindowMs(): number {
-  const raw = Number(process.env.STREAM_DELTA_COALESCE_MS ?? 0);
+  const raw = Number(process.env.STREAM_DELTA_COALESCE_MS ?? 25);
   if (!Number.isFinite(raw) || raw <= 0) {
     return 0;
   }
diff --git a/packages/api/src/types/files.ts b/packages/api/src/types/files.ts
index 4d606f24825..83c3bfc1230 100644
--- a/packages/api/src/types/files.ts
+++ b/packages/api/src/types/files.ts
@@ -91,6 +91,12 @@ export interface OpenAIFileBlock {
   };
 }
 
+/** OpenAI-compatible text part carrying a textual document's decoded contents */
+export interface OpenAITextDocumentBlock {
+  type: 'text';
+  text: string;
+}
+
 /** OpenAI Responses API file format */
 export interface OpenAIInputFileBlock {
   type: 'input_file';
@@ -114,6 +120,7 @@ export type DocumentBlock =
   | AnthropicDocumentBlock
   | GoogleDocumentBlock
   | OpenAIFileBlock
+  | OpenAITextDocumentBlock
   | OpenAIInputFileBlock
   | BedrockDocumentBlock;
 
diff --git a/packages/client/src/components/OriginalDialog.tsx b/packages/client/src/components/OriginalDialog.tsx
index 115487f5158..0a659629510 100644
--- a/packages/client/src/components/OriginalDialog.tsx
+++ b/packages/client/src/components/OriginalDialog.tsx
@@ -122,6 +122,14 @@ const DialogClose: React.ForwardRefExoticComponent<
   DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>
 > = DialogPrimitive.Close;
 
+/**
+ * The scrim. `surface-overlay` is the theme's own scrim color, so a theme that
+ * redefines it moves every OGDialog with it; the opacity stays at 80% because
+ * that leaves the themes whose overlay is black (dark, and both high-contrast
+ * modes) rendering exactly as before, and puts the light theme's gray scrim at
+ * 4.3:1 against the dialog it frames — past the 3:1 floor for a non-text
+ * boundary, and between the two other dialog families' scrims.
+ */
 export const DialogOverlay: React.ForwardRefExoticComponent<
   Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, 'ref'> &
     React.RefAttributes<HTMLDivElement>
@@ -137,7 +145,7 @@ export const DialogOverlay: React.ForwardRefExoticComponent<
       ref={ref}
       style={{ ...style, zIndex: overlayZIndex }}
       className={cn(
-        'fixed inset-0 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
+        'fixed inset-0 bg-surface-overlay/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
         className,
       )}
       {...props}
diff --git a/packages/client/src/components/Radio.tsx b/packages/client/src/components/Radio.tsx
index ed7e2a9029a..0383fbf5c84 100644
--- a/packages/client/src/components/Radio.tsx
+++ b/packages/client/src/components/Radio.tsx
@@ -102,14 +102,21 @@ const Radio: React.NamedExoticComponent<RadioProps> = memo(function Radio({
       return;
     }
     // Wrapped, the indicator also has to move vertically, so it carries its own
-    // height rather than stretching between the container's insets. INDICATOR_INSET
-    // reproduces the `inset-y-1` of the single-row default exactly, so switching a
-    // group to `wrap` does not change how it looks on a row that still fits.
+    // height rather than stretching between the container's insets, and it has to
+    // reproduce what `inset-y-1` produces for a row that still fits.
+    //
+    // That geometry depends on the container's own vertical padding, because the
+    // insets resolve against its padding box: a group styled `px-1` gets a pill
+    // inset inside its segment, while one styled `p-1` gets a pill that covers the
+    // segment exactly. The first row's `offsetTop` is that padding, so measuring it
+    // keeps both cases identical when a group turns `wrap` on; assuming zero shrank
+    // a padded group's pill by 8px and left it floating inside the segment.
+    const rowInset = buttonRefs.current[0]?.offsetTop ?? 0;
     setBackgroundStyle({
       width: `${selectedButton.offsetWidth}px`,
-      height: `${selectedButton.offsetHeight - INDICATOR_INSET * 2}px`,
+      height: `${selectedButton.offsetHeight + rowInset * 2 - INDICATOR_INSET * 2}px`,
       transform: `translate(${selectedButton.offsetLeft}px, ${
-        selectedButton.offsetTop + INDICATOR_INSET
+        selectedButton.offsetTop - rowInset + INDICATOR_INSET
       }px)`,
     });
   }, [currentValue, options, wrap]);
diff --git a/packages/client/src/theme/tailwind.spec.js b/packages/client/src/theme/tailwind.spec.js
index 741d381e10e..084d12fcd3d 100644
--- a/packages/client/src/theme/tailwind.spec.js
+++ b/packages/client/src/theme/tailwind.spec.js
@@ -68,6 +68,9 @@ describe('LibreChat Tailwind preset', () => {
     /** `any-pointer`, not `pointer`: the floor has to apply to a 2-in-1's
      *  touchscreen while its trackpad is the primary device and reports `fine`. */
     expect(variants.touch).toBe('@media (any-pointer: coarse)');
+    /** Its inverse gates hidden-until-hover states, so a 2-in-1's finger user —
+     *  whose trackpad makes `(hover: hover)` true — never loses the control. */
+    expect(variants['no-touch']).toBe('@media not all and (any-pointer: coarse)');
     expect(variants['high-contrast']).toBe('html.high-contrast &');
   });
 
diff --git a/packages/client/tailwind.preset.cjs b/packages/client/tailwind.preset.cjs
index 71182d83352..0950bcc27d6 100644
--- a/packages/client/tailwind.preset.cjs
+++ b/packages/client/tailwind.preset.cjs
@@ -70,6 +70,19 @@ module.exports = {
        * control at all — so the two queries differ on purpose.
        */
       addVariant('touch', '@media (any-pointer: coarse)');
+
+      /**
+       * The inverse of `touch`, for hiding something until hover: hover-gating
+       * alone strands the finger user of a 2-in-1, because `(hover: hover)` is
+       * true there — it describes the trackpad — while the touchscreen sits
+       * right next to it. Gating the hidden state on the absence of any coarse
+       * pointer keeps a reveal-on-hover affordance from ever hiding a control
+       * that only a tap can reach.
+       *
+       * `not all and`, not the Media Queries Level 4 `not (...)`, because
+       * lightningcss lowers this for the production build's browser targets.
+       */
+      addVariant('no-touch', '@media not all and (any-pointer: coarse)');
     },
   ],
 };
diff --git a/packages/data-provider/src/backgroundResults.ts b/packages/data-provider/src/backgroundResults.ts
new file mode 100644
index 00000000000..22902c8fc73
--- /dev/null
+++ b/packages/data-provider/src/backgroundResults.ts
@@ -0,0 +1,15 @@
+/** Shared serialized metadata shape for admission budgeting and continuation rendering. */
+export function backgroundResultMetadata(result: {
+  taskId: string;
+  toolCallId: string;
+  toolName: string;
+  status: 'completed' | 'error' | 'cancelled';
+}) {
+  return {
+    background_task_id: result.taskId,
+    tool_call_id: result.toolCallId,
+    tool: result.toolName,
+    status: result.status,
+    result: '',
+  };
+}
diff --git a/packages/data-provider/src/code/workspace.ts b/packages/data-provider/src/code/workspace.ts
index f1d2b2d1d90..b431232d96d 100644
--- a/packages/data-provider/src/code/workspace.ts
+++ b/packages/data-provider/src/code/workspace.ts
@@ -14,6 +14,7 @@ export const CODE_WORKSPACE_OPERATIONS = [
   'edit_file',
   'execute_command',
 ] as const;
+export const CODE_WORKSPACE_INSTANCE_TYPES = ['git_worktree'] as const;
 export const CODE_WORKSPACE_SELECTION_ERROR_REASONS = [
   'required',
   'invalid',
@@ -25,6 +26,7 @@ export const CODE_WORKSPACE_SELECTION_ERROR_REASONS = [
 export const CODE_ENVIRONMENT_MODES = ['attached', 'without_attached'] as const;
 
 export type CodeWorkspaceOperation = (typeof CODE_WORKSPACE_OPERATIONS)[number];
+export type CodeWorkspaceInstanceType = (typeof CODE_WORKSPACE_INSTANCE_TYPES)[number];
 export type CodeWorkspaceSelectionErrorReason =
   (typeof CODE_WORKSPACE_SELECTION_ERROR_REASONS)[number];
 export type CodeEnvironmentMode = (typeof CODE_ENVIRONMENT_MODES)[number];
@@ -36,6 +38,8 @@ export interface CodeWorkspaceDescriptor {
   instructions?: RepositoryInstructionDescriptor[];
   /** Omitted when every worker-level operation applies to this workspace. */
   operations?: CodeWorkspaceOperation[];
+  /** Optional worker-managed isolation modes available beneath this root. */
+  workspaceInstances?: CodeWorkspaceInstanceType[];
   environment?: {
     fingerprint: string;
     repo?: string;
diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.ts
index 96172839204..71e881c9a92 100644
--- a/packages/data-provider/src/config.spec.ts
+++ b/packages/data-provider/src/config.spec.ts
@@ -6,6 +6,7 @@ import {
   DEFAULT_MAX_RETAINED_TOOL_COUNT_CHARS,
   bedrockModels,
   configSchema,
+  codeEnvironmentUserConfigSchema,
   excludedKeys,
   resolveEndpointType,
   webSearchSchema,
@@ -398,6 +399,28 @@ describe('Agent Management authentication config', () => {
 });
 
 describe('attached code environment user config schema', () => {
+  it.each([0, 1200, 300000])(
+    'preserves an admission budget of %i milliseconds',
+    (maxQueueWaitMs) => {
+      expect(codeEnvironmentUserConfigSchema.parse({ limits: { maxQueueWaitMs } })).toEqual({
+        limits: { maxQueueWaitMs },
+      });
+    },
+  );
+
+  it.each([-1, 0.5, 300001, NaN, Infinity])(
+    'rejects an invalid admission budget of %s',
+    (maxQueueWaitMs) => {
+      expect(
+        codeEnvironmentUserConfigSchema.safeParse({ limits: { maxQueueWaitMs } }).success,
+      ).toBe(false);
+    },
+  );
+
+  it('keeps an omitted admission budget backward compatible', () => {
+    expect(codeEnvironmentUserConfigSchema.parse({ limits: {} })).toEqual({ limits: {} });
+  });
+
   it('accepts typed permission controls exposed by the administrator', () => {
     const result = configSchema.safeParse({
       version: '1.0',
@@ -486,6 +509,25 @@ describe('attached code environment user config schema', () => {
   });
 });
 
+describe('agent background completion batch config', () => {
+  it('defaults and bounds automatic completion coalescing', () => {
+    const defaults = configSchema.parse({
+      version: '1.0',
+      endpoints: { agents: { backgroundTasks: {} } },
+    });
+    expect(defaults.endpoints?.agents?.backgroundTasks?.completionResultBatchSize).toBe(8);
+
+    for (const completionResultBatchSize of [0, 17, 1.5]) {
+      expect(
+        configSchema.safeParse({
+          version: '1.0',
+          endpoints: { agents: { backgroundTasks: { completionResultBatchSize } } },
+        }).success,
+      ).toBe(false);
+    }
+  });
+});
+
 describe('agent event runtime config', () => {
   it('accepts the routing choice and ignores removed rollout fields', () => {
     const result = configSchema.safeParse({
@@ -553,7 +595,9 @@ describe('agent background task config', () => {
       return;
     }
     expect(result.data.endpoints?.agents?.backgroundTasks).toEqual({
+      completionResultBatchSize: 8,
       completionWakeups: true,
+      completionResultMaxChars: 24 * 1024,
       ordinaryToolCancellation: false,
     });
   });
@@ -569,7 +613,9 @@ describe('agent background task config', () => {
       return;
     }
     expect(result.data.endpoints?.agents?.backgroundTasks).toEqual({
+      completionResultBatchSize: 8,
       completionWakeups: false,
+      completionResultMaxChars: 24 * 1024,
       ordinaryToolCancellation: false,
     });
   });
@@ -585,10 +631,33 @@ describe('agent background task config', () => {
       return;
     }
     expect(result.data.endpoints?.agents?.backgroundTasks).toEqual({
+      completionResultBatchSize: 8,
       completionWakeups: true,
+      completionResultMaxChars: 24 * 1024,
       ordinaryToolCancellation: true,
     });
   });
+
+  it('accepts a bounded durable completion result limit', () => {
+    const result = configSchema.safeParse({
+      version: '1.0',
+      endpoints: { agents: { backgroundTasks: { completionResultMaxChars: 4096 } } },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.endpoints?.agents?.backgroundTasks?.completionResultMaxChars).toBe(4096);
+    }
+  });
+
+  it.each([0, 64 * 1024 + 1])('rejects an unsafe completion result limit: %s', (limit) => {
+    expect(
+      configSchema.safeParse({
+        version: '1.0',
+        endpoints: { agents: { backgroundTasks: { completionResultMaxChars: limit } } },
+      }).success,
+    ).toBe(false);
+  });
 });
 
 describe('speechTab schema', () => {
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index f8a3a730ab1..c3979e6de07 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -22,6 +22,9 @@ import {
   MIN_BALANCE_RESERVATION_TTL_MS,
   DEFAULT_BALANCE_RESERVATION_TTL_MS,
 } from './balance';
+
+export const AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT = 24 * 1024;
+export const AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_HARD_MAX = 64 * 1024;
 import {
   MAX_SUBAGENTS,
   MAX_SUBAGENTS_CEILING,
@@ -1160,6 +1163,12 @@ const codeEnvironmentPermissionFieldSchema = z
 export const CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS = 30_000;
 /** Protocol-level ceiling; deployments may only lower this value. */
 export const CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS = 5 * 60_000;
+/**
+ * Client retry horizon across Code API admission windows. Also the hard cap:
+ * deployments may only lower it. `0` disables client retries, not the server's
+ * initial admission wait or an already-admitted operation's execution budget.
+ */
+export const CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS = 5 * 60_000;
 
 /**
  * Typed user-tunable surface for one attached code environment. Omitted fields
@@ -1185,6 +1194,16 @@ export const codeEnvironmentUserConfigSchema = z
           .min(1)
           .max(CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS)
           .optional(),
+        /** Client retry horizon for capacity expirations, shared by preview/edit.
+         * Omission keeps five minutes; `0` makes each required operation try once.
+         * An in-flight request retains Code API's admission/execution budgets and
+         * can finish after this horizon. This is not a server admission timeout. */
+        maxQueueWaitMs: z
+          .number()
+          .int()
+          .min(0)
+          .max(CODE_ENVIRONMENT_QUEUE_WAIT_DEFAULT_MS)
+          .optional(),
       })
       .strict()
       .optional(),
@@ -1449,6 +1468,18 @@ export const agentsEndpointSchema = baseEndpointSchema
       backgroundTasks: z
         .object({
           completionWakeups: z.boolean().optional().default(true),
+          /** Maximum terminal output copied into the private completion receipt.
+           * Generated files remain governed by their separate attachment policy. */
+          completionResultMaxChars: z
+            .number()
+            .int()
+            .min(1)
+            .max(AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_HARD_MAX)
+            .optional()
+            .default(AGENT_BACKGROUND_COMPLETION_RESULT_MAX_CHARS_DEFAULT),
+          /** Maximum message-backed sibling results in one continuation.
+           * Independent receipts retain task-local delivery ownership. */
+          completionResultBatchSize: z.number().int().min(1).max(16).optional().default(8),
           /** Cooperative cancellation for process-local ordinary tools. Off
            * by default so existing deployments opt into the new control. */
           ordinaryToolCancellation: z.boolean().optional().default(false),
diff --git a/packages/data-provider/src/file-config.spec.ts b/packages/data-provider/src/file-config.spec.ts
index 908117c913f..cecd38bfc8e 100644
--- a/packages/data-provider/src/file-config.spec.ts
+++ b/packages/data-provider/src/file-config.spec.ts
@@ -968,6 +968,20 @@ describe('getEndpointFileConfig', () => {
       expect(merged.skills?.fileSizeLimit).toBe(15 * 1024 * 1024);
     });
 
+    it('defaults skill rollback concurrency and preserves configured overrides', () => {
+      expect(mergeFileConfig(undefined).skills?.importCleanupConcurrency).toBe(8);
+      const parsed = fileConfigSchema.parse({ skills: { importCleanupConcurrency: 3 } });
+      const merged = mergeFileConfig(parsed);
+      expect(merged.skills?.importCleanupConcurrency).toBe(3);
+      expect(merged.skills?.fileSizeLimit).toBe(50 * 1024 * 1024);
+    });
+
+    it.each([0, -1, 1.5])('rejects invalid rollback concurrency %s', (concurrency) => {
+      expect(
+        fileConfigSchema.safeParse({ skills: { importCleanupConcurrency: concurrency } }).success,
+      ).toBe(false);
+    });
+
     it('should default skills fileSizeLimit to 50 MB', () => {
       const merged = mergeFileConfig(undefined);
 
diff --git a/packages/data-provider/src/file-config.ts b/packages/data-provider/src/file-config.ts
index 0123c2b6a67..e4541c9cac3 100644
--- a/packages/data-provider/src/file-config.ts
+++ b/packages/data-provider/src/file-config.ts
@@ -3,6 +3,9 @@ import type { EndpointFileConfig, FileConfig, RegexLike } from './types/files';
 import { EModelEndpoint, isAgentsEndpoint, isDocumentSupportedProvider } from './schemas';
 import { normalizeEndpointName } from './utils';
 
+/** Parallel storage deletions during rollback of a failed skill archive import. */
+export const DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY = 8;
+
 export const supportsFiles = {
   [EModelEndpoint.openAI]: true,
   [EModelEndpoint.google]: true,
@@ -536,6 +539,7 @@ export const fileConfig = {
   },
   skills: {
     fileSizeLimit: defaultSkillImportSizeLimit,
+    importCleanupConcurrency: DEFAULT_SKILL_IMPORT_CLEANUP_CONCURRENCY,
   },
   serverFileSizeLimit: defaultSizeLimit,
   avatarSizeLimit: mbToBytes(2),
@@ -588,6 +592,7 @@ export const endpointFileConfigSchema = z.object({
 
 const skillFileConfigSchema = z.object({
   fileSizeLimit: z.number().min(0).optional(),
+  importCleanupConcurrency: z.number().int().positive().optional(),
 });
 
 export const fileConfigSchema = z.object({
@@ -1214,6 +1219,13 @@ export function mergeFileConfig(dynamic: z.infer<typeof fileConfigSchema> | unde
     mergedConfig.fileContextCharLimit = dynamic.fileContextCharLimit;
   }
 
+  if (dynamic.skills?.importCleanupConcurrency !== undefined) {
+    mergedConfig.skills = {
+      ...mergedConfig.skills,
+      importCleanupConcurrency: dynamic.skills.importCleanupConcurrency,
+    };
+  }
+
   if (dynamic.skills?.fileSizeLimit !== undefined) {
     mergedConfig.skills = {
       ...mergedConfig.skills,
diff --git a/packages/data-provider/src/index.ts b/packages/data-provider/src/index.ts
index bcc234688b2..50b07a3ad29 100644
--- a/packages/data-provider/src/index.ts
+++ b/packages/data-provider/src/index.ts
@@ -75,6 +75,7 @@ export { default as createPayload } from './createPayload';
 export * from './feedback';
 export * from './parameterSettings';
 export * from './agentToolOptions';
+export * from './backgroundResults';
 /* code-execution sandbox */
 export * from './codeEnvRef';
 export * from './code/worker';
diff --git a/packages/data-provider/src/resolve-llm-delivery-path.spec.ts b/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
index bc147bfd0f8..ab3728cedd8 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.spec.ts
@@ -793,13 +793,22 @@ describe('hasTurnFileConsumer', () => {
     expect(hasTurnFileConsumer('video/mp4', { executeCode: false, fileSearch: true })).toBe(false);
   });
 
-  it('counts an enabled tool only where the record shows it holds the file', () => {
+  it('counts File Search only where the record shows the vector store holds the file', () => {
     const consumers = { executeCode: false, fileSearch: true };
     expect(hasTurnFileConsumer('text/csv', consumers, { embedded: true })).toBe(true);
     expect(hasTurnFileConsumer('text/csv', consumers, { embedded: false })).toBe(false);
     expect(hasTurnFileConsumer('text/csv', consumers, {})).toBe(false);
   });
 
+  it('counts an enabled Run Code as a reader before the sandbox holds a copy', () => {
+    /* Its first call uploads the file, so no reference is needed in advance. The tool still
+     * has to be able to read the type. */
+    const consumers = { executeCode: true, fileSearch: false };
+    expect(hasTurnFileConsumer('text/csv', consumers, {})).toBe(true);
+    expect(hasTurnFileConsumer('text/csv', consumers, { metadata: {} })).toBe(true);
+    expect(hasTurnFileConsumer(eml, consumers, {})).toBe(false);
+  });
+
   it('pairs the evidence with the tool that can read the type', () => {
     /* Only the sandbox holds this file, so the tool that can read an email export is the one
      * without a copy of it, while csv is served by the tool that has one. */
@@ -955,16 +964,17 @@ describe('resolveTurnLLMDeliveryPath', () => {
     ).toBe('text');
   });
 
-  it('delivers text when Run Code is on but no sandbox holds the file', () => {
-    /* A promoted destination is not uploaded to the sandbox at upload time, so the turn the
-     * file arrives on carries no reference either. */
+  it('leaves a file Run Code can read with Run Code before the sandbox holds it', () => {
+    /* Delivered text counts toward the turn's attachment limits. A turn those limits refuse
+     * never runs code, so the file would never become held and every later turn would carry
+     * the same text and be refused the same way. Run Code uploads the file on its first call. */
     expect(
       resolveTurnLLMDeliveryPath({
         file: routedCsv,
         consumers: { executeCode: true, fileSearch: false },
         endpointConfig,
       }),
-    ).toBe('text');
+    ).toBe('none');
   });
 
   it('delivers text where the tool holding the file cannot read this type', () => {
diff --git a/packages/data-provider/src/resolve-llm-delivery-path.ts b/packages/data-provider/src/resolve-llm-delivery-path.ts
index 1ea941bc550..6b41d378fc8 100644
--- a/packages/data-provider/src/resolve-llm-delivery-path.ts
+++ b/packages/data-provider/src/resolve-llm-delivery-path.ts
@@ -381,25 +381,25 @@ export function hasToolResourceProvisioning(file: TurnDeliveryFile, toolResource
 /**
  * Whether a tool this turn runs can read a file of this type.
  *
- * Passing the record asks the stricter question a delivery decision needs: a tool serves a file
- * only once it holds it. A file tool being enabled is not the same as the file having reached
- * it, and an upload that named no destination is filed under no tool at all, so judging the
- * tool set alone reads an empty vector store as a reader.
+ * Passing the record asks the stricter question a delivery decision needs where a tool serves
+ * only what it already holds. File search reads the vector store, and an upload that named no
+ * destination is filed under no tool at all, so an enabled search tool is a reader only once
+ * the record shows the store holds the file. Run Code needs no copy in advance: its first call
+ * uploads every attachment it can read to the sandbox, so enabling it is enough. Requiring a
+ * copy there would hand the file's text to the prompt on every turn before the first code run,
+ * and a turn that refuses that text never runs code, so the file would never become held.
  */
 export function hasTurnFileConsumer(
   mimeType: string,
   consumers: TurnFileConsumers,
   file?: TurnDeliveryFile,
 ): boolean {
-  const holds = (toolResource: EToolResources): boolean =>
-    file == null || hasToolResourceProvisioning(file, toolResource);
+  const searchHolds = file == null || hasToolResourceProvisioning(file, EToolResources.file_search);
   return (
-    (consumers.executeCode &&
-      canToolResourceConsume(EToolResources.execute_code, mimeType) &&
-      holds(EToolResources.execute_code)) ||
+    (consumers.executeCode && canToolResourceConsume(EToolResources.execute_code, mimeType)) ||
     (consumers.fileSearch &&
       canToolResourceConsume(EToolResources.file_search, mimeType) &&
-      holds(EToolResources.file_search))
+      searchHolds)
   );
 }
 
@@ -454,15 +454,15 @@ export function hasInferredLLMDeliveryPath(file: TurnDeliveryFile): boolean {
  * A record predating routing and a destination the user chose keep what they stored. An
  * inferred route re-resolves against the endpoint handling the turn. A `none` route leaves
  * the file for a tool; where the endpoint enables `textFallbackWithoutTools` and no tool this
- * turn runs both reads the file and already holds it, the text extracted at upload is delivered
- * rather than the file reaching nothing. Consumers left undefined are unknown and not judged, as
- * in {@link resolveUploadDestination}.
+ * turn runs can read the file, the text extracted at upload is delivered rather than the file
+ * reaching nothing. Consumers left undefined are unknown and not judged, as in
+ * {@link resolveUploadDestination}.
  *
- * Holding the file is asked of the record rather than of the tool set, because the two disagree
- * for the upload that needs the fallback most: one that named no destination is filed under no
- * tool, so enabling file search would otherwise withhold the text for a vector store that never
- * received the file, leaving the attachment readable by nothing. Deferred provisioning still
- * fills that store on first use, which delivering the text does not prevent.
+ * For file search, reading is asked of the record rather than of the tool set, because the two
+ * disagree for the upload that needs the fallback most: one that named no destination is filed
+ * under no tool, so enabling file search would otherwise withhold the text for a vector store
+ * that never received the file. Run Code is judged by the tool set: see
+ * {@link hasTurnFileConsumer}.
  */
 export function resolveTurnLLMDeliveryPath(
   routing: Partial<TurnDeliveryRouting> | undefined,
diff --git a/packages/data-provider/src/types/files.ts b/packages/data-provider/src/types/files.ts
index 2651cc6ddb2..5a415af39b5 100644
--- a/packages/data-provider/src/types/files.ts
+++ b/packages/data-provider/src/types/files.ts
@@ -62,6 +62,8 @@ export type FileConfig = {
     [key: string]: EndpointFileConfig;
   };
   skills?: {
+    /** Maximum concurrent blob deletions during failed archive import cleanup. */
+    importCleanupConcurrency?: number;
     fileSizeLimit?: number;
   };
   fileTokenLimit?: number;
@@ -101,6 +103,8 @@ export type FileConfigInput = {
     [key: string]: EndpointFileConfig;
   };
   skills?: {
+    /** Maximum concurrent blob deletions during failed archive import cleanup. */
+    importCleanupConcurrency?: number;
     fileSizeLimit?: number;
   };
   serverFileSizeLimit?: number;
diff --git a/packages/data-provider/src/types/skills.ts b/packages/data-provider/src/types/skills.ts
index c0bd89198e3..a01fe79a1e1 100644
--- a/packages/data-provider/src/types/skills.ts
+++ b/packages/data-provider/src/types/skills.ts
@@ -348,10 +348,59 @@ export type TSkillListResponse = {
   after: string | null;
 };
 
+/**
+ * Why one archive entry could not be imported. A stable code rather than a
+ * message, so the client localizes the reason and server-side storage and
+ * database text never reaches the uploader.
+ */
+export type SkillImportFailureReason =
+  /** Path is absolute, traverses, or uses characters skills cannot store. */
+  | 'invalid_path'
+  /** Entry alone exceeds the per-file decompression limit. */
+  | 'file_too_large'
+  /** Archive exhausted the cumulative decompression budget at or before this entry. */
+  | 'archive_too_large'
+  /** Entry no longer matches what content inspection read. */
+  | 'archive_entry_changed'
+  /** Storage write or database row failed. */
+  | 'persistence_failed';
+
+/** One archive entry POST `/api/skills/import` could not persist. */
+export type TSkillImportFailedFile = {
+  /** Path inside the archive, relative to `SKILL.md`. */
+  path: string;
+  reason: SkillImportFailureReason;
+  /** Limit in MB, when `reason` names a size limit. */
+  limitMb?: number;
+};
+
+/**
+ * Response from a failed `POST /api/skills/import` of an archive.
+ *
+ * `skill_import_incomplete` (422) means at least one bundled file failed and
+ * everything the import created was rolled back. `skill_import_rollback_failed`
+ * (500) means the same failure occurred but the partially created skill could
+ * not be removed, so it may still be listed and needs deleting by hand.
+ * `skill_import_cleanup_incomplete` (500) means the Skill row was removed but
+ * dependent database or blob cleanup did not finish.
+ */
+export type TSkillImportFailedResponse = {
+  error:
+    | 'skill_import_incomplete'
+    | 'skill_import_rollback_failed'
+    | 'skill_import_cleanup_incomplete';
+  message: string;
+  failedFiles: TSkillImportFailedFile[];
+  /** Present when the Skill row may remain and should be surfaced for deletion. */
+  skillId?: string;
+};
+
 /** Response from DELETE `/api/skills/:id`. */
 export type TDeleteSkillResponse = {
   id: string;
   deleted: true;
+  /** False when the Skill row is gone but a dependent cleanup step needs repair. */
+  cleanupComplete?: boolean;
 };
 
 /** Response from GET `/api/skills/:id/files`. */
diff --git a/packages/data-provider/src/types/traces.ts b/packages/data-provider/src/types/traces.ts
index 8210e69b37e..b70bb2d49d0 100644
--- a/packages/data-provider/src/types/traces.ts
+++ b/packages/data-provider/src/types/traces.ts
@@ -6,6 +6,24 @@
 
 export type TTraceRecordKind = 'agent' | 'generation' | 'tool' | 'span' | 'event';
 
+/**
+ * What a record did in the run, in the application's own terms, so a client never reads a tracing
+ * backend's span names. Absent on a record the backend did not describe: it is listed by `kind`.
+ * `run` is a whole agent run, `agent` the named agent inside it, `plumbing` a wrapper that only
+ * frames a model call, `model` a model call of the response, `tools` one round of tool calls, and
+ * the label roles are the model calls that wrote the activity labels the chat shows while a
+ * response runs.
+ */
+export type TTraceRecordRole =
+  | 'run'
+  | 'agent'
+  | 'plumbing'
+  | 'model'
+  | 'tools'
+  | 'stepLabel'
+  | 'reasoningLabel'
+  | 'phaseLabel';
+
 /** `running` marks a record with no end time yet; it has a start but no duration. */
 export type TTraceStatus = 'ok' | 'warning' | 'error' | 'running';
 
@@ -26,6 +44,9 @@ export type TTraceRecord = {
   /** `null` for a root; may name a record that is not loaded (or does not exist). */
   parentId: string | null;
   kind: TTraceRecordKind;
+  role?: TTraceRecordRole;
+  /** The saved agent a `role: 'agent'` record ran; absent for an agent that was never saved. */
+  agentId?: string;
   name: string;
   model?: string;
   /** ISO-8601 timestamps. */
@@ -94,10 +115,47 @@ export type TTraceContent = {
   truncated: boolean;
 };
 
+export type TTraceMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+
+export type TTraceToolCall = {
+  name: string;
+  args?: TTraceContent;
+};
+
+/** One message of a model call's conversation, each bounded on its own so a long one hides no other. */
+export type TTraceMessage = {
+  role: TTraceMessageRole;
+  text?: TTraceContent;
+  /** The tool a `tool` message answers for. */
+  toolName?: string;
+  /** The tools an `assistant` message asked for. */
+  toolCalls?: TTraceToolCall[];
+  /** Parts that are not text (an image, a file), by their type. */
+  attachments?: string[];
+};
+
+/**
+ * What a model call was given, as a conversation. A long one keeps its system
+ * message and its newest messages, which are what the call answered, and
+ * `omitted` counts the older ones left out between them.
+ */
+export type TTracePrompt = {
+  messages: TTraceMessage[];
+  /** Every message the call was given, listed or not. */
+  total: number;
+  omitted: number;
+  /** Names of the tools the model could call. */
+  tools?: string[];
+};
+
 export type TTraceRecordDetail = {
   record: TTraceRecord;
   /** False when the deployment withholds input, output and metadata. */
   contentAvailable: boolean;
+  /** Set when the input is a conversation the backend could read as one; `input` stays the raw form. */
+  prompt?: TTracePrompt;
+  /** Set when the output is a message the backend could read as one; `output` stays the raw form. */
+  reply?: TTraceMessage;
   input?: TTraceContent;
   output?: TTraceContent;
   metadata?: TTraceContent;
diff --git a/packages/data-schemas/src/index.ts b/packages/data-schemas/src/index.ts
index 0b463796ada..4a2a7f5a238 100644
--- a/packages/data-schemas/src/index.ts
+++ b/packages/data-schemas/src/index.ts
@@ -67,6 +67,8 @@ export {
   isCompactionSemanticIndexProjection,
 } from './types/compaction';
 export {
+  AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS,
+  AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
   AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
diff --git a/packages/data-schemas/src/methods/agent.spec.ts b/packages/data-schemas/src/methods/agent.spec.ts
index fc24723e3c3..57facac58df 100644
--- a/packages/data-schemas/src/methods/agent.spec.ts
+++ b/packages/data-schemas/src/methods/agent.spec.ts
@@ -65,6 +65,7 @@ let revertAgentVersion: AgentMethods['revertAgentVersion'];
 let addAgentResourceFile: AgentMethods['addAgentResourceFile'];
 let removeAgentResourceFiles: AgentMethods['removeAgentResourceFiles'];
 let removeAgentResourceFilesFromAllAgents: AgentMethods['removeAgentResourceFilesFromAllAgents'];
+let getSharedResourceFileIds: AgentMethods['getSharedResourceFileIds'];
 let getListAgentsByAccess: AgentMethods['getListAgentsByAccess'];
 let getAgentManagementListByAccess: AgentMethods['getAgentManagementListByAccess'];
 let generateActionMetadataHash: AgentMethods['generateActionMetadataHash'];
@@ -117,6 +118,7 @@ beforeAll(async () => {
   addAgentResourceFile = methods.addAgentResourceFile;
   removeAgentResourceFiles = methods.removeAgentResourceFiles;
   removeAgentResourceFilesFromAllAgents = methods.removeAgentResourceFilesFromAllAgents;
+  getSharedResourceFileIds = methods.getSharedResourceFileIds;
   getListAgentsByAccess = methods.getListAgentsByAccess;
   getAgentManagementListByAccess = methods.getAgentManagementListByAccess;
   generateActionMetadataHash = methods.generateActionMetadataHash;
@@ -4238,6 +4240,146 @@ describe('Agent Methods', () => {
       ).rejects.toThrow('Agent not found for removing resource files');
     });
 
+    describe('getSharedResourceFileIds', () => {
+      beforeEach(async () => {
+        await Agent.deleteMany({});
+      });
+
+      test('reports a file another agent still references, across tool resources', async () => {
+        const sharedFileId = `file_${uuidv4()}`;
+        const soleFileId = `file_${uuidv4()}`;
+
+        const agent = await createBasicAgent();
+        const duplicate = await createBasicAgent();
+
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.file_search,
+          file_id: sharedFileId,
+        });
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.file_search,
+          file_id: soleFileId,
+        });
+        await addAgentResourceFile({
+          agent_id: duplicate.id,
+          tool_resource: EToolResources.context,
+          file_id: sharedFileId,
+        });
+
+        const shared = await getSharedResourceFileIds({
+          file_ids: [sharedFileId, soleFileId],
+          excludeAgentObjectId: String(agent._id),
+        });
+
+        expect(shared).toEqual([sharedFileId]);
+      });
+
+      test('does not count the excluded agent’s own reference', async () => {
+        const fileId = `file_${uuidv4()}`;
+        const agent = await createBasicAgent();
+
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.file_search,
+          file_id: fileId,
+        });
+
+        expect(
+          await getSharedResourceFileIds({
+            file_ids: [fileId],
+            excludeAgentObjectId: String(agent._id),
+          }),
+        ).toEqual([]);
+        expect(await getSharedResourceFileIds({ file_ids: [fileId] })).toEqual([fileId]);
+      });
+
+      test('reports a file the same agent still holds under another tool resource', async () => {
+        const fileId = `file_${uuidv4()}`;
+        const agent = await createBasicAgent();
+
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.file_search,
+          file_id: fileId,
+        });
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.context,
+          file_id: fileId,
+        });
+
+        expect(
+          await getSharedResourceFileIds({
+            file_ids: [fileId],
+            excludeAgentObjectId: String(agent._id),
+            excludeToolResource: EToolResources.file_search,
+          }),
+        ).toEqual([fileId]);
+      });
+
+      test('does not count the pair being removed', async () => {
+        const fileId = `file_${uuidv4()}`;
+        const agent = await createBasicAgent();
+
+        await addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: EToolResources.file_search,
+          file_id: fileId,
+        });
+
+        expect(
+          await getSharedResourceFileIds({
+            file_ids: [fileId],
+            excludeAgentObjectId: String(agent._id),
+            excludeToolResource: EToolResources.file_search,
+          }),
+        ).toEqual([]);
+      });
+
+      test('does not skip another tenant’s agent that shares the logical id', async () => {
+        const sharedId = `agent_${uuidv4()}`;
+        const fileId = `file_${uuidv4()}`;
+        const tenantA = `tenant-${uuidv4()}`;
+        const tenantB = `tenant-${uuidv4()}`;
+
+        /* `id` is unique only with `tenantId`, so two tenants can hold the same logical agent id.
+           Excluding by `id` would call the file unreferenced and destroy tenant B's bytes. */
+        const agentA = await tenantStorage.run({ tenantId: tenantA }, () =>
+          createBasicAgent({ id: sharedId }),
+        );
+        await tenantStorage.run({ tenantId: tenantB }, () => createBasicAgent({ id: sharedId }));
+
+        await tenantStorage.run({ tenantId: tenantA }, () =>
+          addAgentResourceFile({
+            agent_id: sharedId,
+            tool_resource: EToolResources.file_search,
+            file_id: fileId,
+          }),
+        );
+        await tenantStorage.run({ tenantId: tenantB }, () =>
+          addAgentResourceFile({
+            agent_id: sharedId,
+            tool_resource: EToolResources.file_search,
+            file_id: fileId,
+          }),
+        );
+
+        expect(
+          await getSharedResourceFileIds({
+            file_ids: [fileId],
+            excludeAgentObjectId: String(agentA._id),
+            excludeToolResource: EToolResources.file_search,
+          }),
+        ).toEqual([fileId]);
+      });
+
+      test('answers without querying when given no file_ids', async () => {
+        expect(await getSharedResourceFileIds({ file_ids: [] })).toEqual([]);
+      });
+    });
+
     describe('removeAgentResourceFilesFromAllAgents', () => {
       beforeEach(async () => {
         await Agent.deleteMany({});
diff --git a/packages/data-schemas/src/methods/agent.ts b/packages/data-schemas/src/methods/agent.ts
index ceeaa354b0b..e25aa52cc93 100644
--- a/packages/data-schemas/src/methods/agent.ts
+++ b/packages/data-schemas/src/methods/agent.ts
@@ -650,6 +650,15 @@ export function createAgentMethods(
   }: {
     file_ids: string[];
   }) => Promise<{ matchedCount: number; modifiedCount: number }>;
+  getSharedResourceFileIds: ({
+    file_ids,
+    excludeAgentObjectId,
+    excludeToolResource,
+  }: {
+    file_ids: string[];
+    excludeAgentObjectId?: string;
+    excludeToolResource?: string;
+  }) => Promise<string[]>;
 } {
   const { removeAllPermissions, getActions, getSoleOwnedResourceIds, isExternalSkillId } = deps;
 
@@ -1229,6 +1238,68 @@ export function createAgentMethods(
     };
   }
 
+  /**
+   * Reports which of the given file_ids keep a reference once the caller's own is removed, so a
+   * caller can tell a last reference from a shared one.
+   *
+   * The unit of a reference is the `(agent, tool_resource)` pair rather than the agent:
+   * `addAgentResourceFile` stores `file_ids` per resource, so one agent can hold the same file under
+   * both `file_search` and `context`, and removing it from one leaves the other needing the bytes.
+   * `excludeToolResource` narrows the exclusion to the pair being removed; omitting it excludes the
+   * whole agent.
+   *
+   * The agent is excluded by `_id`, because `id` is unique only together with `tenantId`: matching on
+   * `id` alone would skip another tenant's agent of the same name and call its file unreferenced.
+   *
+   * Duplicating an agent copies `file_ids` rather than the files behind them, so one file record
+   * can back two agents; destroying its bytes on behalf of one agent would empty the other. This
+   * is deliberately not scoped by tenant: a reference is a reference, whoever holds it.
+   */
+  async function getSharedResourceFileIds({
+    file_ids,
+    excludeAgentObjectId,
+    excludeToolResource,
+  }: {
+    file_ids: string[];
+    excludeAgentObjectId?: string;
+    excludeToolResource?: string;
+  }): Promise<string[]> {
+    if (!file_ids || file_ids.length === 0) {
+      return [];
+    }
+
+    const Agent = mongoose.models.Agent as Model<IAgent>;
+    const requested = new Set(file_ids);
+    const searchParameter: FilterQuery<IAgent> = {
+      $or: TOOL_RESOURCE_KEYS.map((key) => ({
+        [`tool_resources.${key}.file_ids`]: { $in: file_ids },
+      })),
+    };
+
+    const agents = await Agent.find(searchParameter, { _id: 1, tool_resources: 1 }).lean();
+    const shared = new Set<string>();
+    for (const agent of agents) {
+      const isExcludedAgent =
+        excludeAgentObjectId != null && String(agent._id) === excludeAgentObjectId;
+      for (const key of TOOL_RESOURCE_KEYS) {
+        if (isExcludedAgent && (excludeToolResource == null || key === excludeToolResource)) {
+          continue;
+        }
+        const fileIds = agent.tool_resources?.[key]?.file_ids;
+        if (fileIds == null) {
+          continue;
+        }
+        for (const fileId of fileIds) {
+          if (requested.has(fileId)) {
+            shared.add(fileId);
+          }
+        }
+      }
+    }
+
+    return [...shared];
+  }
+
   /**
    * Deletes an agent based on the provided search parameter.
    */
@@ -1698,6 +1769,7 @@ export function createAgentMethods(
     generateActionMetadataHash,
     removeAgentFromUserFavorites,
     removeAgentResourceFilesFromAllAgents,
+    getSharedResourceFileIds,
   };
 }
 
diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.ts
index 5fa9ae689f9..92ff0173998 100644
--- a/packages/data-schemas/src/methods/conversation.spec.ts
+++ b/packages/data-schemas/src/methods/conversation.spec.ts
@@ -1144,21 +1144,70 @@ describe('Conversation Operations', () => {
       expect(stored?.codeWorkspaces).toEqual([vm]);
     });
 
-    it.each([{}, { codeWorkspaces: [mac] }])(
-      'preserves a legacy decision: %j',
-      async (decision) => {
-        const conversationId = uuidv4();
-        await Conversation.collection.insertOne({ conversationId, user: userId, ...decision });
-        await saveConvo(
-          { userId },
-          { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces: [vm] },
-          { unsetFields },
-        );
-        const stored = await getConvo(userId, conversationId);
-        expect(stored?.codeEnvironmentMode).toBeUndefined();
-        expect(stored?.codeWorkspaces).toEqual(decision.codeWorkspaces);
-      },
-    );
+    it('preserves a legacy decision', async () => {
+      const conversationId = uuidv4();
+      await Conversation.collection.insertOne({
+        conversationId,
+        user: userId,
+        codeWorkspaces: [mac],
+      });
+      await saveConvo(
+        { userId },
+        { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces: [vm] },
+        { unsetFields },
+      );
+      const stored = await getConvo(userId, conversationId);
+      expect(stored?.codeEnvironmentMode).toBeUndefined();
+      expect(stored?.codeWorkspaces).toEqual([mac]);
+    });
+
+    it('records the first decision of a saved chat that holds none', async () => {
+      const conversationId = uuidv4();
+      await Conversation.collection.insertOne({ conversationId, user: userId, title: 'Saved' });
+
+      const saved = await saveConvo(
+        { userId },
+        { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces: [mac] },
+        { unsetFields },
+      );
+
+      expect(saved?.codeEnvironmentMode).toBe('attached');
+      expect(saved?.codeWorkspaces).toEqual([mac]);
+      const stored = await getConvo(userId, conversationId);
+      expect(stored?.codeEnvironmentMode).toBe('attached');
+      expect(stored?.codeWorkspaces).toEqual([mac]);
+    });
+
+    it('keeps the decision it recorded when a later turn resolves another', async () => {
+      const conversationId = uuidv4();
+      await Conversation.collection.insertOne({ conversationId, user: userId, title: 'Saved' });
+      await saveConvo(
+        { userId },
+        { conversationId, codeEnvironmentMode: 'attached', codeWorkspaces: [mac] },
+        { unsetFields },
+      );
+
+      await saveConvo(
+        { userId },
+        { conversationId, codeEnvironmentMode: 'without_attached', codeWorkspaces: [vm] },
+        { unsetFields },
+      );
+
+      const stored = await getConvo(userId, conversationId);
+      expect(stored?.codeEnvironmentMode).toBe('attached');
+      expect(stored?.codeWorkspaces).toEqual([mac]);
+    });
+
+    it('leaves a chat undecided when a save carries selections without a mode', async () => {
+      const conversationId = uuidv4();
+      await Conversation.collection.insertOne({ conversationId, user: userId, title: 'Saved' });
+
+      await saveConvo({ userId }, { conversationId, codeWorkspaces: [vm] }, { unsetFields });
+
+      const stored = await getConvo(userId, conversationId);
+      expect(stored?.codeEnvironmentMode).toBeUndefined();
+      expect(stored?.codeWorkspaces).toBeUndefined();
+    });
   });
 
   describe('replaceConvoCodeEnvironmentDecision', () => {
@@ -2181,10 +2230,14 @@ describe('Conversation Operations', () => {
       const deleteAgentQueuedTurns = jest.fn(async () => {
         transitions.push('queue-retired');
       });
+      const eraseAgentTriggerDeliveryConversationResults = jest.fn(async () => {
+        transitions.push('trigger-results-erased');
+      });
       const scopedMethods = createConversationMethods(mongoose, {
         getMessages,
         deleteMessages,
         deleteAgentQueuedTurns,
+        eraseAgentTriggerDeliveryConversationResults,
       });
 
       await scopedMethods.deleteConvos(
@@ -2200,7 +2253,99 @@ describe('Conversation Operations', () => {
       expect(deleteAgentQueuedTurns).toHaveBeenCalledWith('user123', [
         { conversationId, tenantId: 'tenant-1' },
       ]);
-      expect(transitions).toEqual(['queue-retired', 'generation-drained']);
+      expect(eraseAgentTriggerDeliveryConversationResults).toHaveBeenCalledWith('user123', [
+        conversationId,
+      ]);
+      expect(transitions).toEqual([
+        'queue-retired',
+        'generation-drained',
+        'trigger-results-erased',
+      ]);
+    });
+
+    it('preserves background receipts when a pre-delete drain fails', async () => {
+      const conversationId = uuidv4();
+      await Conversation.create({
+        conversationId,
+        user: 'user123',
+        endpoint: EModelEndpoint.agents,
+      });
+      const eraseAgentTriggerDeliveryConversationResults = jest.fn(async () => undefined);
+      const scopedMethods = createConversationMethods(mongoose, {
+        getMessages,
+        deleteMessages,
+        eraseAgentTriggerDeliveryConversationResults,
+      });
+
+      await expect(
+        scopedMethods.deleteConvos(
+          'user123',
+          { conversationId },
+          { beforeDelete: async () => Promise.reject(new Error('drain unavailable')) },
+        ),
+      ).rejects.toThrow('drain unavailable');
+
+      expect(await Conversation.findOne({ conversationId })).not.toBeNull();
+      expect(eraseAgentTriggerDeliveryConversationResults).not.toHaveBeenCalled();
+    });
+
+    it('finishes descendant bookkeeping and message cleanup when receipt erasure fails', async () => {
+      const parentId = uuidv4();
+      const childId = uuidv4();
+      const grandchildId = uuidv4();
+      const ids = [parentId, childId, grandchildId];
+      const project = await ChatProject.create({ user: 'user123', name: 'Receipt cleanup' });
+      await ConversationTag.create({ user: 'user123', tag: 'work', count: 3, position: 0 });
+      await Conversation.create(
+        ids.map((conversationId, depth) => ({
+          conversationId,
+          user: 'user123',
+          endpoint: EModelEndpoint.agents,
+          tags: ['work'],
+          chatProjectId: project._id.toString(),
+          ...(depth === 0
+            ? {}
+            : {
+                subagentThread: {
+                  rootConversationId: parentId,
+                  parentConversationId: ids[depth - 1],
+                  parentMessageId: `message-${depth}`,
+                  parentToolCallId: `call-${depth}`,
+                  subagentType: 'agent-child',
+                  subagentKind: 'agent',
+                  depth,
+                },
+              }),
+        })),
+      );
+      const prepare = jest.fn(async () => undefined);
+      const erase = jest.fn(async () => {
+        throw new Error('receipt storage unavailable');
+      });
+      const scopedMethods = createConversationMethods(mongoose, {
+        getMessages,
+        deleteMessages,
+        prepareAgentTriggerConversationResultErasure: prepare,
+        eraseAgentTriggerDeliveryConversationResults: erase,
+      });
+
+      const result = await scopedMethods.deleteConvos('user123', { conversationId: parentId });
+      expect(result).toMatchObject({ deletedCount: 3, conversationIds: ids });
+      expect(prepare.mock.calls).toHaveLength(3);
+      expect(erase.mock.calls).toHaveLength(3);
+      expect(await Conversation.countDocuments({ user: 'user123' })).toBe(0);
+      expect((await ConversationTag.findOne({ user: 'user123', tag: 'work' }).lean())?.count).toBe(
+        0,
+      );
+      expect((await ChatProject.findById(project._id).lean())?.conversationCount).toBe(0);
+      expect(deleteMessages).toHaveBeenCalledWith({
+        user: 'user123',
+        conversationId: { $in: ids },
+      });
+
+      await expect(
+        scopedMethods.deleteConvos('user123', { conversationId: parentId }, { allowEmpty: true }),
+      ).resolves.toMatchObject({ deletedCount: 0, conversationIds: [parentId] });
     });
 
     it('fails closed before deleting a conversation when queued-turn retirement fails', async () => {
@@ -2419,13 +2564,22 @@ describe('Conversation Operations', () => {
     });
 
     it('allows a single-conversation cleanup retry after topology and messages are gone', async () => {
-      const result = await deleteConvos(
+      const eraseAgentTriggerDeliveryConversationResults = jest.fn(async () => undefined);
+      const scopedMethods = createConversationMethods(mongoose, {
+        getMessages,
+        deleteMessages,
+        eraseAgentTriggerDeliveryConversationResults,
+      });
+      const result = await scopedMethods.deleteConvos(
         'user123',
         { conversationId: 'already-absent' },
         { allowEmpty: true },
       );
       expect(result.deletedCount).toBe(0);
       expect(result.conversationIds).toEqual(['already-absent']);
+      expect(eraseAgentTriggerDeliveryConversationResults).toHaveBeenCalledWith('user123', [
+        'already-absent',
+      ]);
     });
 
     it('supports an idempotent empty recovery sweep without hiding storage failures', async () => {
diff --git a/packages/data-schemas/src/methods/conversation.ts b/packages/data-schemas/src/methods/conversation.ts
index 36b7f365f2e..3d44b0e6414 100644
--- a/packages/data-schemas/src/methods/conversation.ts
+++ b/packages/data-schemas/src/methods/conversation.ts
@@ -512,6 +512,14 @@ export interface ConversationMethodDeps
     user: string,
     conversations: Array<{ conversationId: string; tenantId?: string; allTenants?: true }>,
   ) => Promise<void>;
+  eraseAgentTriggerDeliveryConversationResults?: (
+    user: string,
+    conversationIds: string[],
+  ) => Promise<void>;
+  prepareAgentTriggerConversationResultErasure?: (
+    user: string,
+    conversationIds: string[],
+  ) => Promise<void>;
 }
 
 export function createConversationMethods(
@@ -2417,6 +2425,31 @@ export function createConversationMethods(
         return null;
       }
 
+      /** `$setOnInsert` only reaches a chat this save creates, yet a chat whose earlier turns never
+       * involved a code-capable agent holds no decision either: without this fill its first
+       * workspace choice is dropped and the next turn starts undecided again. The filter repeats
+       * that absence, so a concurrent writer that decided first keeps its decision and a chat that
+       * already holds one is never touched. Only a whole decision seeds a row, never bare
+       * selections. */
+      if (
+        decisionOnInsert.codeEnvironmentMode != null &&
+        conversation.codeEnvironmentMode == null &&
+        (conversation.codeWorkspaces?.length ?? 0) === 0
+      ) {
+        const seeded = await Conversation.updateOne(
+          {
+            _id: conversation._id,
+            codeEnvironmentMode: { $in: [null] },
+            $or: [{ codeWorkspaces: { $in: [null] } }, { codeWorkspaces: { $size: 0 } }],
+          },
+          { $set: decisionOnInsert },
+          { timestamps: false },
+        );
+        if (seeded.modifiedCount > 0) {
+          Object.assign(conversation, decisionOnInsert);
+        }
+      }
+
       /** Reuse the saved row's chat type when callers omit it, preserving existing deadlines. */
       if (
         interfaceConfig?.retentionMode === RetentionMode.ALL &&
@@ -3210,7 +3243,18 @@ export function createConversationMethods(
           })),
         );
         await options?.beforeDelete?.(waveIds);
+        await deps?.prepareAgentTriggerConversationResultErasure?.(user, waveIds);
         const result = await Conversation.deleteMany({ user, conversationId: { $in: waveIds } });
+        if (result.deletedCount > 0) {
+          /** Result erasure is irreversible. Keep receipts intact when a
+           * pre-delete hook or the conversation delete itself fails, so a
+           * retained conversation cannot lose a receipt-only completion. */
+          try {
+            await deps?.eraseAgentTriggerDeliveryConversationResults?.(user, waveIds);
+          } catch (error) {
+            logger.error('[deleteConvos] Receipt erasure deferred to durable cleanup', error);
+          }
+        }
         acknowledged &&= result.acknowledged;
         deletedCount += result.deletedCount;
         await reconcileDeletedWave(wave, result.deletedCount);
@@ -3241,6 +3285,11 @@ export function createConversationMethods(
             allTenants: true,
           })),
         );
+        try {
+          await deps?.eraseAgentTriggerDeliveryConversationResults?.(user, recoveryConversationIds);
+        } catch (error) {
+          logger.error('[deleteConvos] Receipt erasure deferred to durable cleanup', error);
+        }
       }
 
       const deleteConvoResult: DeleteResult = { acknowledged, deletedCount };
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index 1c7f4563ef1..3ddf1be4b45 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -128,6 +128,8 @@ import {
   type ListSkillsByAccessResult,
   type UpdateSkillResult,
   type ValidationIssue,
+  type DeleteSkillCleanupStep,
+  type DeleteSkillResult,
 } from './skill';
 import { createScheduleMethods, type ScheduleMethods } from './schedule';
 import {
@@ -323,6 +325,10 @@ export function createMethods(
     getMessages: messageMethods.getMessages,
     deleteMessages: messageMethods.deleteMessages,
     searchMessages: messageMethods.searchMessages,
+    eraseAgentTriggerDeliveryConversationResults:
+      agentTriggerDeliveryMethods.eraseAgentTriggerDeliveryConversationResults,
+    prepareAgentTriggerConversationResultErasure:
+      agentTriggerDeliveryMethods.prepareAgentTriggerConversationResultErasure,
     deleteAgentQueuedTurns: async (user, conversations) => {
       /** Queued-turn ownership is ObjectId-backed. Conversation methods also
        * support synthetic/non-ObjectId owners in embedded integrations and
@@ -553,6 +559,8 @@ export type {
   ListSkillsByAccessResult,
   UpdateSkillResult,
   ValidationIssue,
+  DeleteSkillCleanupStep,
+  DeleteSkillResult,
   SkillSyncStatusInput,
   SkillSyncCredentialSummary,
   UpsertSkillSyncCredentialInput,
diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.ts
index eb2083d5a13..83751e49e90 100644
--- a/packages/data-schemas/src/methods/message.spec.ts
+++ b/packages/data-schemas/src/methods/message.spec.ts
@@ -1,7 +1,7 @@
 import mongoose from 'mongoose';
 import { v4 as uuidv4 } from 'uuid';
 import { MongoMemoryServer } from 'mongodb-memory-server';
-import { Constants, RetentionMode } from 'librechat-data-provider';
+import { backgroundResultMetadata, Constants, RetentionMode } from 'librechat-data-provider';
 import type { AppConfig, IMessage } from '..';
 import {
   createMessageMethods,
@@ -1681,6 +1681,118 @@ describe('Message Operations', () => {
         status: 'claimed',
         claim: { kind: 'wakeup', claimId: 'delivery-1' },
       });
+      /** V1 producers have no completionReceipt marker, but the V1 resolver
+       * acquires resultClaim before delivery. A later batch must exclude it. */
+      await expect(
+        claimBackgroundToolResults({
+          userId: 'user123',
+          conversationId: mockMessageData.conversationId as string,
+          messageId: 'msg123',
+          taskId: 'task-3',
+          kind: 'wakeup',
+          claimId: 'delivery-2',
+        }),
+      ).resolves.toMatchObject({
+        status: 'acquired',
+        results: [{ taskId: 'task-3', output: 'three' }],
+      });
+    });
+
+    it.each([true, false])(
+      'keeps independent receipt ownership out of message batches (root=%s)',
+      async (receiptRoot) => {
+        const terminal = (taskId: string, receipt: boolean) => ({
+          type: 'tool_call',
+          tool_call: {
+            id: taskId,
+            output: taskId,
+            backgroundTask: {
+              taskId,
+              toolName: 'tool',
+              status: 'completed',
+              completionWakeup: true,
+              ...(receipt ? { completionReceipt: true } : {}),
+            },
+          },
+        });
+        await saveMessage(mockCtx, {
+          ...mockMessageData,
+          content: [
+            terminal('root', receiptRoot),
+            terminal('independent', true),
+            terminal('message-only', false),
+          ],
+        });
+        const input = {
+          userId: 'user123',
+          conversationId: mockMessageData.conversationId as string,
+          messageId: 'msg123',
+          taskId: 'root',
+          kind: 'wakeup' as const,
+          claimId: 'delivery',
+          limit: 16,
+        };
+        const claim = await claimBackgroundToolResults(input);
+        expect(claim.status).toBe('acquired');
+        if (claim.status !== 'acquired') throw new Error('Expected acquired claim');
+        expect(claim.results.map((r) => r.taskId)).toEqual(
+          receiptRoot ? ['root'] : ['root', 'message-only'],
+        );
+        await expect(claimBackgroundToolResults({ ...input, limit: 1 })).resolves.toEqual(claim);
+        await expect(
+          claimBackgroundToolResults({ ...input, taskId: 'independent', claimId: 'other' }),
+        ).resolves.toMatchObject({
+          status: 'acquired',
+          results: [{ taskId: 'independent' }],
+        });
+      },
+    );
+
+    it('bounds escaped metadata before claiming and freezes membership across competing same-owner preparations', async () => {
+      const ids = Array.from({ length: 16 }, (_, i) => `${i}${'\u0001'.repeat(250)}`);
+      const terminal = (id: string) => ({
+        type: 'tool_call',
+        tool_call: {
+          id,
+          output: 'done',
+          backgroundTask: {
+            taskId: id,
+            toolName: '\u0001'.repeat(256),
+            status: 'completed',
+            completionWakeup: true,
+          },
+        },
+      });
+      await saveMessage(mockCtx, { ...mockMessageData, content: ids.map(terminal) });
+      const input = {
+        userId: 'user123',
+        conversationId: mockMessageData.conversationId as string,
+        messageId: 'msg123',
+        taskId: ids[15],
+        kind: 'wakeup' as const,
+        claimId: 'delivery',
+        limit: 16,
+        maxMetadataChars: 16 * 1024 - 256,
+      };
+      const attempts = await Promise.all([
+        claimBackgroundToolResults(input),
+        claimBackgroundToolResults(input),
+      ]);
+      const claim = attempts.find((result) => result.status === 'acquired');
+      if (claim?.status !== 'acquired') throw new Error('No claim elected');
+      expect(claim.results.some((r) => r.taskId === ids[15])).toBe(true);
+      expect(claim.results.length).toBeLessThan(16);
+      expect(
+        JSON.stringify(claim.results.map(backgroundResultMetadata)).length,
+      ).toBeLessThanOrEqual(input.maxMetadataChars);
+      await Message.updateOne(
+        { messageId: 'msg123', user: 'user123' },
+        { $push: { content: terminal('late') } },
+      );
+      await expect(claimBackgroundToolResults({ ...input, limit: 1 })).resolves.toEqual(claim);
+      await expect(
+        claimBackgroundToolResults({ ...input, taskId: 'late', claimId: 'later' }),
+      ).resolves.toMatchObject({ status: 'acquired' });
     });
 
     it('revalidates each sibling inside the atomic batch claim', async () => {
diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.ts
index c8aae0d6239..49f29584494 100644
--- a/packages/data-schemas/src/methods/message.ts
+++ b/packages/data-schemas/src/methods/message.ts
@@ -1,4 +1,8 @@
-import { HITL_MESSAGE_FILTER_FIELDS, RetentionMode } from 'librechat-data-provider';
+import {
+  backgroundResultMetadata,
+  HITL_MESSAGE_FILTER_FIELDS,
+  RetentionMode,
+} from 'librechat-data-provider';
 import type { DeleteResult, FilterQuery, Model, Types, UpdateQuery } from 'mongoose';
 import type { UserSubmittedMessageFieldPath } from 'librechat-data-provider';
 import type { SearchParams } from 'meilisearch';
@@ -726,6 +730,7 @@ export interface MessageMethods {
       cancelled?: true;
       settledAt: Date;
       completionWakeup?: true;
+      completionReceipt?: true;
       resultClaim?: {
         kind: 'manual' | 'wakeup';
         claimId: string;
@@ -748,6 +753,8 @@ export interface MessageMethods {
     /** Manual owner-process takeover after automatic delivery was retired. */
     allowUnfinished?: boolean;
     limit?: number;
+    /** Includes JSON escaping, delimiters, and empty result fields. */
+    maxMetadataChars?: number;
   }): Promise<BackgroundToolResultClaim>;
   releaseBackgroundToolResultClaims(params: {
     userId: string;
@@ -1224,6 +1231,7 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
       cancelled?: true;
       settledAt: Date;
       completionWakeup?: true;
+      completionReceipt?: true;
       resultClaim?: {
         kind: 'manual' | 'wakeup';
         claimId: string;
@@ -1274,6 +1282,9 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
         partPatch['content.$[part].tool_call.backgroundTask.cancelled'] =
           backgroundTask.cancelled === true;
         partPatch['content.$[part].tool_call.backgroundTask.settledAt'] = backgroundTask.settledAt;
+        if (backgroundTask.completionReceipt === true) {
+          partPatch['content.$[part].tool_call.backgroundTask.completionReceipt'] = true;
+        }
         if (backgroundTask.completionWakeup === true) {
           partPatch['content.$[part].tool_call.backgroundTask.completionWakeup'] = true;
         } else {
@@ -1418,7 +1429,7 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
     }
   }
 
-  const MAX_BACKGROUND_TOOL_RESULT_BATCH = 8;
+  const MAX_BACKGROUND_TOOL_RESULT_BATCH = 16;
   /** Bounds the attachments-merge fence retries. Each lost round means a
    * concurrent writer changed the array, so re-reading converges. */
   const ATTACHMENT_MERGE_CAS_ATTEMPTS = 8;
@@ -1574,19 +1585,11 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
     claimId,
     generationId,
     allowUnfinished = false,
-    limit = kind === 'wakeup' ? MAX_BACKGROUND_TOOL_RESULT_BATCH : 1,
-  }: {
-    userId: string;
-    conversationId: string;
-    messageId?: string;
-    taskId: string;
-    agentId?: string;
-    kind: 'manual' | 'wakeup';
-    claimId: string;
-    generationId?: string;
-    allowUnfinished?: boolean;
-    limit?: number;
-  }): Promise<BackgroundToolResultClaim> {
+    limit = kind === 'wakeup' ? 8 : 1,
+    maxMetadataChars,
+  }: Parameters<
+    MessageMethods['claimBackgroundToolResults']
+  >[0]): Promise<BackgroundToolResultClaim> {
     const requestedMessageId = messageId?.trim();
     const requestedGenerationId = generationId?.trim();
     if (
@@ -1600,7 +1603,11 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
         (requestedGenerationId.length === 0 || requestedGenerationId.length > 256)) ||
       (requestedGenerationId != null && kind !== 'manual') ||
       (allowUnfinished && kind !== 'manual') ||
-      (kind !== 'manual' && kind !== 'wakeup')
+      (kind !== 'manual' && kind !== 'wakeup') ||
+      !Number.isSafeInteger(limit) ||
+      limit < 1 ||
+      (maxMetadataChars != null &&
+        (!Number.isSafeInteger(maxMetadataChars) || maxMetadataChars < 1))
     ) {
       throw new TypeError('Invalid background tool result claim');
     }
@@ -1660,6 +1667,8 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
     const requestedClaim = readBackgroundToolResultClaim(row, taskId);
     const replaying = requestedClaim?.kind === kind && requestedClaim.claimId === claimId;
     const candidates: string[] = [];
+    const costs = new Map<string, number>();
+    let receiptBacked = false;
     let requestedState: 'ready' | 'claimed' | 'missing' = 'missing';
     for (const part of row.content ?? []) {
       if (part == null || typeof part !== 'object' || Array.isArray(part)) {
@@ -1687,6 +1696,7 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
       const claimable =
         terminal && wakeupEligible && sameAgent && (replaying ? replay : resultClaim == null);
       if (candidateId === taskId) {
+        receiptBacked = task?.completionReceipt === true;
         if (claimable) {
           requestedState = 'ready';
         } else if (resultClaim != null) {
@@ -1695,11 +1705,29 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
       }
       if (
         claimable &&
+        (candidateId === taskId || task?.completionReceipt !== true) &&
         (candidateId === taskId || kind === 'wakeup') &&
         candidates.length < boundedLimit
       ) {
         candidates.push(candidateId);
       }
+      if (claimable && (candidateId === taskId || candidates.includes(candidateId))) {
+        const call = (part as { tool_call?: { id?: string } }).tool_call;
+        if (typeof call?.id === 'string' && typeof task?.toolName === 'string') {
+          const terminalStatus = task.status === 'error' ? 'error' : 'completed';
+          costs.set(
+            candidateId,
+            JSON.stringify(
+              backgroundResultMetadata({
+                taskId: candidateId,
+                toolCallId: call.id,
+                toolName: task.toolName,
+                status: task.cancelled === true ? 'cancelled' : terminalStatus,
+              }),
+            ).length + 1,
+          );
+        }
+      }
     }
     if (requestedState === 'missing') {
       return { status: 'not_ready' };
@@ -1715,6 +1743,24 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
       candidates.unshift(taskId);
       candidates.splice(boundedLimit);
     }
+    if (!replaying) {
+      /** A receipt lives on another document, so it cannot join this atomic
+       * message-row batch. Keep its delivery task-local in both directions. */
+      if (receiptBacked) candidates.splice(0, candidates.length, taskId);
+      if (maxMetadataChars != null) {
+        let remaining = maxMetadataChars - 1 - (costs.get(taskId) ?? maxMetadataChars);
+        if (remaining < 0)
+          throw new TypeError('Background result metadata exceeds its input budget');
+        const admitted = candidates.filter((id) => {
+          if (id === taskId) return true;
+          const cost = costs.get(id) ?? maxMetadataChars;
+          if (cost > remaining) return false;
+          remaining -= cost;
+          return true;
+        });
+        candidates.splice(0, candidates.length, ...admitted);
+      }
+    }
     const claimedAt = new Date();
     const claimStamp = {
       kind,
diff --git a/packages/data-schemas/src/methods/skill.spec.ts b/packages/data-schemas/src/methods/skill.spec.ts
index 387ee668859..c7145e2cd42 100644
--- a/packages/data-schemas/src/methods/skill.spec.ts
+++ b/packages/data-schemas/src/methods/skill.spec.ts
@@ -807,7 +807,7 @@ describe('Skill CRUD methods', () => {
     expect(filtered).toEqual([canonical]);
   });
 
-  it('deleteSkill prunes agent allowlists even when skill file cleanup fails', async () => {
+  it('deleteSkill remains retryable after skill file cleanup fails', async () => {
     const { skill } = await methods.createSkill(makeSkillInput({ name: 'flaky-files' }));
     const Agent = mongoose.models.Agent;
     const agent = await Agent.create(makeAgentDoc([skill._id.toString()]));
@@ -816,9 +816,21 @@ describe('Skill CRUD methods', () => {
       .spyOn(SkillFile, 'deleteMany')
       .mockRejectedValueOnce(new Error('transient storage failure'));
     try {
-      await expect(methods.deleteSkill(skill._id.toString())).rejects.toThrow(
-        'transient storage failure',
-      );
+      const first = await methods.deleteSkill(skill._id.toString());
+      expect(first).toEqual({
+        deleted: true,
+        skillAbsent: true,
+        cleanupComplete: false,
+        failedCleanupSteps: ['skill_files'],
+      });
+
+      const retry = await methods.deleteSkill(skill._id.toString());
+      expect(retry).toEqual({
+        deleted: false,
+        skillAbsent: true,
+        cleanupComplete: true,
+        failedCleanupSteps: [],
+      });
     } finally {
       deleteManySpy.mockRestore();
     }
diff --git a/packages/data-schemas/src/methods/skill.ts b/packages/data-schemas/src/methods/skill.ts
index a38afdc5766..e807be080d9 100644
--- a/packages/data-schemas/src/methods/skill.ts
+++ b/packages/data-schemas/src/methods/skill.ts
@@ -44,6 +44,18 @@ export type ValidationIssue = {
   severity?: 'error' | 'warning';
 };
 
+export type DeleteSkillCleanupStep = 'agent_allowlists' | 'skill_files' | 'permissions';
+
+export type DeleteSkillResult = {
+  /** Whether this call removed the Skill row. */
+  deleted: boolean;
+  /** Whether the Skill row is absent after this call, including an idempotent retry. */
+  skillAbsent: boolean;
+  /** Whether every dependent database cleanup step completed. */
+  cleanupComplete: boolean;
+  failedCleanupSteps: DeleteSkillCleanupStep[];
+};
+
 type SkillFileUpsertResult = {
   value: (ISkillFile & { _id: Types.ObjectId }) | null;
   lastErrorObject?: {
@@ -1056,7 +1068,7 @@ export function createSkillMethods(
     expectedVersion: number;
     update: UpdateSkillInput;
   }) => Promise<UpdateSkillResult>;
-  deleteSkill: (id: string) => Promise<{ deleted: boolean }>;
+  deleteSkill: (id: string) => Promise<DeleteSkillResult>;
   deleteUserSkills: (userId: Types.ObjectId | string) => Promise<number>;
   findSkillBySourceIdentity: (params: {
     source: 'github' | 'notion';
@@ -1669,9 +1681,9 @@ export function createSkillMethods(
    * full catalog on purpose -- so disabling them would turn skills off behind
    * the author's back.
    */
-  async function removeSkillsFromAgentAllowlists(skillIds: string[]): Promise<void> {
+  async function removeSkillsFromAgentAllowlists(skillIds: string[]): Promise<boolean> {
     if (skillIds.length === 0) {
-      return;
+      return true;
     }
     const ids = skillIds.map((id) => id.toLowerCase());
     const Agent = mongoose.models.Agent as Model<IAgent>;
@@ -1695,36 +1707,54 @@ export function createSkillMethods(
         { $pull: { skills: { $in: ids } } },
         { timestamps: false },
       );
+      return true;
     } catch (error) {
       logger.error(
         '[removeSkillsFromAgentAllowlists] Error pruning agent skill allowlists:',
         error,
       );
+      return false;
     }
   }
 
-  async function deleteSkill(id: string): Promise<{ deleted: boolean }> {
+  async function deleteSkill(id: string): Promise<DeleteSkillResult> {
     if (!isValidObjectIdString(id)) {
-      return { deleted: false };
+      return {
+        deleted: false,
+        skillAbsent: false,
+        cleanupComplete: false,
+        failedCleanupSteps: [],
+      };
     }
     const Skill = mongoose.models.Skill as Model<ISkillDocument>;
     const SkillFile = mongoose.models.SkillFile as Model<ISkillFileDocument>;
     const objectId = new ObjectId(id);
     const res = await Skill.deleteOne({ _id: objectId });
-    if (!res.deletedCount) {
-      return { deleted: false };
+    const failedCleanupSteps: DeleteSkillCleanupStep[] = [];
+    const allowlistsRemoved = await removeSkillsFromAgentAllowlists([id]);
+    if (!allowlistsRemoved) {
+      failedCleanupSteps.push('agent_allowlists');
     }
-    /** Prune allowlists immediately after the Skill row is gone: if the
-     *  SkillFile cleanup below throws, a retry exits early on
-     *  `deletedCount === 0` and would never reach a later prune. */
-    await removeSkillsFromAgentAllowlists([id]);
-    await SkillFile.deleteMany({ skillId: objectId });
-    try {
-      await deps.removeAllPermissions({ resourceType: ResourceType.SKILL, resourceId: id });
-    } catch (error) {
-      logger.error(`[deleteSkill] Error removing permissions for ${id}:`, error);
+
+    const [filesResult, permissionsResult] = await Promise.allSettled([
+      SkillFile.deleteMany({ skillId: objectId }),
+      deps.removeAllPermissions({ resourceType: ResourceType.SKILL, resourceId: id }),
+    ]);
+    if (filesResult.status === 'rejected') {
+      failedCleanupSteps.push('skill_files');
+      logger.error(`[deleteSkill] Error removing files for ${id}:`, filesResult.reason);
     }
-    return { deleted: true };
+    if (permissionsResult.status === 'rejected') {
+      failedCleanupSteps.push('permissions');
+      logger.error(`[deleteSkill] Error removing permissions for ${id}:`, permissionsResult.reason);
+    }
+
+    return {
+      deleted: Boolean(res.deletedCount),
+      skillAbsent: true,
+      cleanupComplete: failedCleanupSteps.length === 0,
+      failedCleanupSteps,
+    };
   }
 
   async function deleteUserSkills(userId: Types.ObjectId | string): Promise<number> {
diff --git a/packages/data-schemas/src/methods/triggerDelivery.spec.ts b/packages/data-schemas/src/methods/triggerDelivery.spec.ts
index 6ca5b424997..1f0fcc74f6a 100644
--- a/packages/data-schemas/src/methods/triggerDelivery.spec.ts
+++ b/packages/data-schemas/src/methods/triggerDelivery.spec.ts
@@ -18,12 +18,14 @@ import {
   type AgentTriggerDeliveryMethods,
 } from './triggerDelivery';
 import {
+  AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
   AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
 } from '~/types/triggerDelivery';
 import { createAgentTriggerLaneSequenceModel } from '../models/triggerLaneSequence';
 import { createAgentTriggerUserPurgeModel } from '../models/triggerUserPurge';
 import { createAgentTriggerDeliveryModel } from '../models/triggerDelivery';
+import { createConversationModel } from '../models/convo';
 import { createUserModel } from '../models/user';
 
 jest.mock('~/config/winston', () => ({
@@ -32,6 +34,7 @@ jest.mock('~/config/winston', () => ({
   info: jest.fn(),
   debug: jest.fn(),
 }));
+jest.mock('~/models/plugins/mongoMeili', () => jest.fn());
 
 const DB_SETUP_TIMEOUT_MS = 60_000;
 const START = new Date('2026-08-17T12:00:00.000Z');
@@ -50,6 +53,7 @@ beforeAll(async () => {
   LaneSequence = createAgentTriggerLaneSequenceModel(mongoose);
   UserPurge = createAgentTriggerUserPurgeModel(mongoose);
   User = createUserModel(mongoose);
+  createConversationModel(mongoose);
   await Promise.all([Delivery.init(), LaneSequence.init(), UserPurge.init(), User.init()]);
   methods = createAgentTriggerDeliveryMethods(mongoose);
 }, DB_SETUP_TIMEOUT_MS);
@@ -384,7 +388,7 @@ describe('agent trigger delivery methods', () => {
   it('shields background completion work from workers that cannot resolve it', async () => {
     const queued = await methods.enqueueAgentTriggerDelivery(
       enqueueInput({
-        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
       }),
     );
     const claimInput = {
@@ -400,7 +404,7 @@ describe('agent trigger delivery methods', () => {
         ...claimInput,
         workerId: 'background-capable-worker',
         claimToken: 'background-capable-claim',
-        workerCapabilities: [AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1],
+        workerCapabilities: [AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2],
       }),
     ).resolves.toMatchObject({ id: queued.delivery.id });
   });
@@ -412,7 +416,7 @@ describe('agent trigger delivery methods', () => {
       enqueueInput({
         deliveryKey: 'background-completion-producer-lease',
         envelope: { event: { source } },
-        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
         producerLeaseUntil: initialLease,
       }),
     );
@@ -449,6 +453,323 @@ describe('agent trigger delivery methods', () => {
     ).resolves.toEqual({ status: 'live', leaseUntil: renewedUntil });
   });
 
+  it('persists one private background result receipt independently of message rows', async () => {
+    const source = { id: 'background-tool-completion', type: 'internal' };
+    const queued = await methods.enqueueAgentTriggerDelivery(
+      enqueueInput({
+        deliveryKey: 'background-completion-result-receipt',
+        envelope: { event: { source } },
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      }),
+    );
+    const input = {
+      deliveryKey: queued.delivery.deliveryKey,
+      sourceId: source.id,
+      result: { status: 'completed' as const, output: 'durable output', settledAt: START },
+    };
+
+    await expect(methods.persistAgentBackgroundToolResult(input)).resolves.toBe(true);
+    await expect(methods.persistAgentBackgroundToolResult(input)).resolves.toBe(true);
+    await expect(
+      methods.getAgentBackgroundToolResult({
+        deliveryKey: queued.delivery.deliveryKey,
+        sourceId: source.id,
+      }),
+    ).resolves.toEqual(input.result);
+    await expect(
+      methods.persistAgentBackgroundToolResult({
+        ...input,
+        result: { ...input.result, output: 'conflicting output' },
+      }),
+    ).resolves.toBe(false);
+    const ordinaryRead = await Delivery.findById(queued.delivery.id).lean();
+    expect(ordinaryRead).not.toHaveProperty('backgroundToolResult');
+  });
+
+  it('erases private result receipts when their conversation is deleted', async () => {
+    const source = { id: 'background-tool-completion', type: 'internal' };
+    const user = new mongoose.Types.ObjectId();
+    const queued = await methods.enqueueAgentTriggerDelivery(
+      enqueueInput({
+        deliveryKey: 'background-completion-result-to-erase',
+        user,
+        envelope: {
+          event: { source },
+          target: { conversationId: 'conversation-to-delete' },
+        },
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      }),
+    );
+    await methods.persistAgentBackgroundToolResult({
+      deliveryKey: queued.delivery.deliveryKey,
+      sourceId: source.id,
+      result: { status: 'completed', output: 'private output', settledAt: START },
+    });
+
+    await methods.eraseAgentTriggerDeliveryConversationResults(user, ['conversation-to-delete']);
+
+    await expect(
+      methods.getAgentBackgroundToolResult({
+        deliveryKey: queued.delivery.deliveryKey,
+        sourceId: source.id,
+      }),
+    ).resolves.toBeNull();
+    await expect(Delivery.exists({ _id: queued.delivery.id })).resolves.not.toBeNull();
+    await expect(
+      methods.persistAgentBackgroundToolResult({
+        deliveryKey: queued.delivery.deliveryKey,
+        sourceId: source.id,
+        result: { status: 'completed', output: 'late private output', settledAt: START },
+      }),
+    ).resolves.toBe(false);
+  });
+
+  it('does not make legacy string-owned conversation cleanup depend on an ObjectId cast', async () => {
+    await expect(
+      methods.prepareAgentTriggerConversationResultErasure('legacy-user', ['conversation']),
+    ).resolves.toBeUndefined();
+    await expect(
+      methods.eraseAgentTriggerDeliveryConversationResults('legacy-user', ['conversation']),
+    ).resolves.toBeUndefined();
+  });
+
+  it('recovers receipt erasure after a descendant row was already deleted', async () => {
+    const user = new mongoose.Types.ObjectId();
+    const source = { id: 'background-tool-completion', type: 'internal' };
+    const queued = await methods.enqueueAgentTriggerDelivery(
+      enqueueInput({
+        user,
+        envelope: { event: { source }, target: { conversationId: 'deleted-child' } },
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      }),
+    );
+    const lookup = { deliveryKey: queued.delivery.deliveryKey, sourceId: source.id };
+    await methods.persistAgentBackgroundToolResult({
+      ...lookup,
+      result: { status: 'completed', output: 'private child output', settledAt: START },
+    });
+    await methods.prepareAgentTriggerConversationResultErasure(user, ['deleted-child']);
+    await mongoose.models.Conversation.collection.insertOne({
+      user: user.toString(),
+      conversationId: 'deleted-child',
+    });
+    await methods.recoverAgentTriggerUserPurges();
+    await expect(methods.getAgentBackgroundToolResult(lookup)).resolves.not.toBeNull();
+    await mongoose.models.Conversation.deleteOne({ user, conversationId: 'deleted-child' });
+    /** The conversation deletion committed, but the follow-up receipt erasure did not. */
+    await methods.recoverAgentTriggerUserPurges();
+    await expect(methods.getAgentBackgroundToolResult(lookup)).resolves.toBeNull();
+    await expect(
+      Delivery.exists({
+        _id: queued.delivery.id,
+        backgroundToolResultDeletionPendingAt: { $exists: true },
+      }),
+    ).resolves.toBeNull();
+    await expect(
+      methods.persistAgentBackgroundToolResult({
+        ...lookup,
+        result: { status: 'completed', output: 'late write', settledAt: START },
+      }),
+    ).resolves.toBe(false);
+  });
+
+  it.each([
+    ['receipt', 'BACKGROUND_TOOL_PRODUCER_LOST'],
+    ['death', 'BACKGROUND_TOOL_PRODUCER_LOST'],
+    ['receipt', 'PARENT_STATE_UNAVAILABLE'],
+    ['death', 'PARENT_STATE_UNAVAILABLE'],
+  ])('atomically fences result publication when %s wins before %s', async (winner, code) => {
+    const source = { id: 'background-tool-completion', type: 'internal' };
+    const queued = await methods.enqueueAgentTriggerDelivery(
+      enqueueInput({
+        envelope: { event: { source } },
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      }),
+    );
+    const owner = { workerId: 'worker', claimToken: 'claim', now: START };
+    const claimed = await methods.claimNextAgentTriggerDelivery({
+      ...owner,
+      leaseUntil: new Date(START.getTime() + 60_000),
+      workerCapabilities: [AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2],
+    });
+    expect(claimed).not.toBeNull();
+    const attempt = await methods.beginAgentTriggerDeliveryAttempt({ ...owner, id: claimed!.id });
+    const write = () =>
+      methods.persistAgentBackgroundToolResult({
+        deliveryKey: queued.delivery.deliveryKey,
+        sourceId: source.id,
+        result: { status: 'completed', output: 'late output', settledAt: START },
+      });
+    const dead = () =>
+      methods.deadLetterAgentTriggerDelivery({
+        ...owner,
+        id: claimed!.id,
+        attempt: attempt!,
+        settledAt: START,
+        error: transientFailure({ code, retryable: code !== 'BACKGROUND_TOOL_PRODUCER_LOST' }),
+      });
+    await expect(winner === 'receipt' ? write() : dead()).resolves.toBe(true);
+    await expect(winner === 'receipt' ? dead() : write()).resolves.toBe(false);
+  });
+
+  it.each(['shield', 'legacy'] as const)(
+    'recovers a committed receipt after generic retry exhaustion through the %s fence',
+    async (format) => {
+      const source = { id: 'background-tool-completion', type: 'internal' };
+      const queued = await methods.enqueueAgentTriggerDelivery(
+        enqueueInput({
+          envelope: { event: { source } },
+          requiredWorkerCapability:
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+        }),
+      );
+      const owner = { workerId: 'worker', claimToken: 'claim', now: START };
+      const claimed = await methods.claimNextAgentTriggerDelivery({
+        ...owner,
+        leaseUntil: new Date(START.getTime() + 60_000),
+        workerCapabilities: [AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2],
+      });
+      const id = claimed!.id;
+      const attempt = await methods.beginAgentTriggerDeliveryAttempt({ ...owner, id });
+      if (format !== 'shield') {
+        await Delivery.updateOne(
+          { _id: id },
+          {
+            $set: {
+              status: 'capability_leased',
+              leaseBy: owner.workerId,
+              claimToken: owner.claimToken,
+              leaseUntil: new Date(START.getTime() + 60_000),
+            },
+            $unset: {
+              capabilityStatus: 1,
+              capabilityLeaseBy: 1,
+              capabilityLeaseUntil: 1,
+              capabilityClaimToken: 1,
+            },
+          },
+        );
+      }
+      const receipt = { deliveryKey: queued.delivery.deliveryKey, sourceId: source.id };
+      await methods.persistAgentBackgroundToolResult({
+        ...receipt,
+        result: { status: 'completed', output: 'saved output', settledAt: START },
+      });
+      const receiptRetryAt = new Date(START.getTime() + 300_000);
+      const terminal = {
+        ...owner,
+        id,
+        attempt: attempt!,
+        settledAt: START,
+        receiptRetryAt,
+        error: transientFailure({ code: 'PARENT_STATE_UNAVAILABLE' }),
+      };
+      await expect(
+        methods.deadLetterAgentTriggerDelivery({ ...terminal, claimToken: 'stale' }),
+      ).resolves.toBe(false);
+      expect((await Delivery.findById(id).lean())?.attempts).toBe(attempt);
+      await expect(methods.deadLetterAgentTriggerDelivery(terminal)).resolves.toBe(false);
+      expect(await Delivery.findById(id).lean()).toMatchObject({
+        attempts: 0,
+        claimAvailableAt: receiptRetryAt,
+        ...(format === 'shield'
+          ? { capabilityStatus: 'pending' }
+          : { status: 'capability_pending' }),
+      });
+      await expect(methods.getAgentBackgroundToolResult(receipt)).resolves.toMatchObject({
+        output: 'saved output',
+      });
+      const recovered = await methods.claimNextAgentTriggerDelivery({
+        ...owner,
+        claimToken: 'recovered',
+        now: receiptRetryAt,
+        leaseUntil: new Date(receiptRetryAt.getTime() + 60_000),
+        workerCapabilities: [AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2],
+      });
+      expect(recovered?.id).toBe(id);
+      expect(
+        await methods.beginAgentTriggerDeliveryAttempt({
+          ...owner,
+          id,
+          claimToken: 'recovered',
+          now: receiptRetryAt,
+        }),
+      ).toBe(1);
+      await expect(
+        methods.deadLetterAgentTriggerDelivery({
+          ...terminal,
+          claimToken: 'recovered',
+          settledAt: receiptRetryAt,
+          error: transientFailure({ code: 'PARENT_NOT_FOUND', retryable: false }),
+        }),
+      ).resolves.toBe(true);
+    },
+  );
+
+  it('claims an independent result receipt before returning its output', async () => {
+    const source = { id: 'background-tool-completion', type: 'internal' };
+    const user = new mongoose.Types.ObjectId();
+    const queued = await methods.enqueueAgentTriggerDelivery(
+      enqueueInput({
+        deliveryKey: 'background-completion-result-to-claim',
+        user,
+        envelope: {
+          event: {
+            source,
+            payload: { taskId: 'task-1', toolCallId: 'call-1', toolName: 'slow_tool' },
+          },
+          target: {
+            agentId: 'agent-1',
+            conversationId: 'conversation-1',
+            parentMessageId: 'response-1',
+          },
+        },
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      }),
+    );
+    await methods.persistAgentBackgroundToolResult({
+      deliveryKey: queued.delivery.deliveryKey,
+      sourceId: source.id,
+      result: { status: 'completed', output: 'private output', settledAt: START },
+    });
+    const claim = {
+      deliveryKey: queued.delivery.deliveryKey,
+      sourceId: source.id,
+      userId: user.toString(),
+      conversationId: 'conversation-1',
+      parentMessageId: 'response-1',
+      agentId: 'agent-1',
+      claimId: 'delivery-claim-1',
+      limit: 1,
+    };
+
+    await expect(methods.claimAgentBackgroundToolResults(claim)).resolves.toMatchObject({
+      status: 'acquired',
+      results: [{ taskId: 'task-1', output: 'private output' }],
+    });
+    await expect(
+      methods.claimAgentBackgroundToolResults({ ...claim, claimId: 'delivery-claim-2' }),
+    ).resolves.toEqual({ status: 'claimed', claimId: 'delivery-claim-1' });
+    await expect(
+      methods.getAgentBackgroundToolResultClaim({
+        sourceId: source.id,
+        userId: user.toString(),
+        conversationId: 'conversation-1',
+        parentMessageId: 'response-1',
+        taskId: 'task-1',
+      }),
+    ).resolves.toMatchObject({ kind: 'wakeup', claimId: 'delivery-claim-1' });
+    await expect(
+      methods.releaseAgentBackgroundToolResultClaims({
+        sourceId: source.id,
+        userId: user.toString(),
+        conversationId: 'conversation-1',
+        parentMessageId: 'response-1',
+        claimId: 'delivery-claim-1',
+      }),
+    ).resolves.toBe(true);
+  });
+
   it('keeps capability-fenced work limited to capable workers through lease recovery', async () => {
     const queued = await methods.enqueueAgentTriggerDelivery(
       enqueueInput({
diff --git a/packages/data-schemas/src/methods/triggerDelivery.ts b/packages/data-schemas/src/methods/triggerDelivery.ts
index a4569db5fde..f2d12193b0a 100644
--- a/packages/data-schemas/src/methods/triggerDelivery.ts
+++ b/packages/data-schemas/src/methods/triggerDelivery.ts
@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import type { FilterQuery, Model, Types } from 'mongoose';
 import type {
+  AgentBackgroundToolResultReceipt,
   AgentEventActorDetachedAction,
   AgentTriggerDeliveryClaim,
   AgentEventActorReceipt,
@@ -17,6 +18,8 @@ import type {
   IAgentTriggerUserPurgeDocument,
 } from '~/types/triggerDelivery';
 import {
+  AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+  AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS,
   AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1,
   AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1,
@@ -129,6 +132,26 @@ export type AgentTriggerProducerLeaseStatus =
   | { status: 'expired'; leaseUntil: Date }
   | { status: 'missing' };
 
+export interface PersistAgentBackgroundToolResultInput {
+  deliveryKey: string;
+  sourceId: string;
+  result: AgentBackgroundToolResultReceipt;
+}
+
+export type AgentBackgroundToolResultClaim =
+  | { status: 'not_ready' }
+  | { status: 'claimed'; claimId: string }
+  | {
+      status: 'acquired';
+      results: Array<{
+        taskId: string;
+        toolCallId: string;
+        toolName: string;
+        status: AgentBackgroundToolResultReceipt['status'];
+        output: string;
+      }>;
+    };
+
 export interface AgentTriggerDeliveryFence {
   id: string;
   workerId: string;
@@ -277,6 +300,37 @@ export interface AgentTriggerDeliveryMethods {
     sourceId: string;
     now: Date;
   }) => Promise<AgentTriggerProducerLeaseStatus>;
+  persistAgentBackgroundToolResult: (
+    input: PersistAgentBackgroundToolResultInput,
+  ) => Promise<boolean>;
+  getAgentBackgroundToolResult: (input: {
+    deliveryKey: string;
+    sourceId: string;
+  }) => Promise<AgentBackgroundToolResultReceipt | null>;
+  getAgentBackgroundToolResultClaim: (input: {
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    taskId: string;
+  }) => Promise<AgentBackgroundToolResultReceipt['resultClaim'] | null>;
+  claimAgentBackgroundToolResults: (input: {
+    deliveryKey: string;
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    agentId?: string;
+    claimId: string;
+    limit?: number;
+  }) => Promise<AgentBackgroundToolResultClaim>;
+  releaseAgentBackgroundToolResultClaims: (input: {
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    claimId: string;
+  }) => Promise<boolean>;
   settleAgentTriggerHandlingOutcome: (
     input: SettleAgentTriggerHandlingOutcomeInput,
   ) => Promise<boolean>;
@@ -326,6 +380,7 @@ export interface AgentTriggerDeliveryMethods {
       attempt: number;
       error: AgentTriggerDeliveryFailure;
       settledAt: Date;
+      receiptRetryAt?: Date;
     },
   ) => Promise<boolean>;
   getAgentTriggerDelivery: (deliveryKey: string) => Promise<AgentTriggerDeliveryRecord | null>;
@@ -358,6 +413,14 @@ export interface AgentTriggerDeliveryMethods {
   ) => Promise<boolean>;
   recoverAgentTriggerUserPurges: (limit?: number) => Promise<number>;
   deleteAgentTriggerDeliveriesByUser: (user: string | Types.ObjectId) => Promise<void>;
+  eraseAgentTriggerDeliveryConversationResults: (
+    user: string | Types.ObjectId,
+    conversationIds: string[],
+  ) => Promise<void>;
+  prepareAgentTriggerConversationResultErasure: (
+    user: string | Types.ObjectId,
+    conversationIds: string[],
+  ) => Promise<void>;
 }
 
 function normalizeFailure(error: AgentTriggerDeliveryFailure): AgentTriggerDeliveryFailure {
@@ -960,6 +1023,8 @@ export function createAgentTriggerDeliveryMethods(
     if (
       input.requiredWorkerCapability != null &&
       input.requiredWorkerCapability !== AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1 &&
+      input.requiredWorkerCapability !==
+        AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2 &&
       input.requiredWorkerCapability !== AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1 &&
       input.requiredWorkerCapability !== AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1
     ) {
@@ -2122,7 +2187,12 @@ export function createAgentTriggerDeliveryMethods(
     const renewed = await Delivery().updateOne(
       {
         deliveryKey: input.deliveryKey,
-        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+        requiredWorkerCapability: {
+          $in: [
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+          ],
+        },
         'envelope.event.source.type': 'internal',
         'envelope.event.source.id': input.sourceId,
         status: {
@@ -2161,7 +2231,12 @@ export function createAgentTriggerDeliveryMethods(
     const delivery = await Delivery()
       .findOne({
         deliveryKey: input.deliveryKey,
-        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+        requiredWorkerCapability: {
+          $in: [
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1,
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+          ],
+        },
         'envelope.event.source.type': 'internal',
         'envelope.event.source.id': input.sourceId,
       })
@@ -2175,6 +2250,262 @@ export function createAgentTriggerDeliveryMethods(
       : { status: 'expired', leaseUntil: delivery.producerLeaseUntil };
   }
 
+  /** Stores terminal output on the pre-admitted delivery before attempting the
+   * parent-message projection. The first terminal receipt wins; exact retries
+   * are idempotent and conflicting rewrites fail closed. */
+  async function persistAgentBackgroundToolResult(
+    input: PersistAgentBackgroundToolResultInput,
+  ): Promise<boolean> {
+    const { result } = input;
+    if (
+      input.deliveryKey.length === 0 ||
+      input.deliveryKey.length > 256 ||
+      input.sourceId.length === 0 ||
+      input.sourceId.length > 256 ||
+      !['completed', 'error', 'cancelled'].includes(result.status) ||
+      result.output.length > AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS ||
+      !(result.settledAt instanceof Date) ||
+      !Number.isFinite(result.settledAt.getTime())
+    ) {
+      throw new TypeError('Invalid background tool result receipt');
+    }
+    const identity = {
+      deliveryKey: input.deliveryKey,
+      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      'envelope.event.source.type': 'internal',
+      'envelope.event.source.id': input.sourceId,
+      backgroundToolResultErasedAt: { $exists: false },
+    };
+    const updated = await Delivery().updateOne(
+      {
+        ...identity,
+        backgroundToolResult: { $exists: false },
+        status: { $nin: ['dead', 'capability_dead', 'succeeded'] },
+        capabilityStatus: { $ne: 'dead' },
+      },
+      { $set: { backgroundToolResult: result } },
+      { timestamps: false },
+    );
+    if (updated.matchedCount === 1) {
+      return true;
+    }
+    const existing = await Delivery()
+      .findOne(identity)
+      .select('+backgroundToolResult')
+      .lean<Pick<IAgentTriggerDelivery, 'backgroundToolResult'>>();
+    return (
+      existing?.backgroundToolResult?.status === result.status &&
+      existing.backgroundToolResult.output === result.output &&
+      existing.backgroundToolResult.settledAt.getTime() === result.settledAt.getTime()
+    );
+  }
+
+  async function getAgentBackgroundToolResult(input: {
+    deliveryKey: string;
+    sourceId: string;
+  }): Promise<AgentBackgroundToolResultReceipt | null> {
+    if (
+      input.deliveryKey.length === 0 ||
+      input.deliveryKey.length > 256 ||
+      input.sourceId.length === 0 ||
+      input.sourceId.length > 256
+    ) {
+      throw new TypeError('Invalid background tool result receipt lookup');
+    }
+    const delivery = await Delivery()
+      .findOne({
+        deliveryKey: input.deliveryKey,
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+        'envelope.event.source.type': 'internal',
+        'envelope.event.source.id': input.sourceId,
+      })
+      .select('+backgroundToolResult')
+      .lean<Pick<IAgentTriggerDelivery, 'backgroundToolResult'>>();
+    return delivery?.backgroundToolResult ?? null;
+  }
+
+  async function getAgentBackgroundToolResultClaim(input: {
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    taskId: string;
+  }): Promise<AgentBackgroundToolResultReceipt['resultClaim'] | null> {
+    const delivery = await Delivery()
+      .findOne({
+        ...backgroundResultIdentity(input),
+        'envelope.event.payload.taskId': input.taskId,
+        'backgroundToolResult.resultClaim': { $exists: true },
+      })
+      .select('+backgroundToolResult')
+      .lean<Pick<IAgentTriggerDelivery, 'backgroundToolResult'>>();
+    return delivery?.backgroundToolResult?.resultClaim ?? null;
+  }
+
+  function backgroundResultIdentity(input: {
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    agentId?: string;
+  }) {
+    return {
+      user: input.userId,
+      requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+      'envelope.event.source.type': 'internal',
+      'envelope.event.source.id': input.sourceId,
+      'envelope.target.conversationId': input.conversationId,
+      'envelope.target.parentMessageId': input.parentMessageId,
+      ...(input.agentId == null ? {} : { 'envelope.target.agentId': input.agentId }),
+    };
+  }
+
+  function projectBackgroundResult(delivery: {
+    envelope?: unknown;
+    backgroundToolResult?: AgentBackgroundToolResultReceipt;
+  }) {
+    const envelope = delivery.envelope;
+    if (envelope == null || typeof envelope !== 'object' || Array.isArray(envelope)) {
+      return null;
+    }
+    const event = (envelope as { event?: unknown }).event;
+    if (event == null || typeof event !== 'object' || Array.isArray(event)) {
+      return null;
+    }
+    const payload = (event as { payload?: unknown }).payload;
+    if (payload == null || typeof payload !== 'object' || Array.isArray(payload)) {
+      return null;
+    }
+    const { taskId, toolCallId, toolName } = payload as Record<string, unknown>;
+    const receipt = delivery.backgroundToolResult;
+    if (
+      receipt == null ||
+      typeof taskId !== 'string' ||
+      typeof toolCallId !== 'string' ||
+      typeof toolName !== 'string'
+    ) {
+      return null;
+    }
+    return {
+      taskId,
+      toolCallId,
+      toolName,
+      status: receipt.status,
+      output: receipt.output,
+    };
+  }
+
+  /** Elects exactly one automatic continuation for an independently persisted
+   * result. A later stack layer may coalesce siblings after this ownership
+   * boundary, but the durable receipt itself is never dispatched unclaimed. */
+  async function claimAgentBackgroundToolResults(input: {
+    deliveryKey: string;
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    agentId?: string;
+    claimId: string;
+    limit?: number;
+  }): Promise<AgentBackgroundToolResultClaim> {
+    if (
+      input.deliveryKey.length === 0 ||
+      input.deliveryKey.length > 256 ||
+      input.sourceId.length === 0 ||
+      input.sourceId.length > 256 ||
+      input.userId.length === 0 ||
+      input.conversationId.length === 0 ||
+      input.conversationId.length > 256 ||
+      input.parentMessageId.length === 0 ||
+      input.parentMessageId.length > 256 ||
+      input.claimId.length === 0 ||
+      input.claimId.length > 128
+    ) {
+      throw new TypeError('Invalid background tool result receipt claim');
+    }
+    const scope = backgroundResultIdentity(input);
+    const projection = 'envelope +backgroundToolResult';
+    let requested = await Delivery()
+      .findOne({ ...scope, deliveryKey: input.deliveryKey })
+      .select(projection)
+      .lean<Pick<IAgentTriggerDelivery, 'envelope' | 'backgroundToolResult'>>();
+    if (requested?.backgroundToolResult == null) {
+      return { status: 'not_ready' };
+    }
+    const existingClaim = requested.backgroundToolResult.resultClaim;
+    if (existingClaim != null && existingClaim.claimId !== input.claimId) {
+      return { status: 'claimed', claimId: existingClaim.claimId };
+    }
+    if (existingClaim == null) {
+      const claimed = await Delivery().updateOne(
+        {
+          ...scope,
+          deliveryKey: input.deliveryKey,
+          backgroundToolResult: { $exists: true },
+          'backgroundToolResult.resultClaim': { $exists: false },
+        },
+        {
+          $set: {
+            'backgroundToolResult.resultClaim': {
+              kind: 'wakeup',
+              claimId: input.claimId,
+              claimedAt: new Date(),
+            },
+          },
+        },
+        { timestamps: false },
+      );
+      if (claimed.modifiedCount !== 1) {
+        requested = await Delivery()
+          .findOne({ ...scope, deliveryKey: input.deliveryKey })
+          .select(projection)
+          .lean<Pick<IAgentTriggerDelivery, 'envelope' | 'backgroundToolResult'>>();
+        const winner = requested?.backgroundToolResult?.resultClaim;
+        if (winner?.claimId !== input.claimId) {
+          return winner == null
+            ? { status: 'not_ready' }
+            : { status: 'claimed', claimId: winner.claimId };
+        }
+      }
+    }
+    const result = requested == null ? null : projectBackgroundResult(requested);
+    return result == null ? { status: 'not_ready' } : { status: 'acquired', results: [result] };
+  }
+
+  async function releaseAgentBackgroundToolResultClaims(input: {
+    sourceId: string;
+    userId: string;
+    conversationId: string;
+    parentMessageId: string;
+    claimId: string;
+  }): Promise<boolean> {
+    if (
+      input.sourceId.length === 0 ||
+      input.sourceId.length > 256 ||
+      input.userId.length === 0 ||
+      input.conversationId.length === 0 ||
+      input.conversationId.length > 256 ||
+      input.parentMessageId.length === 0 ||
+      input.parentMessageId.length > 256 ||
+      input.claimId.length === 0 ||
+      input.claimId.length > 128
+    ) {
+      throw new TypeError('Invalid background tool result receipt claim release');
+    }
+    const scope = backgroundResultIdentity(input);
+    await Delivery().updateMany(
+      { ...scope, 'backgroundToolResult.resultClaim.claimId': input.claimId },
+      { $unset: { 'backgroundToolResult.resultClaim': 1 } },
+      { timestamps: false },
+    );
+    return (
+      (await Delivery().exists({
+        ...scope,
+        'backgroundToolResult.resultClaim.claimId': input.claimId,
+      })) == null
+    );
+  }
+
   async function settleAgentTriggerHandlingOutcome(
     input: SettleAgentTriggerHandlingOutcomeInput,
   ): Promise<boolean> {
@@ -3076,10 +3407,26 @@ export function createAgentTriggerDeliveryMethods(
       error: AgentTriggerDeliveryFailure;
       availableAt: Date;
     },
+  ): Promise<boolean> {
+    return retryDelivery(input);
+  }
+
+  async function retryDelivery(
+    input: Parameters<AgentTriggerDeliveryMethods['retryAgentTriggerDelivery']>[0],
+    recoverReceipt = false,
   ): Promise<boolean> {
     const error = normalizeFailure(input.error);
+    const receiptFence = recoverReceipt
+      ? {
+          requiredWorkerCapability:
+            AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+          backgroundToolResult: { $exists: true },
+        }
+      : {};
+    const recoveredAttempt = recoverReceipt ? { attempts: 0 } : {};
     const retryUpdate = (status: 'pending' | 'capability_pending') => ({
       $set: {
+        ...recoveredAttempt,
         status,
         availableAt: input.availableAt,
         claimAvailableAt: input.availableAt,
@@ -3108,9 +3455,10 @@ export function createAgentTriggerDeliveryMethods(
       },
     });
     const shieldResult = await Delivery().updateOne(
-      { _id: input.id, ...shieldCapabilityFence(input) },
+      { _id: input.id, ...shieldCapabilityFence(input), ...receiptFence },
       {
         $set: {
+          ...recoveredAttempt,
           status: 'leased',
           availableAt: input.availableAt,
           capabilityStatus: 'pending',
@@ -3134,14 +3482,14 @@ export function createAgentTriggerDeliveryMethods(
       return true;
     }
     const capabilityResult = await Delivery().updateOne(
-      { _id: input.id, ...legacyCapabilityFence(input) },
+      { _id: input.id, ...legacyCapabilityFence(input), ...receiptFence },
       retryUpdate('capability_pending'),
     );
     if (capabilityResult.modifiedCount === 1) {
       return true;
     }
     const result = await Delivery().updateOne(
-      { _id: input.id, ...ordinaryFence(input) },
+      { _id: input.id, ...ordinaryFence(input), ...receiptFence },
       retryUpdate('pending'),
     );
     return result.modifiedCount === 1;
@@ -3152,9 +3500,23 @@ export function createAgentTriggerDeliveryMethods(
       attempt: number;
       error: AgentTriggerDeliveryFailure;
       settledAt: Date;
+      receiptRetryAt?: Date;
     },
   ): Promise<boolean> {
     const error = normalizeFailure(input.error);
+    if (
+      error.retryable &&
+      input.receiptRetryAt != null &&
+      (await retryDelivery({ ...input, availableAt: input.receiptRetryAt }, true))
+    ) {
+      return false;
+    }
+    /** Publication must contend with every retryable terminal transition,
+     * including a receipt committed between recovery and the dead-letter CAS. */
+    const receiptFence =
+      error.retryable || error.code === 'BACKGROUND_TOOL_PRODUCER_LOST'
+        ? { backgroundToolResult: { $exists: false } }
+        : {};
     const deadUpdate = (status: 'dead' | 'capability_dead') => ({
       $set: { status, settledAt: input.settledAt, lastError: error },
       $unset: { leaseBy: 1, leaseUntil: 1, claimToken: 1, expiresAt: 1 },
@@ -3174,7 +3536,7 @@ export function createAgentTriggerDeliveryMethods(
       },
     });
     const shieldDead = await Delivery().updateOne(
-      { _id: input.id, ...shieldCapabilityFence(input) },
+      { _id: input.id, ...shieldCapabilityFence(input), ...receiptFence },
       {
         $set: {
           // The pre-capability runtime already treats `capability_dead` as a
@@ -3201,16 +3563,20 @@ export function createAgentTriggerDeliveryMethods(
       return true;
     }
     const capabilityDead = await Delivery().updateOne(
-      { _id: input.id, ...legacyCapabilityFence(input) },
+      { _id: input.id, ...legacyCapabilityFence(input), ...receiptFence },
       deadUpdate('capability_dead'),
     );
     if (capabilityDead.modifiedCount === 1) {
       return true;
     }
     const dead = await Delivery()
-      .findOneAndUpdate({ _id: input.id, ...ordinaryFence(input) }, deadUpdate('dead'), {
-        new: true,
-      })
+      .findOneAndUpdate(
+        { _id: input.id, ...ordinaryFence(input), ...receiptFence },
+        deadUpdate('dead'),
+        {
+          new: true,
+        },
+      )
       .select('_id orderingKey batchMemberIds batchMembersSettledAt requeueCount')
       .lean<
         Pick<
@@ -3512,6 +3878,31 @@ export function createAgentTriggerDeliveryMethods(
     if (!Number.isSafeInteger(limit) || limit <= 0) {
       throw new TypeError('Agent trigger purge recovery limit must be a positive integer');
     }
+    const pending = await Delivery()
+      .find({
+        backgroundToolResultDeletionPendingAt: { $exists: true },
+      })
+      .select('user envelope')
+      .sort({ backgroundToolResultDeletionPendingAt: 1, _id: 1 })
+      .limit(Math.min(limit, MAX_PURGE_RECOVERY_LIMIT))
+      .lean<IAgentTriggerDelivery[]>();
+    for (const row of pending) {
+      const conversationId = (row.envelope as { target?: { conversationId?: string } }).target
+        ?.conversationId;
+      if (conversationId == null) {
+        continue;
+      }
+      const exists = await mongoose.models.Conversation.exists({ user: row.user, conversationId });
+      if (exists == null) {
+        await eraseAgentTriggerDeliveryConversationResults(row.user, [conversationId]);
+      } else {
+        await Delivery().updateOne(
+          { _id: row._id, backgroundToolResultDeletionPendingAt: { $exists: true } },
+          { $currentDate: { backgroundToolResultDeletionPendingAt: true } },
+          { timestamps: false },
+        );
+      }
+    }
     const markers = await UserPurge()
       .find({})
       .sort({ updatedAt: 1, _id: 1 })
@@ -3565,6 +3956,44 @@ export function createAgentTriggerDeliveryMethods(
     await UserPurge().deleteOne({ _id: user });
   }
 
+  async function eraseAgentTriggerDeliveryConversationResults(
+    user: string | Types.ObjectId,
+    conversationIds: string[],
+  ): Promise<void> {
+    if (conversationIds.length === 0 || !mongoose.isObjectIdOrHexString(user)) {
+      return;
+    }
+    const erasedAt = new Date();
+    await Delivery().updateMany(
+      {
+        user,
+        'envelope.target.conversationId': { $in: conversationIds },
+      },
+      {
+        $set: { backgroundToolResultErasedAt: erasedAt },
+        $unset: { backgroundToolResult: 1, backgroundToolResultDeletionPendingAt: 1 },
+      },
+      { timestamps: false },
+    );
+  }
+
+  async function prepareAgentTriggerConversationResultErasure(
+    user: string | Types.ObjectId,
+    conversationIds: string[],
+  ): Promise<void> {
+    if (conversationIds.length === 0 || !mongoose.isObjectIdOrHexString(user)) return;
+    await Delivery().updateMany(
+      {
+        user,
+        requiredWorkerCapability: AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2,
+        'envelope.target.conversationId': { $in: conversationIds },
+        backgroundToolResultErasedAt: { $exists: false },
+      },
+      { $set: { backgroundToolResultDeletionPendingAt: new Date() } },
+      { timestamps: false },
+    );
+  }
+
   return {
     ensureAgentTriggerDeliveryIndexes,
     enqueueAgentTriggerDelivery,
@@ -3578,6 +4007,11 @@ export function createAgentTriggerDeliveryMethods(
     retireAgentTriggerDelivery,
     renewAgentTriggerDeliveryProducerLease,
     getAgentTriggerDeliveryProducerLease,
+    persistAgentBackgroundToolResult,
+    getAgentBackgroundToolResult,
+    getAgentBackgroundToolResultClaim,
+    claimAgentBackgroundToolResults,
+    releaseAgentBackgroundToolResultClaims,
     settleAgentTriggerHandlingOutcome,
     admitAgentEventActorAction,
     releaseAgentEventActorAction,
@@ -3606,5 +4040,7 @@ export function createAgentTriggerDeliveryMethods(
     cancelAgentTriggerUserPurge,
     recoverAgentTriggerUserPurges,
     deleteAgentTriggerDeliveriesByUser,
+    eraseAgentTriggerDeliveryConversationResults,
+    prepareAgentTriggerConversationResultErasure,
   };
 }
diff --git a/packages/data-schemas/src/methods/userGroup.spec.ts b/packages/data-schemas/src/methods/userGroup.spec.ts
index 46ba4cdc7dc..7a33ac633c8 100644
--- a/packages/data-schemas/src/methods/userGroup.spec.ts
+++ b/packages/data-schemas/src/methods/userGroup.spec.ts
@@ -484,11 +484,14 @@ describe('userGroup methods', () => {
   });
 
   describe('getUserPrincipals caching', () => {
-    function createFakeCache() {
+    function createFakeCache({ onRead }: { onRead?: () => Promise<void> } = {}) {
       const store = new Map<string, unknown>();
       return {
         store,
-        get: jest.fn(async (key: string) => store.get(key)),
+        get: jest.fn(async (key: string) => {
+          await onRead?.();
+          return store.get(key);
+        }),
         set: jest.fn(async (key: string, value: unknown) => {
           store.set(key, value);
         }),
@@ -497,6 +500,29 @@ describe('userGroup methods', () => {
       };
     }
 
+    /**
+     * Holds each cache read until `callers` of them are inside the miss window together, so a
+     * test about deduplicating concurrent builds actually gets concurrent builds. Delaying
+     * every read by a fixed few milliseconds instead leaves the overlap up to the scheduler:
+     * under load the first build can finish before a later caller reads, and that caller then
+     * takes the miss path on its own, which is correct behaviour but not what such a test is
+     * asserting. Reads after the barrier opens pass straight through, so a caller that reads
+     * again mid-build (after taking the lock, say) cannot deadlock.
+     */
+    function arrivalBarrier(callers: number) {
+      let arrived = 0;
+      let open!: () => void;
+      const allArrived = new Promise<void>((resolve) => {
+        open = resolve;
+      });
+      return async () => {
+        if (++arrived >= callers) {
+          open();
+        }
+        await allArrived;
+      };
+    }
+
     function createCachedMethods(cache: ReturnType<typeof createFakeCache>) {
       return createUserGroupMethods(mongoose, { getCache: jest.fn(() => cache) });
     }
@@ -758,14 +784,8 @@ describe('userGroup methods', () => {
 
     it('deduplicates concurrent cache builds for the same member key', async () => {
       const user = await createTestUser({ idOnTheSource: 'dedup-ext-1' });
-      const cache = {
-        get: jest.fn(async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          return undefined;
-        }),
-        set: jest.fn(async () => undefined),
-      };
-      const cachedMethods = createUserGroupMethods(mongoose, { getCache: jest.fn(() => cache) });
+      const cache = createFakeCache({ onRead: arrivalBarrier(3) });
+      const cachedMethods = createCachedMethods(cache);
       const params = {
         userId: user._id.toString(),
         role: SystemRoles.USER,
@@ -787,11 +807,7 @@ describe('userGroup methods', () => {
     it('shares one lock and DB build across concurrent same-process callers', async () => {
       const user = await createTestUser({ idOnTheSource: 'lock-ext-1' });
       const cache = {
-        get: jest.fn(async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          return undefined;
-        }),
-        set: jest.fn(async () => undefined),
+        ...createFakeCache({ onRead: arrivalBarrier(3) }),
         acquireLock: jest.fn(async () => 'lock-token'),
         releaseLock: jest.fn(async () => undefined),
         lockWaitMs: 5000,
diff --git a/packages/data-schemas/src/schema/triggerDelivery.ts b/packages/data-schemas/src/schema/triggerDelivery.ts
index 34cb661587e..1de097809d1 100644
--- a/packages/data-schemas/src/schema/triggerDelivery.ts
+++ b/packages/data-schemas/src/schema/triggerDelivery.ts
@@ -1,5 +1,6 @@
 import { Schema } from 'mongoose';
 import type { IAgentTriggerDeliveryDocument } from '~/types/triggerDelivery';
+import { AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS } from '~/types/triggerDelivery';
 
 const failureSchema = new Schema(
   {
@@ -147,6 +148,38 @@ const triggerDeliverySchema: Schema<IAgentTriggerDeliveryDocument> = new Schema(
     capabilityClaimToken: { type: String },
     /** Private process-owner heartbeat; never projected to legacy consumers. */
     producerLeaseUntil: { type: Date, select: false },
+    backgroundToolResult: {
+      type: new Schema(
+        {
+          status: {
+            type: String,
+            enum: ['completed', 'error', 'cancelled'],
+            required: true,
+          },
+          output: {
+            type: String,
+            required: true,
+            maxlength: AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS,
+          },
+          settledAt: { type: Date, required: true },
+          resultClaim: {
+            type: new Schema(
+              {
+                kind: { type: String, enum: ['wakeup'], required: true },
+                claimId: { type: String, required: true, maxlength: 128 },
+                claimedAt: { type: Date, required: true },
+              },
+              { _id: false },
+            ),
+            required: false,
+          },
+        },
+        { _id: false },
+      ),
+      select: false,
+    },
+    backgroundToolResultErasedAt: { type: Date, select: false },
+    backgroundToolResultDeletionPendingAt: { type: Date, select: false },
     attempts: { type: Number, required: true, default: 0, min: 0 },
     availableAt: { type: Date, required: true },
     envelopeBytes: { type: Number, min: 0 },
@@ -224,6 +257,7 @@ triggerDeliverySchema.index({ 'actorReceipt.resolution': 1 }, { sparse: true });
 triggerDeliverySchema.index({ user: 1, actorActionAdmittedAt: 1 }, { sparse: true });
 triggerDeliverySchema.index({ stagingRecoveryAt: 1 }, { sparse: true });
 triggerDeliverySchema.index({ laneCleanupPendingAt: 1 }, { sparse: true });
+triggerDeliverySchema.index({ backgroundToolResultDeletionPendingAt: 1 }, { sparse: true });
 // Only successful rows receive expiresAt. Dead letters remain available until
 // an operator explicitly requeues or removes them.
 triggerDeliverySchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
diff --git a/packages/data-schemas/src/types/triggerDelivery.ts b/packages/data-schemas/src/types/triggerDelivery.ts
index 7e91c341fc1..be019d65a22 100644
--- a/packages/data-schemas/src/types/triggerDelivery.ts
+++ b/packages/data-schemas/src/types/triggerDelivery.ts
@@ -15,7 +15,10 @@ export type AgentTriggerDeliveryStatus =
 export const AGENT_TRIGGER_WORKER_CAPABILITY_DETACHED_ACTION_V1 = 'event_actor_detached_action_v1';
 export const AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_V1 =
   'background_tool_completion_v1';
+export const AGENT_TRIGGER_WORKER_CAPABILITY_BACKGROUND_COMPLETION_RECEIPT_V2 =
+  'background_tool_completion_receipt_v2';
 export const AGENT_TRIGGER_WORKER_CAPABILITY_QUEUED_TURN_V1 = 'agent_queued_turn_v1';
+export const AGENT_BACKGROUND_TOOL_RESULT_STORAGE_MAX_CHARS: number = 64 * 1024;
 export type AgentTriggerDeliveryOutcome = 'succeeded' | 'retry' | 'dead';
 
 export interface AgentTriggerHandlingState {
@@ -77,6 +80,20 @@ export interface AgentTriggerDeliveryFailure {
   status?: number;
 }
 
+/** Private terminal result produced before a background-completion delivery is
+ * resolved. It is independent of the parent message projection because a fast
+ * task can settle before that response row exists. */
+export interface AgentBackgroundToolResultReceipt {
+  status: 'completed' | 'error' | 'cancelled';
+  output: string;
+  settledAt: Date;
+  resultClaim?: {
+    kind: 'wakeup';
+    claimId: string;
+    claimedAt: Date;
+  };
+}
+
 export interface AgentTriggerDeliveryHistoryEntry {
   attempt: number;
   outcome: AgentTriggerDeliveryOutcome;
@@ -108,6 +125,11 @@ export interface IAgentTriggerDelivery {
   capabilityClaimToken?: string;
   /** Durable liveness evidence for process-owned capability work. */
   producerLeaseUntil?: Date;
+  /** Durable source of truth for a background completion. */
+  backgroundToolResult?: AgentBackgroundToolResultReceipt;
+  /** Conversation-deletion fence preventing a late producer from restoring private output. */
+  backgroundToolResultErasedAt?: Date;
+  backgroundToolResultDeletionPendingAt?: Date;
   attempts: number;
   availableAt: Date;
   envelopeBytes?: number;