@@ -1,18 +1 @@
-import { isServer, type QueryClient } from '@tanstack/react-query'
-import { makeQueryClient } from '@/hooks/queries/utils/query-client'
-
-let browserQueryClient: QueryClient | undefined
-
-/**
- * Returns a QueryClient instance. On the server, creates a new instance per request.
- * On the client, reuses a singleton instance.
- */
-export function getQueryClient() {
-  if (isServer) {
-    return makeQueryClient()
-  }
-  if (!browserQueryClient) {
-    browserQueryClient = makeQueryClient()
-  }
-  return browserQueryClient
-}
+export { getQueryClient } from '@/hooks/queries/utils/get-query-client'
@@ -10,7 +10,7 @@ import { connectorDisplayName } from '@/lib/sim-search/connectors'
 import {
   isHttpUrl,
   type SourceTagData,
-} from '@/app/workspace/[workspaceId]/home/components/message-content/components/special-tags'
+} from '@/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/parse'
 
 /**
  * One card per document, keeping the best-ranked chunk of each: the list is
 
@@ -2,7 +2,7 @@ import type {
   AgentGroupItem,
   NestedAgentGroup,
 } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group-view'
-import { isToolDone } from '@/app/workspace/[workspaceId]/home/components/message-content/utils'
+import { isToolDone } from '@/app/workspace/[workspaceId]/home/components/message-content/tool-status'
 import type { ToolCallData } from '@/app/workspace/[workspaceId]/home/types'
 
 /**
 
@@ -3,206 +3,32 @@
 import { type ComponentType, Fragment, useState } from 'react'
 import { ActivityStatus } from '@/components/ui/activity-status'
 import type { ToolActivity } from '@/lib/mothership/generated/protocol'
-import {
-  CallIntegrationTool,
-  RunCode,
-  SearchWorkspace,
-} from '@/lib/mothership/generated/tool-catalog-v1'
-import { getToolActivitySummaryActions, readCallActivity } from '@/lib/mothership/tools/activity'
-import { getToolStatusDisplayTitle } from '@/lib/mothership/tools/display'
-import { extractStreamingStringArgument } from '@/lib/mothership/tools/streaming-args'
+import { readCallActivity } from '@/lib/mothership/tools/activity'
 import { ActivityStream } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/activity-stream'
-import { getNewestRunningTool } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group-content'
 import { getSearchActivitySources } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/search-activity-details'
 import { SearchActivityResults } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/search-activity-results'
-import type { ToolCallItemProps } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item'
 import {
-  getActivityAttentionKey,
-  needsToolInput,
-} from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-interactions'
+  getActivityHeaderTool,
+  getActivityStatusTool,
+  getCompletedActivityLabel,
+  getInProgressActivityLabel,
+  getToolTitle,
+  isAwaitingTitle,
+  withoutRetriedSearchFailures,
+} from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-activity-labels'
+import type { ToolCallItemProps } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item'
+import { getActivityAttentionKey } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-interactions'
 import { isToolDone } from '@/app/workspace/[workspaceId]/home/components/message-content/utils'
-import { type ToolCallData, ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
-
-/** A completed summary names at most this many distinct actions, and never counts the rest. */
-const MAX_SUMMARY_ACTIONS = 3
-
-function isFailedTool(tool: ToolCallData): boolean {
-  return tool.status === ToolCallStatus.error || tool.status === ToolCallStatus.rejected
-}
-
-/**
- * Drops a search that errored when a later search follows it: the model corrected the query
- * and searched again, so the failed attempt is not part of what the user reads. The last search
- * always stays, so a failure that no search retried, or a run whose searches all failed, still
- * shows its outcome.
- */
-function withoutRetriedSearchFailures(tools: ToolCallData[]): ToolCallData[] {
-  let lastSearch = -1
-  for (const [index, tool] of tools.entries()) {
-    if (tool.toolName === SearchWorkspace.id) lastSearch = index
-  }
-  return tools.filter(
-    (tool, index) =>
-      index >= lastSearch ||
-      tool.toolName !== SearchWorkspace.id ||
-      tool.status !== ToolCallStatus.error
-  )
-}
-
-function toolCountLabel(tools: ToolCallData[]): string {
-  return `${tools.length} tool ${tools.length === 1 ? 'call' : 'calls'}`
-}
-
-function getToolTitle(tool: ToolCallData): string {
-  return getToolStatusDisplayTitle(
-    tool.displayTitle,
-    tool.status,
-    tool.toolName,
-    tool.activityDescription
-  )
-}
-
-/**
- * Summarize completed actions without describing failed or skipped work as
- * successful: a single call, or the only successful one, keeps its own title;
- * several successful calls name their distinct actions ("Navigated, read
- * pages, clicked elements"); stopped or skipped calls append an outcome count.
- */
-function getToolActivitySummary(tools: ToolCallData[]): string {
-  if (tools.length === 1) return getToolTitle(tools[0])
-  const succeeded = tools.filter((tool) => tool.status === ToolCallStatus.success)
-  const [first, ...rest] =
-    succeeded.length === 1
-      ? [getToolTitle(succeeded[0])]
-      : getToolActivitySummaryActions(succeeded, MAX_SUMMARY_ACTIONS)
-  const summary = first
-    ? [first.charAt(0).toUpperCase() + first.slice(1), ...rest].join(', ')
-    : toolCountLabel(tools)
-  return [summary, ...getToolActivityInterruptions(tools)].join(' · ')
-}
-
-function getToolActivityInterruptions(tools: ToolCallData[]): string[] {
-  let stopped = 0
-  let skipped = 0
-  for (const tool of tools) {
-    if (tool.status === ToolCallStatus.cancelled || tool.status === ToolCallStatus.interrupted)
-      stopped++
-    else if (tool.status === ToolCallStatus.skipped) skipped++
-  }
-  return [...(stopped ? [`${stopped} stopped`] : []), ...(skipped ? [`${skipped} skipped`] : [])]
-}
-
-/**
- * An executing call whose streamed arguments do not name its action yet, so its
- * title is only its tool's placeholder: a search before its arguments arrive,
- * a CLI call before its final frame (the verb parsed mid-stream would only flash
- * ahead of the model's description), a `run_code` call before its arguments
- * resolve, while their parameters hold at most the activity, and an
- * integration gateway call before its description streams ("Calling integration").
- * A call awaiting approval is never untitled, so its permission card keeps the
- * header, and neither is one the model already described.
- */
-export function isAwaitingTitle(tool: ToolCallData): boolean {
-  if (tool.status !== ToolCallStatus.executing || tool.activityDescription) return false
-  if (tool.toolName === CallIntegrationTool.id) {
-    const description =
-      tool.params?.description ?? extractStreamingStringArgument(tool.streamingArgs, 'description')
-    return !(typeof description === 'string' && description.trim())
-  }
-  return (
-    (tool.toolName === 'sim_cli' ||
-      tool.toolName.startsWith('cli_') ||
-      tool.toolName === RunCode.id ||
-      tool.toolName === 'search_workspace') &&
-    Object.keys(tool.params ?? {}).every((key) => key === 'activity')
-  )
-}
-
-/**
- * The call an in-progress header describes, label and icon alike, shared by
- * tool group and subagent headers so a live header never flips to placeholder
- * text between steps: the status call, unless it is still awaiting its title,
- * in which case the call the header described before it keeps the header
- * until the new title arrives. A call waiting on the user is never held, since
- * its permission card or handoff would replace the header, and neither is a
- * failed call, which must not read as live. With no such earlier call, the
- * status call.
- */
-export function getActivityHeaderTool(
-  tools: ToolCallData[],
-  statusTool: ToolCallData
-): ToolCallData {
-  if (!isAwaitingTitle(statusTool)) return statusTool
-  return (
-    getActivityStatusTool(
-      tools
-        .slice(
-          0,
-          tools.findIndex((tool) => tool.id === statusTool.id)
-        )
-        .filter((tool) => !isAwaitingTitle(tool) && !needsToolInput(tool) && !isFailedTool(tool))
-    ) ?? statusTool
-  )
-}
-
-/** The wait wording: the turn between steps, and a first call whose own title is still streaming. */
-export const THINKING_LABEL = 'Thinking'
-
-/**
- * The title of an activity in progress for its header call, with earlier
- * stops and skips kept visible. A header call still awaiting its title has no
- * earlier call to hold, so it reads as the activity's intent when the model
- * gave one, else as the wait it continues: a tool's placeholder ("Running CLI
- * command") would flash between the turn's "Thinking" and the model's description.
- */
-export function getInProgressActivityLabel(
-  activeLabel: string,
-  headerTool: ToolCallData,
-  tools: ToolCallData[],
-  activityTitle: string | undefined
-): string {
-  const label = isAwaitingTitle(headerTool) ? activityTitle || THINKING_LABEL : activeLabel
-  return getActiveToolActivityTitle(label, headerTool, tools)
-}
-
-/** Keep earlier interruptions visible while the latest action continues. */
-function getActiveToolActivityTitle(
-  label: string,
-  tool: ToolCallData,
-  tools: ToolCallData[]
-): string {
-  return tool.status === ToolCallStatus.executing || tool.status === ToolCallStatus.success
-    ? [label, ...getToolActivityInterruptions(tools)].join(' · ')
-    : label
-}
-
-/**
- * The call a header describes: the newest running call, else the latest call
- * that did not error or get rejected, so a failed attempt labels the activity
- * only when every call failed. A stopped, skipped, or interrupted call can still be it.
- */
-export function getActivityStatusTool(tools: ToolCallData[]): ToolCallData | undefined {
-  return (
-    getNewestRunningTool(tools) ??
-    tools.filter((tool) => !isFailedTool(tool)).at(-1) ??
-    tools.at(-1)
-  )
-}
-
-/**
- * The label of a finished activity: the model's completed title when every
- * call succeeded, else the summary of what did succeed, so a stopped, skipped,
- * or failed call never hides behind a success title. Main and subagent lanes
- * share this rule.
- */
-export function getCompletedActivityLabel(
-  tools: ToolCallData[],
-  activity: ToolActivity | undefined
-): string {
-  return activity?.completedTitle && tools.every((tool) => tool.status === ToolCallStatus.success)
-    ? activity.completedTitle
-    : getToolActivitySummary(tools)
-}
+import type { ToolCallData } from '@/app/workspace/[workspaceId]/home/types'
+
+export {
+  getActivityHeaderTool,
+  getActivityStatusTool,
+  getCompletedActivityLabel,
+  getInProgressActivityLabel,
+  isAwaitingTitle,
+  THINKING_LABEL,
+} from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-activity-labels'
 
 interface ToolActivityGroupProps {
   activity?: ToolActivity