diff --git a/api/server/controllers/agents/__tests__/openai.spec.js b/api/server/controllers/agents/__tests__/openai.spec.js
index 097da840e30..25ae7ab6022 100644
--- a/api/server/controllers/agents/__tests__/openai.spec.js
+++ b/api/server/controllers/agents/__tests__/openai.spec.js
@@ -576,7 +576,7 @@ describe('OpenAIChatCompletionController', () => {
   );
 
   it.each([true, false])(
-    'publishes only the accepted client call after a model claim (stream=%s)',
+    'publishes accepted client calls after text and a model claim (stream=%s)',
     async (streaming) => {
       const api = require('@librechat/api');
       const actual = jest.requireActual('@librechat/api');
@@ -608,6 +608,9 @@ describe('OpenAIChatCompletionController', () => {
           agentId: 'agent-123',
           messageId: 'claimed-message',
         });
+        await handlers.on_message_delta.handle('on_message_delta', {
+          delta: { content: [{ type: 'text', text: 'Checking the weather.' }] },
+        });
         await handlers.on_model_response.handle('on_model_response', {
           type: 'model_response',
           id: 'accepted-client',
@@ -627,6 +630,9 @@ describe('OpenAIChatCompletionController', () => {
             .map(([frame]) => frame)
             .filter((frame) => frame !== 'data: [DONE]\n\n')
             .map((frame) => JSON.parse(frame.slice(6)));
+          expect(
+            frames.some((frame) => frame.choices[0].delta.content === 'Checking the weather.'),
+          ).toBe(true);
           const calls = frames.flatMap((frame) => frame.choices[0].delta.tool_calls ?? []);
           expect(calls).toEqual([
             { index: 0, id: 'a', type: 'function', function: { name: 'get_time', arguments: '' } },
@@ -642,6 +648,7 @@ describe('OpenAIChatCompletionController', () => {
           expect(frames.at(-1).choices[0].finish_reason).toBe('tool_calls');
         } else {
           const choice = res.json.mock.calls[0][0].choices[0];
+          expect(choice.message.content).toBe('Checking the weather.');
           expect(choice.message.tool_calls).toEqual([
             {
               id: 'a',
@@ -909,6 +916,7 @@ describe('OpenAIChatCompletionController', () => {
       expect.anything(),
       expect.anything(),
       mockCompletionUsage,
+      true,
     );
   });
 
@@ -920,7 +928,12 @@ describe('OpenAIChatCompletionController', () => {
 
     await OpenAIChatCompletionController(req, res);
 
-    expect(sendFinalChunk).toHaveBeenCalledWith(expect.anything(), 'stop', mockCompletionUsage);
+    expect(sendFinalChunk).toHaveBeenCalledWith(
+      expect.anything(),
+      'stop',
+      mockCompletionUsage,
+      true,
+    );
   });
 
   describe('content filtering', () => {
diff --git a/api/server/controllers/agents/openai.js b/api/server/controllers/agents/openai.js
index 1910cab8ef4..6cb1e800531 100644
--- a/api/server/controllers/agents/openai.js
+++ b/api/server/controllers/agents/openai.js
@@ -1180,7 +1180,7 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {
       // Finalize response
       const duration = Date.now() - requestStartTime;
       if (isStreaming) {
-        sendFinalChunk(handlerConfig, 'stop', usage);
+        sendFinalChunk(handlerConfig, 'stop', usage, true);
         res.end();
         logger.debug(`[OpenAI API] Response ${responseId} completed in ${duration}ms (streaming)`);
 
@@ -1216,6 +1216,7 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {
           aggregator.getReasoning(),
           aggregator.toolCalls,
           usage,
+          true,
         );
         res.json(response);
         logger.debug(
diff --git a/api/server/services/Config/app.js b/api/server/services/Config/app.js
index ce157640fc5..d67c0f03641 100644
--- a/api/server/services/Config/app.js
+++ b/api/server/services/Config/app.js
@@ -33,9 +33,9 @@ async function invalidateCodeEnvironmentConfigCache(tenantId) {
   await getCodeEnvironmentRegistry().invalidateAccessibleConfigurations(tenantId);
 }
 
-const loadBaseConfig = async () => {
+const loadBaseConfig = async (mode) => {
   /** @type {TCustomConfig} */
-  const config = (await loadCustomConfig()) ?? {};
+  const config = (await loadCustomConfig(true, { mode })) ?? {};
   /** @type {Record<string, FunctionTool>} */
   const systemTools = loadAndFormatTools({
     adminFilter: config.filteredTools,
diff --git a/api/server/services/Config/loadCustomConfig.js b/api/server/services/Config/loadCustomConfig.js
index 45cec141607..c253c4f14b3 100644
--- a/api/server/services/Config/loadCustomConfig.js
+++ b/api/server/services/Config/loadCustomConfig.js
@@ -1,237 +1,11 @@
 const path = require('path');
-const axios = require('axios');
-const yaml = require('js-yaml');
-const keyBy = require('lodash/keyBy');
-const { loadYaml, redactConfigSecretMaps } = require('@librechat/api');
-const { Providers } = require('@librechat/agents');
-const { logger } = require('@librechat/data-schemas');
-const {
-  configSchema,
-  paramSettings,
-  EModelEndpoint,
-  EImageOutputType,
-  setMaxSubagents,
-  agentParamSettings,
-  validateSettingDefinitions,
-} = require('librechat-data-provider');
+const { loadYaml, redactConfigSecretMaps, createCustomConfigLoader } = require('@librechat/api');
 
 const projectRoot = path.resolve(__dirname, '..', '..', '..', '..');
 const defaultConfigPath = path.resolve(projectRoot, 'librechat.yaml');
 
-let i = 0;
-
-const OPENROUTER_PROMPT_CACHE_DEFAULT = {
-  key: 'promptCache',
-  default: true,
-};
-
-function includesOpenRouter(value) {
-  return typeof value === 'string' && value.toLowerCase().includes(Providers.OPENROUTER);
-}
-
-function isOpenRouterEndpoint(endpoint) {
-  return includesOpenRouter(endpoint.name) || includesOpenRouter(endpoint.baseURL);
-}
-
-function shouldPreserveCustomParams(customParams) {
-  const defaultEndpoint = customParams?.defaultParamsEndpoint;
-  return (
-    defaultEndpoint && defaultEndpoint !== 'custom' && defaultEndpoint !== Providers.OPENROUTER
-  );
-}
-
-function addOpenRouterDefaults(endpoint) {
-  if (!isOpenRouterEndpoint(endpoint)) {
-    return;
-  }
-
-  if (shouldPreserveCustomParams(endpoint.customParams)) {
-    return;
-  }
-
-  const customParams = endpoint.customParams ?? {};
-  const paramDefinitions = customParams.paramDefinitions ?? [];
-  const hasPromptCache = paramDefinitions.some((param) => param.key === 'promptCache');
-
-  endpoint.customParams = {
-    ...customParams,
-    defaultParamsEndpoint: Providers.OPENROUTER,
-    paramDefinitions: hasPromptCache
-      ? paramDefinitions
-      : [...paramDefinitions, OPENROUTER_PROMPT_CACHE_DEFAULT],
-  };
-}
-
-/**
- * Load custom configuration files and caches the object if the `cache` field at root is true.
- * Validation via parsing the config file with the config schema.
- * @function loadCustomConfig
- * @returns {Promise<TCustomConfig | null>} A promise that resolves to null or the custom config object.
- * */
-async function loadCustomConfig(printConfig = true) {
-  // Use CONFIG_PATH if set, otherwise fallback to defaultConfigPath
-  const configPath = process.env.CONFIG_PATH || defaultConfigPath;
-
-  let customConfig;
-
-  if (/^https?:\/\//.test(configPath)) {
-    try {
-      const response = await axios.get(configPath);
-      customConfig = response.data;
-    } catch (error) {
-      i === 0 && logger.error(`Failed to fetch the remote config file from ${configPath}`, error);
-      i === 0 && i++;
-      return null;
-    }
-  } else {
-    customConfig = loadYaml(configPath);
-    if (!customConfig) {
-      i === 0 &&
-        logger.info(
-          'Custom config file missing or YAML format invalid.\n\nCheck out the latest config file guide for configurable options and features.\nhttps://www.librechat.ai/docs/configuration/librechat_yaml\n\n',
-        );
-      i === 0 && i++;
-      return null;
-    }
-
-    if (customConfig.reason || customConfig.stack) {
-      i === 0 && logger.error('Config file YAML format is invalid:', customConfig);
-      i === 0 && i++;
-      return null;
-    }
-  }
-
-  if (typeof customConfig === 'string') {
-    try {
-      customConfig = yaml.load(customConfig);
-    } catch (parseError) {
-      i === 0 && logger.info(`Failed to parse the YAML config from ${configPath}`, parseError);
-      i === 0 && i++;
-      return null;
-    }
-  }
-
-  // Applied before parsing so specs validated in the same pass (whose subagent
-  // presets share the cap) check against the configured limit. Invalid values
-  // are ignored here and rejected by the schema parse below.
-  setMaxSubagents(customConfig?.endpoints?.[EModelEndpoint.agents]?.maxSubagents);
-
-  const result = configSchema.strict().safeParse(customConfig);
-  if (result?.error?.errors?.some((err) => err?.path && err.path?.includes('imageOutputType'))) {
-    throw new Error(
-      `
-Please specify a correct \`imageOutputType\` value (case-sensitive).
-
-      The available options are:
-      - ${EImageOutputType.JPEG}
-      - ${EImageOutputType.PNG}
-      - ${EImageOutputType.WEBP}
-      
-      Refer to the latest config file guide for more information:
-      https://www.librechat.ai/docs/configuration/librechat_yaml`,
-    );
-  }
-  if (!result.success) {
-    let errorMessage = `Invalid custom config file at ${configPath}:
-${JSON.stringify(result.error, null, 2)}`;
-
-    logger.error(errorMessage);
-    const speechError = result.error.errors.find(
-      (err) =>
-        err.code === 'unrecognized_keys' &&
-        (err.message?.includes('stt') || err.message?.includes('tts')),
-    );
-
-    if (speechError) {
-      logger.warn(`
-The Speech-to-text and Text-to-speech configuration format has recently changed.
-If you're getting this error, please refer to the latest documentation:
-
-https://www.librechat.ai/docs/configuration/stt_tts`);
-    }
-
-    if (process.env.CONFIG_BYPASS_VALIDATION === 'true') {
-      logger.warn(
-        'CONFIG_BYPASS_VALIDATION is enabled. Continuing with default configuration despite validation errors.',
-      );
-      return null;
-    }
-
-    logger.error(
-      'Exiting due to invalid configuration. Set CONFIG_BYPASS_VALIDATION=true to bypass this check.',
-    );
-    process.exit(1);
-  } else {
-    if (printConfig) {
-      // Masks map-valued secrets (e.g. `langfuse.headers`) so literal gateway
-      // credentials are not copied into application logs on every startup.
-      const loggableConfig = redactConfigSecretMaps(customConfig);
-      logger.info('Custom config file loaded:');
-      logger.info(JSON.stringify(loggableConfig, null, 2));
-      logger.debug('Custom config:', loggableConfig);
-    }
-  }
-
-  (customConfig.endpoints?.custom ?? []).forEach(addOpenRouterDefaults);
-
-  (customConfig.endpoints?.custom ?? [])
-    .filter((endpoint) => endpoint.customParams)
-    .forEach((endpoint) => parseCustomParams(endpoint.name, endpoint.customParams));
-
-  if (result.data.modelSpecs) {
-    customConfig.modelSpecs = result.data.modelSpecs;
-  }
-
-  return customConfig;
-}
-
-// Validate and fill out missing values for custom parameters
-function parseCustomParams(endpointName, customParams) {
-  const paramEndpoint = customParams.defaultParamsEndpoint ?? 'custom';
-  customParams.defaultParamsEndpoint = paramEndpoint;
-  customParams.paramDefinitions = customParams.paramDefinitions || [];
-
-  // Checks if `defaultParamsEndpoint` is a key in `paramSettings`.
-  const validEndpoints = new Set([
-    ...Object.keys(paramSettings),
-    ...Object.keys(agentParamSettings),
-  ]);
-  if (!validEndpoints.has(paramEndpoint)) {
-    throw new Error(
-      `defaultParamsEndpoint of "${endpointName}" endpoint is invalid. ` +
-        `Valid options are ${Array.from(validEndpoints).join(', ')}`,
-    );
-  }
-
-  // creates default param maps
-  const regularParams = paramSettings[paramEndpoint] ?? [];
-  const agentParams = agentParamSettings[paramEndpoint] ?? [];
-  const defaultParams = regularParams.concat(agentParams);
-  const defaultParamsMap = keyBy(defaultParams, 'key');
-
-  // TODO: Remove this check once we support new parameters not part of default parameters.
-  // Checks if every key in `paramDefinitions` is valid.
-  const validKeys = new Set(Object.keys(defaultParamsMap));
-  const paramKeys = customParams.paramDefinitions.map((param) => param.key);
-  if (paramKeys.some((key) => !validKeys.has(key))) {
-    throw new Error(
-      `paramDefinitions of "${endpointName}" endpoint contains invalid key(s). ` +
-        `Valid parameter keys are ${Array.from(validKeys).join(', ')}`,
-    );
-  }
-
-  // Fill out missing values for custom param definitions
-  customParams.paramDefinitions = customParams.paramDefinitions.map((param) => {
-    return { ...defaultParamsMap[param.key], ...param, optionType: 'custom' };
-  });
-
-  try {
-    validateSettingDefinitions(customParams.paramDefinitions);
-  } catch (e) {
-    throw new Error(
-      `Custom parameter definitions for "${endpointName}" endpoint is malformed: ${e.message}`,
-    );
-  }
-}
-
-module.exports = loadCustomConfig;
+module.exports = createCustomConfigLoader({
+  loadLocal: loadYaml,
+  defaultConfigPath,
+  redactConfig: redactConfigSecretMaps,
+});
diff --git a/api/server/services/Config/loadCustomConfig.spec.js b/api/server/services/Config/loadCustomConfig.spec.js
index ca767a56006..f4e827590fa 100644
--- a/api/server/services/Config/loadCustomConfig.spec.js
+++ b/api/server/services/Config/loadCustomConfig.spec.js
@@ -147,6 +147,57 @@ describe('loadCustomConfig', () => {
     );
   });
 
+  it('does not exit when config validation fails during reload', async () => {
+    process.env.CONFIG_PATH = 'invalidConfig.yaml';
+    loadYaml.mockReturnValueOnce({ invalidField: true });
+
+    await expect(loadCustomConfig(true, { mode: 'reload' })).rejects.toMatchObject({
+      name: 'ConfigReloadError',
+      validationErrors: expect.any(Array),
+    });
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it('rejects a reload when the local config file is missing', async () => {
+    process.env.CONFIG_PATH = 'missingConfig.yaml';
+    loadYaml.mockReturnValueOnce(null);
+
+    await expect(loadCustomConfig(true, { mode: 'reload' })).rejects.toMatchObject({
+      name: 'ConfigReloadError',
+    });
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it('rejects malformed local YAML during reload without exiting', async () => {
+    process.env.CONFIG_PATH = 'invalidConfig.yaml';
+    loadYaml.mockReturnValueOnce(new Error('Malformed YAML'));
+
+    await expect(loadCustomConfig(true, { mode: 'reload' })).rejects.toMatchObject({
+      name: 'ConfigReloadError',
+    });
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it('rejects malformed remote YAML during reload without exiting', async () => {
+    process.env.CONFIG_PATH = 'https://example.com/config.yaml';
+    axios.get.mockResolvedValueOnce({ data: 'version: [unterminated' });
+
+    await expect(loadCustomConfig(true, { mode: 'reload' })).rejects.toMatchObject({
+      name: 'ConfigReloadError',
+    });
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it('rejects a reload when the remote config fetch fails', async () => {
+    process.env.CONFIG_PATH = 'https://example.com/config.yaml';
+    axios.get.mockRejectedValueOnce(new Error('Network error'));
+
+    await expect(loadCustomConfig(true, { mode: 'reload' })).rejects.toMatchObject({
+      name: 'ConfigReloadError',
+    });
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
   it('should handle and return null on YAML parse error for a string response from remote', async () => {
     process.env.CONFIG_PATH = 'http://example.com/config.yaml';
     process.env.CONFIG_BYPASS_VALIDATION = 'true';
@@ -466,6 +517,27 @@ describe('loadCustomConfig', () => {
       });
     });
 
+    it('treats an empty defaultParamsEndpoint as absent for OpenRouter', async () => {
+      const config = {
+        version: '1.0',
+        endpoints: {
+          custom: [
+            {
+              name: 'OpenRouter',
+              apiKey: 'user_provided',
+              baseURL: 'https://openrouter.ai/api/v1',
+              models: { default: ['test-model'] },
+              customParams: { defaultParamsEndpoint: '' },
+            },
+          ],
+        },
+      };
+      loadYaml.mockReturnValueOnce(config);
+
+      const loaded = await loadCustomConfig();
+      expect(loaded.endpoints.custom[0].customParams.defaultParamsEndpoint).toBe('openrouter');
+    });
+
     it('preserves explicit OpenRouter promptCache defaults', async () => {
       const openRouterConfig = {
         version: '1.0',
diff --git a/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx b/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx
index f86047be909..aa67c094f5b 100644
--- a/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx
+++ b/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx
@@ -301,7 +301,10 @@ function LivePhaseHeader({
    *  and suppressed count together so neither can paint with the old value. */
   const comboCount = showSandboxStartup ? 1 : activity.comboCount;
   const { source } = activity;
-  const line = useMemo(() => ({ text, source, comboCount }), [text, source, comboCount]);
+  const line = useMemo(
+    () => ({ text, source, comboCount, isBackgroundTaskCheck: activity.isBackgroundTaskCheck }),
+    [text, source, comboCount, activity.isBackgroundTaskCheck],
+  );
   /** A thought's line is a finished sentence and holds for a beat; everything
    *  else repaints at the ordinary cadence. */
   const painted = useThrottledValue(
@@ -316,7 +319,12 @@ function LivePhaseHeader({
    *  fail while a later one runs, and the line alone would never say so. The
    *  hidden group header carries the same counts in the same words. */
   const { failed, cancelled } = activity.outcome;
-  const combo = painted.comboCount > 1 ? `×${painted.comboCount}` : '';
+  let combo = '';
+  if (painted.comboCount > 1) {
+    combo = painted.isBackgroundTaskCheck
+      ? `· ${localize('com_ui_background_tasks_n_checks', { 0: String(painted.comboCount) })}`
+      : `×${painted.comboCount}`;
+  }
   const failedNote =
     failed > 0
       ? localize(failed === 1 ? 'com_ui_one_action_failed' : 'com_ui_n_actions_failed', {
diff --git a/client/src/components/Chat/Messages/Content/BackgroundTaskCard.tsx b/client/src/components/Chat/Messages/Content/BackgroundTaskCard.tsx
new file mode 100644
index 00000000000..b46897aa917
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/BackgroundTaskCard.tsx
@@ -0,0 +1,158 @@
+import type { BackgroundTaskStatus, BackgroundTaskView } from './Parts/background';
+import type { TranslationKeys } from '~/hooks';
+import { backgroundTaskMessageKey, backgroundTaskNoteKey } from './Parts/guidance';
+import { ToolIcon, getToolIconType, OutputRenderer } from './ToolOutput';
+import { formatBackgroundCodeOutput } from './Parts/background';
+import { parseToolName } from '~/utils/toolLabels';
+import { getToolDisplayLabel, cn } from '~/utils';
+import { useLocalize } from '~/hooks';
+
+const STATUS: Record<BackgroundTaskStatus, { label: TranslationKeys; dot: string }> = {
+  dispatched: { label: 'com_ui_subagent_thread_status_dispatched', dot: 'bg-text-tertiary' },
+  running: { label: 'com_ui_background_tasks_running', dot: 'bg-status-info' },
+  stopping: { label: 'com_ui_background_tasks_stopping', dot: 'bg-status-warning' },
+  accepted: { label: 'com_ui_background_tasks_control_queued', dot: 'bg-status-info' },
+  claimed: { label: 'com_ui_background_tasks_result_claimed', dot: 'bg-text-tertiary' },
+  not_running: { label: 'com_ui_background_tasks_not_running', dot: 'bg-status-warning' },
+  control_not_found: {
+    label: 'com_ui_background_tasks_control_not_found',
+    dot: 'bg-status-warning',
+  },
+  completed: { label: 'com_ui_background_tasks_completed', dot: 'bg-status-success' },
+  error: { label: 'com_ui_failed', dot: 'bg-status-error' },
+  failed: { label: 'com_ui_failed', dot: 'bg-status-error' },
+  interrupted: { label: 'com_ui_subagent_thread_status_interrupted', dot: 'bg-status-error' },
+  cancelled: { label: 'com_ui_cancelled', dot: 'bg-status-warning' },
+};
+
+export default function BackgroundTaskCard({
+  task,
+  mcpIconMap,
+  mcpServerNames,
+}: {
+  task: BackgroundTaskView;
+  mcpIconMap?: Map<string, string>;
+  mcpServerNames?: readonly string[];
+}) {
+  const localize = useLocalize();
+  const isSubagent = task.toolName === 'subagent';
+  const parsedName = parseToolName(task.toolName, mcpServerNames);
+  const serverName = parsedName.mcpServer;
+  let title = getToolDisplayLabel(task.toolName, localize, mcpServerNames);
+  if (isSubagent) {
+    title = localize('com_ui_background_tasks_subagent');
+  } else if (serverName) {
+    title = parsedName.toolName;
+  }
+  const subtitle = task.subagentType || serverName;
+  const iconUrl = serverName ? mcpIconMap?.get(serverName) : undefined;
+  const iconType = getToolIconType(task.toolName);
+  const isCode = iconType === 'bash_tool' || iconType === 'execute_code';
+  const state = STATUS[task.status];
+  const failed =
+    task.status === 'error' || task.status === 'failed' || task.status === 'interrupted';
+  const result = task.result?.trim() ? task.result : undefined;
+  const error = task.error?.trim() && task.error !== result ? task.error : undefined;
+  const noteKey = task.note ? backgroundTaskNoteKey(task.note) : undefined;
+  const messageKey = task.message ? backgroundTaskMessageKey(task.message) : undefined;
+  let delivery: string | undefined;
+  if (task.delivery === 'pending') {
+    delivery = localize('com_ui_background_tasks_result_pending');
+  } else if (task.delivery === 'failed') {
+    delivery = localize('com_ui_background_tasks_result_undelivered');
+  }
+
+  return (
+    <div
+      className="min-w-0 rounded-lg border border-border-light bg-surface-secondary/50 p-3"
+      data-testid="background-task-card"
+    >
+      <div className="flex min-w-0 items-start gap-2.5">
+        <span className="flex size-8 shrink-0 items-center justify-center rounded-md bg-surface-tertiary">
+          <ToolIcon type={iconType} iconUrl={iconUrl} className="text-text-primary" />
+        </span>
+        <div className="min-w-0 flex-1 pt-0.5">
+          <div className="truncate text-sm font-semibold text-text-primary" title={title}>
+            {title}
+          </div>
+          {subtitle && <div className="truncate text-xs text-text-secondary">{subtitle}</div>}
+          {delivery && (
+            <div
+              className={cn(
+                'mt-0.5 text-xs',
+                task.delivery === 'failed' ? 'text-status-warning' : 'text-text-secondary',
+              )}
+            >
+              {delivery}
+            </div>
+          )}
+        </div>
+        <span
+          className={cn(
+            'inline-flex shrink-0 items-center gap-1.5 rounded-full bg-surface-tertiary px-2 py-1 text-xs text-text-secondary',
+            failed && 'text-status-error',
+          )}
+        >
+          <span className={cn('size-1.5 rounded-full', state.dot)} aria-hidden="true" />
+          {localize(state.label)}
+        </span>
+      </div>
+      {result && (
+        <div className="mt-3 border-t border-border-light pt-2.5">
+          <div
+            className={cn(
+              'mb-1.5 text-xs font-medium',
+              failed && !error ? 'text-status-error' : 'text-text-secondary',
+            )}
+          >
+            {localize(failed && !error ? 'com_ui_error' : 'com_ui_output')}
+          </div>
+          <div className="min-w-0 rounded-md bg-surface-primary p-2.5">
+            <OutputRenderer
+              text={isCode ? formatBackgroundCodeOutput(result) : result}
+              copyText={result}
+            />
+          </div>
+        </div>
+      )}
+      {error && (
+        <div className="mt-3 border-t border-border-light pt-2.5">
+          <div className="mb-1.5 text-xs font-medium text-status-error">
+            {localize('com_ui_error')}
+          </div>
+          <div className="min-w-0 rounded-md bg-surface-primary p-2.5">
+            <OutputRenderer
+              text={isCode ? formatBackgroundCodeOutput(error) : error}
+              copyText={error}
+            />
+          </div>
+        </div>
+      )}
+      {!result && !error && task.resultClaimed && task.status !== 'claimed' && (
+        <p className="mt-2 text-xs text-text-secondary">
+          {localize('com_ui_background_tasks_result_claimed')}
+        </p>
+      )}
+      {!result && !error && task.resultAvailable && !task.resultClaimed && (
+        <p className="mt-2 text-xs text-text-secondary">
+          {localize('com_ui_background_tasks_result_available')}
+        </p>
+      )}
+      {noteKey && <p className="mt-2 text-xs text-text-secondary">{localize(noteKey)}</p>}
+      {messageKey && messageKey !== noteKey && (
+        <p className="mt-2 text-xs text-text-secondary">{localize(messageKey)}</p>
+      )}
+      {!result &&
+        !error &&
+        !task.resultAvailable &&
+        !task.resultClaimed &&
+        task.result === '' &&
+        !task.note &&
+        !task.message && (
+          <p className="mt-2 text-xs text-text-secondary">
+            {localize('com_ui_background_tasks_no_output')}
+          </p>
+        )}
+    </div>
+  );
+}
diff --git a/client/src/components/Chat/Messages/Content/Part.tsx b/client/src/components/Chat/Messages/Content/Part.tsx
index 21500f0b5e1..480f81b3406 100644
--- a/client/src/components/Chat/Messages/Content/Part.tsx
+++ b/client/src/components/Chat/Messages/Content/Part.tsx
@@ -31,6 +31,7 @@ import {
   getActivityLabelText,
   getPartKeyIndex,
 } from '~/utils';
+import BackgroundTaskCall from './Parts/BackgroundTaskCall';
 import { getAskUserQuestionPart } from '~/utils/approval';
 import AskUserQuestionCall from './AskUserQuestionCall';
 import { isBashProgrammaticToolCall } from './routing';
@@ -302,6 +303,21 @@ const Part = memo(function Part({
               onExpand={onToolExpand}
             />
           );
+        } else if (toolCall.name === Constants.CHECK_BACKGROUND_TASK) {
+          return (
+            <BackgroundTaskCall
+              args={toolCall.args}
+              output={toolCall.output ?? ''}
+              initialProgress={toolCall.progress ?? 0.1}
+              isSubmitting={isSubmitting}
+              runStepStatus={toolCall.runStepStatus}
+              runStepDurationMs={toolCall.runStepDurationMs}
+              attachments={attachments}
+              hideAttachments={hideAttachments}
+              onExpand={onToolExpand}
+              toolCallId={toolCallId}
+            />
+          );
         } else if (toolCall.name === 'skill') {
           return (
             <SkillCall
diff --git a/client/src/components/Chat/Messages/Content/Parts/BackgroundTaskCall.tsx b/client/src/components/Chat/Messages/Content/Parts/BackgroundTaskCall.tsx
new file mode 100644
index 00000000000..8a4a95d63e0
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/BackgroundTaskCall.tsx
@@ -0,0 +1,234 @@
+import { useMemo, useState, useCallback } from 'react';
+import type { PartMetadata, TAttachment } from 'librechat-data-provider';
+import { backgroundListGuidanceKeys, backgroundTaskNoticeKey } from './guidance';
+import { backgroundTaskOutcome, parseBackgroundTaskOutput } from './background';
+import ProgressText from '~/components/Chat/Messages/Content/ProgressText';
+import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
+import { useLocalize, useLazyCollapseBody } from '~/hooks';
+import { toolPanelSpacingClassName } from '../disclosure';
+import { ToolIcon, OutputRenderer } from '../ToolOutput';
+import BackgroundTaskCard from '../BackgroundTaskCard';
+import useToolCallState from './useToolCallState';
+import { AttachmentGroup } from './Attachment';
+import { useToolCallIntent } from './intent';
+import ToolCallInfo from '../ToolCallInfo';
+import { TOOL_ROW_CLASSES } from '../rows';
+import { cn } from '~/utils';
+
+export default function BackgroundTaskCall({
+  args,
+  output = '',
+  initialProgress = 0.1,
+  isSubmitting,
+  runStepStatus,
+  runStepDurationMs,
+  attachments,
+  hideAttachments = false,
+  onExpand,
+  toolCallId,
+}: {
+  args?: string | Record<string, unknown>;
+  output?: string;
+  initialProgress?: number;
+  isSubmitting: boolean;
+  runStepStatus?: PartMetadata['runStepStatus'];
+  runStepDurationMs?: PartMetadata['runStepDurationMs'];
+  attachments?: TAttachment[];
+  hideAttachments?: boolean;
+  onExpand?: () => void;
+  toolCallId?: string;
+}) {
+  const localize = useLocalize();
+  const [showRaw, setShowRaw] = useState(false);
+  const mcpIconMap = useMCPIconMap();
+  const mcpServerNames = useMCPServerNames();
+  const intent = useToolCallIntent(args);
+  const display = useMemo(() => parseBackgroundTaskOutput(output), [output]);
+  const input = useMemo(() => {
+    if (typeof args === 'string') {
+      return args;
+    }
+    try {
+      return JSON.stringify(args ?? {}) ?? '';
+    } catch {
+      return '';
+    }
+  }, [args]);
+  const hasParams = input.trim() !== '' && input.trim() !== '{}';
+  const outcome = backgroundTaskOutcome(display);
+  const noticeText =
+    display?.kind === 'notice'
+      ? localize(backgroundTaskNoticeKey(display.status, display.message))
+      : undefined;
+  const listGuidance = useMemo(
+    () => (display?.kind === 'list' ? backgroundListGuidanceKeys(display) : []),
+    [display],
+  );
+  const { showCode, toggleCode, expandStyle, expandRef, phase, hasContent } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: hasParams || (attachments?.length ?? 0) > 0,
+    onExpand,
+    runStepStatus,
+    extraError: outcome === 'failed',
+    extraCancelled: outcome === 'cancelled',
+  });
+  const { shouldRenderBody, mountBody, handleTransitionEnd } = useLazyCollapseBody(showCode);
+  const handleToggle = useCallback(() => {
+    mountBody();
+    toggleCode();
+  }, [mountBody, toggleCode]);
+
+  let finishedText = intent ?? localize('com_ui_background_tasks_checked');
+  if (phase === 'cancelled') {
+    finishedText =
+      outcome === 'cancelled' && noticeText != null ? noticeText : localize('com_ui_cancelled');
+  } else if (phase === 'failed' && outcome !== 'failed') {
+    finishedText = intent ?? localize('com_ui_background_tasks_checked');
+  } else if (noticeText != null) {
+    finishedText = noticeText;
+  } else if (display?.kind === 'list' && outcome === 'failed') {
+    finishedText = localize('com_ui_background_tasks_incomplete');
+  }
+
+  let announcedText = finishedText;
+  if (phase === 'running') {
+    announcedText = localize('com_ui_background_tasks_checking');
+  } else if (phase === 'failed' && (noticeText == null || outcome !== 'failed')) {
+    announcedText =
+      display?.kind === 'list'
+        ? localize('com_ui_background_tasks_incomplete')
+        : localize('com_ui_failed_subject', { 0: localize('com_ui_background_tasks') });
+  }
+
+  return (
+    <>
+      <span className="sr-only" aria-live="polite" aria-atomic="true">
+        {announcedText}
+      </span>
+      <div
+        className={TOOL_ROW_CLASSES}
+        data-testid="background-task-call"
+        data-tool-call-id={toolCallId}
+      >
+        <ProgressText
+          phase={phase}
+          onClick={handleToggle}
+          inProgressText={intent ?? localize('com_ui_background_tasks_checking')}
+          finishedText={finishedText}
+          durationMs={runStepDurationMs}
+          icon={<ToolIcon type="background_tasks" isAnimating={phase === 'running'} />}
+          hasInput={hasContent}
+          isExpanded={showCode}
+        />
+      </div>
+      <div
+        style={expandStyle}
+        onTransitionEnd={handleTransitionEnd}
+        data-tool-call-output-id={toolCallId}
+      >
+        <div className="overflow-hidden" ref={expandRef}>
+          {hasContent && shouldRenderBody && (
+            <div
+              className={cn(
+                toolPanelSpacingClassName,
+                'overflow-hidden rounded-lg border border-border-light bg-surface-secondary',
+              )}
+            >
+              {display?.kind === 'task' && (
+                <div className="p-2.5">
+                  <BackgroundTaskCard
+                    task={display.task}
+                    mcpIconMap={mcpIconMap}
+                    mcpServerNames={mcpServerNames}
+                  />
+                </div>
+              )}
+              {display?.kind === 'list' && (
+                <div className="p-2.5">
+                  <div className="mb-2 flex items-center gap-2 text-xs font-medium text-text-secondary">
+                    {localize('com_ui_background_tasks')}
+                    <span className="rounded-full bg-surface-tertiary px-1.5 tabular-nums">
+                      {display.tasks.length}
+                    </span>
+                  </div>
+                  {display.tasks.length > 0 ? (
+                    <ul
+                      tabIndex={0}
+                      aria-label={localize('com_ui_background_tasks')}
+                      className="flex max-h-96 flex-col gap-2 overflow-y-auto pr-1 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-border-heavy"
+                    >
+                      {display.tasks.map((task) => (
+                        <li key={task.taskId}>
+                          <BackgroundTaskCard
+                            task={task}
+                            mcpIconMap={mcpIconMap}
+                            mcpServerNames={mcpServerNames}
+                          />
+                        </li>
+                      ))}
+                    </ul>
+                  ) : (
+                    <p className="text-sm text-text-secondary">
+                      {localize('com_ui_background_tasks_empty')}
+                    </p>
+                  )}
+                  {(display.partial || display.warning) && (
+                    <p role="alert" className="mt-2 text-xs text-status-warning">
+                      {localize('com_ui_background_tasks_incomplete')}
+                    </p>
+                  )}
+                  {listGuidance.map((key) => (
+                    <p key={key} className="mt-2 text-xs text-text-secondary">
+                      {localize(key)}
+                    </p>
+                  ))}
+                </div>
+              )}
+              {display?.kind === 'notice' && (
+                <p
+                  className={cn(
+                    'p-3 text-sm',
+                    outcome === 'failed' || display.status === 'result_persisting'
+                      ? 'text-status-warning'
+                      : 'text-text-secondary',
+                  )}
+                >
+                  {noticeText}
+                </p>
+              )}
+              {(display == null || hasParams) && (
+                <div className={cn(display != null && 'border-t border-border-light')}>
+                  <ToolCallInfo
+                    input={input}
+                    output={display == null ? output : undefined}
+                    attachments={attachments}
+                  />
+                </div>
+              )}
+              {display != null && (
+                <details
+                  className="border-t border-border-light px-3 py-2"
+                  onToggle={(event) => setShowRaw(event.currentTarget.open)}
+                >
+                  <summary className="cursor-pointer rounded text-xs text-text-secondary hover:text-text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-border-heavy">
+                    {localize('com_ui_background_tasks_raw_details')}
+                  </summary>
+                  {showRaw && (
+                    <div className="mt-2 rounded-md bg-surface-primary p-2.5">
+                      <OutputRenderer text={output} copyText={output} />
+                    </div>
+                  )}
+                </details>
+              )}
+            </div>
+          )}
+        </div>
+      </div>
+      {!hideAttachments && attachments && attachments.length > 0 && (
+        <AttachmentGroup attachments={attachments} />
+      )}
+    </>
+  );
+}
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/BackgroundTaskCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/BackgroundTaskCall.test.tsx
new file mode 100644
index 00000000000..45078e9cb4f
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/BackgroundTaskCall.test.tsx
@@ -0,0 +1,429 @@
+import React from 'react';
+import { RecoilRoot } from 'recoil';
+import { fireEvent, render, screen, within } from '@testing-library/react';
+import BackgroundTaskCall from '../BackgroundTaskCall';
+
+jest.mock('~/hooks', () => ({
+  useLocalize: () => (key: string) => key,
+  useProgress: (progress: number) => progress,
+  useExpandCollapse: jest.requireActual('~/hooks/Messages/useExpandCollapse').default,
+  useLazyCollapseBody: jest.requireActual('~/hooks/Messages/useLazyCollapseBody').default,
+}));
+
+jest.mock('~/hooks/MCP', () => ({
+  useMCPIconMap: () => new Map(),
+  useMCPServerNames: () => [],
+}));
+
+jest.mock('~/utils', () => ({
+  cn: (...classes: Array<string | false | null | undefined>) => classes.filter(Boolean).join(' '),
+  getToolDisplayLabel: (name: string) =>
+    (({ bash_tool: 'Code', web_search: 'Web Search' }) as Record<string, string>)[name] ?? name,
+}));
+
+jest.mock('../../ProgressText', () => ({
+  __esModule: true,
+  default: ({
+    phase,
+    inProgressText,
+    finishedText,
+    onClick,
+    hasInput,
+    isExpanded,
+  }: {
+    phase: string;
+    inProgressText: string;
+    finishedText: string;
+    onClick: () => void;
+    hasInput: boolean;
+    isExpanded: boolean;
+  }) => (
+    <button
+      type="button"
+      data-testid="task-header"
+      data-phase={phase}
+      aria-expanded={isExpanded}
+      disabled={!hasInput}
+      onClick={onClick}
+    >
+      {phase === 'running' ? inProgressText : finishedText}
+    </button>
+  ),
+}));
+
+jest.mock('../../ToolOutput', () => ({
+  ToolIcon: ({ type }: { type: string }) => <span data-testid="tool-icon">{type}</span>,
+  getToolIconType: (name: string) => name,
+  getMCPServerName: () => '',
+  OutputRenderer: ({ text, copyText }: { text: string; copyText?: string }) => (
+    <pre data-testid="task-output" data-copy-text={copyText}>
+      {text}
+    </pre>
+  ),
+  isError: () => false,
+}));
+
+jest.mock('../../ToolCallInfo', () => ({
+  __esModule: true,
+  default: ({ input, output }: { input: string; output?: string }) => (
+    <div data-testid="tool-call-info" data-input={input} data-output={output} />
+  ),
+}));
+
+jest.mock('../Attachment', () => ({
+  AttachmentGroup: () => <div data-testid="task-attachments" />,
+}));
+
+const completed = {
+  background_task_id: 'bg-1',
+  tool: 'bash_tool',
+  status: 'completed',
+  result: 'stdout:\nchecked at=2026-09-27T00:11:09Z\n{"checks":[]}\n[exit code: 0]',
+};
+
+function renderCall(
+  output: string,
+  props: Partial<React.ComponentProps<typeof BackgroundTaskCall>> = {},
+) {
+  return render(
+    <RecoilRoot>
+      <BackgroundTaskCall
+        args={'{"background_task_id":"bg-1"}'}
+        output={output}
+        isSubmitting={false}
+        initialProgress={1}
+        {...props}
+      />
+    </RecoilRoot>,
+  );
+}
+
+describe('BackgroundTaskCall', () => {
+  it('presents a completed code task as a native result without leaking its JSON envelope', () => {
+    renderCall(JSON.stringify(completed));
+    const header = screen.getByTestId('task-header');
+    expect(header).toHaveTextContent('com_ui_background_tasks_checked');
+    expect(header).toHaveAttribute('aria-expanded', 'false');
+    expect(screen.queryByTestId('task-output')).not.toBeInTheDocument();
+
+    fireEvent.click(header);
+    const card = screen.getByTestId('background-task-card');
+    expect(within(card).getByText('Code')).toBeInTheDocument();
+    expect(within(card).getByText('com_ui_background_tasks_completed')).toBeInTheDocument();
+    expect(within(card).getByTestId('tool-icon')).toHaveTextContent('bash_tool');
+    expect(within(card).getByTestId('task-output')).toHaveTextContent('checked at=2026-09-27');
+    expect(within(card).getByTestId('task-output').textContent).toContain('{\n  "checks": []\n}');
+    expect(within(card).getByTestId('task-output')).toHaveAttribute(
+      'data-copy-text',
+      completed.result,
+    );
+    expect(screen.getByTestId('tool-call-info')).not.toHaveAttribute('data-output');
+    expect(screen.queryByText(/"background_task_id"/)).not.toBeInTheDocument();
+  });
+
+  it('renders an empty list as an empty state and warns when discovery is incomplete', () => {
+    renderCall(JSON.stringify({ tasks: [], outstanding: 0, partial: true, warning: 'Try again.' }));
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'failed');
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.getByText('com_ui_background_tasks_empty')).toBeInTheDocument();
+    expect(screen.getByRole('alert')).toHaveTextContent('com_ui_background_tasks_incomplete');
+    expect(screen.queryByText('Try again.')).not.toBeInTheDocument();
+  });
+
+  it('distinguishes a running task from a finished result pending automatic delivery', () => {
+    renderCall(
+      JSON.stringify({
+        tasks: [
+          { background_task_id: 'bg-1', tool: 'web_search', status: 'running' },
+          {
+            background_task_id: 'bg-2',
+            tool: 'bash_tool',
+            status: 'completed',
+            delivery: 'pending',
+            result_available: true,
+          },
+        ],
+        outstanding: 2,
+      }),
+      { args: '{}' },
+    );
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.getByRole('list', { name: 'com_ui_background_tasks' })).toHaveAttribute(
+      'tabindex',
+      '0',
+    );
+    const [running, pending] = screen.getAllByTestId('background-task-card');
+    expect(within(running).getByText('Web Search')).toBeInTheDocument();
+    expect(within(running).getByText('com_ui_background_tasks_running')).toBeInTheDocument();
+    expect(within(pending).getByText('com_ui_background_tasks_result_pending')).toBeInTheDocument();
+    expect(
+      within(pending).getByText('com_ui_background_tasks_result_available'),
+    ).toBeInTheDocument();
+    expect(within(pending).queryByText('com_ui_background_tasks_no_output')).toBeNull();
+  });
+
+  it('shows an error with a failed task outcome and its actual error text', () => {
+    renderCall(
+      JSON.stringify({ ...completed, status: 'error', result: undefined, error: 'Disk full' }),
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'failed');
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.getByText('com_ui_failed')).toBeInTheDocument();
+    expect(screen.getByText('Disk full')).toBeInTheDocument();
+  });
+
+  it('shows accepted subagent controls as queued while preserving the control id in raw details', () => {
+    renderCall(
+      JSON.stringify({
+        background_task_id: 'bg-1',
+        tool: 'subagent',
+        subagent_type: 'researcher',
+        status: 'accepted',
+        control_id: 'control-42',
+      }),
+    );
+    fireEvent.click(screen.getByTestId('task-header'));
+    const card = screen.getByTestId('background-task-card');
+    expect(within(card).getByText('com_ui_background_tasks_control_queued')).toBeInTheDocument();
+    expect(within(card).getByText('researcher')).toBeInTheDocument();
+    expect(within(card).queryByText('com_ui_background_tasks_completed')).toBeNull();
+    expect(screen.queryByText(/control-42/)).not.toBeInTheDocument();
+  });
+
+  it('keeps an already-claimed subagent result out of the available-on-request state', () => {
+    renderCall(
+      JSON.stringify({
+        background_task_id: 'bg-1',
+        tool: 'subagent',
+        subagent_type: 'researcher',
+        status: 'claimed',
+        result_available: true,
+        result_claimed: true,
+      }),
+    );
+    fireEvent.click(screen.getByTestId('task-header'));
+    const card = screen.getByTestId('background-task-card');
+    expect(within(card).getByText('com_ui_background_tasks_result_claimed')).toBeInTheDocument();
+    expect(within(card).queryByText('com_ui_background_tasks_result_available')).toBeNull();
+  });
+
+  it('marks an interrupted subagent poll as failed even when the poll run step succeeded', () => {
+    renderCall(
+      JSON.stringify({
+        background_task_id: 'bg-1',
+        tool: 'subagent',
+        status: 'interrupted',
+        error: 'Server restarted before completion.',
+      }),
+      { runStepStatus: 'completed' },
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'failed');
+    fireEvent.click(screen.getByTestId('task-header'));
+    const card = screen.getByTestId('background-task-card');
+    expect(within(card).getByText('com_ui_subagent_thread_status_interrupted')).toBeInTheDocument();
+    expect(within(card).getByText('Server restarted before completion.')).toBeInTheDocument();
+  });
+
+  it.each([
+    ['invalid', 'com_ui_background_tasks_notice_invalid'],
+    ['rejected', 'com_ui_background_tasks_notice_rejected'],
+    ['unavailable', 'com_ui_background_tasks_notice_unavailable'],
+    ['not_found', 'com_ui_background_tasks_notice_not_found'],
+    ['outcome_unknown', 'com_ui_background_tasks_notice_outcome_unknown'],
+    ['result_unavailable', 'com_ui_background_tasks_notice_result_unavailable'],
+  ])(
+    'announces a %s warning notice as a failed check even if the tool step succeeded',
+    (status, label) => {
+      const hostMessage = 'Host advice in English, for the agent only.';
+      const { container } = renderCall(JSON.stringify({ status, message: hostMessage }), {
+        runStepStatus: 'completed',
+      });
+      expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'failed');
+      expect(container.querySelector('[aria-live="polite"]')).toHaveTextContent(label);
+      fireEvent.click(screen.getByTestId('task-header'));
+      expect(screen.getAllByText(label).length).toBeGreaterThan(1);
+      expect(screen.queryByText(hostMessage)).not.toBeInTheDocument();
+    },
+  );
+
+  it('localizes guidance without promising that a running task or pending result has finished', () => {
+    const note =
+      'Still running outside this turn; its result will arrive as a new turn when it finishes.';
+    const message =
+      'Automatic completion delivery is enabled for this subagent task. Continue independent work if available; otherwise end this turn and the host will resume you when the task finishes. Do not repeatedly poll an unchanged running task. Use check_background_task only for explicit status or control, or as a fallback if automatic delivery is unavailable.';
+    renderCall(
+      JSON.stringify({
+        tasks: [{ background_task_id: 'bg-1', tool: 'subagent', status: 'running', note, message }],
+        message,
+      }),
+    );
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.getByText('com_ui_background_tasks_running_elsewhere')).toBeInTheDocument();
+    expect(screen.getAllByText('com_ui_background_tasks_subagent_wakeup_guidance')).toHaveLength(2);
+    expect(screen.queryByText(note)).not.toBeInTheDocument();
+    expect(screen.queryByText(message)).not.toBeInTheDocument();
+  });
+
+  it('shows unknown host prose only inside raw task details, while preserving tool result text', () => {
+    const note = 'Advice from a later server version.';
+    const raw = JSON.stringify({
+      background_task_id: 'bg-1',
+      tool: 'bash_tool',
+      status: 'completed',
+      result: 'Tool-created output remains visible in its own language.',
+      note,
+    });
+    renderCall(raw);
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.getByText('com_ui_background_tasks_more_in_raw_details')).toBeInTheDocument();
+    expect(
+      screen.getByText('Tool-created output remains visible in its own language.'),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(note)).not.toBeInTheDocument();
+    const details = screen.getByText('com_ui_background_tasks_raw_details').closest('details');
+    if (details == null) {
+      throw new Error('Task details disclosure is missing');
+    }
+    details.open = true;
+    fireEvent(details, new Event('toggle', { bubbles: true }));
+    expect(screen.getAllByTestId('task-output')).toHaveLength(2);
+    expect(screen.getAllByTestId('task-output')[1]).toHaveTextContent(note);
+  });
+
+  it('shows control notices as localized text and preserves unfamiliar responses as raw output', () => {
+    const { rerender } = renderCall(
+      JSON.stringify({
+        status: 'delivery_scheduled',
+        background_task_id: 'bg-1',
+        message: 'This result will arrive in a new turn.',
+      }),
+    );
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(
+      screen.getAllByText('com_ui_background_tasks_notice_delivery_scheduled').length,
+    ).toBeGreaterThan(1);
+    expect(screen.queryByText('This result will arrive in a new turn.')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('tool-call-info')).not.toHaveAttribute('data-output');
+
+    const raw = '{"status":"unexpected","result":"preserve this"}';
+    rerender(
+      <RecoilRoot>
+        <BackgroundTaskCall args="{}" output={raw} isSubmitting={false} initialProgress={1} />
+      </RecoilRoot>,
+    );
+    expect(screen.getByTestId('tool-call-info')).toHaveAttribute('data-output', raw);
+  });
+
+  it('reveals the exact control receipt only when raw details are opened', () => {
+    const output = JSON.stringify({
+      status: 'accepted',
+      background_task_id: 'bg-1',
+      control_id: 'control-42',
+      message: 'The control request was queued.',
+    });
+    renderCall(output);
+    fireEvent.click(screen.getByTestId('task-header'));
+    expect(screen.queryByText(/control-42/)).not.toBeInTheDocument();
+
+    const details = screen.getByText('com_ui_background_tasks_raw_details').closest('details');
+    expect(details).not.toBeNull();
+    if (details == null) {
+      throw new Error('Task details disclosure is missing');
+    }
+    details.open = true;
+    fireEvent(details, new Event('toggle', { bubbles: true }));
+    expect(screen.getByTestId('task-output')).toHaveTextContent('control-42');
+  });
+
+  it('announces stable progress across intent deltas, then the settled intent once', () => {
+    const firstArgs = '{"intent":"Checking the backgr';
+    const finalArgs = '{"intent":"Checking the background task","background_task_id":"bg-1"}';
+    const { container, rerender } = renderCall('', {
+      args: firstArgs,
+      isSubmitting: true,
+      initialProgress: 0.1,
+    });
+    const announcement = container.querySelector('[aria-live="polite"]');
+    expect(announcement).toHaveClass('sr-only');
+    expect(announcement).toHaveAttribute('aria-atomic', 'true');
+    expect(announcement).toHaveTextContent('com_ui_background_tasks_checking');
+    rerender(
+      <RecoilRoot>
+        <BackgroundTaskCall args={finalArgs} output="" isSubmitting={true} initialProgress={0.1} />
+      </RecoilRoot>,
+    );
+    expect(announcement).toHaveTextContent('com_ui_background_tasks_checking');
+    rerender(
+      <RecoilRoot>
+        <BackgroundTaskCall
+          args={finalArgs}
+          output={JSON.stringify(completed)}
+          isSubmitting={false}
+          initialProgress={1}
+          runStepStatus="completed"
+        />
+      </RecoilRoot>,
+    );
+    expect(announcement).toHaveTextContent('Checking the background task');
+  });
+
+  it.each([
+    ['delivery_scheduled', 'com_ui_background_tasks_notice_delivery_scheduled'],
+    ['result_persisting', 'com_ui_background_tasks_notice_result_persisting'],
+  ])('announces %s as a pending state rather than a task failure', (status, label) => {
+    const { container } = renderCall(
+      JSON.stringify({ status, message: 'Untranslated backend status message.' }),
+      { runStepStatus: 'completed' },
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'completed');
+    expect(screen.getByTestId('task-header')).toHaveTextContent(label);
+    expect(container.querySelector('[aria-live="polite"]')).toHaveTextContent(label);
+  });
+
+  it.each([
+    ['failed', 'com_ui_failed_subject'],
+    ['cancelled', 'com_ui_cancelled'],
+  ])('announces an explicit %s tool-run status ahead of benign output', (runStepStatus, label) => {
+    const { container } = renderCall(
+      JSON.stringify({ status: 'delivery_scheduled', message: 'The result will arrive later.' }),
+      { runStepStatus: runStepStatus as 'failed' | 'cancelled' },
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', runStepStatus);
+    expect(container.querySelector('[aria-live="polite"]')).toHaveTextContent(label);
+    expect(container.querySelector('[aria-live="polite"]')).not.toHaveTextContent(
+      'com_ui_background_tasks_notice_delivery_scheduled',
+    );
+  });
+
+  it('announces cancellation rather than a successful check when a result is discarded', () => {
+    const { container } = renderCall(
+      JSON.stringify({ status: 'cancelled', message: 'Discarded the result.' }),
+      {
+        runStepStatus: 'completed',
+      },
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'cancelled');
+    expect(container.querySelector('[aria-live="polite"]')).toHaveTextContent(
+      'com_ui_background_tasks_result_discarded',
+    );
+  });
+
+  it('keeps the row in progress while a poll streams and updates it after settlement', () => {
+    const { rerender } = renderCall('', { isSubmitting: true, initialProgress: 0.1 });
+    expect(screen.getByTestId('task-header')).toHaveAttribute('data-phase', 'running');
+    fireEvent.click(screen.getByTestId('task-header'));
+    rerender(
+      <RecoilRoot>
+        <BackgroundTaskCall
+          args={'{"background_task_id":"bg-1"}'}
+          output={JSON.stringify(completed)}
+          isSubmitting={false}
+          initialProgress={1}
+          runStepStatus="completed"
+        />
+      </RecoilRoot>,
+    );
+    expect(screen.getByTestId('task-header')).toHaveAttribute('aria-expanded', 'true');
+    expect(screen.getByTestId('task-output')).toHaveTextContent('checked at=2026-09-27');
+  });
+});
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/background.test.ts b/client/src/components/Chat/Messages/Content/Parts/__tests__/background.test.ts
new file mode 100644
index 00000000000..6726754532d
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/background.test.ts
@@ -0,0 +1,293 @@
+import {
+  backgroundTaskOutcome,
+  formatBackgroundCodeOutput,
+  parseBackgroundTaskOutput,
+} from '../background';
+
+describe('formatBackgroundCodeOutput', () => {
+  it('indents a JSON log line without changing surrounding stdout and exit code', () => {
+    const raw =
+      'stdout:\nchecked at=2026-09-27T00:11:09Z\n{"checks":[{"status":"IN_PROGRESS"}]}\n[exit code: 0]';
+    expect(formatBackgroundCodeOutput(raw)).toBe(
+      'stdout:\nchecked at=2026-09-27T00:11:09Z\n{\n  "checks": [\n    {\n      "status": "IN_PROGRESS"\n    }\n  ]\n}\n[exit code: 0]',
+    );
+  });
+
+  it('leaves non-JSON lines, single JSON results, and very large outputs untouched', () => {
+    expect(formatBackgroundCodeOutput('stdout:\n[exit code: 0]')).toBe('stdout:\n[exit code: 0]');
+    expect(formatBackgroundCodeOutput('{"ok":true}')).toBe('{"ok":true}');
+    const large = `stdout:\n${'a'.repeat(64_001)}`;
+    expect(formatBackgroundCodeOutput(large)).toBe(large);
+  });
+});
+
+describe('backgroundTaskOutcome', () => {
+  it.each([
+    'invalid',
+    'rejected',
+    'unavailable',
+    'not_found',
+    'outcome_unknown',
+    'result_unavailable',
+    'error',
+    'future_control_rejected',
+  ])('flags the %s notice as a failed task check, despite a successful tool run step', (status) => {
+    const display = parseBackgroundTaskOutput(JSON.stringify({ status, message: 'Host advice' }));
+    expect(backgroundTaskOutcome(display)).toBe('failed');
+  });
+
+  it.each(['delivery_scheduled', 'result_persisting'])(
+    'does not mistake the %s retry state for a failed task',
+    (status) => {
+      const display = parseBackgroundTaskOutput(JSON.stringify({ status, message: 'Host advice' }));
+      expect(backgroundTaskOutcome(display)).toBeUndefined();
+    },
+  );
+
+  it.each(['error', 'interrupted', 'failed', 'not_running', 'control_not_found'])(
+    'flags a %s task or control receipt as failed',
+    (status) => {
+      const display = parseBackgroundTaskOutput(
+        JSON.stringify({ background_task_id: 't1', tool: 'subagent', status }),
+      );
+      expect(backgroundTaskOutcome(display)).toBe('failed');
+    },
+  );
+
+  it('distinguishes a discarded result from a still-running cancellation request', () => {
+    expect(
+      backgroundTaskOutcome(
+        parseBackgroundTaskOutput(
+          JSON.stringify({ status: 'cancelled', message: 'Result discarded.' }),
+        ),
+      ),
+    ).toBe('cancelled');
+    expect(
+      backgroundTaskOutcome(
+        parseBackgroundTaskOutput(
+          JSON.stringify({
+            background_task_id: 't1',
+            tool: 'bash_tool',
+            status: 'cancellation_requested',
+          }),
+        ),
+      ),
+    ).toBeUndefined();
+  });
+
+  it('warns about an incomplete list, not an ordinary list of already failed tasks', () => {
+    const incomplete = parseBackgroundTaskOutput(
+      JSON.stringify({ tasks: [], partial: true, warning: 'Some results are missing.' }),
+    );
+    const complete = parseBackgroundTaskOutput(
+      JSON.stringify({
+        tasks: [{ background_task_id: 't1', tool: 'bash_tool', status: 'error' }],
+        partial: false,
+      }),
+    );
+    expect(backgroundTaskOutcome(incomplete)).toBe('failed');
+    expect(backgroundTaskOutcome(complete)).toBeUndefined();
+  });
+});
+
+describe('parseBackgroundTaskOutput', () => {
+  it('parses an ordinary task result with the receipt and its exact output', () => {
+    const result =
+      'stdout:\nchecked at=2026-09-27T00:11:09Z\n{"checks":[{"status":"IN_PROGRESS"}]}\n[exit code: 0]';
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({
+          background_task_id: 'task-1',
+          tool: 'bash_tool',
+          status: 'completed',
+          result,
+          delivery: 'delivered',
+          started_at: '2026-09-27T00:11:00Z',
+        }),
+      ),
+    ).toEqual({
+      kind: 'task',
+      task: {
+        taskId: 'task-1',
+        toolName: 'bash_tool',
+        status: 'completed',
+        result,
+        delivery: 'delivered',
+      },
+    });
+  });
+
+  it('parses running, failed, cancelled, and pending tasks in a list without inventing results', () => {
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({
+          tasks: [
+            { background_task_id: 't1', tool: 'web_search', status: 'running' },
+            {
+              background_task_id: 't2',
+              tool: 'execute_code',
+              status: 'completed',
+              delivery: 'pending',
+              result_available: true,
+            },
+            {
+              background_task_id: 't3',
+              tool: 'read_file',
+              status: 'error',
+              error: 'Could not read file',
+              delivery: 'failed',
+            },
+            {
+              background_task_id: 't4',
+              tool: 'subagent',
+              status: 'cancelled',
+              subagent_type: 'researcher',
+            },
+          ],
+          outstanding: 2,
+          partial: true,
+          warning: 'Some results were not loaded.',
+        }),
+      ),
+    ).toEqual({
+      kind: 'list',
+      tasks: [
+        { taskId: 't1', toolName: 'web_search', status: 'running' },
+        {
+          taskId: 't2',
+          toolName: 'execute_code',
+          status: 'completed',
+          delivery: 'pending',
+          resultAvailable: true,
+        },
+        {
+          taskId: 't3',
+          toolName: 'read_file',
+          status: 'error',
+          error: 'Could not read file',
+          delivery: 'failed',
+        },
+        {
+          taskId: 't4',
+          toolName: 'subagent',
+          status: 'cancelled',
+          subagentType: 'researcher',
+        },
+      ],
+      partial: true,
+      warning: 'Some results were not loaded.',
+    });
+  });
+
+  it('shows a cancellation request as still stopping rather than cancelled', () => {
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({
+          background_task_id: 'task-1',
+          tool: 'bash_tool',
+          status: 'cancellation_requested',
+          message: 'Cancellation requested; execution continues until settlement.',
+        }),
+      ),
+    ).toMatchObject({ kind: 'task', task: { status: 'stopping' } });
+  });
+
+  it('shows a cancellation_requested flag in a list as stopping, not cancelled', () => {
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({
+          tasks: [
+            {
+              background_task_id: 'task-1',
+              tool: 'bash_tool',
+              status: 'running',
+              cancellation_requested: true,
+            },
+          ],
+          outstanding: 1,
+        }),
+      ),
+    ).toMatchObject({ kind: 'list', tasks: [{ status: 'stopping' }] });
+  });
+
+  it('keeps accepted subagent controls queued rather than labeling them completed', () => {
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({
+          background_task_id: 'subagent-1',
+          subagent_thread_id: 'thread-1',
+          tool: 'subagent',
+          subagent_type: 'researcher',
+          status: 'accepted',
+          control_id: 'control-42',
+        }),
+      ),
+    ).toEqual({
+      kind: 'task',
+      task: {
+        taskId: 'subagent-1',
+        toolName: 'subagent',
+        subagentType: 'researcher',
+        status: 'accepted',
+      },
+    });
+  });
+
+  it.each(['claimed', 'not_running', 'control_not_found'])(
+    'renders a subagent %s receipt as a task instead of raw JSON',
+    (status) => {
+      expect(
+        parseBackgroundTaskOutput(
+          JSON.stringify({
+            background_task_id: 'task-1',
+            tool: 'subagent',
+            subagent_type: 'researcher',
+            status,
+            result_available: true,
+            result_claimed: true,
+          }),
+        ),
+      ).toEqual({
+        kind: 'task',
+        task: {
+          taskId: 'task-1',
+          toolName: 'subagent',
+          subagentType: 'researcher',
+          status,
+          resultAvailable: true,
+          resultClaimed: true,
+        },
+      });
+    },
+  );
+
+  it('recognizes delivery and invalid-id notices without pretending they are tasks', () => {
+    const message = 'The result is already assigned to an automatic continuation.';
+    expect(
+      parseBackgroundTaskOutput(
+        JSON.stringify({ status: 'delivery_scheduled', background_task_id: 't1', message }),
+      ),
+    ).toEqual({ kind: 'notice', status: 'delivery_scheduled', message });
+  });
+
+  it.each([
+    '',
+    '{"tasks":',
+    JSON.stringify({ tasks: [{ background_task_id: 't1', tool: 'bash_tool', status: 'unknown' }] }),
+    JSON.stringify({
+      tasks: [
+        { background_task_id: 't1', tool: 'bash_tool', status: 'running', delivery: 'unknown' },
+      ],
+    }),
+    JSON.stringify({
+      background_task_id: 't1',
+      tool: 'bash_tool',
+      status: 'completed',
+      result: {},
+    }),
+    JSON.stringify({ status: 'completed', result: 'unrelated tool output' }),
+    JSON.stringify({ tasks: 'corrupt', status: 'invalid', message: 'Retry the request.' }),
+  ])('keeps malformed or unknown tool output on the raw fallback path', (output) => {
+    expect(parseBackgroundTaskOutput(output)).toBeNull();
+  });
+});
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/guidance.test.ts b/client/src/components/Chat/Messages/Content/Parts/__tests__/guidance.test.ts
new file mode 100644
index 00000000000..348f86cb790
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/guidance.test.ts
@@ -0,0 +1,177 @@
+import {
+  backgroundListGuidanceKeys,
+  backgroundTaskMessageKey,
+  backgroundTaskNoteKey,
+  backgroundTaskNoticeKey,
+} from '../guidance';
+import { parseBackgroundTaskOutput } from '../background';
+
+describe('background task host guidance', () => {
+  it.each([
+    [
+      'Generated files were saved and attached to the tool call that dispatched this task.',
+      'com_ui_background_tasks_files_attached',
+    ],
+    [
+      'Output and any generated files are being attached to the tool call that dispatched this task.',
+      'com_ui_background_tasks_files_attaching',
+    ],
+    [
+      'The tool produced an artifact that is not included inline.',
+      'com_ui_background_tasks_artifact_not_inline',
+    ],
+    [
+      'Still running outside this turn; its result will arrive as a new turn when it finishes.',
+      'com_ui_background_tasks_running_elsewhere',
+    ],
+    [
+      'Finished, but its result has not been delivered; it will arrive as a new turn unless you poll or cancel it.',
+      'com_ui_background_tasks_pending_delivery_note',
+    ],
+    [
+      'Automatic delivery failed; this result will not arrive as a new turn. Poll it to collect the result.',
+      'com_ui_background_tasks_failed_delivery_note',
+    ],
+  ])('localizes known task note variants: %s', (note, expected) => {
+    expect(backgroundTaskNoteKey(note)).toBe(expected);
+  });
+
+  it('keeps unknown host notes and messages behind raw details', () => {
+    expect(backgroundTaskNoteKey('New server-side note with context.')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+    expect(backgroundTaskMessageKey('New server-side control advice.')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+    expect(backgroundTaskNoteKey('constructor')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+    expect(backgroundTaskMessageKey('__proto__')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+    expect(backgroundTaskNoticeKey('constructor', 'Unexpected status.')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+  });
+
+  it('localizes known task messages without losing the cancellation and automatic-delivery rules', () => {
+    expect(
+      backgroundTaskMessageKey(
+        'Cancellation was requested. The task remains active until its executor settles; poll again for a terminal result.',
+      ),
+    ).toBe('com_ui_background_tasks_cancellation_requested');
+    expect(
+      backgroundTaskMessageKey(
+        'Automatic completion delivery is enabled for this subagent task. Continue independent work if available; otherwise end this turn and the host will resume you when the task finishes. Do not repeatedly poll an unchanged running task. Use check_background_task only for explicit status or control, or as a fallback if automatic delivery is unavailable.',
+      ),
+    ).toBe('com_ui_background_tasks_subagent_wakeup_guidance');
+  });
+
+  it.each([
+    ['invalid', 'Wrong arguments.', 'com_ui_background_tasks_notice_invalid'],
+    ['rejected', 'Capacity reached.', 'com_ui_background_tasks_notice_rejected'],
+    ['not_found', 'No task here.', 'com_ui_background_tasks_notice_not_found'],
+    [
+      'outcome_unknown',
+      'Unable to confirm result.',
+      'com_ui_background_tasks_notice_outcome_unknown',
+    ],
+    [
+      'result_unavailable',
+      'Receipt temporarily unavailable.',
+      'com_ui_background_tasks_notice_result_unavailable',
+    ],
+    [
+      'result_persisting',
+      'Receipt is settling.',
+      'com_ui_background_tasks_notice_result_persisting',
+    ],
+    [
+      'delivery_scheduled',
+      'Assigned to another poll.',
+      'com_ui_background_tasks_notice_delivery_scheduled',
+    ],
+    ['unavailable', 'Process disconnected.', 'com_ui_background_tasks_notice_unavailable'],
+    ['cancelled', 'Result discarded.', 'com_ui_background_tasks_result_discarded'],
+  ])('gives %s a localized, conservative notice', (status, message, expected) => {
+    expect(backgroundTaskNoticeKey(status, message)).toBe(expected);
+  });
+
+  it('distinguishes disabled cancellation, unsupported controls, and a failed discard', () => {
+    expect(
+      backgroundTaskNoticeKey(
+        'invalid',
+        'Cancellation is not enabled for ordinary background tools.',
+      ),
+    ).toBe('com_ui_background_tasks_cancel_disabled');
+    expect(
+      backgroundTaskNoticeKey(
+        'invalid',
+        'This control action is supported only for subagent tasks.',
+      ),
+    ).toBe('com_ui_background_tasks_notice_subagent_only');
+    expect(
+      backgroundTaskNoticeKey(
+        'unavailable',
+        'The pending result could not be discarded right now. It may still arrive as a new turn; retry the cancel shortly.',
+      ),
+    ).toBe('com_ui_background_tasks_notice_discard_unavailable');
+    expect(backgroundTaskNoticeKey('new_status', 'Unexpected server advice.')).toBe(
+      'com_ui_background_tasks_more_in_raw_details',
+    );
+  });
+
+  it('summarizes pending and failed delivery from task status, not backend English', () => {
+    const display = parseBackgroundTaskOutput(
+      JSON.stringify({
+        tasks: [
+          {
+            background_task_id: 'ordinary-pending',
+            tool: 'bash_tool',
+            status: 'completed',
+            delivery: 'pending',
+          },
+          {
+            background_task_id: 'ordinary-failed',
+            tool: 'read_file',
+            status: 'completed',
+            delivery: 'failed',
+          },
+          {
+            background_task_id: 'subagent-pending',
+            tool: 'subagent',
+            status: 'error',
+            delivery: 'pending',
+          },
+          { background_task_id: 'subagent-running', tool: 'subagent', status: 'running' },
+        ],
+        message:
+          'Some other text. Automatic completion delivery is enabled for this subagent task.',
+      }),
+    );
+    if (display?.kind !== 'list') {
+      throw new Error('Expected a task list');
+    }
+    expect(backgroundListGuidanceKeys(display)).toEqual([
+      'com_ui_background_tasks_pending_delivery_guidance',
+      'com_ui_background_tasks_failed_delivery_guidance',
+      'com_ui_background_tasks_subagent_pending_guidance',
+      'com_ui_background_tasks_subagent_wakeup_guidance',
+    ]);
+  });
+
+  it('never promises automatic delivery for a running subagent without host guidance', () => {
+    const display = parseBackgroundTaskOutput(
+      JSON.stringify({
+        tasks: [{ background_task_id: 'subagent', tool: 'subagent', status: 'running' }],
+        message: 'Poll for results manually.',
+      }),
+    );
+    if (display?.kind !== 'list') {
+      throw new Error('Expected a task list');
+    }
+    expect(backgroundListGuidanceKeys(display)).toEqual([
+      'com_ui_background_tasks_more_in_raw_details',
+    ]);
+  });
+});
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/wakeup.test.ts b/client/src/components/Chat/Messages/Content/Parts/__tests__/wakeup.test.ts
index 682a2d62a3e..a20ec801c31 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/wakeup.test.ts
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/wakeup.test.ts
@@ -73,6 +73,33 @@ describe('parseWakeupText', () => {
     });
   });
 
+  it('parses a cancelled background tool wake-up without exposing its host envelope', () => {
+    const text = [
+      'A background tool task has finished. Continue using its durable result below.',
+      JSON.stringify([
+        {
+          background_task_id: 'bg-2',
+          tool_call_id: 'call-2',
+          tool: 'bash_tool',
+          status: 'cancelled',
+          result: 'Cancelled by the user.',
+        },
+      ]),
+    ].join('\n');
+    expect(parseWakeupText(text)).toEqual({
+      kind: 'background_tool',
+      tasks: [
+        {
+          taskId: 'bg-2',
+          toolCallId: 'call-2',
+          toolName: 'bash_tool',
+          status: 'cancelled',
+          result: 'Cancelled by the user.',
+        },
+      ],
+    });
+  });
+
   it('parses a plural background tool wake-up', () => {
     const text = [
       '2 background tool tasks have finished. Continue using their durable results below.',
diff --git a/client/src/components/Chat/Messages/Content/Parts/background.ts b/client/src/components/Chat/Messages/Content/Parts/background.ts
new file mode 100644
index 00000000000..db5589de06f
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/background.ts
@@ -0,0 +1,217 @@
+import type { BackgroundTaskDelivery } from 'librechat-data-provider';
+import type { WakeupTaskStatus } from './wakeup';
+
+export function formatBackgroundCodeOutput(output: string): string {
+  if (output.length > 64_000 || !output.includes('\n')) {
+    return output;
+  }
+  const lines = output.split('\n');
+  if (lines.length > 500) {
+    return output;
+  }
+  return lines
+    .map((line) => {
+      const trimmed = line.trim();
+      if (
+        trimmed.length < 2 ||
+        trimmed.length > 8_000 ||
+        !(
+          (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+          (trimmed.startsWith('[') && trimmed.endsWith(']'))
+        )
+      ) {
+        return line;
+      }
+      try {
+        const value: unknown = JSON.parse(trimmed);
+        if (value == null || typeof value !== 'object') {
+          return line;
+        }
+        const indent = line.slice(0, line.length - line.trimStart().length);
+        return `${indent}${JSON.stringify(value, null, 2).replace(/\n/g, `\n${indent}`)}`;
+      } catch {
+        return line;
+      }
+    })
+    .join('\n');
+}
+
+export type BackgroundTaskStatus =
+  | WakeupTaskStatus
+  | 'running'
+  | 'stopping'
+  | 'accepted'
+  | 'claimed'
+  | 'not_running'
+  | 'control_not_found'
+  | 'dispatched'
+  | 'failed'
+  | 'interrupted';
+
+export type BackgroundTaskView = {
+  taskId: string;
+  toolName: string;
+  status: BackgroundTaskStatus;
+  result?: string;
+  error?: string;
+  note?: string;
+  message?: string;
+  subagentType?: string;
+  resultAvailable?: boolean;
+  resultClaimed?: boolean;
+  delivery?: BackgroundTaskDelivery;
+};
+
+export type BackgroundTaskDisplay =
+  | { kind: 'task'; task: BackgroundTaskView }
+  | {
+      kind: 'list';
+      tasks: BackgroundTaskView[];
+      partial: boolean;
+      warning?: string;
+      message?: string;
+    }
+  | { kind: 'notice'; message: string; status: string };
+
+const PENDING_NOTICES = new Set(['delivery_scheduled', 'result_persisting']);
+
+/** The poll step succeeding is not proof that its underlying task or control succeeded. */
+export function backgroundTaskOutcome(
+  display: BackgroundTaskDisplay | null,
+): 'failed' | 'cancelled' | undefined {
+  if (display == null) {
+    return;
+  }
+  if (display.kind === 'notice') {
+    if (display.status === 'cancelled') {
+      return 'cancelled';
+    }
+    return PENDING_NOTICES.has(display.status) ? undefined : 'failed';
+  }
+  if (display.kind === 'list') {
+    return display.partial || display.warning ? 'failed' : undefined;
+  }
+  const status = display.task.status;
+  if (status === 'cancelled') {
+    return 'cancelled';
+  }
+  return status === 'error' ||
+    status === 'failed' ||
+    status === 'interrupted' ||
+    status === 'not_running' ||
+    status === 'control_not_found'
+    ? 'failed'
+    : undefined;
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value != null && typeof value === 'object' && !Array.isArray(value);
+
+const optionalString = (value: unknown): value is string | undefined =>
+  value === undefined || typeof value === 'string';
+
+const taskStatus = (value: unknown): BackgroundTaskStatus | null => {
+  if (value === 'cancellation_requested') {
+    return 'stopping';
+  }
+  if (
+    value === 'running' ||
+    value === 'accepted' ||
+    value === 'claimed' ||
+    value === 'not_running' ||
+    value === 'control_not_found' ||
+    value === 'completed' ||
+    value === 'error' ||
+    value === 'cancelled' ||
+    value === 'dispatched' ||
+    value === 'failed' ||
+    value === 'interrupted'
+  ) {
+    return value;
+  }
+  return null;
+};
+
+const deliveryStatus = (value: unknown): value is BackgroundTaskDelivery | undefined =>
+  value === undefined || value === 'pending' || value === 'failed' || value === 'delivered';
+
+function parseTask(value: unknown): BackgroundTaskView | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const status = taskStatus(value.status);
+  if (
+    typeof value.background_task_id !== 'string' ||
+    value.background_task_id === '' ||
+    typeof value.tool !== 'string' ||
+    value.tool === '' ||
+    status == null ||
+    !optionalString(value.result) ||
+    !optionalString(value.error) ||
+    !optionalString(value.note) ||
+    !optionalString(value.message) ||
+    !optionalString(value.subagent_type) ||
+    (value.result_available != null && typeof value.result_available !== 'boolean') ||
+    (value.result_claimed != null && typeof value.result_claimed !== 'boolean') ||
+    !deliveryStatus(value.delivery)
+  ) {
+    return null;
+  }
+  return {
+    taskId: value.background_task_id,
+    toolName: value.tool,
+    status: status === 'running' && value.cancellation_requested === true ? 'stopping' : status,
+    ...(typeof value.result === 'string' ? { result: value.result } : {}),
+    ...(typeof value.error === 'string' ? { error: value.error } : {}),
+    ...(typeof value.note === 'string' ? { note: value.note } : {}),
+    ...(typeof value.message === 'string' ? { message: value.message } : {}),
+    ...(typeof value.subagent_type === 'string' ? { subagentType: value.subagent_type } : {}),
+    ...(value.result_available === true ? { resultAvailable: true } : {}),
+    ...(value.result_claimed === true ? { resultClaimed: true } : {}),
+    ...(value.delivery != null ? { delivery: value.delivery } : {}),
+  };
+}
+
+/** Only host-shaped results become cards. Unknown or partial output stays visible as raw tool output. */
+export function parseBackgroundTaskOutput(output?: string | null): BackgroundTaskDisplay | null {
+  if (!output || output.length > 2_000_000) {
+    return null;
+  }
+  const text = output.trim();
+  if (!text.startsWith('{') || !text.endsWith('}')) {
+    return null;
+  }
+  let payload: unknown;
+  try {
+    payload = JSON.parse(text) as unknown;
+  } catch {
+    return null;
+  }
+  if (!isRecord(payload)) {
+    return null;
+  }
+  if ('tasks' in payload && !Array.isArray(payload.tasks)) {
+    return null;
+  }
+  if (Array.isArray(payload.tasks)) {
+    const tasks = payload.tasks.map(parseTask);
+    if (tasks.some((task) => task == null)) {
+      return null;
+    }
+    return {
+      kind: 'list',
+      tasks: tasks as BackgroundTaskView[],
+      partial: payload.partial === true,
+      ...(typeof payload.warning === 'string' ? { warning: payload.warning } : {}),
+      ...(typeof payload.message === 'string' ? { message: payload.message } : {}),
+    };
+  }
+  const task = parseTask(payload);
+  if (task != null) {
+    return { kind: 'task', task };
+  }
+  if (typeof payload.status === 'string' && typeof payload.message === 'string') {
+    return { kind: 'notice', status: payload.status, message: payload.message };
+  }
+  return null;
+}
diff --git a/client/src/components/Chat/Messages/Content/Parts/guidance.ts b/client/src/components/Chat/Messages/Content/Parts/guidance.ts
new file mode 100644
index 00000000000..09e3821f581
--- /dev/null
+++ b/client/src/components/Chat/Messages/Content/Parts/guidance.ts
@@ -0,0 +1,106 @@
+import type { BackgroundTaskDisplay } from './background';
+import type { TranslationKeys } from '~/hooks';
+
+const RAW_DETAILS_KEY: TranslationKeys = 'com_ui_background_tasks_more_in_raw_details';
+
+/** Backend messages are model-facing English; show localized labels, not their raw prose. */
+const NOTE_KEYS: Record<string, TranslationKeys> = {
+  'Generated files were saved and attached to the tool call that dispatched this task.':
+    'com_ui_background_tasks_files_attached',
+  'Output and any generated files are being attached to the tool call that dispatched this task.':
+    'com_ui_background_tasks_files_attaching',
+  'The tool produced an artifact that is not included inline.':
+    'com_ui_background_tasks_artifact_not_inline',
+  'Still running outside this turn; its result will arrive as a new turn when it finishes.':
+    'com_ui_background_tasks_running_elsewhere',
+  'Finished, but its result has not been delivered; it will arrive as a new turn unless you poll or cancel it.':
+    'com_ui_background_tasks_pending_delivery_note',
+  'Automatic delivery failed; this result will not arrive as a new turn. Poll it to collect the result.':
+    'com_ui_background_tasks_failed_delivery_note',
+};
+
+const MESSAGE_KEYS: Record<string, TranslationKeys> = {
+  'Cancellation was requested. The task remains active until its executor settles; poll again for a terminal result.':
+    'com_ui_background_tasks_cancellation_requested',
+  'Automatic completion delivery is enabled for this subagent task. Continue independent work if available; otherwise end this turn and the host will resume you when the task finishes. Do not repeatedly poll an unchanged running task. Use check_background_task only for explicit status or control, or as a fallback if automatic delivery is unavailable.':
+    'com_ui_background_tasks_subagent_wakeup_guidance',
+};
+
+const NOTICE_KEYS: Record<string, TranslationKeys> = {
+  invalid: 'com_ui_background_tasks_notice_invalid',
+  rejected: 'com_ui_background_tasks_notice_rejected',
+  unavailable: 'com_ui_background_tasks_notice_unavailable',
+  not_found: 'com_ui_background_tasks_notice_not_found',
+  outcome_unknown: 'com_ui_background_tasks_notice_outcome_unknown',
+  result_unavailable: 'com_ui_background_tasks_notice_result_unavailable',
+  result_persisting: 'com_ui_background_tasks_notice_result_persisting',
+  delivery_scheduled: 'com_ui_background_tasks_notice_delivery_scheduled',
+  cancelled: 'com_ui_background_tasks_result_discarded',
+  error: 'com_ui_background_tasks_notice_error',
+};
+
+export const backgroundTaskNoteKey = (note: string): TranslationKeys =>
+  Object.hasOwn(NOTE_KEYS, note) ? NOTE_KEYS[note] : RAW_DETAILS_KEY;
+
+export const backgroundTaskMessageKey = (message: string): TranslationKeys =>
+  Object.hasOwn(MESSAGE_KEYS, message) ? MESSAGE_KEYS[message] : RAW_DETAILS_KEY;
+
+export function backgroundTaskNoticeKey(status: string, message: string): TranslationKeys {
+  if (
+    status === 'invalid' &&
+    message === 'Cancellation is not enabled for ordinary background tools.'
+  ) {
+    return 'com_ui_background_tasks_cancel_disabled';
+  }
+  if (
+    status === 'invalid' &&
+    message === 'This control action is supported only for subagent tasks.'
+  ) {
+    return 'com_ui_background_tasks_notice_subagent_only';
+  }
+  if (
+    status === 'unavailable' &&
+    message.startsWith('The pending result could not be discarded right now.')
+  ) {
+    return 'com_ui_background_tasks_notice_discard_unavailable';
+  }
+  return Object.hasOwn(NOTICE_KEYS, status) ? NOTICE_KEYS[status] : RAW_DETAILS_KEY;
+}
+
+export function backgroundListGuidanceKeys(
+  display: Extract<BackgroundTaskDisplay, { kind: 'list' }>,
+): TranslationKeys[] {
+  if (!display.message) {
+    return [];
+  }
+  let toolPending = false;
+  let toolFailed = false;
+  let subagentPending = false;
+  let subagentRunning = false;
+  for (const task of display.tasks) {
+    if (task.toolName === 'subagent') {
+      subagentPending ||= task.delivery === 'pending' && task.status !== 'running';
+      subagentRunning ||= task.status === 'running';
+      continue;
+    }
+    toolPending ||= task.delivery === 'pending' && task.status !== 'running';
+    toolFailed ||= task.delivery === 'failed';
+  }
+  const keys: TranslationKeys[] = [];
+  if (toolPending) {
+    keys.push('com_ui_background_tasks_pending_delivery_guidance');
+  }
+  if (toolFailed) {
+    keys.push('com_ui_background_tasks_failed_delivery_guidance');
+  }
+  if (subagentPending) {
+    keys.push('com_ui_background_tasks_subagent_pending_guidance');
+  }
+  if (
+    subagentRunning &&
+    display.message.includes('Automatic completion delivery is enabled for this subagent task.')
+  ) {
+    keys.push('com_ui_background_tasks_subagent_wakeup_guidance');
+  }
+  return keys.length > 0 ? keys : [RAW_DETAILS_KEY];
+}
diff --git a/client/src/components/Chat/Messages/Content/Parts/wakeup.ts b/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
index ce46d45990c..1b90e90ee65 100644
--- a/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
+++ b/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
@@ -72,7 +72,6 @@ const backgroundWakeupTask = (payload: unknown): WakeupTask | null => {
   const status = wakeupStatus(payload.status);
   if (
     status == null ||
-    status === 'cancelled' ||
     typeof payload.background_task_id !== 'string' ||
     typeof payload.tool_call_id !== 'string' ||
     typeof payload.tool !== 'string' ||
diff --git a/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx b/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx
index 1a47e3a7015..c0080bf4cd5 100644
--- a/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx
@@ -1,8 +1,8 @@
 import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
 import { useRecoilValue } from 'recoil';
 import { Button } from '@librechat/client';
-import { ChevronDown, MessageCircleQuestion, Users } from 'lucide-react';
 import { Tools, Constants, ContentTypes } from 'librechat-data-provider';
+import { ChevronDown, ListChecks, MessageCircleQuestion, Users } from 'lucide-react';
 import type { TAttachment, TMessageContentParts } from 'librechat-data-provider';
 import type { PartWithIndex } from './ParallelContent';
 import type { ToolMeta } from './outcome';
@@ -144,6 +144,7 @@ export default function ToolCallGroup({
     let fileSearchCount = 0;
     let subagentCount = 0;
     let askQuestionCount = 0;
+    let taskCheckCount = 0;
     let failedCount = 0;
     let cancelledCount = 0;
 
@@ -156,6 +157,8 @@ export default function ToolCallGroup({
         subagentCount++;
       } else if (tool.name === ASK_USER_QUESTION) {
         askQuestionCount++;
+      } else if (tool.name === Constants.CHECK_BACKGROUND_TASK) {
+        taskCheckCount++;
       }
       if (tool.failed) {
         failedCount++;
@@ -183,6 +186,7 @@ export default function ToolCallGroup({
       fileSearchCount,
       subagentCount,
       askQuestionCount,
+      taskCheckCount,
       failedCount,
       cancelledCount,
       toolNameSummary,
@@ -215,6 +219,8 @@ export default function ToolCallGroup({
    *  tools: ask_user_question") with a question glyph. */
   const allAskQuestions =
     activitySummary.askQuestionCount > 0 && activitySummary.askQuestionCount === count;
+  const allTaskChecks =
+    activitySummary.taskCheckCount > 0 && activitySummary.taskCheckCount === count;
   /**
    * An answered question is the group's completion proof. The `tool_call`
    * part carries no output until the turn finalizes, so `allCompleted` stays
@@ -405,6 +411,11 @@ export default function ToolCallGroup({
         ? localize('com_ui_asked_n_questions', { 0: String(count) })
         : localize('com_ui_asking_n_questions', { 0: String(count) });
     }
+    if (allTaskChecks) {
+      return localize(
+        groupDone ? 'com_ui_background_tasks_checked' : 'com_ui_background_tasks_checking',
+      );
+    }
     if (activitySummary.webSearchCount === count) {
       return localize(groupDone ? 'com_ui_web_searched' : 'com_ui_web_searching');
     }
@@ -430,6 +441,8 @@ export default function ToolCallGroup({
   const groupDetailParts: string[] = [];
   if (searchesOnly && count > 1) {
     groupDetailParts.push(localize('com_ui_n_searches', { 0: String(count) }));
+  } else if (allTaskChecks && count > 1) {
+    groupDetailParts.push(localize('com_ui_background_tasks_n_checks', { 0: String(count) }));
   } else if (!allSubagents && !allAskQuestions && count > 1) {
     groupDetailParts.push(activitySummary.toolNameSummary);
   }
@@ -471,7 +484,12 @@ export default function ToolCallGroup({
     ? groupDetailParts.filter((part) => part && part !== failedNote).join(' · ')
     : groupDetail;
   /** Single category glyph for homogeneous groups (else StackedToolIcons). */
-  const CategoryIcon = allSubagents ? Users : MessageCircleQuestion;
+  let CategoryIcon = ListChecks;
+  if (allSubagents) {
+    CategoryIcon = Users;
+  } else if (allAskQuestions) {
+    CategoryIcon = MessageCircleQuestion;
+  }
   const iconStatus = getOutcomeStatus({
     failed: activityFailed ? 1 : activitySummary.failedCount,
     cancelled: activitySummary.cancelledCount,
@@ -509,12 +527,9 @@ export default function ToolCallGroup({
           aria-expanded={isExpanded}
           aria-label={groupAriaLabel}
         >
-          {iconStatus == null && (allSubagents || allAskQuestions) ? (
-            /** Homogeneous category groups get a single category glyph instead
-             *  of StackedToolIcons' generic wrenches: a Users glyph for
-             *  subagents, a question glyph for ask_user_question — matching
-             *  their individual card headers and reading as the category
-             *  rather than "tools". */
+          {iconStatus == null && (allSubagents || allAskQuestions || allTaskChecks) ? (
+            /** Homogeneous categories keep the same glyph as their individual
+             *  cards instead of stacking identical tool icons. */
             <div
               className={cn(
                 ROW_GLYPH_SLOT,
diff --git a/client/src/components/Chat/Messages/Content/ToolOutput/OutputRenderer.tsx b/client/src/components/Chat/Messages/Content/ToolOutput/OutputRenderer.tsx
index 1b71b8923c5..f51375058bc 100644
--- a/client/src/components/Chat/Messages/Content/ToolOutput/OutputRenderer.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolOutput/OutputRenderer.tsx
@@ -99,9 +99,10 @@ const VISIBLE_LINES = 15;
 
 interface OutputRendererProps {
   text: string;
+  copyText?: string;
 }
 
-export default function OutputRenderer({ text }: OutputRendererProps) {
+export default function OutputRenderer({ text, copyText }: OutputRendererProps) {
   const localize = useLocalize();
   const { text: displayText, rawError, error, isJson } = useMemo(() => extractText(text), [text]);
   const [isExpanded, setIsExpanded] = useState(false);
@@ -110,9 +111,9 @@ export default function OutputRenderer({ text }: OutputRendererProps) {
 
   const handleCopy = useCallback(() => {
     setIsCopied(true);
-    copy(displayText, { format: 'text/plain' });
+    copy(copyText ?? displayText, { format: 'text/plain' });
     setTimeout(() => setIsCopied(false), 3000);
-  }, [displayText]);
+  }, [copyText, displayText]);
 
   if (!displayText) {
     return null;
diff --git a/client/src/components/Chat/Messages/Content/ToolOutput/ToolIcon.tsx b/client/src/components/Chat/Messages/Content/ToolOutput/ToolIcon.tsx
index 61babdc2703..665b6335e09 100644
--- a/client/src/components/Chat/Messages/Content/ToolOutput/ToolIcon.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolOutput/ToolIcon.tsx
@@ -12,6 +12,7 @@ import {
   Brain,
   Zap,
   Wrench,
+  ListChecks,
 } from 'lucide-react';
 import LangIcon from '~/components/Messages/Content/LangIcon';
 import CustomIcon from '~/components/ui/CustomIcon';
@@ -32,6 +33,7 @@ export type ToolIconType =
   | 'skill'
   | 'read_file'
   | 'bash_tool'
+  | 'background_tasks'
   | 'ask_user_question'
   | 'memory'
   | 'action'
@@ -48,6 +50,7 @@ const ICON_MAP: Record<ToolIconType, React.ComponentType<{ className?: string }>
   skill: ScrollText,
   read_file: FileText,
   bash_tool: BashIcon,
+  background_tasks: ListChecks,
   ask_user_question: MessageCircleQuestion,
   memory: Brain,
   action: Zap,
@@ -61,6 +64,9 @@ export function getToolIconType(name: string): ToolIconType {
   if (name.includes(Constants.mcp_delimiter)) {
     return 'mcp';
   }
+  if (name === Constants.CHECK_BACKGROUND_TASK) {
+    return 'background_tasks';
+  }
   if (name === 'execute_code' || name === Constants.PROGRAMMATIC_TOOL_CALLING) {
     return 'execute_code';
   }
diff --git a/client/src/components/Chat/Messages/Content/ToolOutput/__tests__/OutputRenderer.test.tsx b/client/src/components/Chat/Messages/Content/ToolOutput/__tests__/OutputRenderer.test.tsx
index 77ff54aaeef..aff34c258fa 100644
--- a/client/src/components/Chat/Messages/Content/ToolOutput/__tests__/OutputRenderer.test.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolOutput/__tests__/OutputRenderer.test.tsx
@@ -1,5 +1,6 @@
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import copy from 'copy-to-clipboard';
+import { fireEvent, render, screen } from '@testing-library/react';
 import OutputRenderer, { isError } from '../OutputRenderer';
 
 jest.mock('copy-to-clipboard', () => jest.fn());
@@ -10,7 +11,9 @@ jest.mock('~/hooks', () => ({
 
 jest.mock('~/components/Messages/Content/CopyButton', () => ({
   __esModule: true,
-  default: () => <button type="button" data-testid="copy-output" />,
+  default: ({ onClick }: { onClick: () => void }) => (
+    <button type="button" data-testid="copy-output" onClick={onClick} />
+  ),
 }));
 
 describe('OutputRenderer', () => {
@@ -22,6 +25,13 @@ describe('OutputRenderer', () => {
     expect(copyPositioner?.parentElement).toHaveClass('relative', 'pr-10');
   });
 
+  it('copies original bytes when a code result has been formatted for display', () => {
+    const raw = 'stdout:\n{"ok":true}';
+    render(<OutputRenderer text={'stdout:\n{\n  "ok": true\n}'} copyText={raw} />);
+    fireEvent.click(screen.getByTestId('copy-output'));
+    expect(copy).toHaveBeenCalledWith(raw, { format: 'text/plain' });
+  });
+
   it('does not treat text between bracketed prefixes as a tool-call error', () => {
     expect(isError('Error: [agent] unexpected [search] tool call failed: unavailable')).toBe(false);
   });
diff --git a/client/src/components/Chat/Messages/Content/Wakeup.tsx b/client/src/components/Chat/Messages/Content/Wakeup.tsx
index 53c8b48cd78..7ef6cfe4740 100644
--- a/client/src/components/Chat/Messages/Content/Wakeup.tsx
+++ b/client/src/components/Chat/Messages/Content/Wakeup.tsx
@@ -16,6 +16,7 @@ import { useLocalize, useExpandCollapse, useLazyCollapseBody } from '~/hooks';
 import { useOpenSubagentPanel } from '~/components/Chat/Subagents/surface';
 import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
 import { useShareContext } from '~/Providers/ShareContext';
+import BackgroundTaskCard from './BackgroundTaskCard';
 import { cn, getToolDisplayLabel } from '~/utils';
 import { useMessageContext } from '~/Providers';
 import { StackedToolIcons } from './ToolOutput';
@@ -33,15 +34,12 @@ const threadStatus = (status: WakeupTask['status']) =>
 
 function WakeupTaskCard({
   task,
-  kind,
   conversationId,
 }: {
   task: WakeupTask;
-  kind: WakeupDisplay['kind'];
   conversationId?: string | null;
 }) {
   const localize = useLocalize();
-  const mcpServerNames = useMCPServerNames();
   const { isSharedConvo } = useShareContext();
   const { messageId } = useMessageContext();
   const { byThreadId } = useParentSubagents();
@@ -78,10 +76,7 @@ function WakeupTaskCard({
   }, [child, conversationId, isSharedConvo, messageId, task]);
   const status = threadStatus(task.status);
   const StatusIcon = subagentStatusIcon(status);
-  const title =
-    kind === 'subagent'
-      ? (task.subagentType ?? '')
-      : getToolDisplayLabel(task.toolName ?? '', localize, mcpServerNames);
+  const title = task.subagentType ?? '';
   const hasResult = task.result.trim() !== '';
 
   const openActivity = useCallback(() => {
@@ -150,7 +145,7 @@ const Wakeup = memo(function Wakeup({
     setIsExpanded((previous) => !previous);
   }, [mountBody]);
 
-  const anyFailed = display.tasks.some((task) => task.status === 'error');
+  const anyFailed = display.tasks.some((task) => task.status !== 'completed');
   const headerLabel = useMemo(() => {
     if (display.kind === 'subagent') {
       const status = display.tasks[0]?.status ?? 'completed';
@@ -159,11 +154,13 @@ const Wakeup = memo(function Wakeup({
     if (display.tasks.length > 1) {
       return localize('com_ui_wakeup_tasks_finished', { 0: String(display.tasks.length) });
     }
-    return localize(
-      display.tasks[0]?.status === 'error'
-        ? 'com_ui_wakeup_task_errored'
-        : 'com_ui_wakeup_task_finished',
-    );
+    if (display.tasks[0]?.status === 'cancelled') {
+      return localize('com_ui_wakeup_task_cancelled');
+    }
+    if (display.tasks[0]?.status === 'error') {
+      return localize('com_ui_wakeup_task_errored');
+    }
+    return localize('com_ui_wakeup_task_finished');
   }, [display.kind, display.tasks, localize]);
 
   const nameSummary = useMemo(() => {
@@ -226,17 +223,29 @@ const Wakeup = memo(function Wakeup({
         {shouldRenderBody && (
           <div className="overflow-hidden" ref={expandRef}>
             <div className="pb-1">
-              <div className="mt-1 text-xs text-text-secondary">
-                {localize('com_ui_wakeup_explainer')}
-              </div>
-              {display.tasks.map((task) => (
-                <WakeupTaskCard
-                  key={task.taskId}
-                  task={task}
-                  kind={display.kind}
-                  conversationId={conversationId}
-                />
-              ))}
+              {display.kind === 'subagent' && (
+                <div className="mt-1 text-xs text-text-secondary">
+                  {localize('com_ui_wakeup_explainer')}
+                </div>
+              )}
+              {display.tasks.map((task) =>
+                display.kind === 'background_tool' ? (
+                  <div key={task.taskId} className="my-2">
+                    <BackgroundTaskCard
+                      task={{
+                        taskId: task.taskId,
+                        toolName: task.toolName ?? '',
+                        status: task.status,
+                        result: task.result,
+                      }}
+                      mcpIconMap={mcpIconMap}
+                      mcpServerNames={mcpServerNames}
+                    />
+                  </div>
+                ) : (
+                  <WakeupTaskCard key={task.taskId} task={task} conversationId={conversationId} />
+                ),
+              )}
             </div>
           </div>
         )}
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx
index 5a3c0de2d5c..73bbfc989b2 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx
@@ -595,7 +595,7 @@ describe('ActivityPhaseGroup open live header', () => {
     expect(within(header).queryByTitle('Next I check the ordering.')).toBeNull();
   });
 
-  test('falls back to the generic thinking line when no label has landed', () => {
+  test('falls back to a running line no row uses when no label has landed', () => {
     render(
       <ActivityPhaseGroup labelPart={makeLabelPart('')} hasContent liveParts={[thought()]}>
         <div data-testid="phase-content" />
@@ -603,7 +603,62 @@ describe('ActivityPhaseGroup open live header', () => {
     );
     fireEvent.click(screen.getByRole('button'));
     settle();
-    expect(within(screen.getByRole('button')).getByTitle('com_ui_thinking')).toBeInTheDocument();
+    const header = screen.getByRole('button');
+    expect(within(header).getByTitle('com_ui_running')).toBeInTheDocument();
+    expect(within(header).queryByTitle('com_ui_thinking')).toBeNull();
+  });
+
+  const runningCall = (intent: string): TMessageContentParts =>
+    ({
+      type: ContentTypes.TOOL_CALL,
+      [ContentTypes.TOOL_CALL]: {
+        id: 'r1',
+        name: 'list_documents',
+        args: JSON.stringify({ intent }),
+        type: 'tool_call',
+        progress: 0.5,
+        output: '',
+      },
+    }) as unknown as TMessageContentParts;
+  const batchLabel = (text: string): TMessageContentParts =>
+    ({
+      type: ContentTypes.ACTIVITY_LABEL,
+      activity_label: text,
+      activity_label_type: 'batch',
+      pending: false,
+    }) as unknown as TMessageContentParts;
+
+  test("does not repeat the newest call's intent, which is its own row", () => {
+    const intent = 'Reading the roadmap card so edits preserve project choices';
+    render(
+      <ActivityPhaseGroup
+        labelPart={makeLabelPart('')}
+        hasContent
+        liveParts={[runningCall(intent)]}
+      >
+        <div data-testid="phase-content" />
+      </ActivityPhaseGroup>,
+    );
+    fireEvent.click(screen.getByRole('button'));
+    settle();
+    const header = screen.getByRole('button');
+    expect(within(header).queryByTitle(intent)).toBeNull();
+    expect(within(header).getByTitle('com_ui_running')).toBeInTheDocument();
+  });
+
+  test('titles an open card by the newest batch label behind a running call', () => {
+    render(
+      <ActivityPhaseGroup
+        labelPart={makeLabelPart('')}
+        hasContent
+        liveParts={[batchLabel('Found the recap'), runningCall('Reading the roadmap card')]}
+      >
+        <div data-testid="phase-content" />
+      </ActivityPhaseGroup>,
+    );
+    fireEvent.click(screen.getByRole('button'));
+    settle();
+    expect(within(screen.getByRole('button')).getByTitle('Found the recap')).toBeInTheDocument();
   });
 });
 
diff --git a/client/src/components/Chat/Messages/Content/__tests__/LiveParity.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/LiveParity.test.tsx
index 0eae37dc85e..439b494a29c 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/LiveParity.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/LiveParity.test.tsx
@@ -309,6 +309,80 @@ describe('live fold parity with the cards it hides', () => {
     expect(screen.queryByTestId('activity-phase-card')).toBeNull();
   });
 
+  it('describes repeated background-task polls as checks in the live fold', () => {
+    jest.useFakeTimers();
+    const poll = (id: string, output: string) =>
+      toPart(
+        {
+          name: Constants.CHECK_BACKGROUND_TASK,
+          args: { background_task_id: 'same-task' },
+          output,
+        },
+        id,
+      );
+    const completed = JSON.stringify({
+      background_task_id: 'same-task',
+      tool: Tools.bash_tool,
+      status: 'running',
+    });
+    const view = mount(
+      [poll('first', completed), poll('second', completed), poll('third', completed)],
+      undefined,
+      true,
+    );
+    const header = within(screen.getByTestId('activity-phase-card')).getByRole('button');
+
+    expect(header).toHaveAccessibleName('Checked background tasks · 3 checks');
+    expect(screen.getByTestId('live-phase-combo')).toHaveTextContent('· 3 checks');
+    expect(header).not.toHaveTextContent('check_background_task');
+
+    view.rerender(
+      <QueryClientProvider client={new QueryClient()}>
+        <RecoilRoot>
+          <ContentParts
+            content={[
+              poll('first', completed),
+              poll('second', completed),
+              poll('third', completed),
+              poll('fourth', ''),
+            ]}
+            messageId="m1"
+            conversationId="c1"
+            isCreatedByUser={false}
+            isLast
+            isLatestMessage
+            isSubmitting
+            showThinking={false}
+          />
+        </RecoilRoot>
+      </QueryClientProvider>,
+    );
+    act(() => {
+      jest.advanceTimersByTime(500);
+    });
+    expect(header).toHaveAccessibleName('Checking background tasks · 4 checks');
+  });
+
+  it.each([
+    ['error', 'Failed: Background tasks · 1 failed'],
+    ['cancelled', 'Cancelled · 1 cancelled'],
+  ])('keeps the %s verdict of a polled background task in the live fold', (status, label) => {
+    const output = JSON.stringify({
+      background_task_id: 'bg1',
+      tool: Tools.bash_tool,
+      status,
+    });
+    mount(
+      [toPart({ name: Constants.CHECK_BACKGROUND_TASK, output, runStepStatus: 'completed' })],
+      undefined,
+      true,
+    );
+    expect(
+      within(screen.getByTestId('activity-phase-card')).getAllByRole('button')[0],
+    ).toHaveAccessibleName(label);
+    expect(screen.queryByTestId('live-phase-combo')).toBeNull();
+  });
+
   it('shows a multiplier for consecutive uses of the same tool and resets on a different tool', () => {
     jest.useFakeTimers();
     const first = toPart({ name: 'create_file', output: 'created' }, 'first');
diff --git a/client/src/components/Chat/Messages/Content/__tests__/Part.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/Part.test.tsx
index bf6c75a6ad9..c4488db080d 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/Part.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/Part.test.tsx
@@ -62,6 +62,13 @@ jest.mock('../ToolCall', () => ({
   ),
 }));
 
+jest.mock('../Parts/BackgroundTaskCall', () => ({
+  __esModule: true,
+  default: ({ output }: { output: string }) => (
+    <div data-testid="background-task-call" data-output={output} />
+  ),
+}));
+
 jest.mock('../Image', () => ({
   __esModule: true,
   default: ({ alignRight }: { alignRight?: boolean }) => (
@@ -222,6 +229,20 @@ describe('Part tool renderer selection', () => {
     expect(screen.queryByTestId('tool-call')).not.toBeInTheDocument();
   });
 
+  it('routes the native background poll tool to its structured task renderer', () => {
+    const output = JSON.stringify({ tasks: [], outstanding: 0 });
+    const part = toolCallPart(Constants.CHECK_BACKGROUND_TASK) as Extract<
+      TMessageContentParts,
+      { type: typeof ContentTypes.TOOL_CALL }
+    >;
+    Object.assign(part[ContentTypes.TOOL_CALL], { output });
+
+    renderPart(part);
+
+    expect(screen.getByTestId('background-task-call')).toHaveAttribute('data-output', output);
+    expect(screen.queryByTestId('tool-call')).not.toBeInTheDocument();
+  });
+
   it('renders a cancelled generic background tool as cancelled', () => {
     const part = toolCallPart('search_mcp_docs') as Extract<
       TMessageContentParts,
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ToolCallGroup.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ToolCallGroup.test.tsx
index 4013817d099..cc6c1c6528a 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ToolCallGroup.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ToolCallGroup.test.tsx
@@ -21,6 +21,15 @@ jest.mock('~/hooks', () => ({
     if (key === 'com_ui_n_searches') {
       return `${values?.[0]} searches`;
     }
+    if (key === 'com_ui_background_tasks_checked') {
+      return 'Checked background tasks';
+    }
+    if (key === 'com_ui_background_tasks_checking') {
+      return 'Checking background tasks';
+    }
+    if (key === 'com_ui_background_tasks_n_checks') {
+      return `${values?.[0]} checks`;
+    }
     if (key === 'com_ui_n_actions_failed') {
       return `${values?.[0]} failed`;
     }
@@ -110,6 +119,7 @@ jest.mock('lucide-react', () => ({
   ),
   Users: () => <span>{'users'}</span>,
   MessageCircleQuestion: () => <span data-testid="question-icon">{'question'}</span>,
+  ListChecks: () => <span data-testid="task-check-icon">{'checks'}</span>,
   TriangleAlert: () => <span>{'warning'}</span>,
 }));
 
@@ -144,6 +154,7 @@ jest.mock('~/utils', () => ({
       create_file: 'Create File',
       edit_file: 'Edit File',
       ask_user_question: 'Question',
+      check_background_task: 'Background tasks',
     };
     return friendlyNames[name] ?? name;
   },
@@ -857,6 +868,138 @@ describe('ToolCallGroup image hoisting', () => {
     ).toBeInTheDocument();
   });
 
+  it('summarizes repeated task checks as checks rather than separate tasks or generic actions', () => {
+    const parts = Array.from({ length: 3 }, (_, idx) => ({
+      part: makePart(
+        `check-${idx}`,
+        JSON.stringify({
+          background_task_id: 'same-task',
+          tool: 'bash_tool',
+          status: 'running',
+        }),
+        Constants.CHECK_BACKGROUND_TASK,
+      ),
+      idx,
+    }));
+    renderGroup({ ...baseProps, parts, lastContentIdx: 2 });
+
+    expect(
+      screen.getByRole('button', { name: 'Checked background tasks, 3 checks' }),
+    ).toBeInTheDocument();
+    expect(screen.getByText('· 3 checks')).toBeInTheDocument();
+    expect(screen.getByTestId('task-check-icon')).toBeInTheDocument();
+    expect(screen.queryByTestId('stacked-icons')).not.toBeInTheDocument();
+    expect(screen.queryByText(/Ran 3 actions|check_background_task/)).not.toBeInTheDocument();
+  });
+
+  it('keeps the check group active until its outstanding poll settles', () => {
+    renderGroup({
+      ...baseProps,
+      isSubmitting: true,
+      parts: [
+        { part: makePart('check-1', '{"tasks":[]}', Constants.CHECK_BACKGROUND_TASK), idx: 0 },
+        { part: makePart('check-2', '', Constants.CHECK_BACKGROUND_TASK), idx: 1 },
+      ],
+    });
+
+    expect(
+      screen.getByRole('button', { name: 'Checking background tasks, 2 checks' }),
+    ).toBeInTheDocument();
+    expect(screen.getByTestId('task-check-icon').parentElement).toHaveClass('animate-pulse');
+  });
+
+  it('uses the same check verb for one poll and preserves mixed-tool summaries', () => {
+    const check = makePart('check-1', '{"tasks":[]}', Constants.CHECK_BACKGROUND_TASK);
+    const { rerender } = renderGroup({
+      ...baseProps,
+      parts: [{ part: check, idx: 0 }],
+      lastContentIdx: 0,
+    });
+    expect(screen.getByRole('button', { name: 'Checked background tasks' })).toBeInTheDocument();
+
+    rerender(
+      <RecoilRoot>
+        <ToolCallGroup
+          {...baseProps}
+          parts={[
+            { part: check, idx: 0 },
+            { part: makePart('b1', 'done', Tools.bash_tool), idx: 1 },
+          ]}
+        />
+      </RecoilRoot>,
+    );
+    expect(
+      screen.getByRole('button', { name: 'Ran 2 actions, Background tasks, Code' }),
+    ).toBeInTheDocument();
+    expect(screen.getByTestId('stacked-icons')).toBeInTheDocument();
+  });
+
+  it.each([
+    ['error', '1 failed'],
+    ['cancelled', '1 cancelled'],
+    ['interrupted', '1 failed'],
+  ])('reflects a %s task poll in the collapsed group', (status, suffix) => {
+    renderGroup({
+      ...baseProps,
+      parts: [
+        {
+          part: makePart(
+            'check-1',
+            JSON.stringify({
+              background_task_id: 'bg-1',
+              tool: 'bash_tool',
+              status,
+              ...(status === 'error' ? { error: 'Disk full' } : {}),
+            }),
+            Constants.CHECK_BACKGROUND_TASK,
+          ),
+          idx: 0,
+        },
+      ],
+      lastContentIdx: 0,
+    });
+
+    expect(
+      screen.getByRole('button', { name: `Checked background tasks, ${suffix}` }),
+    ).toBeInTheDocument();
+  });
+
+  it.each(['invalid', 'rejected', 'unavailable', 'outcome_unknown', 'result_unavailable'])(
+    'shows a failed group for the %s background-task notice even when the poll step succeeds',
+    (status) => {
+      const part = makePart(
+        'poll-1',
+        JSON.stringify({ status, message: 'Host guidance about the failed check.' }),
+        Constants.CHECK_BACKGROUND_TASK,
+      );
+      Object.assign(part[ContentTypes.TOOL_CALL] ?? {}, { runStepStatus: 'completed' });
+      renderGroup({ ...baseProps, parts: [{ part, idx: 0 }], lastContentIdx: 0 });
+      expect(
+        screen.getByRole('button', { name: 'Checked background tasks, 1 failed' }),
+      ).toBeInTheDocument();
+    },
+  );
+
+  it('marks an incomplete background-task list as a failed check', () => {
+    renderGroup({
+      ...baseProps,
+      parts: [
+        {
+          part: makePart(
+            'poll-1',
+            JSON.stringify({ tasks: [], partial: true, warning: 'A replica is unreachable.' }),
+            Constants.CHECK_BACKGROUND_TASK,
+          ),
+          idx: 0,
+        },
+      ],
+      lastContentIdx: 0,
+    });
+    expect(
+      screen.getByRole('button', { name: 'Checked background tasks, 1 failed' }),
+    ).toBeInTheDocument();
+  });
+
   it('counts background failures per step when provider call IDs repeat', () => {
     const executions = [
       { stepId: 'step-success', status: 'completed' },
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ToolIcon.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ToolIcon.test.tsx
index 4befd9df695..2734ccb44e0 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ToolIcon.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ToolIcon.test.tsx
@@ -26,6 +26,13 @@ describe('getToolIconType - ACTN-01: Action delimiter detection', () => {
     expect(getToolIconType('some_plain_tool')).toBe('generic');
   });
 
+  it('gives the native background-task tool its own icon while preserving MCP identity', () => {
+    expect(getToolIconType(Constants.CHECK_BACKGROUND_TASK)).toBe('background_tasks');
+    expect(
+      getToolIconType(`${Constants.CHECK_BACKGROUND_TASK}${Constants.mcp_delimiter}remote`),
+    ).toBe('mcp');
+  });
+
   it('returns correct types for existing tool names', () => {
     expect(getToolIconType('execute_code')).toBe('execute_code');
     expect(getToolIconType(Constants.PROGRAMMATIC_TOOL_CALLING)).toBe('execute_code');
diff --git a/client/src/components/Chat/Messages/Content/__tests__/Wakeup.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/Wakeup.test.tsx
index 5d66cf7e7b9..a694b0cdc44 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/Wakeup.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/Wakeup.test.tsx
@@ -1,7 +1,7 @@
 import React from 'react';
 import { RecoilRoot } from 'recoil';
 import { useAtomValue } from 'jotai';
-import { fireEvent, render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, within } from '@testing-library/react';
 import type { ParentSubagentSummary } from 'librechat-data-provider';
 import { activeSubagentPanel } from '~/components/Chat/Subagents/state';
 import { ChatSurfaceHarness } from 'test/harness';
@@ -17,12 +17,20 @@ jest.mock('~/hooks', () => ({
 }));
 
 jest.mock('~/hooks/MCP', () => ({
-  useMCPIconMap: () => ({}),
-  useMCPServerNames: () => ({}),
+  useMCPIconMap: () => new Map(),
+  useMCPServerNames: () => [],
 }));
 
 jest.mock('../ToolOutput', () => ({
   StackedToolIcons: () => <div data-testid="stacked-tool-icons" />,
+  ToolIcon: ({ type }: { type: string }) => <span data-testid="tool-icon">{type}</span>,
+  getToolIconType: (name: string) => name,
+  getMCPServerName: () => '',
+  OutputRenderer: ({ text, copyText }: { text: string; copyText?: string }) => (
+    <pre data-testid="task-output" data-copy-text={copyText}>
+      {text}
+    </pre>
+  ),
 }));
 
 jest.mock('../MarkdownLite', () => ({
@@ -173,10 +181,109 @@ describe('Wakeup', () => {
     const header = screen.getByRole('button', { name: 'com_ui_wakeup_tasks_finished:2' });
     fireEvent.click(header);
     expect(screen.getByTestId('stacked-tool-icons')).toBeInTheDocument();
-    expect(screen.getByText('com_ui_subagent_thread_status_completed')).toBeInTheDocument();
-    expect(screen.getByText('com_ui_subagent_thread_status_failed')).toBeInTheDocument();
+    expect(screen.getByText('com_ui_background_tasks_completed')).toBeInTheDocument();
+    expect(screen.getByText('com_ui_failed')).toBeInTheDocument();
+    expect(screen.getAllByTestId('background-task-card')).toHaveLength(2);
+    expect(screen.getByText('com_ui_error')).toHaveClass('text-status-error');
+    expect(screen.queryByTestId('markdown')).not.toBeInTheDocument();
     expect(
       screen.queryByRole('button', { name: 'com_ui_wakeup_view_activity' }),
     ).not.toBeInTheDocument();
   });
+
+  it('shows a cancelled background result as a warning with its task details', () => {
+    render(
+      <ChatSurfaceHarness>
+        <RecoilRoot>
+          <Wakeup
+            display={{
+              kind: 'background_tool',
+              tasks: [
+                {
+                  taskId: 'bg-cancelled',
+                  status: 'cancelled',
+                  result: 'The task was stopped.',
+                  toolCallId: 'call-cancelled',
+                  toolName: 'bash_tool',
+                },
+              ],
+            }}
+          />
+        </RecoilRoot>
+      </ChatSurfaceHarness>,
+    );
+    const header = screen.getByRole('button', { name: 'com_ui_wakeup_task_cancelled' });
+    expect(header.querySelector('[role="status"]')).toHaveClass('text-text-warning');
+    fireEvent.click(header);
+    expect(screen.getByTestId('background-task-card')).toHaveTextContent('com_ui_cancelled');
+    expect(screen.getByTestId('task-output')).toHaveTextContent('The task was stopped.');
+  });
+
+  it('shows the originating MCP tool and its server separately', () => {
+    render(
+      <ChatSurfaceHarness>
+        <RecoilRoot>
+          <Wakeup
+            display={{
+              kind: 'background_tool',
+              tasks: [
+                {
+                  taskId: 'bg-mcp',
+                  status: 'completed',
+                  result: 'Found 3 documents.',
+                  toolCallId: 'call-mcp',
+                  toolName: 'search_repository_mcp_Docs',
+                },
+              ],
+            }}
+          />
+        </RecoilRoot>
+      </ChatSurfaceHarness>,
+    );
+    fireEvent.click(screen.getByRole('button', { name: 'com_ui_wakeup_task_finished' }));
+    const card = screen.getByTestId('background-task-card');
+    expect(within(card).getByText('search_repository')).toBeInTheDocument();
+    expect(within(card).getByText('Docs')).toBeInTheDocument();
+    expect(within(card).getByTestId('task-output')).toHaveTextContent('Found 3 documents.');
+  });
+
+  it('renders the code completion as tool output rather than prose or host-internal JSON', () => {
+    const output = 'stdout:\nchecked at=2026-09-27T00:11:09Z\n{"checks":[]}\n[exit code: 0]';
+    render(
+      <ChatSurfaceHarness>
+        <RecoilRoot>
+          <Wakeup
+            display={{
+              kind: 'background_tool',
+              tasks: [
+                {
+                  taskId: 'bg-1',
+                  status: 'completed',
+                  result: output,
+                  toolCallId: 'call-1',
+                  toolName: 'bash_tool',
+                },
+              ],
+            }}
+          />
+        </RecoilRoot>
+      </ChatSurfaceHarness>,
+    );
+
+    const header = screen.getByRole('button', { name: 'com_ui_wakeup_task_finished' });
+    expect(header.parentElement).not.toHaveClass('w-[36rem]');
+    fireEvent.click(header);
+    expect(header.parentElement).toHaveClass('w-[36rem]');
+
+    const card = screen.getByTestId('background-task-card');
+    expect(card).toHaveTextContent('com_ui_tool_name_code');
+    expect(card).toHaveTextContent('com_ui_background_tasks_completed');
+    expect(screen.getByTestId('tool-icon')).toHaveTextContent('bash_tool');
+    expect(screen.getByText('com_ui_output')).toBeInTheDocument();
+    expect(screen.getByTestId('task-output')).toHaveTextContent('"checks": []');
+    expect(screen.getByTestId('task-output').textContent).toContain('{\n  "checks": []\n}');
+    expect(screen.getByTestId('task-output')).toHaveAttribute('data-copy-text', output);
+    expect(screen.queryByText('com_ui_wakeup_explainer')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('markdown')).not.toBeInTheDocument();
+  });
 });
diff --git a/client/src/components/Chat/Messages/Content/live.ts b/client/src/components/Chat/Messages/Content/live.ts
index 78298412db5..216cc2e4c17 100644
--- a/client/src/components/Chat/Messages/Content/live.ts
+++ b/client/src/components/Chat/Messages/Content/live.ts
@@ -39,6 +39,8 @@ export type LiveActivity = {
    *  only while the line is the tool's own generic label, which is the only
    *  thing a count of that tool can modify. */
   comboCount: number;
+  /** The generic line counts checks of a task rather than independent tool actions. */
+  isBackgroundTaskCheck?: boolean;
   /** Failed and stopped calls anywhere in the span, not just the newest line. */
   outcome: SpanOutcome;
 };
@@ -133,6 +135,16 @@ function toolCallLine(
   if (intent != null) {
     return { text: intent, generic: false };
   }
+  if (toolCall.name === Constants.CHECK_BACKGROUND_TASK) {
+    return {
+      text: localize(
+        meta?.hasOutput === true
+          ? 'com_ui_background_tasks_checked'
+          : 'com_ui_background_tasks_checking',
+      ),
+      generic: true,
+    };
+  }
   if (!label) {
     return { text: localize('com_assistants_running_action'), generic: true };
   }
@@ -270,7 +282,10 @@ function newestLine(
   serverNames: readonly string[],
   span: SpanSummary,
   preferLabels: boolean,
-): Pick<LiveActivity, 'text' | 'source' | 'pendingToolCallId' | 'comboCount'> {
+): Pick<
+  LiveActivity,
+  'text' | 'source' | 'pendingToolCallId' | 'comboCount' | 'isBackgroundTaskCheck'
+> {
   for (let position = parts.length - 1; position >= 0; position -= 1) {
     const part = parts[position];
     if (part == null) {
@@ -284,11 +299,19 @@ function newestLine(
        *  repeating a line of it under the reader's eyes is noise, so the
        *  header keeps to the thought's label. */
       const reasoning = typeof part.think === 'string' ? part.think : (part.think?.value ?? '');
-      const sentence = preferLabels ? undefined : lastReasoningSentence(reasoning);
+      const label = part.reasoning_label?.trim();
+      if (preferLabels) {
+        /** Only a generated label will do: the generic thinking line is what
+         *  the grouped thought row itself says. */
+        if (label) {
+          return { text: label, source: `think:${position}`, comboCount: 1 };
+        }
+        continue;
+      }
+      const sentence = lastReasoningSentence(reasoning);
       if (sentence != null) {
         return { text: sentence, source: `think:${position}`, comboCount: 1 };
       }
-      const label = part.reasoning_label?.trim();
       if (label || reasoning.trim()) {
         return {
           text: label || localize('com_ui_thinking'),
@@ -315,6 +338,11 @@ function newestLine(
       return { text: labelText, source: `label:${position}`, comboCount: 1 };
     }
     const toolCall = getStandardToolCall(part);
+    /** A call's line, intent or generic, is the text of its own row, so an
+     *  open card walks past it to the newest label instead. */
+    if (toolCall != null && preferLabels) {
+      continue;
+    }
     if (toolCall != null) {
       const line = toolCallLine(part, toolCall, localize, serverNames, span);
       return {
@@ -327,10 +355,15 @@ function newestLine(
          *  own work, or reports how it ended, the count has nothing left to
          *  multiply and reads as a claim about that sentence. */
         comboCount: line.generic ? Math.max(1, span.trailingToolCount) : 1,
+        ...(toolCall.name === Constants.CHECK_BACKGROUND_TASK && { isBackgroundTaskCheck: true }),
         ...(isAwaitingStartup(part, toolCall, span) && { pendingToolCallId: toolCall.id }),
       };
     }
   }
+  /** An open card with no label yet is titled by a line no row uses. */
+  if (preferLabels && parts.some((part) => part != null)) {
+    return { text: localize('com_ui_running'), source: 'running', comboCount: 1 };
+  }
   return { text: '', source: '', comboCount: 1 };
 }
 
@@ -350,10 +383,11 @@ export function getLiveActivity(
   localize: Localize,
   serverNames: readonly string[],
   attachmentsById?: Record<string, TAttachment[] | undefined>,
-  /** Name the span by its newest LABEL: a thought's generated label or the
-   *  generic thinking line, a batch label, a call's line — never a line of
-   *  reasoning or commentary. For a header whose rows are on screen, where
-   *  quoting them back is repetition. */
+  /** Name the span by its newest generated LABEL alone: a batch label or a
+   *  thought's label, else a generic running line. Never a call's intent, a
+   *  reasoning sentence, commentary or the generic thinking line, since each
+   *  of those is the text of a row. For a header whose rows are on screen,
+   *  where quoting any of them back is repetition. */
   preferLabels = false,
 ): LiveActivity {
   const span = summarizeSpan(parts, attachmentsById);
diff --git a/client/src/components/Chat/Messages/Content/outcome.ts b/client/src/components/Chat/Messages/Content/outcome.ts
index bd855feae67..7b039c0c3fa 100644
--- a/client/src/components/Chat/Messages/Content/outcome.ts
+++ b/client/src/components/Chat/Messages/Content/outcome.ts
@@ -1,4 +1,4 @@
-import { Tools, ContentTypes, ToolCallTypes } from 'librechat-data-provider';
+import { Tools, Constants, ContentTypes, ToolCallTypes } from 'librechat-data-provider';
 import type {
   Agents,
   TAttachment,
@@ -6,6 +6,7 @@ import type {
   FunctionToolCall,
   TMessageContentParts,
 } from 'librechat-data-provider';
+import { backgroundTaskOutcome, parseBackgroundTaskOutput } from './Parts/background';
 import { parseBackgroundHandle, splitBackgroundAttachments } from './Parts/handle';
 import { resolveToolCallPhase } from '~/utils/toolCallPhase';
 import { isMemoryFailureOutput } from './Parts/MemoryCall';
@@ -133,9 +134,13 @@ export function getToolMeta(
     const { backgroundStatus, fileAttachments } = splitBackgroundAttachments(ownAttachments, tc.id);
     const backgroundSettled = backgroundStatus != null || (fileAttachments?.length ?? 0) > 0;
     const backgroundFailed = backgroundHandle != null && backgroundStatus === 'error';
+    const polled =
+      name === Constants.CHECK_BACKGROUND_TASK ? parseBackgroundTaskOutput(tc.output) : null;
+    const polledOutcome = backgroundTaskOutcome(polled);
     const backgroundCancelled =
       tc.backgroundTask?.cancelled === true ||
-      (backgroundHandle != null && backgroundStatus === 'cancelled');
+      (backgroundHandle != null && backgroundStatus === 'cancelled') ||
+      polledOutcome === 'cancelled';
     return {
       name,
       iconName,
@@ -145,7 +150,7 @@ export function getToolMeta(
       ...resolveOutcome(
         backgroundCancelled ? 'cancelled' : runStepStatus,
         completed,
-        failedOutput || backgroundFailed,
+        failedOutput || backgroundFailed || polledOutcome === 'failed',
       ),
     };
   }
diff --git a/client/src/components/Conversations/Conversations.tsx b/client/src/components/Conversations/Conversations.tsx
index f8fc368a5f6..dae11862ef4 100644
--- a/client/src/components/Conversations/Conversations.tsx
+++ b/client/src/components/Conversations/Conversations.tsx
@@ -25,6 +25,7 @@ import {
   useUnpinDroppedConversation,
 } from './dnd';
 import { useLocalize, TranslationKeys, useElementSize, useOuterScrollWindow } from '~/hooks';
+import { groupConversationsWithRunning, RUNNING_CHATS_GROUP } from './running';
 import { groupConversations, cn } from '~/utils';
 import { useActiveJobs } from '~/data-provider';
 import Convo from './Convo';
@@ -159,10 +160,14 @@ const DateLabel: FC<{ groupName: string; isFirst?: boolean; isAlphabetical?: boo
     const displayName = localize(groupName as TranslationKeys) || groupName;
     return (
       <h2
-        aria-label={localize(
-          isAlphabetical ? 'com_a11y_chats_alpha_section' : 'com_a11y_chats_date_section',
-          isAlphabetical ? { letter: displayName } : { date: displayName },
-        )}
+        aria-label={
+          groupName === RUNNING_CHATS_GROUP
+            ? localize('com_a11y_chats_running_section')
+            : localize(
+                isAlphabetical ? 'com_a11y_chats_alpha_section' : 'com_a11y_chats_date_section',
+                isAlphabetical ? { letter: displayName } : { date: displayName },
+              )
+        }
         className={cn('pl-1 pt-1 text-text-secondary', isFirst === true ? 'mt-0' : 'mt-2')}
         style={{ fontSize: '0.7rem' }}
       >
@@ -262,10 +267,17 @@ const Conversations: FC<ConversationsProps> = ({
 
   // Fetch active job IDs for showing generation indicators
   const { data: activeJobsData } = useActiveJobs();
-  const activeJobIds = useMemo(
-    () => new Set(activeJobsData?.activeJobIds ?? []),
-    [activeJobsData?.activeJobIds],
-  );
+  const activeJobIdsRef = useRef<Set<string> | null>(null);
+  const activeJobIds = useMemo(() => {
+    const ids = activeJobsData?.activeJobIds ?? [];
+    const next = new Set(ids);
+    const previous = activeJobIdsRef.current;
+    if (previous && next.size === previous.size && ids.every((id) => previous.has(id))) {
+      return previous;
+    }
+    activeJobIdsRef.current = next;
+    return next;
+  }, [activeJobsData?.activeJobIds]);
 
   const filteredConversations = useMemo(
     () => rawConversations.filter(Boolean) as TConversation[],
@@ -275,7 +287,7 @@ const Conversations: FC<ConversationsProps> = ({
   /** The pinned section above carries pins, so they stay out of these groups — except in
    *  the archive, which that section does not cover: an archived pin would otherwise be
    *  absent from the sidebar entirely rather than merely further down it. */
-  const groupedConversations = useMemo(
+  const datedConversations = useMemo(
     () =>
       groupConversations(filteredConversations, {
         field: sort.field,
@@ -284,6 +296,15 @@ const Conversations: FC<ConversationsProps> = ({
       }),
     [filteredConversations, isArchivedView, sort.direction, sort.field],
   );
+  const groupedConversations = useMemo(
+    () =>
+      groupConversationsWithRunning(datedConversations, activeJobIds, {
+        field: sort.field,
+        direction: sort.direction,
+        includePinned: isArchivedView,
+      }),
+    [datedConversations, activeJobIds, isArchivedView, sort.direction, sort.field],
+  );
 
   /* Pins are stripped from the date groups. An all-pin page leaves the
      virtual list with no rows, so onRowsRendered never fires and later
diff --git a/client/src/components/Conversations/__tests__/Conversations.test.tsx b/client/src/components/Conversations/__tests__/Conversations.test.tsx
index fe196f84d28..5916901cea9 100644
--- a/client/src/components/Conversations/__tests__/Conversations.test.tsx
+++ b/client/src/components/Conversations/__tests__/Conversations.test.tsx
@@ -13,6 +13,7 @@ import store from '~/store';
 /* The section resolves a conversation's project from the query cache, so the
  * tree needs a client even though the data hooks themselves are mocked. */
 const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+let mockActiveJobIds: string[] = [];
 
 jest.mock('react-virtualized', () => {
   const actual = jest.requireActual('react-virtualized');
@@ -80,19 +81,21 @@ jest.mock('@librechat/client', () => ({
 }));
 
 jest.mock('~/data-provider', () => ({
-  useActiveJobs: () => ({ data: undefined }),
+  useActiveJobs: () => ({ data: { activeJobIds: mockActiveJobIds } }),
   useAssignConversationToProjectMutation: () => ({ mutate: jest.fn() }),
   usePinConversationMutation: () => ({ mutate: jest.fn() }),
 }));
 
 jest.mock('~/utils', () => ({
-  groupConversations: () => [],
+  groupConversations: jest.fn(jest.requireActual('~/utils/convos').groupConversations),
   cn: (...args: unknown[]) => args.filter(Boolean).join(' '),
 }));
 
 jest.mock('../Convo', () => ({
   __esModule: true,
-  default: () => <div data-testid="convo" />,
+  default: ({ conversation }: { conversation: TConversation }) => (
+    <div data-testid="convo">{conversation.title}</div>
+  ),
 }));
 
 const pinnedConvo = {
@@ -104,6 +107,77 @@ const pinnedConvo = {
   updatedAt: new Date().toISOString(),
 } as TConversation;
 
+describe('Conversations: live running order', () => {
+  const containerRef = createRef<List>();
+  const newer = {
+    conversationId: 'newer',
+    title: 'Newer idle chat',
+    createdAt: '2026-09-26T00:00:00.000Z',
+    updatedAt: '2026-09-26T00:00:00.000Z',
+  } as TConversation;
+  const running = {
+    conversationId: 'running',
+    title: 'Older running chat',
+    createdAt: '2026-08-01T00:00:00.000Z',
+    updatedAt: '2026-08-01T00:00:00.000Z',
+  } as TConversation;
+
+  afterEach(() => {
+    mockActiveJobIds = [];
+  });
+
+  it('promotes and restores a chat without changing its paged input', () => {
+    const conversations = [newer, running];
+    const renderList = () => (
+      <QueryClientProvider client={queryClient}>
+        <DndProvider backend={HTML5Backend}>
+          <RecoilRoot>
+            <Conversations
+              conversations={conversations}
+              moveToTop={jest.fn()}
+              toggleNav={jest.fn()}
+              containerRef={containerRef}
+              loadMoreConversations={jest.fn()}
+              isLoading={false}
+              isSearchLoading={false}
+              isChatsExpanded={true}
+              setIsChatsExpanded={jest.fn()}
+              scrollViewport={null}
+              scrollContent={null}
+            />
+          </RecoilRoot>
+        </DndProvider>
+      </QueryClientProvider>
+    );
+    const rowOrder = () => screen.getAllByTestId('convo').map((row) => row.textContent);
+
+    const view = render(renderList());
+    const groupConversationsMock = jest.requireMock('~/utils').groupConversations as jest.Mock;
+    groupConversationsMock.mockClear();
+    expect(rowOrder()).toEqual(['Newer idle chat', 'Older running chat']);
+    expect(screen.queryByRole('heading', { name: 'com_a11y_chats_running_section' })).toBeNull();
+
+    mockActiveJobIds = ['running'];
+    view.rerender(renderList());
+    expect(
+      screen.getByRole('heading', { name: 'com_a11y_chats_running_section' }),
+    ).toBeInTheDocument();
+    expect(rowOrder()).toEqual(['Older running chat', 'Newer idle chat']);
+    expect(groupConversationsMock).not.toHaveBeenCalled();
+
+    mockActiveJobIds = ['running'];
+    view.rerender(renderList());
+    expect(groupConversationsMock).not.toHaveBeenCalled();
+    expect(rowOrder()).toEqual(['Older running chat', 'Newer idle chat']);
+
+    mockActiveJobIds = [];
+    view.rerender(renderList());
+    expect(screen.queryByRole('heading', { name: 'com_a11y_chats_running_section' })).toBeNull();
+    expect(rowOrder()).toEqual(['Newer idle chat', 'Older running chat']);
+    expect(conversations).toEqual([newer, running]);
+  });
+});
+
 describe('Conversations: pinned chats live in PinnedSection', () => {
   const containerRef = createRef<List>();
 
diff --git a/client/src/components/Conversations/__tests__/DateLabel.test.tsx b/client/src/components/Conversations/__tests__/DateLabel.test.tsx
index fc5fdb80a59..92857dc8a15 100644
--- a/client/src/components/Conversations/__tests__/DateLabel.test.tsx
+++ b/client/src/components/Conversations/__tests__/DateLabel.test.tsx
@@ -8,6 +8,8 @@ jest.mock('~/hooks', () => ({
     const translations: Record<string, string> = {
       com_a11y_chats_date_section: `Chats from ${params?.date ?? ''}`,
       com_a11y_chats_alpha_section: `Chats with titles starting with ${params?.letter ?? ''}`,
+      com_a11y_chats_running_section: 'Running chats',
+      com_ui_running_chats: 'Running',
       com_ui_date_today: 'Today',
       com_ui_date_yesterday: 'Yesterday',
       com_ui_date_previous_7_days: 'Previous 7 days',
@@ -22,6 +24,13 @@ describe('DateLabel', () => {
     expect(screen.getByRole('heading', { level: 2, name: 'Chats from Today' })).toBeInTheDocument();
   });
 
+  it('announces the running group without describing it as a date', () => {
+    render(<DateLabel groupName="com_ui_running_chats" />);
+    expect(screen.getByRole('heading', { level: 2, name: 'Running chats' })).toHaveTextContent(
+      'Running',
+    );
+  });
+
   it('uses the alphabetical accessible name for title groups', () => {
     render(<DateLabel groupName="A" isAlphabetical />);
     expect(
diff --git a/client/src/components/Conversations/__tests__/running.spec.ts b/client/src/components/Conversations/__tests__/running.spec.ts
new file mode 100644
index 00000000000..42996ed427b
--- /dev/null
+++ b/client/src/components/Conversations/__tests__/running.spec.ts
@@ -0,0 +1,91 @@
+import type { TConversation } from 'librechat-data-provider';
+import type { ConversationGroupOptions } from '~/utils/convos';
+import { groupConversationsWithRunning as partitionGroups, RUNNING_CHATS_GROUP } from '../running';
+import { groupConversations } from '~/utils/convos';
+
+const convo = (conversationId: string, daysAgo: number, pinned = false): TConversation =>
+  ({
+    conversationId,
+    title: conversationId,
+    updatedAt: new Date(Date.now() - daysAgo * 86_400_000).toISOString(),
+    createdAt: new Date(Date.now() - 90 * 86_400_000).toISOString(),
+    pinned,
+  }) as TConversation;
+
+const ids = (groups: ReturnType<typeof groupConversations>) =>
+  groups.flatMap(([, conversations]) => conversations.map((c) => c.conversationId));
+
+const newestFirst = { field: 'updatedAt' as const, direction: 'desc' as const };
+const groupConversationsWithRunning = (
+  conversations: TConversation[],
+  activeJobIds: ReadonlySet<string>,
+  options: ConversationGroupOptions,
+) => partitionGroups(groupConversations(conversations, options), activeJobIds, options);
+
+describe('groupConversationsWithRunning', () => {
+  it('returns the same date groups when the polled jobs do not affect loaded rows', () => {
+    const dated = groupConversations([convo('idle', 1)], newestFirst);
+    expect(partitionGroups(dated, new Set(), newestFirst)).toBe(dated);
+    expect(partitionGroups(dated, new Set(['not-loaded']), newestFirst)).toBe(dated);
+  });
+  it('lifts loaded running chats above newer idle chats without changing the server rows', () => {
+    const newer = convo('newer', 0);
+    const running = convo('running', 45);
+    const older = convo('older', 60);
+    const conversations = [newer, running, older];
+    const snapshot = JSON.stringify(conversations);
+
+    const groups = groupConversationsWithRunning(
+      conversations,
+      new Set(['running', 'not-loaded']),
+      newestFirst,
+    );
+
+    expect(groups[0]).toEqual([RUNNING_CHATS_GROUP, [running]]);
+    expect(ids(groups)).toEqual(['running', 'newer', 'older']);
+    expect(JSON.stringify(conversations)).toBe(snapshot);
+  });
+
+  it('keeps multiple running chats in their fetched order and deduplicates overlapping pages', () => {
+    const older = convo('older', 70);
+    const recent = convo('recent', 2);
+    const pinned = convo('pinned', 1, true);
+    const groups = groupConversationsWithRunning(
+      [recent, pinned, older, recent, older],
+      new Set(['older', 'recent', 'pinned']),
+      newestFirst,
+    );
+
+    expect(groups).toEqual([[RUNNING_CHATS_GROUP, [recent, older]]]);
+    expect(ids(groups)).toEqual(['recent', 'older']);
+  });
+
+  it('restores date grouping as soon as a run finishes', () => {
+    const conversations = [convo('newer', 0), convo('running', 50)];
+    const running = groupConversationsWithRunning(conversations, new Set(['running']), newestFirst);
+    const finished = groupConversationsWithRunning(conversations, new Set(), newestFirst);
+
+    expect(running[0][0]).toBe(RUNNING_CHATS_GROUP);
+    expect(finished).toEqual(groupConversations(conversations, newestFirst));
+    expect(ids(finished)).toEqual(['newer', 'running']);
+  });
+
+  it.each([
+    { field: 'updatedAt' as const, direction: 'asc' as const },
+    { field: 'createdAt' as const, direction: 'desc' as const },
+    { field: 'title' as const, direction: 'asc' as const },
+  ])('respects the explicit $field $direction sort', (options) => {
+    const conversations = [convo('newer', 0), convo('running', 50)];
+    expect(groupConversationsWithRunning(conversations, new Set(['running']), options)).toEqual(
+      groupConversations(conversations, options),
+    );
+  });
+
+  it('keeps archive grouping untouched, including archived pinned rows', () => {
+    const conversations = [convo('newer', 0), convo('pinned', 50, true)];
+    const options = { ...newestFirst, includePinned: true };
+    expect(groupConversationsWithRunning(conversations, new Set(['pinned']), options)).toEqual(
+      groupConversations(conversations, options),
+    );
+  });
+});
diff --git a/client/src/components/Conversations/running.ts b/client/src/components/Conversations/running.ts
new file mode 100644
index 00000000000..9d874ec771d
--- /dev/null
+++ b/client/src/components/Conversations/running.ts
@@ -0,0 +1,39 @@
+import type { TConversation, GroupedConversations } from 'librechat-data-provider';
+import type { ConversationGroupOptions } from '~/utils/convos';
+
+export const RUNNING_CHATS_GROUP = 'com_ui_running_chats';
+
+/** Partition the existing server-ordered groups without re-sorting them on every job update. */
+export function groupConversationsWithRunning(
+  groups: GroupedConversations,
+  activeJobIds: ReadonlySet<string>,
+  options: ConversationGroupOptions,
+): GroupedConversations {
+  if (
+    options.includePinned ||
+    options.field !== 'updatedAt' ||
+    options.direction !== 'desc' ||
+    activeJobIds.size === 0
+  ) {
+    return groups;
+  }
+
+  const running: TConversation[] = [];
+  const remaining: GroupedConversations = [];
+  for (const [groupName, conversations] of groups) {
+    const idle: TConversation[] = [];
+    for (const conversation of conversations) {
+      const id = conversation.conversationId;
+      if (id && activeJobIds.has(id)) {
+        running.push(conversation);
+      } else {
+        idle.push(conversation);
+      }
+    }
+    if (idle.length > 0) {
+      remaining.push([groupName, idle]);
+    }
+  }
+
+  return running.length === 0 ? groups : [[RUNNING_CHATS_GROUP, running], ...remaining];
+}
diff --git a/client/src/hooks/Chat/__tests__/useTokenUsage.spec.tsx b/client/src/hooks/Chat/__tests__/useTokenUsage.spec.tsx
index 9e93a7c061c..442ca2872a8 100644
--- a/client/src/hooks/Chat/__tests__/useTokenUsage.spec.tsx
+++ b/client/src/hooks/Chat/__tests__/useTokenUsage.spec.tsx
@@ -138,6 +138,50 @@ describe('useTokenUsage — post-snapshot output', () => {
     expect(result.current.runwayTurns).toBe(2);
   });
 
+  it('never reports less than the instructions and messages the snapshot breaks down', () => {
+    /** Remaining was measured as if only the 2 message tokens were sent, while the
+     *  same snapshot publishes a 57-token system prompt: 7 used would leave the
+     *  breakdown a negative message share. */
+    const inconsistent = {
+      ...tailSnapshot,
+      remainingContextTokens: 199998,
+      completedOutputTokens: 5,
+      breakdown: { maxContextTokens: 200000, instructionTokens: 57, messageTokens: 2 },
+    } as ContextSnapshot;
+    const { result } = renderTokenUsage(undefined, { snapshot: inconsistent });
+
+    expect(result.current.usedTokens).toBe(57 + 2 + 5);
+  });
+
+  it('includes the summary when a remaining-based count undercuts the breakdown', () => {
+    const inconsistent = {
+      ...tailSnapshot,
+      remainingContextTokens: 199998,
+      completedOutputTokens: 5,
+      breakdown: {
+        ...tailSnapshot.breakdown,
+        instructionTokens: 57,
+        summaryTokens: 11,
+        messageTokens: 2,
+      },
+    } as ContextSnapshot;
+    const { result } = renderTokenUsage(undefined, { snapshot: inconsistent });
+
+    expect(result.current.usedTokens).toBe(57 + 11 + 2 + 5);
+    expect(result.current.usedTokens - 57 - 11).toBe(7);
+  });
+
+  it('keeps the remaining-based count when it exceeds the breakdown', () => {
+    const withSummary = {
+      ...tailSnapshot,
+      breakdown: { ...tailSnapshot.breakdown, summaryTokens: 700 },
+    } as ContextSnapshot;
+    const { result } = renderTokenUsage(undefined, { snapshot: withSummary });
+
+    /** 195000 pre-invoke used covers content the 14700-token breakdown omits. */
+    expect(result.current.usedTokens).toBe(197000);
+  });
+
   it('counts the finalized output in what a summarization could reclaim', () => {
     const { result } = renderTokenUsage();
 
@@ -157,6 +201,20 @@ describe('useTokenUsage — post-snapshot output', () => {
       breakdown: { maxContextTokens: 200000, instructionTokens: 4000, messageTokens },
     }) as unknown as ContextSnapshot;
 
+  const summarizedLegacySnapshot = (): ContextSnapshot => ({
+    ...legacySnapshot(2),
+    anchorMessageId: 'a2',
+    completedOutputTokens: 5,
+    breakdown: { ...legacySnapshot(2).breakdown, instructionTokens: 57, summaryTokens: 11 },
+  });
+
+  it('includes the summary in a snapshot saved without remaining headroom', () => {
+    const { result } = renderTokenUsage(undefined, { snapshot: summarizedLegacySnapshot() });
+
+    expect(result.current.usedTokens).toBe(57 + 11 + 2 + 5);
+    expect(result.current.usedTokens - 57 - 11).toBe(7);
+  });
+
   it('projects a branch whose snapshots predate the remaining-token field', () => {
     /** Both readings are instruction+messages sums — 13000 then 14000, so the
      *  call grew 1000. Reading the absent remaining as zero would score both
@@ -245,6 +303,21 @@ describe('useTokenUsage — post-snapshot output', () => {
     expect(result.current.runwayTurns).toBe(194);
   });
 
+  it('restores the summary in a legacy snapshot saved on the viewed branch', () => {
+    const saved = summarizedLegacySnapshot();
+    const { result } = renderTokenUsage(new Map(), {
+      snapshot: { ...tailSnapshot, anchorMessageId: 'unrelated-branch' },
+      messages: messages.map((message) =>
+        message.messageId === 'a2'
+          ? ({ ...message, metadata: { contextUsage: saved } } as TMessage)
+          : message,
+      ),
+    });
+
+    expect(result.current.snapshot?.anchorMessageId).toBe('a2');
+    expect(result.current.usedTokens).toBe(57 + 11 + 2 + 5);
+  });
+
   it('excludes the retained latest tool result from compaction savings', () => {
     const { result } = renderTokenUsage(undefined, {
       messages: messages.map((message) =>
diff --git a/client/src/hooks/Chat/useTokenUsage.ts b/client/src/hooks/Chat/useTokenUsage.ts
index 96dcf4da471..2af292eb147 100644
--- a/client/src/hooks/Chat/useTokenUsage.ts
+++ b/client/src/hooks/Chat/useTokenUsage.ts
@@ -313,10 +313,17 @@ export default function useTokenUsage({
         effective.remainingContextTokens != null
           ? normalizeTokenCount(effective.remainingContextTokens)
           : null;
+      const breakdownUsed =
+        instructionTokens +
+        normalizeTokenCount(breakdown.summaryTokens) +
+        normalizeTokenCount(breakdown.messageTokens);
+      /** A remaining count measured against a smaller instruction total than the
+       *  snapshot publishes would put used below the instruction and summary
+       *  shares the breakdown subtracts, hiding the Messages row. */
       const baseUsed =
         remainingContextTokens != null
-          ? maxTokens - remainingContextTokens
-          : instructionTokens + normalizeTokenCount(breakdown.messageTokens);
+          ? Math.max(maxTokens - remainingContextTokens, breakdownUsed)
+          : breakdownUsed;
       /** The snapshot is pre-invoke: in-flight output rides on `liveTokens` (0
        *  unless streaming this branch), the last call's finalized output on
        *  `completedOutputTokens`, and retained tool results on
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 2e177591972..2ae5ecd7f34 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -1,12 +1,23 @@
 {
   "com_ui_background_tasks": "Background tasks",
   "com_ui_background_tasks_cancel_disabled": "Stopping background tools is not enabled on this server",
+  "com_ui_background_tasks_checked": "Checked background tasks",
+  "com_ui_background_tasks_checking": "Checking background tasks",
   "com_ui_background_tasks_completed": "Completed",
+  "com_ui_background_tasks_control_not_found": "Control not found",
+  "com_ui_background_tasks_control_queued": "Control queued",
+  "com_ui_background_tasks_empty": "No background tasks yet",
   "com_ui_background_tasks_failed_label": "Background tasks, {{0}} results not delivered",
   "com_ui_background_tasks_finished": "Finished",
   "com_ui_background_tasks_incomplete": "Some background results may not be shown. Check again later.",
   "com_ui_background_tasks_label": "Background tasks, {{0}} running",
+  "com_ui_background_tasks_n_checks": "{{0}} checks",
+  "com_ui_background_tasks_no_output": "No output returned",
+  "com_ui_background_tasks_not_running": "No longer running",
   "com_ui_background_tasks_pending_label": "Background tasks, {{0}} results pending",
+  "com_ui_background_tasks_raw_details": "Raw task details",
+  "com_ui_background_tasks_result_available": "Result available on request",
+  "com_ui_background_tasks_result_claimed": "Result claimed",
   "com_ui_background_tasks_result_pending": "Result pending",
   "com_ui_background_tasks_result_undelivered": "Result not delivered",
   "com_ui_background_tasks_running": "Running",
@@ -17,6 +28,30 @@
   "com_ui_background_tasks_load_failed": "Could not load all tasks. The list may be incomplete. Try again.",
   "com_ui_background_tasks_stopping": "Stopping…",
   "com_ui_background_tasks_subagent": "Subagent",
+  "com_ui_background_tasks_artifact_not_inline": "This task produced an artifact that is not shown here.",
+  "com_ui_background_tasks_cancellation_requested": "Cancellation requested. The task may still be running; check again for its final status.",
+  "com_ui_background_tasks_failed_delivery_guidance": "Automatic delivery failed. Poll each affected task to collect its result; it will not arrive as a new turn.",
+  "com_ui_background_tasks_failed_delivery_note": "Automatic delivery failed. Poll this task to collect its result; it will not arrive as a new turn.",
+  "com_ui_background_tasks_files_attached": "Generated files are attached to the original tool call.",
+  "com_ui_background_tasks_files_attaching": "Output and generated files are being attached to the original tool call.",
+  "com_ui_background_tasks_more_in_raw_details": "More information in raw task details.",
+  "com_ui_background_tasks_notice_delivery_scheduled": "Result assigned to another poll or automatic delivery. It may still arrive as a new turn.",
+  "com_ui_background_tasks_notice_discard_unavailable": "Could not discard the pending result. It may still arrive as a new turn; try again shortly.",
+  "com_ui_background_tasks_notice_error": "The background-task check failed. See raw task details.",
+  "com_ui_background_tasks_notice_invalid": "Invalid background-task request. Check the task ID or control arguments.",
+  "com_ui_background_tasks_notice_not_found": "No background task with that ID was found in this conversation.",
+  "com_ui_background_tasks_notice_outcome_unknown": "The task's outcome is unknown. Inspect the target system before repeating an action.",
+  "com_ui_background_tasks_notice_rejected": "The request was rejected. Check raw details before trying again.",
+  "com_ui_background_tasks_notice_result_persisting": "The result is being saved or recovered. Check again shortly; do not rerun the task.",
+  "com_ui_background_tasks_notice_result_unavailable": "The result is temporarily unavailable. Check again later; do not automatically repeat a mutating action.",
+  "com_ui_background_tasks_notice_subagent_only": "This control action is available only for subagent tasks.",
+  "com_ui_background_tasks_notice_unavailable": "Task or control temporarily unavailable. Check again; do not assume the task stopped or its result will not arrive.",
+  "com_ui_background_tasks_pending_delivery_guidance": "Finished results are pending delivery. Poll to collect now or wait for the agent to resume; do not treat them as delivered yet.",
+  "com_ui_background_tasks_pending_delivery_note": "Result pending delivery. It may still arrive as a new turn; poll to collect it sooner.",
+  "com_ui_background_tasks_result_discarded": "Finished result discarded. It will not arrive as a new turn.",
+  "com_ui_background_tasks_running_elsewhere": "Still running outside this turn. Its result may arrive as a new turn.",
+  "com_ui_background_tasks_subagent_pending_guidance": "Finished subagent results are pending delivery. Poll to collect now or wait for the agent to resume.",
+  "com_ui_background_tasks_subagent_wakeup_guidance": "This subagent will automatically resume the agent when it finishes; there is no need to poll it repeatedly.",
   "com_ui_repository_instructions": "Repository instructions",
   "com_ui_repository_instructions_prefer": "Prefer repository conventions",
   "com_ui_repository_instructions_defer": "Prefer agent conventions",
@@ -92,6 +127,7 @@
   "com_a11y_ai_composing": "The AI is still composing.",
   "com_a11y_chats_date_section": "Chats from {{date}}",
   "com_a11y_chats_alpha_section": "Chats with titles starting with {{letter}}",
+  "com_a11y_chats_running_section": "Running chats",
   "com_a11y_end": "The AI has finished their reply.",
   "com_a11y_selected": "selected",
   "com_a11y_start": "The AI has started their reply.",
@@ -2126,6 +2162,7 @@
   "com_ui_run_code": "Run Code",
   "com_ui_run_code_error": "There was an error running the code",
   "com_ui_running": "Running...",
+  "com_ui_running_chats": "Running",
   "com_ui_running_command": "Running command",
   "com_ui_running_n_actions": "Running {{0}} actions",
   "com_ui_running_n_agents": "Running {{0}} agents",
@@ -2892,10 +2929,11 @@
   "com_ui_versions": "Versions",
   "com_ui_via_server": "in {{0}}",
   "com_ui_view_memory": "View Memory",
-  "com_ui_wakeup_explainer": "This durable result woke the agent to continue the conversation.",
+  "com_ui_wakeup_explainer": "The agent continued with this result.",
   "com_ui_wakeup_subagent_cancelled": "Subagent task cancelled",
   "com_ui_wakeup_subagent_completed": "Subagent task completed",
   "com_ui_wakeup_subagent_errored": "Subagent task failed",
+  "com_ui_wakeup_task_cancelled": "Background task cancelled",
   "com_ui_wakeup_task_errored": "Background task failed",
   "com_ui_wakeup_task_finished": "Background task finished",
   "com_ui_wakeup_tasks_finished": "{{0}} background tasks finished",
diff --git a/client/src/utils/__tests__/toolLabels.test.ts b/client/src/utils/__tests__/toolLabels.test.ts
index e0d1f9ee441..0b96db80241 100644
--- a/client/src/utils/__tests__/toolLabels.test.ts
+++ b/client/src/utils/__tests__/toolLabels.test.ts
@@ -74,6 +74,18 @@ describe('getToolDisplayLabel', () => {
     );
   });
 
+  it('uses the background task label for the native poll tool, not an MCP tool with that name', () => {
+    expect(getToolDisplayLabel(Constants.CHECK_BACKGROUND_TASK, identityLocalize)).toBe(
+      'com_ui_background_tasks',
+    );
+    expect(
+      getToolDisplayLabel(
+        `${Constants.CHECK_BACKGROUND_TASK}${Constants.mcp_delimiter}remote`,
+        identityLocalize,
+      ),
+    ).toBe('remote');
+  });
+
   it.each(['set_memory', 'delete_memory'])('returns a friendly memory label for %s', (toolName) => {
     expect(getToolDisplayLabel(toolName, identityLocalize)).toBe(TOOL_FRIENDLY_NAME_KEYS[toolName]);
   });
diff --git a/client/src/utils/tokens.spec.ts b/client/src/utils/tokens.spec.ts
index 6f5dcef76d2..ddac55b6351 100644
--- a/client/src/utils/tokens.spec.ts
+++ b/client/src/utils/tokens.spec.ts
@@ -1016,14 +1016,19 @@ describe('per-message usage index (branch + total)', () => {
         'a1',
         {
           contextBudget: 1000,
-          breakdown: { maxContextTokens: 1000, instructionTokens: 100, messageTokens: 60 },
+          breakdown: {
+            maxContextTokens: 1000,
+            instructionTokens: 100,
+            summaryTokens: 25,
+            messageTokens: 60,
+          },
         },
       ],
       /** Nothing to read at all — skipped rather than counted as a full window. */
       ['a2', { contextBudget: 1000, breakdown: { maxContextTokens: 1000 } }],
     ]);
 
-    expect(collectAnchorSeries(CONVO, 'a2', anchors)).toEqual([{ used: 160, basis: 'breakdown' }]);
+    expect(collectAnchorSeries(CONVO, 'a2', anchors)).toEqual([{ used: 185, basis: 'breakdown' }]);
   });
 
   it('latestExchangeTokens sums the tail response and its user turn', () => {
diff --git a/client/src/utils/tokens.ts b/client/src/utils/tokens.ts
index c7205e15d1e..e3fc8d50a32 100644
--- a/client/src/utils/tokens.ts
+++ b/client/src/utils/tokens.ts
@@ -547,7 +547,7 @@ export function prunedBranchTokens(
 /**
  * One persisted snapshot's used-context reading, with the basis it was measured
  * on. `remaining` is the authoritative pre-invoke figure (`budget − remaining`);
- * `breakdown` is the instruction+messages sum a snapshot saved before
+ * `breakdown` is the instructions+summary+messages sum a snapshot saved before
  * `remainingContextTokens` existed still supports. The two measure different
  * quantities (the backend's remaining covers content the breakdown does not),
  * so a growth delta may only compare readings of the same basis.
@@ -615,8 +615,8 @@ export function collectAnchorSeries(
         snapshot.contextBudget ?? snapshot.breakdown?.maxContextTokens,
       );
       const configuration = snapshotConfiguration(snapshot);
-      /** Same precedence as the render path's `baseUsed`: the backend's
-       *  remaining headroom when it was saved, else the breakdown sum. */
+      /** Runway growth keeps the raw remaining basis, even if the gauge floors
+       *  that reading to the breakdown; older snapshots use all breakdown parts. */
       if (snapshot.remainingContextTokens != null && budget > 0) {
         const remaining = normalizeTokenCount(snapshot.remainingContextTokens);
         series.push({ used: Math.max(0, budget - remaining), basis: 'remaining', configuration });
@@ -624,7 +624,9 @@ export function collectAnchorSeries(
         const used =
           normalizeTokenCount(
             snapshot.effectiveInstructionTokens ?? snapshot.breakdown?.instructionTokens,
-          ) + normalizeTokenCount(snapshot.breakdown?.messageTokens);
+          ) +
+          normalizeTokenCount(snapshot.breakdown?.summaryTokens) +
+          normalizeTokenCount(snapshot.breakdown?.messageTokens);
         if (used > 0) {
           series.push({ used, basis: 'breakdown', configuration });
         }
diff --git a/client/src/utils/toolLabels.ts b/client/src/utils/toolLabels.ts
index d0dbe41c2af..190df413bf3 100644
--- a/client/src/utils/toolLabels.ts
+++ b/client/src/utils/toolLabels.ts
@@ -14,6 +14,7 @@ export const TOOL_FRIENDLY_NAME_KEYS: Record<string, TranslationKeys> = {
   run_tools_with_code: 'com_ui_tool_name_code',
   run_tools_with_bash: 'com_ui_tool_name_code',
   bash_tool: 'com_ui_tool_name_code',
+  [Constants.CHECK_BACKGROUND_TASK]: 'com_ui_background_tasks',
   web_search: 'com_ui_tool_name_web_search',
   image_gen_oai: 'com_ui_tool_name_image_gen',
   image_edit_oai: 'com_ui_tool_name_image_edit',
diff --git a/e2e/specs/mock/activity-thought.spec.ts b/e2e/specs/mock/activity-thought.spec.ts
index 8890ce60f37..3e566689f24 100644
--- a/e2e/specs/mock/activity-thought.spec.ts
+++ b/e2e/specs/mock/activity-thought.spec.ts
@@ -57,7 +57,9 @@ test.describe('live reasoning', () => {
         if (process.env.E2E_FOLD_SHOTS) {
           await page.screenshot({ path: `${process.env.E2E_FOLD_SHOTS}/thought-open.png` });
         }
-        expect(open, 'open card title').not.toMatch(/[a-z]\.$/);
+        /** No label has landed on this span, so the open card takes the
+         *  generic running line, never a sentence of the thought below. */
+        expect(open, 'open card title').toBe('Running...');
         expect(await messagesView(page).getByTestId('streaming-thought-peek').count()).toBe(0);
       }
     }
diff --git a/packages/api/src/agents/openai/README.md b/packages/api/src/agents/openai/README.md
index a2bbc248994..d9cb6b293b6 100644
--- a/packages/api/src/agents/openai/README.md
+++ b/packages/api/src/agents/openai/README.md
@@ -59,7 +59,7 @@ Missing names, missing arguments, malformed JSON or unattributable argument data
 
 ## Accepted-result terminal behavior
 
-The SDK projector accepts only client-disposition calls from graph-accepted responses. A newer accepted text/internal result or a model-tool claim discards superseded calls for that agent. Calls are validated, given unique outward IDs and emitted at successful response completion; failed or aborted runs never publish buffered calls. Internal tools followed by a text answer finish with `stop` and no outward calls. The shared response builders use `tool_calls` as the finish reason when client calls exist without text.
+The SDK projector accepts only client-disposition calls from graph-accepted responses. A newer accepted text/internal result or a model-tool claim discards superseded calls for that agent. Calls are validated, given unique outward IDs and emitted at successful response completion; failed or aborted runs never publish buffered calls. Internal tools followed by a text answer finish with `stop` and no outward calls. Both in-repo hosts explicitly mark the SDK map as accepted-only when calling the shared serializers: if any accepted client calls remain, the final reason is `tool_calls`, even when text was already emitted. Compatibility consumers of the legacy run-step projector retain the previous `stop` finish reason for historical calls followed by text.
 
 ## Verification and limits
 
diff --git a/packages/api/src/agents/openai/handlers.spec.ts b/packages/api/src/agents/openai/handlers.spec.ts
index 1a3edca37ae..59a1d15c58f 100644
--- a/packages/api/src/agents/openai/handlers.spec.ts
+++ b/packages/api/src/agents/openai/handlers.spec.ts
@@ -50,13 +50,18 @@ describe('OpenAI-compatible agent stream handlers', () => {
         invalidToolCalls: [],
       });
       expect(frames).toHaveLength(3);
-      sendFinalChunk(config, 'stop', {
-        prompt_tokens: 12,
-        completion_tokens: 3,
-        total_tokens: 15,
-        primary: { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 },
-        subagent: { prompt_tokens: 2, completion_tokens: 1, total_tokens: 3 },
-      });
+      sendFinalChunk(
+        config,
+        'stop',
+        {
+          prompt_tokens: 12,
+          completion_tokens: 3,
+          total_tokens: 15,
+          primary: { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 },
+          subagent: { prompt_tokens: 2, completion_tokens: 1, total_tokens: 3 },
+        },
+        true,
+      );
       return frames;
     };
 
@@ -75,7 +80,7 @@ describe('OpenAI-compatible agent stream handlers', () => {
       },
       {},
     ]);
-    expect(chunks[chunks.length - 1].choices[0].finish_reason).toBe('stop');
+    expect(chunks[chunks.length - 1].choices[0].finish_reason).toBe('tool_calls');
     expect(chunks[chunks.length - 1].usage).toMatchObject({
       total_tokens: 15,
       subagent: { total_tokens: 3 },
diff --git a/packages/api/src/agents/openai/handlers.ts b/packages/api/src/agents/openai/handlers.ts
index 69643326dd9..550c14b0f78 100644
--- a/packages/api/src/agents/openai/handlers.ts
+++ b/packages/api/src/agents/openai/handlers.ts
@@ -807,14 +807,16 @@ export function sendFinalChunk(
   config: OpenAIContentStreamConfig,
   finishReason: ChatCompletionChunkChoice['finish_reason'] = 'stop',
   usageOverride?: CompletionUsage,
+  /** True when the map contains only accepted client-owned calls, not legacy run-step history. */
+  acceptedToolCallsOnly = false,
 ): void {
   const { context, tracker } = config;
   const writer = getStreamWriter(config);
   tracker.finishToolCalls?.();
 
-  // Determine finish reason based on content
+  // Legacy run-step history followed by text stays 'stop'; accepted client calls must be executed.
   let reason = finishReason;
-  if (tracker.toolCalls.size > 0 && !tracker.hasText) {
+  if (tracker.toolCalls.size > 0 && (acceptedToolCallsOnly || !tracker.hasText)) {
     reason = 'tool_calls';
   }
 
diff --git a/packages/api/src/agents/openai/service.spec.ts b/packages/api/src/agents/openai/service.spec.ts
index d37b0582336..852e1418aa3 100644
--- a/packages/api/src/agents/openai/service.spec.ts
+++ b/packages/api/src/agents/openai/service.spec.ts
@@ -161,6 +161,60 @@ describe('createAgentChatCompletion - MCP permission user propagation', () => {
     },
   );
 
+  it.each([true, false])(
+    'finishes with tool_calls when an accepted client call follows text (stream=%s)',
+    async (stream) => {
+      const req = createMockReq(
+        { id: 'user' },
+        { model: 'agent_test', messages: [{ role: 'user', content: 'hi' }], stream },
+      );
+      const res = createMockRes();
+      processStream.mockImplementationOnce(async () => {
+        const { customHandlers: handlers } = createRun.mock.calls[0][0] as Parameters<
+          NonNullable<ChatCompletionDependencies['createRun']>
+        >[0];
+        await handlers.on_message_delta.handle('on_message_delta', {
+          delta: { content: [{ type: 'text', text: 'Checking the weather.' }] },
+        });
+        await handlers.on_model_response.handle('on_model_response', {
+          type: 'model_response',
+          id: 'accepted-client',
+          agentId: 'agent_test',
+          toolCalls: [{ id: 'client', name: 'lookup', args: { city: 'Madrid' } }],
+          toolCallDispositions: ['client'],
+          invalidToolCalls: [],
+        });
+      });
+
+      await createAgentChatCompletion(req, res, deps);
+
+      if (stream) {
+        const chunks: ChatCompletionChunk[] = (res.write as jest.Mock).mock.calls
+          .map(([frame]: [string]) => frame)
+          .filter((frame) => frame !== 'data: [DONE]\n\n')
+          .map((frame) => JSON.parse(frame.slice(6)));
+        expect(
+          chunks.some((chunk) => chunk.choices[0].delta.content === 'Checking the weather.'),
+        ).toBe(true);
+        expect(
+          chunks
+            .flatMap((chunk) => chunk.choices[0].delta.tool_calls ?? [])
+            .some((call) => call.id === 'client'),
+        ).toBe(true);
+        expect(chunks[chunks.length - 1].choices[0].finish_reason).toBe('tool_calls');
+      } else {
+        const response = getResponseMock(res, 'json').mock.calls[0][0] as {
+          choices: [
+            { message: { content: string; tool_calls: [{ id: string }] }; finish_reason: string },
+          ];
+        };
+        expect(response.choices[0].message.content).toBe('Checking the weather.');
+        expect(response.choices[0].message.tool_calls[0].id).toBe('client');
+        expect(response.choices[0].finish_reason).toBe('tool_calls');
+      }
+    },
+  );
+
   it.each([true, false])(
     'does not publish fallback arguments after provider failure (stream=%s)',
     async (stream) => {
diff --git a/packages/api/src/agents/openai/service.ts b/packages/api/src/agents/openai/service.ts
index 6d4204eb501..71a061b2cf3 100644
--- a/packages/api/src/agents/openai/service.ts
+++ b/packages/api/src/agents/openai/service.ts
@@ -570,9 +570,12 @@ export function buildNonStreamingResponse(
   reasoning: string,
   toolCalls: Map<number, ToolCall>,
   usage: CompletionUsage,
+  /** True when the map contains only accepted client-owned calls, not legacy run-step history. */
+  acceptedToolCallsOnly = false,
 ): ChatCompletionResponse {
   const toolCallsArray = Array.from(toolCalls.values());
-  const finishReason = toolCallsArray.length > 0 && !text ? 'tool_calls' : 'stop';
+  const finishReason =
+    toolCallsArray.length > 0 && (acceptedToolCallsOnly || !text) ? 'tool_calls' : 'stop';
 
   return {
     id: context.requestId,
@@ -920,7 +923,7 @@ export async function createAgentChatCompletion(
 
     // Finalize response
     if (isStreaming && handlerConfig) {
-      sendFinalChunk(handlerConfig);
+      sendFinalChunk(handlerConfig, 'stop', undefined, true);
       res.end();
     } else if (aggregator) {
       aggregator.finishToolCalls?.();
@@ -939,6 +942,7 @@ export async function createAgentChatCompletion(
         aggregator.getReasoning(),
         aggregator.toolCalls,
         usage,
+        true,
       );
       res.json(response);
     }
diff --git a/packages/api/src/app/index.ts b/packages/api/src/app/index.ts
index bd924896ebc..52e45da305a 100644
--- a/packages/api/src/app/index.ts
+++ b/packages/api/src/app/index.ts
@@ -1,4 +1,5 @@
 export * from './service';
+export * from './loader';
 export * from './config';
 export * from './metrics';
 export * from './permissions';
diff --git a/packages/api/src/app/loader.ts b/packages/api/src/app/loader.ts
new file mode 100644
index 00000000000..6365450c4ea
--- /dev/null
+++ b/packages/api/src/app/loader.ts
@@ -0,0 +1,331 @@
+import axios from 'axios';
+import yaml from 'js-yaml';
+import { Providers } from '@librechat/agents';
+import { logger } from '@librechat/data-schemas';
+import {
+  configSchema,
+  paramSettings,
+  EModelEndpoint,
+  EImageOutputType,
+  getMaxSubagents,
+  setMaxSubagents,
+  agentParamSettings,
+  validateSettingDefinitions,
+} from 'librechat-data-provider';
+import type { TCustomConfig, TEndpoint } from 'librechat-data-provider';
+import type { ZodIssue } from 'zod';
+
+type CustomParams = NonNullable<TEndpoint['customParams']>;
+type CustomParamDefinition = NonNullable<CustomParams['paramDefinitions']>[number];
+
+export type CustomConfigLoadMode = 'startup' | 'reload';
+
+export interface CustomConfigLoadOptions {
+  mode?: CustomConfigLoadMode;
+}
+
+export interface CustomConfigLoaderOptions {
+  defaultConfigPath: string;
+  loadLocal: (configPath: string) => unknown;
+  fetchRemote?: (configPath: string) => Promise<unknown>;
+  redactConfig: (config: TCustomConfig) => TCustomConfig;
+}
+
+export class ConfigReloadError extends Error {
+  readonly validationErrors?: readonly ZodIssue[];
+  override readonly cause?: unknown;
+
+  constructor(message: string, cause?: unknown, validationErrors?: readonly ZodIssue[]) {
+    super(message);
+    this.name = 'ConfigReloadError';
+    this.cause = cause;
+    this.validationErrors = validationErrors;
+  }
+}
+
+const OPENROUTER_PROMPT_CACHE_DEFAULT = {
+  key: 'promptCache',
+  default: true,
+};
+
+function includesOpenRouter(value: string | undefined): boolean {
+  return typeof value === 'string' && value.toLowerCase().includes(Providers.OPENROUTER);
+}
+
+function isOpenRouterEndpoint(endpoint: TEndpoint): boolean {
+  return includesOpenRouter(endpoint.name) || includesOpenRouter(endpoint.baseURL);
+}
+
+function shouldPreserveCustomParams(customParams: CustomParams | undefined): boolean {
+  const defaultEndpoint = customParams?.defaultParamsEndpoint;
+  return (
+    !!defaultEndpoint && defaultEndpoint !== 'custom' && defaultEndpoint !== Providers.OPENROUTER
+  );
+}
+
+function addOpenRouterDefaults(endpoint: TEndpoint): void {
+  if (!isOpenRouterEndpoint(endpoint) || shouldPreserveCustomParams(endpoint.customParams)) {
+    return;
+  }
+
+  const customParams: CustomParams = endpoint.customParams ?? {
+    defaultParamsEndpoint: 'custom',
+  };
+  const paramDefinitions = customParams.paramDefinitions ?? [];
+  const hasPromptCache = paramDefinitions.some((param) => param.key === 'promptCache');
+
+  endpoint.customParams = {
+    ...customParams,
+    defaultParamsEndpoint: Providers.OPENROUTER,
+    paramDefinitions: hasPromptCache
+      ? paramDefinitions
+      : [...paramDefinitions, OPENROUTER_PROMPT_CACHE_DEFAULT],
+  };
+}
+
+function getConfiguredMaxSubagents(config: unknown): number | undefined {
+  if (typeof config !== 'object' || config == null || !('endpoints' in config)) {
+    return undefined;
+  }
+  const endpoints = config.endpoints;
+  if (typeof endpoints !== 'object' || endpoints == null || !(EModelEndpoint.agents in endpoints)) {
+    return undefined;
+  }
+  const agents = endpoints[EModelEndpoint.agents];
+  if (typeof agents !== 'object' || agents == null || !('maxSubagents' in agents)) {
+    return undefined;
+  }
+  return typeof agents.maxSubagents === 'number' ? agents.maxSubagents : undefined;
+}
+
+function parseCustomParams(endpointName: string | undefined, customParams: CustomParams): void {
+  const paramEndpoint = customParams.defaultParamsEndpoint ?? 'custom';
+  customParams.defaultParamsEndpoint = paramEndpoint;
+  const paramDefinitions = customParams.paramDefinitions ?? [];
+  customParams.paramDefinitions = paramDefinitions;
+
+  const validEndpoints = new Set([
+    ...Object.keys(paramSettings),
+    ...Object.keys(agentParamSettings),
+  ]);
+  if (!validEndpoints.has(paramEndpoint)) {
+    throw new Error(
+      `defaultParamsEndpoint of "${endpointName}" endpoint is invalid. ` +
+        `Valid options are ${Array.from(validEndpoints).join(', ')}`,
+    );
+  }
+
+  const regularParams = paramSettings[paramEndpoint] ?? [];
+  const agentParams = agentParamSettings[paramEndpoint] ?? [];
+  const defaultParams = regularParams.concat(agentParams);
+  const defaultParamsMap = new Map(
+    defaultParams.map((param) => [param.key, param as CustomParamDefinition]),
+  );
+  const invalidKeys = paramDefinitions
+    .map((param) => param.key)
+    .filter((key) => !defaultParamsMap.has(key));
+  if (invalidKeys.length > 0) {
+    throw new Error(
+      `paramDefinitions of "${endpointName}" endpoint contains invalid key(s). ` +
+        `Valid parameter keys are ${Array.from(defaultParamsMap.keys()).join(', ')}`,
+    );
+  }
+
+  const parsedDefinitions = paramDefinitions.map((param) => ({
+    ...defaultParamsMap.get(param.key),
+    ...param,
+    optionType: 'custom',
+  })) as CustomParamDefinition[];
+  customParams.paramDefinitions = parsedDefinitions;
+
+  try {
+    validateSettingDefinitions(
+      parsedDefinitions as Parameters<typeof validateSettingDefinitions>[0],
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Custom parameter definitions for "${endpointName}" endpoint is malformed: ${message}`,
+    );
+  }
+}
+
+function isRemoteConfigPath(configPath: string): boolean {
+  return /^https?:\/\//.test(configPath);
+}
+
+/** Creates one process-local custom-config reader. */
+export function createCustomConfigLoader({
+  defaultConfigPath,
+  loadLocal,
+  redactConfig,
+  fetchRemote = async (configPath: string): Promise<unknown> => (await axios.get(configPath)).data,
+}: CustomConfigLoaderOptions): (
+  printConfig?: boolean,
+  options?: CustomConfigLoadOptions,
+) => Promise<TCustomConfig | null> {
+  let hasLoggedSourceFailure = false;
+
+  return async function loadCustomConfig(
+    printConfig = true,
+    options: CustomConfigLoadOptions = {},
+  ): Promise<TCustomConfig | null> {
+    const mode = options.mode ?? 'startup';
+    const configPath = process.env.CONFIG_PATH || defaultConfigPath;
+    const previousMaxSubagents = getMaxSubagents();
+    let loadedSuccessfully = false;
+
+    const failSourceLoad = (
+      message: string,
+      cause?: unknown,
+      startupLogLevel: 'error' | 'info' = 'error',
+    ): null => {
+      if (mode === 'reload') {
+        if (cause == null) {
+          logger.error(message);
+        } else {
+          logger.error(message, cause);
+        }
+        throw new ConfigReloadError(message, cause);
+      }
+      if (!hasLoggedSourceFailure) {
+        if (startupLogLevel === 'error') {
+          logger.error(message, cause);
+        } else if (cause == null) {
+          logger.info(message);
+        } else {
+          logger.info(message, cause);
+        }
+        hasLoggedSourceFailure = true;
+      }
+      return null;
+    };
+
+    try {
+      let loadedConfig: unknown;
+      if (isRemoteConfigPath(configPath)) {
+        try {
+          loadedConfig = await fetchRemote(configPath);
+        } catch (error) {
+          return failSourceLoad(`Failed to fetch the remote config file from ${configPath}`, error);
+        }
+      } else {
+        loadedConfig = loadLocal(configPath);
+        if (!loadedConfig) {
+          return failSourceLoad(
+            'Custom config file missing or YAML format invalid.\n\n' +
+              'Check out the latest config file guide for configurable options and features.\n' +
+              'https://www.librechat.ai/docs/configuration/librechat_yaml\n\n',
+            undefined,
+            'info',
+          );
+        }
+        if (
+          loadedConfig instanceof Error ||
+          (typeof loadedConfig === 'object' &&
+            loadedConfig != null &&
+            ('reason' in loadedConfig || 'stack' in loadedConfig))
+        ) {
+          return failSourceLoad('Config file YAML format is invalid:', loadedConfig);
+        }
+      }
+
+      if (typeof loadedConfig === 'string') {
+        try {
+          loadedConfig = yaml.load(loadedConfig);
+        } catch (error) {
+          return failSourceLoad(
+            `Failed to parse the YAML config from ${configPath}`,
+            error,
+            'info',
+          );
+        }
+      }
+
+      setMaxSubagents(getConfiguredMaxSubagents(loadedConfig));
+      const result = configSchema.strict().safeParse(loadedConfig);
+      if (
+        result.error?.errors.some(
+          (error) => error.path != null && error.path.includes('imageOutputType'),
+        )
+      ) {
+        throw new Error(
+          `\nPlease specify a correct \`imageOutputType\` value (case-sensitive).\n\n` +
+            'The available options are:\n' +
+            `- ${EImageOutputType.JPEG}\n` +
+            `- ${EImageOutputType.PNG}\n` +
+            `- ${EImageOutputType.WEBP}\n\n` +
+            'Refer to the latest config file guide for more information:\n' +
+            'https://www.librechat.ai/docs/configuration/librechat_yaml',
+        );
+      }
+      if (!result.success) {
+        const message = `Invalid custom config file at ${configPath}:\n${JSON.stringify(result.error, null, 2)}`;
+        logger.error(message);
+        const speechError = result.error.errors.find(
+          (error) =>
+            error.code === 'unrecognized_keys' &&
+            (error.message?.includes('stt') || error.message?.includes('tts')),
+        );
+        if (speechError) {
+          logger.warn(
+            '\nThe Speech-to-text and Text-to-speech configuration format has recently changed.\n' +
+              "If you're getting this error, please refer to the latest documentation:\n\n" +
+              'https://www.librechat.ai/docs/configuration/stt_tts',
+          );
+        }
+
+        if (process.env.CONFIG_BYPASS_VALIDATION === 'true') {
+          logger.warn(
+            'CONFIG_BYPASS_VALIDATION is enabled. Continuing with default configuration despite validation errors.',
+          );
+          if (mode === 'reload') {
+            throw new ConfigReloadError(message, result.error, result.error.errors);
+          }
+          return null;
+        }
+        if (mode === 'reload') {
+          throw new ConfigReloadError(message, result.error, result.error.errors);
+        }
+
+        logger.error(
+          'Exiting due to invalid configuration. Set CONFIG_BYPASS_VALIDATION=true to bypass this check.',
+        );
+        process.exit(1);
+      }
+
+      const customConfig = loadedConfig as TCustomConfig;
+      const customEndpoints = (customConfig.endpoints?.custom ?? []) as TEndpoint[];
+      for (const endpoint of customEndpoints) {
+        addOpenRouterDefaults(endpoint);
+      }
+      for (const endpoint of customEndpoints) {
+        if (endpoint.customParams) {
+          parseCustomParams(endpoint.name, endpoint.customParams);
+        }
+      }
+      if (result.data.modelSpecs) {
+        customConfig.modelSpecs = result.data.modelSpecs;
+      }
+
+      if (printConfig) {
+        const loggableConfig = redactConfig(customConfig);
+        logger.info('Custom config file loaded:');
+        logger.info(JSON.stringify(loggableConfig, null, 2));
+        logger.debug('Custom config:', loggableConfig);
+      }
+
+      loadedSuccessfully = true;
+      return customConfig;
+    } catch (error) {
+      if (mode === 'reload' && !(error instanceof ConfigReloadError)) {
+        throw new ConfigReloadError(`Failed to reload custom config from ${configPath}`, error);
+      }
+      throw error;
+    } finally {
+      if (!loadedSuccessfully) {
+        setMaxSubagents(previousMaxSubagents);
+      }
+    }
+  };
+}
diff --git a/packages/api/src/app/service.spec.ts b/packages/api/src/app/service.spec.ts
index d8c562acf4a..16f9306daed 100644
--- a/packages/api/src/app/service.spec.ts
+++ b/packages/api/src/app/service.spec.ts
@@ -1,3 +1,4 @@
+import { getMaxSubagents, setMaxSubagents } from 'librechat-data-provider';
 import type { AppConfig } from '@librechat/data-schemas';
 import {
   createAppConfigService,
@@ -65,6 +66,7 @@ describe('createAppConfigService', () => {
       const config = await getAppConfig();
 
       expect(deps.loadBaseConfig).toHaveBeenCalledTimes(1);
+      expect(deps.loadBaseConfig).toHaveBeenCalledWith('startup');
       expect(config).toEqual(deps._baseConfig);
     });
 
@@ -103,6 +105,92 @@ describe('createAppConfigService', () => {
       await getAppConfig({ refresh: true });
 
       expect(deps.loadBaseConfig).toHaveBeenCalledTimes(2);
+      expect(deps.loadBaseConfig).toHaveBeenLastCalledWith('reload');
+    });
+
+    it.each(['invalid YAML', 'missing local file', 'remote fetch failure'])(
+      'keeps the last good base config when reload fails: %s',
+      async (message) => {
+        const deps = createDeps();
+        const { getAppConfig, clearAppConfigCache } = createAppConfigService(deps);
+        const initial = await getAppConfig({ baseOnly: true });
+        deps.loadBaseConfig.mockRejectedValueOnce(new Error(message));
+
+        await clearAppConfigCache();
+        const reloaded = await getAppConfig({ baseOnly: true });
+
+        expect(reloaded).toBe(initial);
+        expect(deps._cache._store.get('app_config:_BASE_')).toBe(initial);
+        expect(deps.loadBaseConfig).toHaveBeenLastCalledWith('reload');
+      },
+    );
+
+    it.each(['tools', 'cache'])(
+      'restores the subagent cap if %s publication fails',
+      async (stage) => {
+        const deps = createDeps({
+          loadBaseConfig: jest.fn().mockResolvedValue({
+            config: { endpoints: { agents: { maxSubagents: 3 } } },
+            availableTools: { previous: {} },
+          }),
+        });
+        const { getAppConfig, clearAppConfigCache } = createAppConfigService(deps);
+        try {
+          await getAppConfig({ baseOnly: true });
+          setMaxSubagents(3);
+          await clearAppConfigCache();
+          deps.loadBaseConfig.mockImplementationOnce(async () => {
+            setMaxSubagents(20);
+            return {
+              config: { endpoints: { agents: { maxSubagents: 20 } } },
+              availableTools: { new: {} },
+            };
+          });
+          if (stage === 'tools') {
+            deps.setCachedTools.mockRejectedValueOnce(new Error('tools unavailable'));
+          } else {
+            deps._cache.set.mockRejectedValueOnce(new Error('cache unavailable'));
+          }
+
+          const kept = await getAppConfig({ baseOnly: true });
+          expect(kept.config?.endpoints?.agents?.maxSubagents).toBe(3);
+          expect(getMaxSubagents()).toBe(3);
+        } finally {
+          setMaxSubagents(undefined);
+        }
+      },
+    );
+
+    it('single-flights concurrent base config reloads', async () => {
+      const deps = createDeps();
+      const { getAppConfig, clearAppConfigCache } = createAppConfigService(deps);
+      const initial = await getAppConfig({ baseOnly: true });
+      await clearAppConfigCache();
+
+      let resolveReload: ((config: AppConfig) => void) | undefined;
+      deps.loadBaseConfig.mockImplementationOnce(
+        () =>
+          new Promise<AppConfig>((resolve) => {
+            resolveReload = resolve;
+          }),
+      );
+      const reloads = Array.from({ length: 10 }, () => getAppConfig({ baseOnly: true }));
+      await Promise.resolve();
+      expect(deps.loadBaseConfig).toHaveBeenCalledTimes(2);
+
+      const next = { ...initial, interfaceConfig: { modelSelect: false } };
+      resolveReload?.(next);
+      await expect(Promise.all(reloads)).resolves.toEqual(Array(10).fill(next));
+      expect(deps.loadBaseConfig).toHaveBeenCalledTimes(2);
+    });
+
+    it('does not convert a startup load failure into an empty config', async () => {
+      const failure = new Error('invalid startup config');
+      const deps = createDeps({ loadBaseConfig: jest.fn().mockRejectedValue(failure) });
+      const { getAppConfig } = createAppConfigService(deps);
+
+      await expect(getAppConfig({ baseOnly: true })).rejects.toBe(failure);
+      expect(deps.loadBaseConfig).toHaveBeenCalledWith('startup');
     });
 
     it('queries DB for applicable configs', async () => {
diff --git a/packages/api/src/app/service.ts b/packages/api/src/app/service.ts
index 4d1c2173d28..ebc4da01f95 100644
--- a/packages/api/src/app/service.ts
+++ b/packages/api/src/app/service.ts
@@ -1,4 +1,8 @@
-import { PrincipalType, materializeModelSpecEndpoints } from 'librechat-data-provider';
+import {
+  PrincipalType,
+  materializeModelSpecEndpoints,
+  setMaxSubagents,
+} from 'librechat-data-provider';
 import {
   logger,
   getTenantId,
@@ -7,6 +11,7 @@ import {
 } from '@librechat/data-schemas';
 import type { AppConfig, IConfig } from '@librechat/data-schemas';
 import type { Types } from 'mongoose';
+import type { CustomConfigLoadMode } from './loader';
 
 const BASE_CONFIG_KEY = '_BASE_';
 
@@ -47,7 +52,7 @@ interface CacheStore {
 
 export interface AppConfigServiceDeps {
   /** Load the base AppConfig from YAML + AppService processing. */
-  loadBaseConfig: () => Promise<AppConfig | undefined>;
+  loadBaseConfig: (mode?: CustomConfigLoadMode) => Promise<AppConfig | undefined>;
   /** Cache tools after base config is loaded. */
   setCachedTools: (tools: Record<string, unknown>) => Promise<void>;
   /** Get a cache store by key. */
@@ -163,6 +168,8 @@ export function createAppConfigService(deps: AppConfigServiceDeps): {
   } = deps;
 
   const cache = getCache(cacheKeys.APP_CONFIG);
+  let lastGoodBaseConfig: AppConfig | undefined;
+  let baseConfigFlight: Promise<AppConfig> | undefined;
 
   async function buildPrincipals(
     role?: string,
@@ -186,29 +193,80 @@ export function createAppConfigService(deps: AppConfigServiceDeps): {
     return principals;
   }
 
+  async function restoreLastGoodBaseConfig(error: unknown): Promise<AppConfig> {
+    const lastGood = lastGoodBaseConfig;
+    if (!lastGood) {
+      throw error;
+    }
+
+    setMaxSubagents(lastGood.config?.endpoints?.agents?.maxSubagents);
+    logger.error(
+      '[ensureBaseConfig] Failed to reload base configuration; keeping the last good configuration.',
+      error,
+    );
+    const restorations = [cache.set(BASE_CONFIG_KEY, lastGood)];
+    if (lastGood.availableTools) {
+      restorations.push(setCachedTools(lastGood.availableTools));
+    }
+    const results = await Promise.allSettled(restorations);
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        logger.error('[ensureBaseConfig] Failed to restore last-good config state:', result.reason);
+      }
+    }
+    return lastGood;
+  }
+
+  async function loadAndCacheBaseConfig(mode: CustomConfigLoadMode): Promise<AppConfig> {
+    try {
+      logger.info('[ensureBaseConfig] Loading base configuration...');
+      const loaded = await loadBaseConfig(mode);
+      if (!loaded) {
+        throw new Error('Failed to initialize app configuration through AppService.');
+      }
+
+      const baseConfig = materializeConfigModelSpecs(loaded);
+      if (baseConfig.availableTools) {
+        await setCachedTools(baseConfig.availableTools);
+      }
+      await cache.set(BASE_CONFIG_KEY, baseConfig);
+      lastGoodBaseConfig = baseConfig;
+      return baseConfig;
+    } catch (error) {
+      if (mode === 'startup') {
+        throw error;
+      }
+      return restoreLastGoodBaseConfig(error);
+    }
+  }
+
   /**
    * Ensure the YAML-derived base config is loaded and cached.
    * Returns the `_BASE_` config (YAML + AppService). No DB queries.
    */
   async function ensureBaseConfig(refresh?: boolean): Promise<AppConfig> {
-    let baseConfig = (await cache.get(BASE_CONFIG_KEY)) as AppConfig | undefined;
-    if (!baseConfig || refresh) {
-      logger.info('[ensureBaseConfig] Loading base configuration...');
-      baseConfig = await loadBaseConfig();
-
-      if (!baseConfig) {
-        throw new Error('Failed to initialize app configuration through AppService.');
+    const cached = (await cache.get(BASE_CONFIG_KEY)) as AppConfig | undefined;
+    if (cached) {
+      lastGoodBaseConfig ??= cached;
+      if (!refresh) {
+        return cached;
       }
+    }
 
-      baseConfig = materializeConfigModelSpecs(baseConfig);
+    if (baseConfigFlight) {
+      return baseConfigFlight;
+    }
 
-      if (baseConfig.availableTools) {
-        await setCachedTools(baseConfig.availableTools);
+    const mode: CustomConfigLoadMode = lastGoodBaseConfig ? 'reload' : 'startup';
+    const flight = loadAndCacheBaseConfig(mode);
+    baseConfigFlight = flight;
+    try {
+      return await flight;
+    } finally {
+      if (baseConfigFlight === flight) {
+        baseConfigFlight = undefined;
       }
-
-      await cache.set(BASE_CONFIG_KEY, baseConfig);
     }
-    return baseConfig;
   }
 
   /**